10 files changed, 83 insertions, 125 deletions

diff --git a/fs/reiserfs/bitmap.c b/fs/reiserfs/bitmap.c
index 483442e66ed..d1aca1df4f9 100644
--- a/fs/reiserfs/bitmap.c
+++ b/fs/reiserfs/bitmap.c
@@ -214,7 +214,7 @@ static int scan_bitmap_block(struct reiserfs_transaction_handle *th,
                                         }
                                         /* otherwise we clear all bit were set ... */
                                         while (--i >= *beg)
-                                                reiserfs_test_and_clear_le_bit
+                                                reiserfs_clear_le_bit
                                                     (i, bh->b_data);
                                         reiserfs_restore_prepared_buffer(s, bh);
                                         *beg = org;
@@ -1222,15 +1222,11 @@ void reiserfs_cache_bitmap_metadata(struct super_block *sb,
         info->free_count = 0;
 
         while (--cur >= (unsigned long *)bh->b_data) {
-                int i;
-
                 /* 0 and ~0 are special, we can optimize for them */
                 if (*cur == 0)
                         info->free_count += BITS_PER_LONG;
                 else if (*cur != ~0L)   /* A mix, investigate */
-                        for (i = BITS_PER_LONG - 1; i >= 0; i--)
-                                if (!reiserfs_test_le_bit(i, cur))
-                                        info->free_count++;
+                        info->free_count += BITS_PER_LONG - hweight_long(*cur);
         }
 }
 
diff --git a/fs/reiserfs/dir.c b/fs/reiserfs/dir.c
index 198dabf1b2b..133e9355dc6 100644
--- a/fs/reiserfs/dir.c
+++ b/fs/reiserfs/dir.c
@@ -14,7 +14,8 @@
 extern const struct reiserfs_key MIN_KEY;
 
 static int reiserfs_readdir(struct file *, void *, filldir_t);
