Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs

[~andy/linux] / fs / reiserfs / xattr.c

diff --git a/fs/reiserfs/xattr.c b/fs/reiserfs/xattr.c
index c69cdd749f09b98b702c103062262c38b92606e1..5cdfbd638b5c929382d844d358105619301eed48 100644 (file)
--- a/fs/reiserfs/xattr.c
+++ b/fs/reiserfs/xattr.c
@@ -50,6 +50,7 @@
 #include <linux/stat.h>
 #include <linux/quotaops.h>
 #include <linux/security.h>
+#include <linux/posix_acl_xattr.h>
 
 #define PRIVROOT_NAME ".reiserfs_priv"
 #define XAROOT_NAME   "xattrs"
@@ -81,8 +82,7 @@ static int xattr_unlink(struct inode *dir, struct dentry *dentry)
        int error;
        BUG_ON(!mutex_is_locked(&dir->i_mutex));
 
-       reiserfs_mutex_lock_nested_safe(&dentry->d_inode->i_mutex,
-                                       I_MUTEX_CHILD, dir->i_sb);
+       mutex_lock_nested(&dentry->d_inode->i_mutex, I_MUTEX_CHILD);
        error = dir->i_op->unlink(dir, dentry);
        mutex_unlock(&dentry->d_inode->i_mutex);
 
@@ -96,8 +96,7 @@ static int xattr_rmdir(struct inode *dir, struct dentry *dentry)
        int error;
        BUG_ON(!mutex_is_locked(&dir->i_mutex));
 
-       reiserfs_mutex_lock_nested_safe(&dentry->d_inode->i_mutex,
-                                       I_MUTEX_CHILD, dir->i_sb);
+       mutex_lock_nested(&dentry->d_inode->i_mutex, I_MUTEX_CHILD);
        error = dir->i_op->rmdir(dir, dentry);
        if (!error)
                dentry->d_inode->i_flags |= S_DEAD;
@@ -232,22 +231,17 @@ static int reiserfs_for_each_xattr(struct inode *inode,
        if (IS_PRIVATE(inode) || get_inode_sd_version(inode) == STAT_DATA_V1)
                return 0;
 
-       reiserfs_write_unlock(inode->i_sb);
        dir = open_xa_dir(inode, XATTR_REPLACE);
        if (IS_ERR(dir)) {
                err = PTR_ERR(dir);
-               reiserfs_write_lock(inode->i_sb);
                goto out;
        } else if (!dir->d_inode) {
                err = 0;
-               reiserfs_write_lock(inode->i_sb);
                goto out_dir;
        }
 
        mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_XATTR);
 
