VFS: normal filesystems (and lustre): d_inode() annotations

[linux-2.6-block.git] / fs / ecryptfs / inode.c

diff --git a/fs/ecryptfs/inode.c b/fs/ecryptfs/inode.c
index b08b5187f6622cb6c7934d6dba9fcdfdbb0aefb6..fc850b55db67a27a99663596e1e8c711c8d71237 100644 (file)
--- a/fs/ecryptfs/inode.c
+++ b/fs/ecryptfs/inode.c
@@ -41,13 +41,13 @@ static struct dentry *lock_parent(struct dentry *dentry)
        struct dentry *dir;
 
        dir = dget_parent(dentry);
-       mutex_lock_nested(&(dir->d_inode->i_mutex), I_MUTEX_PARENT);
+       mutex_lock_nested(&(d_inode(dir)->i_mutex), I_MUTEX_PARENT);
        return dir;
 }
 
 static void unlock_dir(struct dentry *dir)
 {
-       mutex_unlock(&dir->d_inode->i_mutex);
+       mutex_unlock(&d_inode(dir)->i_mutex);
        dput(dir);
 }
 
@@ -131,7 +131,7 @@ struct inode *ecryptfs_get_inode(struct inode *lower_inode,
 static int ecryptfs_interpose(struct dentry *lower_dentry,
                              struct dentry *dentry, struct super_block *sb)
 {
-       struct inode *inode = ecryptfs_get_inode(lower_dentry->d_inode, sb);
+       struct inode *inode = ecryptfs_get_inode(d_inode(lower_dentry), sb);
 
        if (IS_ERR(inode))
                return PTR_ERR(inode);
@@ -189,21 +189,21 @@ ecryptfs_do_create(struct inode *directory_inode,
 
        lower_dentry = ecryptfs_dentry_to_lower(ecryptfs_dentry);
        lower_dir_dentry = lock_parent(lower_dentry);
-       rc = vfs_create(lower_dir_dentry->d_inode, lower_dentry, mode, true);
+       rc = vfs_create(d_inode(lower_dir_dentry), lower_dentry, mode, true);
        if (rc) {
                printk(KERN_ERR "%s: Failure to create dentry in lower fs; "
                       "rc = [%d]\n", __func__, rc);
                inode = ERR_PTR(rc);
                goto out_lock;
        }
-       inode = __ecryptfs_get_inode(lower_dentry->d_inode,
+       inode = __ecryptfs_get_inode(d_inode(lower_dentry),
                                     directory_inode->i_sb);
        if (IS_ERR(inode)) {
-               vfs_unlink(lower_dir_dentry->d_inode, lower_dentry, NULL);
+               vfs_unlink(d_inode(lower_dir_dentry), lower_dentry, NULL);
                goto out_lock;
        }
-       fsstack_copy_attr_times(directory_inode, lower_dir_dentry->d_inode);
-       fsstack_copy_inode_size(directory_inode, lower_dir_dentry->d_inode);
+       fsstack_copy_attr_times(directory_inode, d_inode(lower_dir_dentry));
+       fsstack_copy_inode_size(directory_inode, d_inode(lower_dir_dentry));
 out_lock:
        unlock_dir(lower_dir_dentry);
        return inode;
@@ -332,7 +332,7 @@ static int ecryptfs_lookup_interpose(struct dentry *dentry,
                                     struct dentry *lower_dentry,
                                     struct inode *dir_inode)
 {
-       struct inode *inode, *lower_inode = lower_dentry->d_inode;
+       struct inode *inode, *lower_inode = d_inode(lower_dentry);
        struct ecryptfs_dentry_info *dentry_info;
        struct vfsmount *lower_mnt;
        int rc = 0;
@@ -347,14 +347,14 @@ static int ecryptfs_lookup_interpose(struct dentry *dentry,
        }
 
        lower_mnt = mntget(ecryptfs_dentry_to_lower_mnt(dentry->d_parent));
-       fsstack_copy_attr_atime(dir_inode, lower_dentry->d_parent->d_inode);
+       fsstack_copy_attr_atime(dir_inode, d_inode(lower_dentry->d_parent));
        BUG_ON(!d_count(lower_dentry));
 
        ecryptfs_set_dentry_private(dentry, dentry_info);
        dentry_info->lower_path.mnt = lower_mnt;
        dentry_info->lower_path.dentry = lower_dentry;
 
-       if (!lower_dentry->d_inode) {
+       if (d_really_is_negative(lower_dentry)) {
                /* We want to add because we couldn't find in lower */
                d_add(dentry, NULL);
                return 0;
@@ -400,11 +400,11 @@ static struct dentry *ecryptfs_lookup(struct inode *ecryptfs_dir_inode,
        int rc = 0;
 
        lower_dir_dentry = ecryptfs_dentry_to_lower(ecryptfs_dentry->d_parent);
-       mutex_lock(&lower_dir_dentry->d_inode->i_mutex);
+       mutex_lock(&d_inode(lower_dir_dentry)->i_mutex);
        lower_dentry = lookup_one_len(ecryptfs_dentry->d_name.name,
                                      lower_dir_dentry,
                                      ecryptfs_dentry->d_name.len);
-       mutex_unlock(&lower_dir_dentry->d_inode->i_mutex);
+       mutex_unlock(&d_inode(lower_dir_dentry)->i_mutex);
        if (IS_ERR(lower_dentry)) {
                rc = PTR_ERR(lower_dentry);
                ecryptfs_printk(KERN_DEBUG, "%s: lookup_one_len() returned "
@@ -412,7 +412,7 @@ static struct dentry *ecryptfs_lookup(struct inode *ecryptfs_dir_inode,
                                ecryptfs_dentry);
                goto out;
        }
-       if (lower_dentry->d_inode)
+       if (d_really_is_positive(lower_dentry))
                goto interpose;
        mount_crypt_stat = &ecryptfs_superblock_to_private(
                                ecryptfs_dentry->d_sb)->mount_crypt_stat;
@@ -429,11 +429,11 @@ static struct dentry *ecryptfs_lookup(struct inode *ecryptfs_dir_inode,
                       "filename; rc = [%d]\n", __func__, rc);
                goto out;
        }
-       mutex_lock(&lower_dir_dentry->d_inode->i_mutex);
+       mutex_lock(&d_inode(lower_dir_dentry)->i_mutex);
        lower_dentry = lookup_one_len(encrypted_and_encoded_name,
                                      lower_dir_dentry,
                                      encrypted_and_encoded_name_size);
-       mutex_unlock(&lower_dir_dentry->d_inode->i_mutex);
+       mutex_unlock(&d_inode(lower_dir_dentry)->i_mutex);
        if (IS_ERR(lower_dentry)) {
                rc = PTR_ERR(lower_dentry);
                ecryptfs_printk(KERN_DEBUG, "%s: lookup_one_len() returned "
@@ -458,24 +458,24 @@ static int ecryptfs_link(struct dentry *old_dentry, struct inode *dir,
        u64 file_size_save;
        int rc;
 
-       file_size_save = i_size_read(old_dentry->d_inode);
+       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, lower_dir_dentry->d_inode,
+       rc = vfs_link(lower_old_dentry, d_inode(lower_dir_dentry),
                      lower_new_dentry, NULL);
-       if (rc || !lower_new_dentry->d_inode)
+       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, lower_dir_dentry->d_inode);
-       fsstack_copy_inode_size(dir, lower_dir_dentry->d_inode);
-       set_nlink(old_dentry->d_inode,
-                 ecryptfs_inode_to_lower(old_dentry->d_inode)->i_nlink);
-       i_size_write(new_dentry->d_inode, file_size_save);
+       fsstack_copy_attr_times(dir, d_inode(lower_dir_dentry));
+       fsstack_copy_inode_size(dir, d_inode(lower_dir_dentry));
+       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);
@@ -485,7 +485,7 @@ out_lock:
 
 static int ecryptfs_unlink(struct inode *dir, struct dentry *dentry)
 {
-       return ecryptfs_do_unlink(dir, dentry, dentry->d_inode);
+       return ecryptfs_do_unlink(dir, dentry, d_inode(dentry));
 }
 
 static int ecryptfs_symlink(struct inode *dir, struct dentry *dentry,
@@ -510,20 +510,20 @@ static int ecryptfs_symlink(struct inode *dir, struct dentry *dentry,
                                                  strlen(symname));
        if (rc)
                goto out_lock;
-       rc = vfs_symlink(lower_dir_dentry->d_inode, lower_dentry,
+       rc = vfs_symlink(d_inode(lower_dir_dentry), lower_dentry,
                         encoded_symname);
        kfree(encoded_symname);
-       if (rc || !lower_dentry->d_inode)
+       if (rc || d_really_is_negative(lower_dentry))
                goto out_lock;
        rc = ecryptfs_interpose(lower_dentry, dentry, dir->i_sb);
        if (rc)
                goto out_lock;
-       fsstack_copy_attr_times(dir, lower_dir_dentry->d_inode);
-       fsstack_copy_inode_size(dir, lower_dir_dentry->d_inode);
+       fsstack_copy_attr_times(dir, d_inode(lower_dir_dentry));
+       fsstack_copy_inode_size(dir, d_inode(lower_dir_dentry));
 out_lock:
        unlock_dir(lower_dir_dentry);
        dput(lower_dentry);
-       if (!dentry->d_inode)
+       if (d_really_is_negative(dentry))
                d_drop(dentry);
        return rc;
 }
@@ -536,18 +536,18 @@ static int ecryptfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode
 
        lower_dentry = ecryptfs_dentry_to_lower(dentry);
        lower_dir_dentry = lock_parent(lower_dentry);
-       rc = vfs_mkdir(lower_dir_dentry->d_inode, lower_dentry, mode);
-       if (rc || !lower_dentry->d_inode)
+       rc = vfs_mkdir(d_inode(lower_dir_dentry), 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, lower_dir_dentry->d_inode);
-       fsstack_copy_inode_size(dir, lower_dir_dentry->d_inode);
-       set_nlink(dir, lower_dir_dentry->d_inode->i_nlink);
+       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);
 out:
        unlock_dir(lower_dir_dentry);
-       if (!dentry->d_inode)
+       if (d_really_is_negative(dentry))
                d_drop(dentry);
        return rc;
 }
@@ -562,12 +562,12 @@ static int ecryptfs_rmdir(struct inode *dir, struct dentry *dentry)
        dget(dentry);
        lower_dir_dentry = lock_parent(lower_dentry);
        dget(lower_dentry);
-       rc = vfs_rmdir(lower_dir_dentry->d_inode, lower_dentry);
+       rc = vfs_rmdir(d_inode(lower_dir_dentry), lower_dentry);
        dput(lower_dentry);
-       if (!rc && dentry->d_inode)
-               clear_nlink(dentry->d_inode);
-       fsstack_copy_attr_times(dir, lower_dir_dentry->d_inode);
-       set_nlink(dir, lower_dir_dentry->d_inode->i_nlink);
+       if (!rc && d_really_is_positive(dentry))
+               clear_nlink(d_inode(dentry));
+       fsstack_copy_attr_times(dir, d_inode(lower_dir_dentry));
+       set_nlink(dir, d_inode(lower_dir_dentry)->i_nlink);
        unlock_dir(lower_dir_dentry);
        if (!rc)
                d_drop(dentry);
@@ -584,17 +584,17 @@ ecryptfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t dev
 
        lower_dentry = ecryptfs_dentry_to_lower(dentry);
        lower_dir_dentry = lock_parent(lower_dentry);
-       rc = vfs_mknod(lower_dir_dentry->d_inode, lower_dentry, mode, dev);
-       if (rc || !lower_dentry->d_inode)
+       rc = vfs_mknod(d_inode(lower_dir_dentry), 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, lower_dir_dentry->d_inode);
-       fsstack_copy_inode_size(dir, lower_dir_dentry->d_inode);
+       fsstack_copy_attr_times(dir, d_inode(lower_dir_dentry));
+       fsstack_copy_inode_size(dir, d_inode(lower_dir_dentry));
 out:
        unlock_dir(lower_dir_dentry);
-       if (!dentry->d_inode)
+       if (d_really_is_negative(dentry))
                d_drop(dentry);
        return rc;
 }
@@ -617,7 +617,7 @@ ecryptfs_rename(struct inode *old_dir, struct dentry *old_dentry,
        dget(lower_new_dentry);
        lower_old_dir_dentry = dget_parent(lower_old_dentry);
        lower_new_dir_dentry = dget_parent(lower_new_dentry);
-       target_inode = new_dentry->d_inode;
+       target_inode = d_inode(new_dentry);
        trap = lock_rename(lower_old_dir_dentry, lower_new_dir_dentry);
        /* source should not be ancestor of target */
        if (trap == lower_old_dentry) {
@@ -629,17 +629,17 @@ ecryptfs_rename(struct inode *old_dir, struct dentry *old_dentry,
                rc = -ENOTEMPTY;
                goto out_lock;
        }
-       rc = vfs_rename(lower_old_dir_dentry->d_inode, lower_old_dentry,
-                       lower_new_dir_dentry->d_inode, lower_new_dentry,
+       rc = vfs_rename(d_inode(lower_old_dir_dentry), lower_old_dentry,
+                       d_inode(lower_new_dir_dentry), lower_new_dentry,
                        NULL, 0);
        if (rc)
                goto out_lock;
        if (target_inode)
                fsstack_copy_attr_all(target_inode,
                                      ecryptfs_inode_to_lower(target_inode));
-       fsstack_copy_attr_all(new_dir, lower_new_dir_dentry->d_inode);
+       fsstack_copy_attr_all(new_dir, d_inode(lower_new_dir_dentry));
        if (new_dir != old_dir)
-               fsstack_copy_attr_all(old_dir, lower_old_dir_dentry->d_inode);
+               fsstack_copy_attr_all(old_dir, d_inode(lower_old_dir_dentry));
 out_lock:
        unlock_rename(lower_old_dir_dentry, lower_new_dir_dentry);
        dput(lower_new_dir_dentry);
@@ -662,7 +662,7 @@ static char *ecryptfs_readlink_lower(struct dentry *dentry, size_t *bufsiz)
                return ERR_PTR(-ENOMEM);
        old_fs = get_fs();
        set_fs(get_ds());
-       rc = lower_dentry->d_inode->i_op->readlink(lower_dentry,
+       rc = d_inode(lower_dentry)->i_op->readlink(lower_dentry,
                                                   (char __user *)lower_buf,
                                                   PATH_MAX);
        set_fs(old_fs);
@@ -681,8 +681,8 @@ static void *ecryptfs_follow_link(struct dentry *dentry, struct nameidata *nd)
        char *buf = ecryptfs_readlink_lower(dentry, &len);
        if (IS_ERR(buf))
                goto out;
-       fsstack_copy_attr_atime(dentry->d_inode,
-                               ecryptfs_dentry_to_lower(dentry)->d_inode);
+       fsstack_copy_attr_atime(d_inode(dentry),
+                               d_inode(ecryptfs_dentry_to_lower(dentry)));
        buf[len] = '\0';
 out:
        nd_set_link(nd, buf);
@@ -738,7 +738,7 @@ static int truncate_upper(struct dentry *dentry, struct iattr *ia,
                          struct iattr *lower_ia)
 {
        int rc = 0;
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct ecryptfs_crypt_stat *crypt_stat;
        loff_t i_size = i_size_read(inode);
        loff_t lower_size_before_truncate;
@@ -751,7 +751,7 @@ static int truncate_upper(struct dentry *dentry, struct iattr *ia,
        rc = ecryptfs_get_lower_file(dentry, inode);
        if (rc)
                return rc;
-       crypt_stat = &ecryptfs_inode_to_private(dentry->d_inode)->crypt_stat;
+       crypt_stat = &ecryptfs_inode_to_private(d_inode(dentry))->crypt_stat;
        /* Switch on growing or shrinking file */
        if (ia->ia_size > i_size) {
                char zero[] = { 0x00 };
@@ -858,7 +858,7 @@ int ecryptfs_truncate(struct dentry *dentry, loff_t new_length)
        struct iattr lower_ia = { .ia_valid = 0 };
        int rc;
 
-       rc = ecryptfs_inode_newsize_ok(dentry->d_inode, new_length);
+       rc = ecryptfs_inode_newsize_ok(d_inode(dentry), new_length);
        if (rc)
                return rc;
 
@@ -866,9 +866,9 @@ int ecryptfs_truncate(struct dentry *dentry, loff_t new_length)
        if (!rc && lower_ia.ia_valid & ATTR_SIZE) {
                struct dentry *lower_dentry = ecryptfs_dentry_to_lower(dentry);
 
-               mutex_lock(&lower_dentry->d_inode->i_mutex);
+               mutex_lock(&d_inode(lower_dentry)->i_mutex);
                rc = notify_change(lower_dentry, &lower_ia, NULL);
-               mutex_unlock(&lower_dentry->d_inode->i_mutex);
+               mutex_unlock(&d_inode(lower_dentry)->i_mutex);
        }
        return rc;
 }
@@ -900,10 +900,10 @@ static int ecryptfs_setattr(struct dentry *dentry, struct iattr *ia)
        struct inode *lower_inode;
        struct ecryptfs_crypt_stat *crypt_stat;
 
-       crypt_stat = &ecryptfs_inode_to_private(dentry->d_inode)->crypt_stat;
+       crypt_stat = &ecryptfs_inode_to_private(d_inode(dentry))->crypt_stat;
        if (!(crypt_stat->flags & ECRYPTFS_STRUCT_INITIALIZED))
                ecryptfs_init_crypt_stat(crypt_stat);
-       inode = dentry->d_inode;
+       inode = d_inode(dentry);
        lower_inode = ecryptfs_inode_to_lower(inode);
        lower_dentry = ecryptfs_dentry_to_lower(dentry);
        mutex_lock(&crypt_stat->cs_mutex);
@@ -967,9 +967,9 @@ static int ecryptfs_setattr(struct dentry *dentry, struct iattr *ia)
        if (lower_ia.ia_valid & (ATTR_KILL_SUID | ATTR_KILL_SGID))
                lower_ia.ia_valid &= ~ATTR_MODE;
 
-       mutex_lock(&lower_dentry->d_inode->i_mutex);
+       mutex_lock(&d_inode(lower_dentry)->i_mutex);
        rc = notify_change(lower_dentry, &lower_ia, NULL);
-       mutex_unlock(&lower_dentry->d_inode->i_mutex);
+       mutex_unlock(&d_inode(lower_dentry)->i_mutex);
 out:
        fsstack_copy_attr_all(inode, lower_inode);
        return rc;
@@ -983,7 +983,7 @@ static int ecryptfs_getattr_link(struct vfsmount *mnt, struct dentry *dentry,
 
        mount_crypt_stat = &ecryptfs_superblock_to_private(
                                                dentry->d_sb)->mount_crypt_stat;
-       generic_fillattr(dentry->d_inode, stat);
+       generic_fillattr(d_inode(dentry), stat);
        if (mount_crypt_stat->flags & ECRYPTFS_GLOBAL_ENCRYPT_FILENAMES) {
                char *target;
                size_t targetsiz;
@@ -1007,9 +1007,9 @@ static int ecryptfs_getattr(struct vfsmount *mnt, struct dentry *dentry,
 
        rc = vfs_getattr(ecryptfs_dentry_to_lower_path(dentry), &lower_stat);
        if (!rc) {
-               fsstack_copy_attr_all(dentry->d_inode,
-                                     ecryptfs_inode_to_lower(dentry->d_inode));
-               generic_fillattr(dentry->d_inode, stat);
+               fsstack_copy_attr_all(d_inode(dentry),
+                                     ecryptfs_inode_to_lower(d_inode(dentry)));
+               generic_fillattr(d_inode(dentry), stat);
                stat->blocks = lower_stat.blocks;
        }
        return rc;
@@ -1023,14 +1023,14 @@ ecryptfs_setxattr(struct dentry *dentry, const char *name, const void *value,
        struct dentry *lower_dentry;
 
        lower_dentry = ecryptfs_dentry_to_lower(dentry);
-       if (!lower_dentry->d_inode->i_op->setxattr) {
+       if (!d_inode(lower_dentry)->i_op->setxattr) {
                rc = -EOPNOTSUPP;
                goto out;
        }
 
        rc = vfs_setxattr(lower_dentry, name, value, size, flags);
-       if (!rc && dentry->d_inode)
-               fsstack_copy_attr_all(dentry->d_inode, lower_dentry->d_inode);
+       if (!rc && d_really_is_positive(dentry))
+               fsstack_copy_attr_all(d_inode(dentry), d_inode(lower_dentry));
 out:
        return rc;
 }
@@ -1041,14 +1041,14 @@ ecryptfs_getxattr_lower(struct dentry *lower_dentry, const char *name,
 {
        int rc = 0;
 
-       if (!lower_dentry->d_inode->i_op->getxattr) {
+       if (!d_inode(lower_dentry)->i_op->getxattr) {
                rc = -EOPNOTSUPP;
                goto out;
        }
-       mutex_lock(&lower_dentry->d_inode->i_mutex);
-       rc = lower_dentry->d_inode->i_op->getxattr(lower_dentry, name, value,
+       mutex_lock(&d_inode(lower_dentry)->i_mutex);
+       rc = d_inode(lower_dentry)->i_op->getxattr(lower_dentry, name, value,
                                                   size);
-       mutex_unlock(&lower_dentry->d_inode->i_mutex);
+       mutex_unlock(&d_inode(lower_dentry)->i_mutex);
 out:
        return rc;
 }
@@ -1068,13 +1068,13 @@ ecryptfs_listxattr(struct dentry *dentry, char *list, size_t size)
        struct dentry *lower_dentry;
 
        lower_dentry = ecryptfs_dentry_to_lower(dentry);
-       if (!lower_dentry->d_inode->i_op->listxattr) {
+       if (!d_inode(lower_dentry)->i_op->listxattr) {
                rc = -EOPNOTSUPP;
                goto out;
        }
-       mutex_lock(&lower_dentry->d_inode->i_mutex);
-       rc = lower_dentry->d_inode->i_op->listxattr(lower_dentry, list, size);
-       mutex_unlock(&lower_dentry->d_inode->i_mutex);
+       mutex_lock(&d_inode(lower_dentry)->i_mutex);
+       rc = d_inode(lower_dentry)->i_op->listxattr(lower_dentry, list, size);
+       mutex_unlock(&d_inode(lower_dentry)->i_mutex);
 out:
        return rc;
 }
@@ -1085,13 +1085,13 @@ static int ecryptfs_removexattr(struct dentry *dentry, const char *name)
        struct dentry *lower_dentry;
 
        lower_dentry = ecryptfs_dentry_to_lower(dentry);
-       if (!lower_dentry->d_inode->i_op->removexattr) {
+       if (!d_inode(lower_dentry)->i_op->removexattr) {
                rc = -EOPNOTSUPP;
                goto out;
        }
-       mutex_lock(&lower_dentry->d_inode->i_mutex);
-       rc = lower_dentry->d_inode->i_op->removexattr(lower_dentry, name);
-       mutex_unlock(&lower_dentry->d_inode->i_mutex);
+       mutex_lock(&d_inode(lower_dentry)->i_mutex);
+       rc = d_inode(lower_dentry)->i_op->removexattr(lower_dentry, name);
+       mutex_unlock(&d_inode(lower_dentry)->i_mutex);
 out:
        return rc;
 }