Merge branch 'work.ecryptfs' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs

Pull exryptfs updates from Al Viro:
 "The interesting part here is (ecryptfs) lock_parent() fixes - its
  treatment of ->d_parent had been very wrong.

  The rest is trivial cleanups"

* 'work.ecryptfs' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs:
  ecryptfs: ecryptfs_dentry_info->crypt_stat is never used
  ecryptfs: get rid of unused accessors
  ecryptfs: saner API for lock_parent()
  ecryptfs: get rid of pointless dget/dput in ->symlink() and ->link()

diff --combined fs/ecryptfs/inode.c
index 7169ea8733472d767e640739f744c0af24bd80c5,861a01713f3f4c16e726c051e52a39673a9f872d..0a1ab1db14503df4bd240494a799e2d016afe879
--- 1/fs/ecryptfs/inode.c
--- 2/fs/ecryptfs/inode.c
+++ b/fs/ecryptfs/inode.c
@@@ -18,23 -18,21 +18,22 @@@
  #include <linux/fs_stack.h>
  #include <linux/slab.h>
  #include <linux/xattr.h>
 +#include <linux/fileattr.h>
  #include <asm/unaligned.h>
  #include "ecryptfs_kernel.h"
  
- static struct dentry *lock_parent(struct dentry *dentry)
+ static int lock_parent(struct dentry *dentry,
+                      struct dentry **lower_dentry,
+                      struct inode **lower_dir)
  {
-       struct dentry *dir;
+       struct dentry *lower_dir_dentry;
  
-       dir = dget_parent(dentry);
-       inode_lock_nested(d_inode(dir), I_MUTEX_PARENT);
-       return dir;
- }
+       lower_dir_dentry = ecryptfs_dentry_to_lower(dentry->d_parent);
+       *lower_dir = d_inode(lower_dir_dentry);
+       *lower_dentry = ecryptfs_dentry_to_lower(dentry);
  
- static void unlock_dir(struct dentry *dir)
- {
-       inode_unlock(d_inode(dir));
-       dput(dir);
+       inode_lock_nested(*lower_dir, I_MUTEX_PARENT);
+       return (*lower_dentry)->d_parent == lower_dir_dentry ? 0 : -EINVAL;
  }
  
  static int ecryptfs_inode_test(struct inode *inode, void *lower_inode)
