7 files changed, 61 insertions, 85 deletions

diff --git a/fs/ext3/acl.c b/fs/ext3/acl.c
index 9d021c0d472a..6c29bf0df04a 100644
--- a/fs/ext3/acl.c
+++ b/fs/ext3/acl.c
@@ -131,7 +131,7 @@ fail:
  *
  * inode->i_mutex: don't care
  */
-static struct posix_acl *
+struct posix_acl *
 ext3_get_acl(struct inode *inode, int type)
 {
         int name_index;
@@ -239,29 +239,6 @@ ext3_set_acl(handle_t *handle, struct inode *inode, int type,
         return error;
 }
 
-int
-ext3_check_acl(struct inode *inode, int mask, unsigned int flags)
-{
-        struct posix_acl *acl;
-
-        if (flags & IPERM_FLAG_RCU) {
-                if (!negative_cached_acl(inode, ACL_TYPE_ACCESS))
-                        return -ECHILD;
-                return -EAGAIN;
-        }
-
-        acl = ext3_get_acl(inode, ACL_TYPE_ACCESS);
-        if (IS_ERR(acl))
-                return PTR_ERR(acl);
-        if (acl) {
-                int error = posix_acl_permission(inode, acl, mask);
-                posix_acl_release(acl);
-                return error;
-        }
-
-        return -EAGAIN;
-}
-
 /*
  * Initialize the ACLs of a new inode. Called from ext3_new_inode.
  *
@@ -284,8 +261,7 @@ ext3_init_acl(handle_t *handle, struct inode *inode, struct inode *dir)
                         inode->i_mode &= ~current_umask();
         }
         if (test_opt(inode->i_sb, POSIX_ACL) && acl) {
-                struct posix_acl *clone;
-                mode_t mode;
+                mode_t mode = inode->i_mode;
 
                 if (S_ISDIR(inode->i_mode)) {
                         error = ext3_set_acl(handle, inode,
@@ -293,22 +269,15 @@ ext3_init_acl(handle_t *handle, struct inode *inode, struct inode *dir)
                         if (error)
                                 goto cleanup;
                 }
-                clone = posix_acl_clone(acl, GFP_NOFS);
-                error = -ENOMEM;
-                if (!clone)
-                        goto cleanup;
-
-                mode = inode->i_mode;
-                error = posix_acl_create_masq(clone, &mode);
-                if (error >= 0) {
-                        inode->i_mode = mode;
-                        if (error > 0) {
-                                /* This is an extended ACL */
-                                error = ext3_set_acl(handle, inode,
-                                                     ACL_TYPE_ACCESS, clone);
-                        }
+                error = posix_acl_create(&acl, GFP_NOFS, &mode);
+                if (error < 0)
+                        return error;
+
+                inode->i_mode = mode;
+                if (error > 0) {
+                        /* This is an extended ACL */
+                        error = ext3_set_acl(handle, inode, ACL_TYPE_ACCESS, acl);
                 }
-                posix_acl_release(clone);
         }
 cleanup:
         posix_acl_release(acl);