-       reiserfs_write_lock(inode->i_sb);
-
        buf.xadir = dir;
        while (1) {
                err = reiserfs_readdir_inode(dir->d_inode, &buf.ctx);
@@ -281,14 +275,17 @@ static int reiserfs_for_each_xattr(struct inode *inode,
                int blocks = JOURNAL_PER_BALANCE_CNT * 2 + 2 +
                             4 * REISERFS_QUOTA_TRANS_BLOCKS(inode->i_sb);
                struct reiserfs_transaction_handle th;
+               reiserfs_write_lock(inode->i_sb);
                err = journal_begin(&th, inode->i_sb, blocks);
+               reiserfs_write_unlock(inode->i_sb);
                if (!err) {
                        int jerror;
-                       reiserfs_mutex_lock_nested_safe(
-                                         &dir->d_parent->d_inode->i_mutex,
-                                         I_MUTEX_XATTR, inode->i_sb);
+                       mutex_lock_nested(&dir->d_parent->d_inode->i_mutex,
+                                         I_MUTEX_XATTR);
                        err = action(dir, data);
+                       reiserfs_write_lock(inode->i_sb);
                        jerror = journal_end(&th, inode->i_sb, blocks);
+                       reiserfs_write_unlock(inode->i_sb);
                        mutex_unlock(&dir->d_parent->d_inode->i_mutex);
                        err = jerror ?: err;
                }
@@ -455,9 +452,7 @@ static int lookup_and_delete_xattr(struct inode *inode, const char *name)
        }
 
        if (dentry->d_inode) {
-               reiserfs_write_lock(inode->i_sb);
                err = xattr_unlink(xadir->d_inode, dentry);
-               reiserfs_write_unlock(inode->i_sb);
                update_ctime(inode);
        }
 
@@ -491,24 +486,17 @@ reiserfs_xattr_set_handle(struct reiserfs_transaction_handle *th,
        if (get_inode_sd_version(inode) == STAT_DATA_V1)
                return -EOPNOTSUPP;
 
-       reiserfs_write_unlock(inode->i_sb);
-
        if (!buffer) {
                err = lookup_and_delete_xattr(inode, name);
-               reiserfs_write_lock(inode->i_sb);
                return err;
        }
 
        dentry = xattr_lookup(inode, name, flags);
-       if (IS_ERR(dentry)) {
-               reiserfs_write_lock(inode->i_sb);
+       if (IS_ERR(dentry))
                return PTR_ERR(dentry);
-       }
 
        down_write(&REISERFS_I(inode)->i_xattr_sem);
 
-       reiserfs_write_lock(inode->i_sb);
-
        xahash = xattr_hash(buffer, buffer_size);
        while (buffer_pos < buffer_size || buffer_pos == 0) {
                size_t chunk;
@@ -538,6 +526,7 @@ reiserfs_xattr_set_handle(struct reiserfs_transaction_handle *th,
                        rxh->h_hash = cpu_to_le32(xahash);
                }
 
+               reiserfs_write_lock(inode->i_sb);
                err = __reiserfs_write_begin(page, page_offset, chunk + skip);
                if (!err) {
                        if (buffer)
@@ -546,6 +535,7 @@ reiserfs_xattr_set_handle(struct reiserfs_transaction_handle *th,
                                                    page_offset + chunk +
                                                    skip);
                }
+               reiserfs_write_unlock(inode->i_sb);
                unlock_page(page);
                reiserfs_put_page(page);
                buffer_pos += chunk;
@@ -563,10 +553,8 @@ reiserfs_xattr_set_handle(struct reiserfs_transaction_handle *th,
                        .ia_valid = ATTR_SIZE | ATTR_CTIME,
                };
 
-               reiserfs_write_unlock(inode->i_sb);
                mutex_lock_nested(&dentry->d_inode->i_mutex, I_MUTEX_XATTR);
                inode_dio_wait(dentry->d_inode);
-               reiserfs_write_lock(inode->i_sb);
 
                err = reiserfs_setattr(dentry, &newattrs);
                mutex_unlock(&dentry->d_inode->i_mutex);
@@ -592,18 +580,19 @@ int reiserfs_xattr_set(struct inode *inode, const char *name,
 
        reiserfs_write_lock(inode->i_sb);
        error = journal_begin(&th, inode->i_sb, jbegin_count);
+       reiserfs_write_unlock(inode->i_sb);
        if (error) {
-               reiserfs_write_unlock(inode->i_sb);
                return error;
        }
 
        error = reiserfs_xattr_set_handle(&th, inode, name,
                                          buffer, buffer_size, flags);
 
+       reiserfs_write_lock(inode->i_sb);
        error2 = journal_end(&th, inode->i_sb, jbegin_count);
+       reiserfs_write_unlock(inode->i_sb);
        if (error == 0)
                error = error2;
-       reiserfs_write_unlock(inode->i_sb);
 
        return error;
 }
@@ -916,8 +905,8 @@ static const struct xattr_handler *reiserfs_xattr_handlers[] = {
        &reiserfs_xattr_security_handler,
 #endif
 #ifdef CONFIG_REISERFS_FS_POSIX_ACL
-       &reiserfs_posix_acl_access_handler,
-       &reiserfs_posix_acl_default_handler,
+       &posix_acl_access_xattr_handler,
+       &posix_acl_default_xattr_handler,
 #endif
        NULL
 };
@@ -968,7 +957,7 @@ int reiserfs_lookup_privroot(struct super_block *s)
        int err = 0;
 
        /* If we don't have the privroot located yet - go find it */
-       reiserfs_mutex_lock_safe(&s->s_root->d_inode->i_mutex, s);
+       mutex_lock(&s->s_root->d_inode->i_mutex);
        dentry = lookup_one_len(PRIVROOT_NAME, s->s_root,
                                strlen(PRIVROOT_NAME));
        if (!IS_ERR(dentry)) {
@@ -996,14 +985,14 @@ int reiserfs_xattr_init(struct super_block *s, int mount_flags)
                goto error;
 
        if (!privroot->d_inode && !(mount_flags & MS_RDONLY)) {
-               reiserfs_mutex_lock_safe(&s->s_root->d_inode->i_mutex, s);
+               mutex_lock(&s->s_root->d_inode->i_mutex);
                err = create_privroot(REISERFS_SB(s)->priv_root);
                mutex_unlock(&s->s_root->d_inode->i_mutex);
        }
 
        if (privroot->d_inode) {
                s->s_xattr = reiserfs_xattr_handlers;
-               reiserfs_mutex_lock_safe(&privroot->d_inode->i_mutex, s);
+               mutex_lock(&privroot->d_inode->i_mutex);
                if (!REISERFS_SB(s)->xattr_root) {
                        struct dentry *dentry;
                        dentry = lookup_one_len(XAROOT_NAME, privroot,