-static int reiserfs_dir_fsync(struct file *filp, int datasync);
+static int reiserfs_dir_fsync(struct file *filp, loff_t start, loff_t end,
+                              int datasync);
 
 const struct file_operations reiserfs_dir_operations = {
         .llseek = generic_file_llseek,
@@ -27,13 +28,21 @@ const struct file_operations reiserfs_dir_operations = {
 #endif
 };
 
-static int reiserfs_dir_fsync(struct file *filp, int datasync)
+static int reiserfs_dir_fsync(struct file *filp, loff_t start, loff_t end,
+                              int datasync)
 {
         struct inode *inode = filp->f_mapping->host;
         int err;
+
+        err = filemap_write_and_wait_range(inode->i_mapping, start, end);
+        if (err)
+                return err;
+
+        mutex_lock(&inode->i_mutex);
         reiserfs_write_lock(inode->i_sb);
         err = reiserfs_commit_for_inode(inode);
         reiserfs_write_unlock(inode->i_sb);
+        mutex_unlock(&inode->i_mutex);
         if (err < 0)
                 return err;
         return 0;
diff --git a/fs/reiserfs/file.c b/fs/reiserfs/file.c
index 91f080cc76c..ace635053a3 100644
--- a/fs/reiserfs/file.c
+++ b/fs/reiserfs/file.c
@@ -140,12 +140,18 @@ static void reiserfs_vfs_truncate_file(struct inode *inode)
  * be removed...
  */
 
-static int reiserfs_sync_file(struct file *filp, int datasync)
+static int reiserfs_sync_file(struct file *filp, loff_t start, loff_t end,
+                              int datasync)
 {
         struct inode *inode = filp->f_mapping->host;
         int err;
         int barrier_done;
 
+        err = filemap_write_and_wait_range(inode->i_mapping, start, end);
+        if (err)
+                return err;
+
+        mutex_lock(&inode->i_mutex);
         BUG_ON(!S_ISREG(inode->i_mode));
         err = sync_mapping_buffers(inode->i_mapping);
         reiserfs_write_lock(inode->i_sb);
@@ -153,6 +159,7 @@ static int reiserfs_sync_file(struct file *filp, int datasync)
         reiserfs_write_unlock(inode->i_sb);
         if (barrier_done != 1 && reiserfs_barrier_flush(inode->i_sb))
                 blkdev_issue_flush(inode->i_sb->s_bdev, GFP_KERNEL, NULL);
+        mutex_unlock(&inode->i_mutex);
         if (barrier_done < 0)
                 return barrier_done;
         return (err < 0) ? -EIO : 0;
@@ -312,4 +319,5 @@ const struct inode_operations reiserfs_file_inode_operations = {
         .listxattr = reiserfs_listxattr,
         .removexattr = reiserfs_removexattr,
         .permission = reiserfs_permission,
+        .get_acl = reiserfs_get_acl,
 };
diff --git a/fs/reiserfs/inode.c b/fs/reiserfs/inode.c
index 4fd5bb33dbb..9b0d4b78b4f 100644
--- a/fs/reiserfs/inode.c
+++ b/fs/reiserfs/inode.c
@@ -1475,6 +1475,11 @@ void reiserfs_read_locked_inode(struct inode *inode,
 
         reiserfs_check_path(&path_to_sd);       /* init inode should be relsing */
 
+        /*
+         * Stat data v1 doesn't support ACLs.
+         */
+        if (get_inode_sd_version(inode) == STAT_DATA_V1)
+                cache_no_acl(inode);
 }
 
 /**
@@ -3068,9 +3073,8 @@ static ssize_t reiserfs_direct_IO(int rw, struct kiocb *iocb,
         struct inode *inode = file->f_mapping->host;
         ssize_t ret;
 
-        ret = blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev, iov,
-                                  offset, nr_segs,
-                                  reiserfs_get_blocks_direct_io, NULL);
+        ret = blockdev_direct_IO(rw, iocb, inode, iov, offset, nr_segs,
+                                  reiserfs_get_blocks_direct_io);
 
         /*
          * In case of error extending write may have instantiated a few
@@ -3114,6 +3118,9 @@ int reiserfs_setattr(struct dentry *dentry, struct iattr *attr)
                         error = -EFBIG;
                         goto out;
                 }
+
+                inode_dio_wait(inode);
+
                 /* fill in hole pointers in the expanding truncate case. */
                 if (attr->ia_size > inode->i_size) {
                         error = generic_cont_expand_simple(inode, attr->ia_size);
diff --git a/fs/reiserfs/journal.c b/fs/reiserfs/journal.c
index c5e82ece7c6..a159ba5a35e 100644
--- a/fs/reiserfs/journal.c
+++ b/fs/reiserfs/journal.c
@@ -678,23 +678,19 @@ struct buffer_chunk {
 static void write_chunk(struct buffer_chunk *chunk)
 {
         int i;
-        get_fs_excl();
         for (i = 0; i < chunk->nr; i++) {
                 submit_logged_buffer(chunk->bh[i]);
         }
         chunk->nr = 0;
-        put_fs_excl();
 }
 
 static void write_ordered_chunk(struct buffer_chunk *chunk)
 {
         int i;
-        get_fs_excl();
         for (i = 0; i < chunk->nr; i++) {
                 submit_ordered_buffer(chunk->bh[i]);
         }
         chunk->nr = 0;
-        put_fs_excl();
 }
 
 static int add_to_chunk(struct buffer_chunk *chunk, struct buffer_head *bh,
@@ -986,8 +982,6 @@ static int flush_commit_list(struct super_block *s,
                 return 0;
         }
 
-        get_fs_excl();
-
         /* before we can put our commit blocks on disk, we have to make sure everyone older than
          ** us is on disk too
          */
@@ -1145,7 +1139,6 @@ static int flush_commit_list(struct super_block *s,
         if (retval)
                 reiserfs_abort(s, retval, "Journal write error in %s",
                                __func__);
-        put_fs_excl();
         return retval;
 }
 
@@ -1374,8 +1367,6 @@ static int flush_journal_list(struct super_block *s,
                 return 0;
         }
 
-        get_fs_excl();
-
         /* if all the work is already done, get out of here */
         if (atomic_read(&(jl->j_nonzerolen)) <= 0 &&
             atomic_read(&(jl->j_commit_left)) <= 0) {
@@ -1597,7 +1588,6 @@ static int flush_journal_list(struct super_block *s,
         put_journal_list(s, jl);
         if (flushall)
                 mutex_unlock(&journal->j_flush_mutex);
-        put_fs_excl();
         return err;
 }
 
@@ -3108,7 +3098,6 @@ static int do_journal_begin_r(struct reiserfs_transaction_handle *th,
         th->t_trans_id = journal->j_trans_id;
         unlock_journal(sb);
         INIT_LIST_HEAD(&th->t_list);
-        get_fs_excl();
         return 0;
 
       out_fail:
@@ -3964,7 +3953,6 @@ static int do_journal_end(struct reiserfs_transaction_handle *th,
         flush = flags & FLUSH_ALL;
         wait_on_commit = flags & WAIT;
 
-        put_fs_excl();
         current->journal_info = th->t_handle_save;
         reiserfs_check_lock_depth(sb, "journal end");
         if (journal->j_len == 0) {
@@ -4316,4 +4304,3 @@ void reiserfs_abort_journal(struct super_block *sb, int errno)
         dump_stack();
 #endif
 }
-
diff --git a/fs/reiserfs/namei.c b/fs/reiserfs/namei.c
index 118662690cd..ef392324bbf 100644
--- a/fs/reiserfs/namei.c
+++ b/fs/reiserfs/namei.c
@@ -1529,6 +1529,7 @@ const struct inode_operations reiserfs_dir_inode_operations = {
         .listxattr = reiserfs_listxattr,
         .removexattr = reiserfs_removexattr,
         .permission = reiserfs_permission,
+        .get_acl = reiserfs_get_acl,
 };
 
 /*
@@ -1545,6 +1546,7 @@ const struct inode_operations reiserfs_symlink_inode_operations = {
         .listxattr = reiserfs_listxattr,
         .removexattr = reiserfs_removexattr,
         .permission = reiserfs_permission,
+        .get_acl = reiserfs_get_acl,
 
 };
 
@@ -1558,5 +1560,5 @@ const struct inode_operations reiserfs_special_inode_operations = {
         .listxattr = reiserfs_listxattr,
         .removexattr = reiserfs_removexattr,
         .permission = reiserfs_permission,
-
+        .get_acl = reiserfs_get_acl,
 };
diff --git a/fs/reiserfs/resize.c b/fs/reiserfs/resize.c
index b3a94d20f0f..b6b9b1fe33b 100644
--- a/fs/reiserfs/resize.c
+++ b/fs/reiserfs/resize.c
@@ -136,7 +136,7 @@ int reiserfs_resize(struct super_block *s, unsigned long block_count_new)
                                 return -EIO;
                         }
                         memset(bh->b_data, 0, sb_blocksize(sb));
-                        reiserfs_test_and_set_le_bit(0, bh->b_data);
+                        reiserfs_set_le_bit(0, bh->b_data);
                         reiserfs_cache_bitmap_metadata(s, bh, bitmap + i);
 
                         set_buffer_uptodate(bh);
@@ -172,7 +172,7 @@ int reiserfs_resize(struct super_block *s, unsigned long block_count_new)
 
         reiserfs_prepare_for_journal(s, bh, 1);
         for (i = block_r; i < s->s_blocksize * 8; i++)
-                reiserfs_test_and_clear_le_bit(i, bh->b_data);
+                reiserfs_clear_le_bit(i, bh->b_data);
         info->free_count += s->s_blocksize * 8 - block_r;
 
         journal_mark_dirty(&th, s, bh);
@@ -190,7 +190,7 @@ int reiserfs_resize(struct super_block *s, unsigned long block_count_new)
 
         reiserfs_prepare_for_journal(s, bh, 1);
         for (i = block_r_new; i < s->s_blocksize * 8; i++)
-                reiserfs_test_and_set_le_bit(i, bh->b_data);
+                reiserfs_set_le_bit(i, bh->b_data);
         journal_mark_dirty(&th, s, bh);
         brelse(bh);
 
diff --git a/fs/reiserfs/super.c b/fs/reiserfs/super.c
index aa91089162c..5e3527be114 100644
--- a/fs/reiserfs/super.c
+++ b/fs/reiserfs/super.c
@@ -453,16 +453,20 @@ int remove_save_link(struct inode *inode, int truncate)
 static void reiserfs_kill_sb(struct super_block *s)
 {
         if (REISERFS_SB(s)) {
-                if (REISERFS_SB(s)->xattr_root) {
-                        d_invalidate(REISERFS_SB(s)->xattr_root);
-                        dput(REISERFS_SB(s)->xattr_root);
-                        REISERFS_SB(s)->xattr_root = NULL;
-                }
-                if (REISERFS_SB(s)->priv_root) {
-                        d_invalidate(REISERFS_SB(s)->priv_root);
-                        dput(REISERFS_SB(s)->priv_root);
-                        REISERFS_SB(s)->priv_root = NULL;
-                }
+                /*
+                 * Force any pending inode evictions to occur now. Any
+                 * inodes to be removed that have extended attributes
+                 * associated with them need to clean them up before
+                 * we can release the extended attribute root dentries.
+                 * shrink_dcache_for_umount will BUG if we don't release
+                 * those before it's called so ->put_super is too late.
+                 */
+                shrink_dcache_sb(s);
+
+                dput(REISERFS_SB(s)->xattr_root);
+                REISERFS_SB(s)->xattr_root = NULL;
+                dput(REISERFS_SB(s)->priv_root);
+                REISERFS_SB(s)->priv_root = NULL;
         }
 
         kill_block_super(s);
@@ -1164,7 +1168,8 @@ static void handle_quota_files(struct super_block *s, char **qf_names,
                         kfree(REISERFS_SB(s)->s_qf_names[i]);
                 REISERFS_SB(s)->s_qf_names[i] = qf_names[i];
         }
-        REISERFS_SB(s)->s_jquota_fmt = *qfmt;
+        if (*qfmt)
+                REISERFS_SB(s)->s_jquota_fmt = *qfmt;
 }
 #endif
 
@@ -1643,6 +1648,7 @@ static int reiserfs_fill_super(struct super_block *s, void *data, int silent)
         /* Set default values for options: non-aggressive tails, RO on errors */
         REISERFS_SB(s)->s_mount_opt |= (1 << REISERFS_SMALLTAIL);
         REISERFS_SB(s)->s_mount_opt |= (1 << REISERFS_ERROR_RO);
+        REISERFS_SB(s)->s_mount_opt |= (1 << REISERFS_BARRIER_FLUSH);
         /* no preallocation minimum, be smart in
            reiserfs_file_write instead */
         REISERFS_SB(s)->s_alloc_options.preallocmin = 0;
diff --git a/fs/reiserfs/xattr.c b/fs/reiserfs/xattr.c
index d7808969096..6bc346c160e 100644
--- a/fs/reiserfs/xattr.c
+++ b/fs/reiserfs/xattr.c
@@ -555,11 +555,10 @@ reiserfs_xattr_set_handle(struct reiserfs_transaction_handle *th,
 
                 reiserfs_write_unlock(inode->i_sb);
                 mutex_lock_nested(&dentry->d_inode->i_mutex, I_MUTEX_XATTR);
-                down_write(&dentry->d_inode->i_alloc_sem);
+                inode_dio_wait(dentry->d_inode);
                 reiserfs_write_lock(inode->i_sb);
 
                 err = reiserfs_setattr(dentry, &newattrs);
-                up_write(&dentry->d_inode->i_alloc_sem);
                 mutex_unlock(&dentry->d_inode->i_mutex);
         } else
                 update_ctime(inode);
@@ -868,27 +867,6 @@ out:
         return err;
 }
 
-static int reiserfs_check_acl(struct inode *inode, int mask, unsigned int flags)
-{
-        struct posix_acl *acl;
-        int error = -EAGAIN; /* do regular unix permission checks by default */
-
-        if (flags & IPERM_FLAG_RCU)
-                return -ECHILD;
-
-        acl = reiserfs_get_acl(inode, ACL_TYPE_ACCESS);
-
-        if (acl) {
-                if (!IS_ERR(acl)) {
-                        error = posix_acl_permission(inode, acl, mask);
-                        posix_acl_release(acl);
-                } else if (PTR_ERR(acl) != -ENODATA)
-                        error = PTR_ERR(acl);
-        }
-
-        return error;
-}
-
 static int create_privroot(struct dentry *dentry)
 {
         int err;
@@ -952,7 +930,7 @@ static int xattr_mount_check(struct super_block *s)
         return 0;
 }
 
-int reiserfs_permission(struct inode *inode, int mask, unsigned int flags)
+int reiserfs_permission(struct inode *inode, int mask)
 {
         /*
          * We don't do permission checks on the internal objects.
@@ -961,15 +939,7 @@ int reiserfs_permission(struct inode *inode, int mask, unsigned int flags)
         if (IS_PRIVATE(inode))
                 return 0;
 
-#ifdef CONFIG_REISERFS_FS_XATTR
-        /*
-         * Stat data v1 doesn't support ACLs.
-         */
-        if (get_inode_sd_version(inode) != STAT_DATA_V1)
-                return generic_permission(inode, mask, flags,
-                                        reiserfs_check_acl);
-#endif
-        return generic_permission(inode, mask, flags, NULL);
+        return generic_permission(inode, mask);
 }
 
 static int xattr_hide_revalidate(struct dentry *dentry, struct nameidata *nd)
diff --git a/fs/reiserfs/xattr_acl.c b/fs/reiserfs/xattr_acl.c
index 3dc38f1206f..6da0396e505 100644
--- a/fs/reiserfs/xattr_acl.c
+++ b/fs/reiserfs/xattr_acl.c
@@ -272,12 +272,10 @@ reiserfs_set_acl(struct reiserfs_transaction_handle *th, struct inode *inode,
         case ACL_TYPE_ACCESS:
                 name = POSIX_ACL_XATTR_ACCESS;
                 if (acl) {
-                        mode_t mode = inode->i_mode;
-                        error = posix_acl_equiv_mode(acl, &mode);
+                        error = posix_acl_equiv_mode(acl, &inode->i_mode);
                         if (error < 0)
                                 return error;
                         else {
-                                inode->i_mode = mode;
                                 if (error == 0)
                                         acl = NULL;
                         }
@@ -354,10 +352,6 @@ reiserfs_inherit_default_acl(struct reiserfs_transaction_handle *th,
                 return PTR_ERR(acl);
 
         if (acl) {
-                struct posix_acl *acl_copy;
-                mode_t mode = inode->i_mode;
-                int need_acl;
-
                 /* Copy the default ACL to the default ACL of a new directory */
                 if (S_ISDIR(inode->i_mode)) {
                         err = reiserfs_set_acl(th, inode, ACL_TYPE_DEFAULT,
@@ -368,29 +362,13 @@ reiserfs_inherit_default_acl(struct reiserfs_transaction_handle *th,
 
                 /* Now we reconcile the new ACL and the mode,
                    potentially modifying both */
-                acl_copy = posix_acl_clone(acl, GFP_NOFS);
-                if (!acl_copy) {
-                        err = -ENOMEM;
-                        goto cleanup;
-                }
-
-                need_acl = posix_acl_create_masq(acl_copy, &mode);
-                if (need_acl >= 0) {
-                        if (mode != inode->i_mode) {
-                                inode->i_mode = mode;
-                        }
+                err = posix_acl_create(&acl, GFP_NOFS, &inode->i_mode);
+                if (err < 0)
+                        return err;
 
-                        /* If we need an ACL.. */
-                        if (need_acl > 0) {
-                                err = reiserfs_set_acl(th, inode,
-                                                       ACL_TYPE_ACCESS,
-                                                       acl_copy);
-                                if (err)
-                                        goto cleanup_copy;
-                        }
-                }
-              cleanup_copy:
-                posix_acl_release(acl_copy);
+                /* If we need an ACL.. */
+                if (err > 0)
+                        err = reiserfs_set_acl(th, inode, ACL_TYPE_ACCESS, acl);
               cleanup:
                 posix_acl_release(acl);
         } else {
@@ -445,7 +423,10 @@ int reiserfs_cache_default_acl(struct inode *inode)
 
 int reiserfs_acl_chmod(struct inode *inode)
 {
-        struct posix_acl *acl, *clone;
+        struct reiserfs_transaction_handle th;
+        struct posix_acl *acl;
+        size_t size;
+        int depth;
         int error;
 
         if (S_ISLNK(inode->i_mode))
@@ -463,30 +444,22 @@ int reiserfs_acl_chmod(struct inode *inode)
                 return 0;
         if (IS_ERR(acl))
                 return PTR_ERR(acl);
-        clone = posix_acl_clone(acl, GFP_NOFS);
-        posix_acl_release(acl);
-        if (!clone)
-                return -ENOMEM;
-        error = posix_acl_chmod_masq(clone, inode->i_mode);
+        error = posix_acl_chmod(&acl, GFP_NOFS, inode->i_mode);
+        if (error)
+                return error;
+
+        size = reiserfs_xattr_nblocks(inode, reiserfs_acl_size(acl->a_count));
+        depth = reiserfs_write_lock_once(inode->i_sb);
+        error = journal_begin(&th, inode->i_sb, size * 2);
         if (!error) {
-                struct reiserfs_transaction_handle th;
-                size_t size = reiserfs_xattr_nblocks(inode,
-                                             reiserfs_acl_size(clone->a_count));
-                int depth;
-
-                depth = reiserfs_write_lock_once(inode->i_sb);
-                error = journal_begin(&th, inode->i_sb, size * 2);
-                if (!error) {
-                        int error2;
-                        error = reiserfs_set_acl(&th, inode, ACL_TYPE_ACCESS,
-                                                 clone);
-                        error2 = journal_end(&th, inode->i_sb, size * 2);
-                        if (error2)
-                                error = error2;
-                }
-                reiserfs_write_unlock_once(inode->i_sb, depth);
+                int error2;
+                error = reiserfs_set_acl(&th, inode, ACL_TYPE_ACCESS, acl);
+                error2 = journal_end(&th, inode->i_sb, size * 2);
+                if (error2)
+                        error = error2;
         }
-        posix_acl_release(clone);
+        reiserfs_write_unlock_once(inode->i_sb, depth);
+        posix_acl_release(acl);
         return error;
 }