@@@ -128,32 -126,29 +127,29 @@@ static int ecryptfs_interpose(struct de
  static int ecryptfs_do_unlink(struct inode *dir, struct dentry *dentry,
                              struct inode *inode)
  {
-       struct dentry *lower_dentry = ecryptfs_dentry_to_lower(dentry);
-       struct dentry *lower_dir_dentry;
-       struct inode *lower_dir_inode;
+       struct dentry *lower_dentry;
+       struct inode *lower_dir;
        int rc;
  
-       lower_dir_dentry = ecryptfs_dentry_to_lower(dentry->d_parent);
-       lower_dir_inode = d_inode(lower_dir_dentry);
-       inode_lock_nested(lower_dir_inode, I_MUTEX_PARENT);
+       rc = lock_parent(dentry, &lower_dentry, &lower_dir);
        dget(lower_dentry);     // don't even try to make the lower negative
-       if (lower_dentry->d_parent != lower_dir_dentry)
-               rc = -EINVAL;
-       else if (d_unhashed(lower_dentry))
-               rc = -EINVAL;
-       else
-               rc = vfs_unlink(&init_user_ns, lower_dir_inode, lower_dentry,
-                               NULL);
+       if (!rc) {
+               if (d_unhashed(lower_dentry))
+                       rc = -EINVAL;
+               else
+                       rc = vfs_unlink(&init_user_ns, lower_dir, lower_dentry,
+                                       NULL);
+       }
        if (rc) {
                printk(KERN_ERR "Error in vfs_unlink; rc = [%d]\n", rc);
                goto out_unlock;
        }
-       fsstack_copy_attr_times(dir, lower_dir_inode);
+       fsstack_copy_attr_times(dir, lower_dir);
        set_nlink(inode, ecryptfs_inode_to_lower(inode)->i_nlink);
        inode->i_ctime = dir->i_ctime;
  out_unlock:
        dput(lower_dentry);
-       inode_unlock(lower_dir_inode);
+       inode_unlock(lower_dir);
        if (!rc)
                d_drop(dentry);
        return rc;
@@@ -177,13 -172,13 +173,13 @@@ ecryptfs_do_create(struct inode *direct
  {
        int rc;
        struct dentry *lower_dentry;
-       struct dentry *lower_dir_dentry;
+       struct inode *lower_dir;
        struct inode *inode;
  
-       lower_dentry = ecryptfs_dentry_to_lower(ecryptfs_dentry);
-       lower_dir_dentry = lock_parent(lower_dentry);
-       rc = vfs_create(&init_user_ns, d_inode(lower_dir_dentry), lower_dentry,
-                       mode, true);
+       rc = lock_parent(ecryptfs_dentry, &lower_dentry, &lower_dir);
+       if (!rc)
+               rc = vfs_create(&init_user_ns, lower_dir,
+                               lower_dentry, mode, true);
        if (rc) {
                printk(KERN_ERR "%s: Failure to create dentry in lower fs; "
                       "rc = [%d]\n", __func__, rc);
@@@ -193,14 -188,13 +189,13 @@@
        inode = __ecryptfs_get_inode(d_inode(lower_dentry),
                                     directory_inode->i_sb);
        if (IS_ERR(inode)) {
-               vfs_unlink(&init_user_ns, d_inode(lower_dir_dentry),
-                          lower_dentry, NULL);
+               vfs_unlink(&init_user_ns, lower_dir, lower_dentry, NULL);
                goto out_lock;
        }
-       fsstack_copy_attr_times(directory_inode, d_inode(lower_dir_dentry));
-       fsstack_copy_inode_size(directory_inode, d_inode(lower_dir_dentry));
+       fsstack_copy_attr_times(directory_inode, lower_dir);
+       fsstack_copy_inode_size(directory_inode, lower_dir);
  out_lock:
-       unlock_dir(lower_dir_dentry);
+       inode_unlock(lower_dir);
        return inode;
  }
  
@@@ -431,32 -425,28 +426,28 @@@ static int ecryptfs_link(struct dentry 
  {
        struct dentry *lower_old_dentry;
        struct dentry *lower_new_dentry;
-       struct dentry *lower_dir_dentry;
+       struct inode *lower_dir;
        u64 file_size_save;
        int rc;
  
        file_size_save = i_size_read(d_inode(old_dentry));
        lower_old_dentry = ecryptfs_dentry_to_lower(old_dentry);
-       lower_new_dentry = ecryptfs_dentry_to_lower(new_dentry);
-       dget(lower_old_dentry);
-       dget(lower_new_dentry);
-       lower_dir_dentry = lock_parent(lower_new_dentry);
-       rc = vfs_link(lower_old_dentry, &init_user_ns,
-                     d_inode(lower_dir_dentry), lower_new_dentry, NULL);
+       rc = lock_parent(new_dentry, &lower_new_dentry, &lower_dir);
+       if (!rc)
+               rc = vfs_link(lower_old_dentry, &init_user_ns, lower_dir,
+                             lower_new_dentry, NULL);
        if (rc || d_really_is_negative(lower_new_dentry))
                goto out_lock;
        rc = ecryptfs_interpose(lower_new_dentry, new_dentry, dir->i_sb);
        if (rc)
                goto out_lock;
-       fsstack_copy_attr_times(dir, d_inode(lower_dir_dentry));
-       fsstack_copy_inode_size(dir, d_inode(lower_dir_dentry));
+       fsstack_copy_attr_times(dir, lower_dir);
+       fsstack_copy_inode_size(dir, lower_dir);
        set_nlink(d_inode(old_dentry),
                  ecryptfs_inode_to_lower(d_inode(old_dentry))->i_nlink);
        i_size_write(d_inode(new_dentry), file_size_save);
  out_lock:
-       unlock_dir(lower_dir_dentry);
-       dput(lower_new_dentry);
-       dput(lower_old_dentry);
+       inode_unlock(lower_dir);
        return rc;
  }
  
@@@ -471,14 -461,14 +462,14 @@@ static int ecryptfs_symlink(struct user
  {
        int rc;
        struct dentry *lower_dentry;
-       struct dentry *lower_dir_dentry;
+       struct inode *lower_dir;
        char *encoded_symname;
        size_t encoded_symlen;
        struct ecryptfs_mount_crypt_stat *mount_crypt_stat = NULL;
  
-       lower_dentry = ecryptfs_dentry_to_lower(dentry);
-       dget(lower_dentry);
-       lower_dir_dentry = lock_parent(lower_dentry);
+       rc = lock_parent(dentry, &lower_dentry, &lower_dir);
+       if (rc)
+               goto out_lock;
        mount_crypt_stat = &ecryptfs_superblock_to_private(
                dir->i_sb)->mount_crypt_stat;
        rc = ecryptfs_encrypt_and_encode_filename(&encoded_symname,
@@@ -487,7 -477,7 +478,7 @@@
                                                  strlen(symname));
        if (rc)
                goto out_lock;
-       rc = vfs_symlink(&init_user_ns, d_inode(lower_dir_dentry), lower_dentry,
+       rc = vfs_symlink(&init_user_ns, lower_dir, lower_dentry,
                         encoded_symname);
        kfree(encoded_symname);
        if (rc || d_really_is_negative(lower_dentry))
@@@ -495,11 -485,10 +486,10 @@@
        rc = ecryptfs_interpose(lower_dentry, dentry, dir->i_sb);
        if (rc)
                goto out_lock;
-       fsstack_copy_attr_times(dir, d_inode(lower_dir_dentry));
-       fsstack_copy_inode_size(dir, d_inode(lower_dir_dentry));
+       fsstack_copy_attr_times(dir, lower_dir);
+       fsstack_copy_inode_size(dir, lower_dir);
  out_lock:
-       unlock_dir(lower_dir_dentry);
-       dput(lower_dentry);
+       inode_unlock(lower_dir);
        if (d_really_is_negative(dentry))
                d_drop(dentry);
        return rc;
@@@ -510,22 -499,22 +500,22 @@@ static int ecryptfs_mkdir(struct user_n
  {
        int rc;
        struct dentry *lower_dentry;
-       struct dentry *lower_dir_dentry;
+       struct inode *lower_dir;
  
-       lower_dentry = ecryptfs_dentry_to_lower(dentry);
-       lower_dir_dentry = lock_parent(lower_dentry);
-       rc = vfs_mkdir(&init_user_ns, d_inode(lower_dir_dentry), lower_dentry,
-                      mode);
+       rc = lock_parent(dentry, &lower_dentry, &lower_dir);
+       if (!rc)
+               rc = vfs_mkdir(&init_user_ns, lower_dir,
+                              lower_dentry, mode);
        if (rc || d_really_is_negative(lower_dentry))
                goto out;
        rc = ecryptfs_interpose(lower_dentry, dentry, dir->i_sb);
        if (rc)
                goto out;
-       fsstack_copy_attr_times(dir, d_inode(lower_dir_dentry));
-       fsstack_copy_inode_size(dir, d_inode(lower_dir_dentry));
-       set_nlink(dir, d_inode(lower_dir_dentry)->i_nlink);
+       fsstack_copy_attr_times(dir, lower_dir);
+       fsstack_copy_inode_size(dir, lower_dir);
+       set_nlink(dir, lower_dir->i_nlink);
  out:
-       unlock_dir(lower_dir_dentry);
+       inode_unlock(lower_dir);
        if (d_really_is_negative(dentry))
                d_drop(dentry);
        return rc;
@@@ -534,29 -523,24 +524,24 @@@
  static int ecryptfs_rmdir(struct inode *dir, struct dentry *dentry)
  {
        struct dentry *lower_dentry;
-       struct dentry *lower_dir_dentry;
-       struct inode *lower_dir_inode;
+       struct inode *lower_dir;
        int rc;
  
-       lower_dentry = ecryptfs_dentry_to_lower(dentry);
-       lower_dir_dentry = ecryptfs_dentry_to_lower(dentry->d_parent);
-       lower_dir_inode = d_inode(lower_dir_dentry);
- 
-       inode_lock_nested(lower_dir_inode, I_MUTEX_PARENT);
+       rc = lock_parent(dentry, &lower_dentry, &lower_dir);
        dget(lower_dentry);     // don't even try to make the lower negative
-       if (lower_dentry->d_parent != lower_dir_dentry)
-               rc = -EINVAL;
-       else if (d_unhashed(lower_dentry))
-               rc = -EINVAL;
-       else
-               rc = vfs_rmdir(&init_user_ns, lower_dir_inode, lower_dentry);
+       if (!rc) {
+               if (d_unhashed(lower_dentry))
+                       rc = -EINVAL;
+               else
+                       rc = vfs_rmdir(&init_user_ns, lower_dir, lower_dentry);
+       }
        if (!rc) {
                clear_nlink(d_inode(dentry));
-               fsstack_copy_attr_times(dir, lower_dir_inode);
-               set_nlink(dir, lower_dir_inode->i_nlink);
+               fsstack_copy_attr_times(dir, lower_dir);
+               set_nlink(dir, lower_dir->i_nlink);
        }
        dput(lower_dentry);
-       inode_unlock(lower_dir_inode);
+       inode_unlock(lower_dir);
        if (!rc)
                d_drop(dentry);
        return rc;
@@@ -568,21 -552,21 +553,21 @@@ ecryptfs_mknod(struct user_namespace *m
  {
        int rc;
        struct dentry *lower_dentry;
-       struct dentry *lower_dir_dentry;
+       struct inode *lower_dir;
  
-       lower_dentry = ecryptfs_dentry_to_lower(dentry);
-       lower_dir_dentry = lock_parent(lower_dentry);
-       rc = vfs_mknod(&init_user_ns, d_inode(lower_dir_dentry), lower_dentry,
-                      mode, dev);
+       rc = lock_parent(dentry, &lower_dentry, &lower_dir);
+       if (!rc)
+               rc = vfs_mknod(&init_user_ns, lower_dir,
+                              lower_dentry, mode, dev);
        if (rc || d_really_is_negative(lower_dentry))
                goto out;
        rc = ecryptfs_interpose(lower_dentry, dentry, dir->i_sb);
        if (rc)
                goto out;
-       fsstack_copy_attr_times(dir, d_inode(lower_dir_dentry));
-       fsstack_copy_inode_size(dir, d_inode(lower_dir_dentry));
+       fsstack_copy_attr_times(dir, lower_dir);
+       fsstack_copy_inode_size(dir, lower_dir);
  out:
-       unlock_dir(lower_dir_dentry);
+       inode_unlock(lower_dir);
        if (d_really_is_negative(dentry))
                d_drop(dentry);
        return rc;
@@@ -1119,23 -1103,6 +1104,23 @@@ out
        return rc;
  }
  
 +static int ecryptfs_fileattr_get(struct dentry *dentry, struct fileattr *fa)
 +{
 +      return vfs_fileattr_get(ecryptfs_dentry_to_lower(dentry), fa);
 +}
 +
 +static int ecryptfs_fileattr_set(struct user_namespace *mnt_userns,
 +                               struct dentry *dentry, struct fileattr *fa)
 +{
 +      struct dentry *lower_dentry = ecryptfs_dentry_to_lower(dentry);
 +      int rc;
 +
 +      rc = vfs_fileattr_set(&init_user_ns, lower_dentry, fa);
 +      fsstack_copy_attr_all(d_inode(dentry), d_inode(lower_dentry));
 +
 +      return rc;
 +}
 +
  const struct inode_operations ecryptfs_symlink_iops = {
        .get_link = ecryptfs_get_link,
        .permission = ecryptfs_permission,
@@@ -1157,8 -1124,6 +1142,8 @@@ const struct inode_operations ecryptfs_
        .permission = ecryptfs_permission,
        .setattr = ecryptfs_setattr,
        .listxattr = ecryptfs_listxattr,
 +      .fileattr_get = ecryptfs_fileattr_get,
 +      .fileattr_set = ecryptfs_fileattr_set,
  };
  
  const struct inode_operations ecryptfs_main_iops = {
@@@ -1166,8 -1131,6 +1151,8 @@@
        .setattr = ecryptfs_setattr,
        .getattr = ecryptfs_getattr,
        .listxattr = ecryptfs_listxattr,
 +      .fileattr_get = ecryptfs_fileattr_get,
 +      .fileattr_set = ecryptfs_fileattr_set,
  };
  
  static int ecryptfs_xattr_get(const struct xattr_handler *handler,