reiserfs: locking, push write lock out of xattr code

The reiserfs xattr code doesn't need the write lock and sleeps all over
the place. We can simplify the locking by releasing it and reacquiring
after the xattr call.

Signed-off-by: Jeff Mahoney <jeffm@suse.com>

1 files changed, 17 insertions, 29 deletions

diff --git a/fs/reiserfs/xattr.c b/fs/reiserfs/xattr.c
index c69cdd749f09..8a9e2dcfe004 100644
--- a/fs/reiserfs/xattr.c
+++ b/fs/reiserfs/xattr.c
@@ -81,8 +81,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 +95,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 +230,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 +274,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 +451,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 +485,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 +525,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 +534,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 +552,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 +579,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;
 }
@@ -968,7 +956,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 +984,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,