@@ -332,7 +301,9 @@ cleanup:
 int
 ext3_acl_chmod(struct inode *inode)
 {
-        struct posix_acl *acl, *clone;
+        struct posix_acl *acl;
+        handle_t *handle;
+        int retries = 0;
         int error;
 
         if (S_ISLNK(inode->i_mode))
@@ -342,31 +313,24 @@ ext3_acl_chmod(struct inode *inode)
         acl = ext3_get_acl(inode, ACL_TYPE_ACCESS);
         if (IS_ERR(acl) || !acl)
                 return PTR_ERR(acl);
-        clone = posix_acl_clone(acl, GFP_KERNEL);
-        posix_acl_release(acl);
-        if (!clone)
-                return -ENOMEM;
-        error = posix_acl_chmod_masq(clone, inode->i_mode);
-        if (!error) {
-                handle_t *handle;
-                int retries = 0;
-
-        retry:
-                handle = ext3_journal_start(inode,
-                                EXT3_DATA_TRANS_BLOCKS(inode->i_sb));
-                if (IS_ERR(handle)) {
-                        error = PTR_ERR(handle);
-                        ext3_std_error(inode->i_sb, error);
-                        goto out;
-                }
-                error = ext3_set_acl(handle, inode, ACL_TYPE_ACCESS, clone);
-                ext3_journal_stop(handle);
-                if (error == -ENOSPC &&
-                    ext3_should_retry_alloc(inode->i_sb, &retries))
-                        goto retry;
+        error = posix_acl_chmod(&acl, GFP_KERNEL, inode->i_mode);
+        if (error)
+                return error;
+retry:
+        handle = ext3_journal_start(inode,
+                        EXT3_DATA_TRANS_BLOCKS(inode->i_sb));
+        if (IS_ERR(handle)) {
+                error = PTR_ERR(handle);
+                ext3_std_error(inode->i_sb, error);
+                goto out;
         }
+        error = ext3_set_acl(handle, inode, ACL_TYPE_ACCESS, acl);
+        ext3_journal_stop(handle);
+        if (error == -ENOSPC &&
+            ext3_should_retry_alloc(inode->i_sb, &retries))
+                goto retry;
 out:
-        posix_acl_release(clone);
+        posix_acl_release(acl);
         return error;
 }
 
diff --git a/fs/ext3/acl.h b/fs/ext3/acl.h
index 5faf8048e906..dbc921e458c5 100644
--- a/fs/ext3/acl.h
+++ b/fs/ext3/acl.h
@@ -54,13 +54,13 @@ static inline int ext3_acl_count(size_t size)
 #ifdef CONFIG_EXT3_FS_POSIX_ACL
 
 /* acl.c */
-extern int ext3_check_acl (struct inode *, int, unsigned int);
+extern struct posix_acl *ext3_get_acl(struct inode *inode, int type);
 extern int ext3_acl_chmod (struct inode *);
 extern int ext3_init_acl (handle_t *, struct inode *, struct inode *);
 
 #else  /* CONFIG_EXT3_FS_POSIX_ACL */
 #include <linux/sched.h>
-#define ext3_check_acl NULL
+#define ext3_get_acl NULL
 
 static inline int
 ext3_acl_chmod(struct inode *inode)
diff --git a/fs/ext3/file.c b/fs/ext3/file.c
index 86c8ab343f6f..724df69847dc 100644
--- a/fs/ext3/file.c
+++ b/fs/ext3/file.c
@@ -78,7 +78,7 @@ const struct inode_operations ext3_file_inode_operations = {
         .listxattr      = ext3_listxattr,
         .removexattr    = generic_removexattr,
 #endif
-        .check_acl      = ext3_check_acl,
+        .get_acl        = ext3_get_acl,
         .fiemap         = ext3_fiemap,
 };
 
diff --git a/fs/ext3/fsync.c b/fs/ext3/fsync.c
index 06a4394d2bc3..d494c554c6e6 100644
--- a/fs/ext3/fsync.c
+++ b/fs/ext3/fsync.c
@@ -44,7 +44,7 @@
  * inode to disk.
  */
 
-int ext3_sync_file(struct file *file, int datasync)
+int ext3_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
 {
         struct inode *inode = file->f_mapping->host;
         struct ext3_inode_info *ei = EXT3_I(inode);
@@ -52,13 +52,23 @@ int ext3_sync_file(struct file *file, int datasync)
         int ret, needs_barrier = 0;
         tid_t commit_tid;
 
-        J_ASSERT(ext3_journal_current_handle() == NULL);
-
         trace_ext3_sync_file_enter(file, datasync);
 
         if (inode->i_sb->s_flags & MS_RDONLY)
                 return 0;
 
+        ret = filemap_write_and_wait_range(inode->i_mapping, start, end);
+        if (ret)
+                goto out;
+
+        /*
+         * Taking the mutex here just to keep consistent with how fsync was
+         * called previously, however it looks like we don't need to take
+         * i_mutex at all.
+         */
+        mutex_lock(&inode->i_mutex);
+
+        J_ASSERT(ext3_journal_current_handle() == NULL);
 
         /*
          * data=writeback,ordered:
@@ -75,6 +85,7 @@ int ext3_sync_file(struct file *file, int datasync)
          *  safe in-journal, which is all fsync() needs to ensure.
          */
         if (ext3_should_journal_data(inode)) {
+                mutex_unlock(&inode->i_mutex);
                 ret = ext3_force_commit(inode->i_sb);
                 goto out;
         }
@@ -98,6 +109,7 @@ int ext3_sync_file(struct file *file, int datasync)
         if (needs_barrier)
                 blkdev_issue_flush(inode->i_sb->s_bdev, GFP_KERNEL, NULL);
 
+        mutex_unlock(&inode->i_mutex);
 out:
         trace_ext3_sync_file_exit(inode, ret);
         return ret;
diff --git a/fs/ext3/inode.c b/fs/ext3/inode.c
index f57c87b0cb83..04da6acde85d 100644
--- a/fs/ext3/inode.c
+++ b/fs/ext3/inode.c
@@ -1876,9 +1876,8 @@ static ssize_t ext3_direct_IO(int rw, struct kiocb *iocb,
         }
 
 retry:
-        ret = blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev, iov,
-                                 offset, nr_segs,
-                                 ext3_get_block, NULL);
+        ret = blockdev_direct_IO(rw, iocb, inode, iov, offset, nr_segs,
+                                 ext3_get_block);
         /*
          * In case of error extending write may have instantiated a few
          * blocks outside i_size. Trim these off again.
@@ -3276,6 +3275,9 @@ int ext3_setattr(struct dentry *dentry, struct iattr *attr)
                 ext3_journal_stop(handle);
         }
 
+        if (attr->ia_valid & ATTR_SIZE)
+                inode_dio_wait(inode);
+
         if (S_ISREG(inode->i_mode) &&
             attr->ia_valid & ATTR_SIZE && attr->ia_size < inode->i_size) {
                 handle_t *handle;
diff --git a/fs/ext3/namei.c b/fs/ext3/namei.c
index 0465368598bd..6e18a0b7750d 100644
--- a/fs/ext3/namei.c
+++ b/fs/ext3/namei.c
@@ -1039,15 +1039,11 @@ static struct dentry *ext3_lookup(struct inode * dir, struct dentry *dentry, str
                         return ERR_PTR(-EIO);
                 }
                 inode = ext3_iget(dir->i_sb, ino);
-                if (IS_ERR(inode)) {
-                        if (PTR_ERR(inode) == -ESTALE) {
-                                ext3_error(dir->i_sb, __func__,
-                                                "deleted inode referenced: %lu",
-                                                ino);
-                                return ERR_PTR(-EIO);
-                        } else {
-                                return ERR_CAST(inode);
-                        }
+                if (inode == ERR_PTR(-ESTALE)) {
+                        ext3_error(dir->i_sb, __func__,
+                                        "deleted inode referenced: %lu",
+                                        ino);
+                        return ERR_PTR(-EIO);
                 }
         }
         return d_splice_alias(inode, dentry);
@@ -2536,7 +2532,7 @@ const struct inode_operations ext3_dir_inode_operations = {
         .listxattr      = ext3_listxattr,
         .removexattr    = generic_removexattr,
 #endif
-        .check_acl      = ext3_check_acl,
+        .get_acl        = ext3_get_acl,
 };
 
 const struct inode_operations ext3_special_inode_operations = {
@@ -2547,5 +2543,5 @@ const struct inode_operations ext3_special_inode_operations = {
         .listxattr      = ext3_listxattr,
         .removexattr    = generic_removexattr,
 #endif
-        .check_acl      = ext3_check_acl,
+        .get_acl        = ext3_get_acl,
 };
diff --git a/fs/ext3/super.c b/fs/ext3/super.c
index 662290fb6fff..7beb69ae0015 100644
--- a/fs/ext3/super.c
+++ b/fs/ext3/super.c
@@ -1730,6 +1730,8 @@ static int ext3_fill_super (struct super_block *sb, void *data, int silent)
         sbi->s_resuid = le16_to_cpu(es->s_def_resuid);
         sbi->s_resgid = le16_to_cpu(es->s_def_resgid);
 
+        /* enable barriers by default */
+        set_opt(sbi->s_mount_opt, BARRIER);
         set_opt(sbi->s_mount_opt, RESERVATION);
 
         if (!parse_options ((char *) data, sb, &journal_inum, &journal_devnum,