11 files changed, 290 insertions, 177 deletions
diff --git a/fs/ext3/acl.c b/fs/ext3/acl.c
index 9d021c0d472..3091f62e55b 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;
@@ -199,12 +199,10 @@ ext3_set_acl(handle_t *handle, struct inode *inode, int type,
                case ACL_TYPE_ACCESS:
                        name_index = EXT3_XATTR_INDEX_POSIX_ACL_ACCESS;
                        if (acl) {
-                                mode_t mode = inode->i_mode;
+                                error = posix_acl_equiv_mode(acl, &inode->i_mode);
-                                error = posix_acl_equiv_mode(acl, &mode);
                                if (error < 0)
                                        return error;
                                else {
-                                        inode->i_mode = mode;
                                        inode->i_ctime = CURRENT_TIME_SEC;
                                        ext3_mark_inode_dirty(handle, inode);
                                        if (error == 0)
@@ -239,29 +237,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,31 +259,20 @@ 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;
                if (S_ISDIR(inode->i_mode)) {
                        error = ext3_set_acl(handle, inode,
                                             ACL_TYPE_DEFAULT, acl);
                        if (error)
                                goto cleanup;
                }
-                clone = posix_acl_clone(acl, GFP_NOFS);
+                error = posix_acl_create(&acl, GFP_NOFS, &inode->i_mode);
-                error = -ENOMEM;
+                if (error < 0)
-                if (!clone)
+                        return error;
-                        goto cleanup;
+                if (error > 0) {
-                mode = inode->i_mode;
+                        /* This is an extended ACL */
-                error = posix_acl_create_masq(clone, &mode);
+                        error = ext3_set_acl(handle, inode, ACL_TYPE_ACCESS, acl);
-                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);
-                        }
                }
-                posix_acl_release(clone);
        }
 cleanup:
        posix_acl_release(acl);
@@ -332,7 +296,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 +308,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);
+        error = posix_acl_chmod(&acl, GFP_KERNEL, inode->i_mode);
-        posix_acl_release(acl);
+        if (error)
-        if (!clone)
+                return error;
-                return -ENOMEM;
+retry:
-        error = posix_acl_chmod_masq(clone, inode->i_mode);
+        handle = ext3_journal_start(inode,
-        if (!error) {
+                        EXT3_DATA_TRANS_BLOCKS(inode->i_sb));
-                handle_t *handle;
+        if (IS_ERR(handle)) {
-                int retries = 0;
+                error = PTR_ERR(handle);
+                ext3_std_error(inode->i_sb, error);
-        retry:
+                goto out;
-                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 = 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 5faf8048e90..dbc921e458c 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/balloc.c b/fs/ext3/balloc.c
index fe52297e31a..6386d76f44a 100644
--- a/fs/ext3/balloc.c
+++ b/fs/ext3/balloc.c
@@ -21,6 +21,7 @@
 #include <linux/quotaops.h>
 #include <linux/buffer_head.h>
 #include <linux/blkdev.h>
+#include <trace/events/ext3.h>
 /*
 * balloc.c contains the blocks allocation and deallocation routines
@@ -161,6 +162,7 @@ read_block_bitmap(struct super_block *sb, unsigned int block_group)
        desc = ext3_get_group_desc(sb, block_group, NULL);
        if (!desc)
                return NULL;
+        trace_ext3_read_block_bitmap(sb, block_group);
        bitmap_blk = le32_to_cpu(desc->bg_block_bitmap);
        bh = sb_getblk(sb, bitmap_blk);
        if (unlikely(!bh)) {
@@ -351,6 +353,7 @@ void ext3_rsv_window_add(struct super_block *sb,
        struct rb_node * parent = NULL;
        struct ext3_reserve_window_node *this;
+        trace_ext3_rsv_window_add(sb, rsv);
        while (*p)
        {
                parent = *p;
@@ -476,8 +479,10 @@ void ext3_discard_reservation(struct inode *inode)
        rsv = &block_i->rsv_window_node;
        if (!rsv_is_empty(&rsv->rsv_window)) {
                spin_lock(rsv_lock);
-                if (!rsv_is_empty(&rsv->rsv_window))
+                if (!rsv_is_empty(&rsv->rsv_window)) {
+                        trace_ext3_discard_reservation(inode, rsv);
                        rsv_window_remove(inode->i_sb, rsv);
+                }
                spin_unlock(rsv_lock);
        }
 }
@@ -683,14 +688,10 @@ error_return:
 void ext3_free_blocks(handle_t *handle, struct inode *inode,
                        ext3_fsblk_t block, unsigned long count)
 {
-        struct super_block * sb;
+        struct super_block *sb = inode->i_sb;
        unsigned long dquot_freed_blocks;
-        sb = inode->i_sb;
+        trace_ext3_free_blocks(inode, block, count);
-        if (!sb) {
-                printk ("ext3_free_blocks: nonexistent device");
-                return;
-        }
        ext3_free_blocks_sb(handle, sb, block, count, &dquot_freed_blocks);
        if (dquot_freed_blocks)
                dquot_free_block(inode, dquot_freed_blocks);
@@ -1136,6 +1137,7 @@ static int alloc_new_reservation(struct ext3_reserve_window_node *my_rsv,
        else
                start_block = grp_goal + group_first_block;
+        trace_ext3_alloc_new_reservation(sb, start_block);
        size = my_rsv->rsv_goal_size;
        if (!rsv_is_empty(&my_rsv->rsv_window)) {
@@ -1230,8 +1232,11 @@ retry:
         * check if the first free block is within the
         * free space we just reserved
         */
-        if (start_block >= my_rsv->rsv_start && start_block <= my_rsv->rsv_end)
+        if (start_block >= my_rsv->rsv_start &&
+            start_block <= my_rsv->rsv_end) {
+                trace_ext3_reserved(sb, start_block, my_rsv);
                return 0;               /* success */
+        }
        /*
         * if the first free bit we found is out of the reservable space
         * continue search for next reservable space,
@@ -1514,10 +1519,6 @@ ext3_fsblk_t ext3_new_blocks(handle_t *handle, struct inode *inode,
        *errp = -ENOSPC;
        sb = inode->i_sb;
-        if (!sb) {
-                printk("ext3_new_block: nonexistent device");
-                return 0;
-        }
        /*
         * Check quota for allocation of this block.
@@ -1528,8 +1529,10 @@ ext3_fsblk_t ext3_new_blocks(handle_t *handle, struct inode *inode,
                return 0;
        }
+        trace_ext3_request_blocks(inode, goal, num);
        sbi = EXT3_SB(sb);
-        es = EXT3_SB(sb)->s_es;
+        es = sbi->s_es;
        ext3_debug("goal=%lu.\n", goal);
        /*
         * Allocate a block from reservation only when
@@ -1742,6 +1745,10 @@ allocated:
        brelse(bitmap_bh);
        dquot_free_block(inode, *count-num);
        *count = num;
+        trace_ext3_allocate_blocks(inode, goal, num,
+                                   (unsigned long long)ret_block);
        return ret_block;
 io_error:
@@ -1996,6 +2003,7 @@ ext3_grpblk_t ext3_trim_all_free(struct super_block *sb, unsigned int group,
                if ((next - start) < minblocks)
                        goto free_extent;
+                trace_ext3_discard_blocks(sb, discard_block, next - start);
                 /* Send the TRIM command down to the device */
                err = sb_issue_discard(sb, discard_block, next - start,
                                       GFP_NOFS, 0);
@@ -2100,7 +2108,7 @@ int ext3_trim_fs(struct super_block *sb, struct fstrim_range *range)
        if (unlikely(minlen > EXT3_BLOCKS_PER_GROUP(sb)))
                return -EINVAL;
        if (start >= max_blks)
-                goto out;
+                return -EINVAL;
        if (start + len > max_blks)
                len = max_blks - start;
@@ -2148,8 +2156,6 @@ int ext3_trim_fs(struct super_block *sb, struct fstrim_range *range)
        if (ret >= 0)
                ret = 0;
-out:
        range->len = trimmed * sb->s_blocksize;
        return ret;
diff --git a/fs/ext3/file.c b/fs/ext3/file.c
index f55df0e61cb..724df69847d 100644
--- a/fs/ext3/file.c
+++ b/fs/ext3/file.c
@@ -71,7 +71,6 @@ const struct file_operations ext3_file_operations = {
 };
 const struct inode_operations ext3_file_inode_operations = {
-        .truncate       = ext3_truncate,
        .setattr        = ext3_setattr,
 #ifdef CONFIG_EXT3_FS_XATTR
        .setxattr       = generic_setxattr,
@@ -79,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 09b13bb34c9..d494c554c6e 100644
--- a/fs/ext3/fsync.c
+++ b/fs/ext3/fsync.c
@@ -30,6 +30,7 @@
 #include <linux/jbd.h>
 #include <linux/ext3_fs.h>
 #include <linux/ext3_jbd.h>
+#include <trace/events/ext3.h>
 /*
 * akpm: A new design for ext3_sync_file().
@@ -43,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);
@@ -51,9 +52,22 @@ int ext3_sync_file(struct file *file, int datasync)
        int ret, needs_barrier = 0;
        tid_t commit_tid;
+        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);
        /*
@@ -70,8 +84,11 @@ int ext3_sync_file(struct file *file, int datasync)
         *  (they were dirtied by commit).  But that's OK - the blocks are
         *  safe in-journal, which is all fsync() needs to ensure.
         */
-        if (ext3_should_journal_data(inode))
+        if (ext3_should_journal_data(inode)) {
-                return ext3_force_commit(inode->i_sb);
+                mutex_unlock(&inode->i_mutex);
+                ret = ext3_force_commit(inode->i_sb);
+                goto out;
+        }
        if (datasync)
                commit_tid = atomic_read(&ei->i_datasync_tid);
@@ -91,5 +108,9 @@ 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/ialloc.c b/fs/ext3/ialloc.c
index bfc2dc43681..bf09cbf938c 100644
--- a/fs/ext3/ialloc.c
+++ b/fs/ext3/ialloc.c
@@ -23,6 +23,7 @@
 #include <linux/buffer_head.h>
 #include <linux/random.h>
 #include <linux/bitops.h>
+#include <trace/events/ext3.h>
 #include <asm/byteorder.h>
@@ -118,6 +119,7 @@ void ext3_free_inode (handle_t *handle, struct inode * inode)
        ino = inode->i_ino;
        ext3_debug ("freeing inode %lu\n", ino);
+        trace_ext3_free_inode(inode);
        is_directory = S_ISDIR(inode->i_mode);
@@ -426,6 +428,7 @@ struct inode *ext3_new_inode(handle_t *handle, struct inode * dir,
                return ERR_PTR(-EPERM);
        sb = dir->i_sb;
+        trace_ext3_request_inode(dir, mode);
        inode = new_inode(sb);
        if (!inode)
                return ERR_PTR(-ENOMEM);
@@ -601,6 +604,7 @@ got:
        }
        ext3_debug("allocating inode %lu\n", inode->i_ino);
+        trace_ext3_allocate_inode(inode, dir, mode);
        goto really_out;
 fail:
        ext3_std_error(sb, err);
diff --git a/fs/ext3/inode.c b/fs/ext3/inode.c
index 3451d23c3ba..2ce3c52db32 100644
--- a/fs/ext3/inode.c
+++ b/fs/ext3/inode.c
@@ -38,10 +38,12 @@
 #include <linux/bio.h>
 #include <linux/fiemap.h>
 #include <linux/namei.h>
+#include <trace/events/ext3.h>
 #include "xattr.h"
 #include "acl.h"
 static int ext3_writepage_trans_blocks(struct inode *inode);
+static int ext3_block_truncate_page(struct inode *inode, loff_t from);
 /*
 * Test whether an inode is a fast symlink.
@@ -70,6 +72,7 @@ int ext3_forget(handle_t *handle, int is_metadata, struct inode *inode,
        might_sleep();
+        trace_ext3_forget(inode, is_metadata, blocknr);
        BUFFER_TRACE(bh, "enter");
        jbd_debug(4, "forgetting bh %p: is_metadata = %d, mode %o, "
@@ -194,20 +197,47 @@ static int truncate_restart_transaction(handle_t *handle, struct inode *inode)
 */
 void ext3_evict_inode (struct inode *inode)
 {
+        struct ext3_inode_info *ei = EXT3_I(inode);
        struct ext3_block_alloc_info *rsv;
        handle_t *handle;
        int want_delete = 0;
+        trace_ext3_evict_inode(inode);
        if (!inode->i_nlink && !is_bad_inode(inode)) {
                dquot_initialize(inode);
                want_delete = 1;
        }
+        /*
+         * When journalling data dirty buffers are tracked only in the journal.
+         * So although mm thinks everything is clean and ready for reaping the
+         * inode might still have some pages to write in the running
+         * transaction or waiting to be checkpointed. Thus calling
+         * journal_invalidatepage() (via truncate_inode_pages()) to discard
+         * these buffers can cause data loss. Also even if we did not discard
+         * these buffers, we would have no way to find them after the inode
+         * is reaped and thus user could see stale data if he tries to read
+         * them before the transaction is checkpointed. So be careful and
+         * force everything to disk here... We use ei->i_datasync_tid to
+         * store the newest transaction containing inode's data.
+         *
+         * Note that directories do not have this problem because they don't
+         * use page cache.
+         */
+        if (inode->i_nlink && ext3_should_journal_data(inode) &&
+            (S_ISLNK(inode->i_mode) || S_ISREG(inode->i_mode))) {
+                tid_t commit_tid = atomic_read(&ei->i_datasync_tid);
+                journal_t *journal = EXT3_SB(inode->i_sb)->s_journal;
+                log_start_commit(journal, commit_tid);
+                log_wait_commit(journal, commit_tid);
+                filemap_write_and_wait(&inode->i_data);
+        }
        truncate_inode_pages(&inode->i_data, 0);
        ext3_discard_reservation(inode);
-        rsv = EXT3_I(inode)->i_block_alloc_info;
+        rsv = ei->i_block_alloc_info;
-        EXT3_I(inode)->i_block_alloc_info = NULL;
+        ei->i_block_alloc_info = NULL;
        if (unlikely(rsv))
                kfree(rsv);
@@ -231,15 +261,13 @@ void ext3_evict_inode (struct inode *inode)
        if (inode->i_blocks)
                ext3_truncate(inode);
        /*
-         * Kill off the orphan record which ext3_truncate created.
+         * Kill off the orphan record created when the inode lost the last
-         * AKPM: I think this can be inside the above `if'.
+         * link.  Note that ext3_orphan_del() has to be able to cope with the
-         * Note that ext3_orphan_del() has to be able to cope with the
+         * deletion of a non-existent orphan - ext3_truncate() could
-         * deletion of a non-existent orphan - this is because we don't
+         * have removed the record.
-         * know if ext3_truncate() actually created an orphan record.
-         * (Well, we could do this if we need to, but heck - it works)
         */
        ext3_orphan_del(handle, inode);
-        EXT3_I(inode)->i_dtime  = get_seconds();
+        ei->i_dtime = get_seconds();
        /*
         * One subtle ordering requirement: if anything has gone wrong
@@ -842,6 +870,7 @@ int ext3_get_blocks_handle(handle_t *handle, struct inode *inode,
        ext3_fsblk_t first_block = 0;
+        trace_ext3_get_blocks_enter(inode, iblock, maxblocks, create);
        J_ASSERT(handle != NULL || create == 0);
        depth = ext3_block_to_path(inode,iblock,offsets,&blocks_to_boundary);
@@ -886,6 +915,9 @@ int ext3_get_blocks_handle(handle_t *handle, struct inode *inode,
        if (!create || err == -EIO)
                goto cleanup;
+        /*
+         * Block out ext3_truncate while we alter the tree
+         */
        mutex_lock(&ei->truncate_mutex);
        /*
@@ -934,9 +966,6 @@ int ext3_get_blocks_handle(handle_t *handle, struct inode *inode,
         */
        count = ext3_blks_to_allocate(partial, indirect_blks,
                                        maxblocks, blocks_to_boundary);
-        /*
-         * Block out ext3_truncate while we alter the tree
-         */
        err = ext3_alloc_branch(handle, inode, indirect_blks, &count, goal,
                                offsets + (partial - chain), partial);
@@ -970,6 +999,9 @@ cleanup:
        }
        BUFFER_TRACE(bh_result, "returned");
 out:
+        trace_ext3_get_blocks_exit(inode, iblock,
+                                   depth ? le32_to_cpu(chain[depth-1].key) : 0,
+                                   count, err);
        return err;
 }
@@ -1102,7 +1134,7 @@ struct buffer_head *ext3_bread(handle_t *handle, struct inode *inode,
                return bh;
        if (buffer_uptodate(bh))
                return bh;
-        ll_rw_block(READ_META, 1, &bh);
+        ll_rw_block(READ | REQ_META | REQ_PRIO, 1, &bh);
        wait_on_buffer(bh);
        if (buffer_uptodate(bh))
                return bh;
@@ -1202,6 +1234,16 @@ static void ext3_truncate_failed_write(struct inode *inode)
        ext3_truncate(inode);
 }
+/*
+ * Truncate blocks that were not used by direct IO write. We have to zero out
+ * the last file block as well because direct IO might have written to it.
+ */
+static void ext3_truncate_failed_direct_write(struct inode *inode)
+{
+        ext3_block_truncate_page(inode, inode->i_size);
+        ext3_truncate(inode);
+}
 static int ext3_write_begin(struct file *file, struct address_space *mapping,
                                loff_t pos, unsigned len, unsigned flags,
                                struct page **pagep, void **fsdata)
@@ -1217,6 +1259,8 @@ static int ext3_write_begin(struct file *file, struct address_space *mapping,
         * we allocate blocks but write fails for some reason */
        int needed_blocks = ext3_writepage_trans_blocks(inode) + 1;
+        trace_ext3_write_begin(inode, pos, len, flags);
        index = pos >> PAGE_CACHE_SHIFT;
        from = pos & (PAGE_CACHE_SIZE - 1);
        to = from + len;
@@ -1332,6 +1376,7 @@ static int ext3_ordered_write_end(struct file *file,
        unsigned from, to;
        int ret = 0, ret2;
+        trace_ext3_ordered_write_end(inode, pos, len, copied);
        copied = block_write_end(file, mapping, pos, len, copied, page, fsdata);
        from = pos & (PAGE_CACHE_SIZE - 1);
@@ -1367,6 +1412,7 @@ static int ext3_writeback_write_end(struct file *file,
        struct inode *inode = file->f_mapping->host;
        int ret;
+        trace_ext3_writeback_write_end(inode, pos, len, copied);
        copied = block_write_end(file, mapping, pos, len, copied, page, fsdata);
        update_file_sizes(inode, pos, copied);
        /*
@@ -1391,10 +1437,12 @@ static int ext3_journalled_write_end(struct file *file,
 {
        handle_t *handle = ext3_journal_current_handle();
        struct inode *inode = mapping->host;
+        struct ext3_inode_info *ei = EXT3_I(inode);
        int ret = 0, ret2;
        int partial = 0;
        unsigned from, to;
+        trace_ext3_journalled_write_end(inode, pos, len, copied);
        from = pos & (PAGE_CACHE_SIZE - 1);
        to = from + len;
@@ -1419,8 +1467,9 @@ static int ext3_journalled_write_end(struct file *file,
        if (pos + len > inode->i_size && ext3_can_truncate(inode))
                ext3_orphan_add(handle, inode);
        ext3_set_inode_state(inode, EXT3_STATE_JDATA);
-        if (inode->i_size > EXT3_I(inode)->i_disksize) {
+        atomic_set(&ei->i_datasync_tid, handle->h_transaction->t_tid);
-                EXT3_I(inode)->i_disksize = inode->i_size;
+        if (inode->i_size > ei->i_disksize) {
+                ei->i_disksize = inode->i_size;
                ret2 = ext3_mark_inode_dirty(handle, inode);
                if (!ret)
                        ret = ret2;
@@ -1568,7 +1617,13 @@ static int ext3_ordered_writepage(struct page *page,
        int err;
        J_ASSERT(PageLocked(page));
-        WARN_ON_ONCE(IS_RDONLY(inode));
+        /*
+         * We don't want to warn for emergency remount. The condition is
+         * ordered to avoid dereferencing inode->i_sb in non-error case to
+         * avoid slow-downs.
+         */
+        WARN_ON_ONCE(IS_RDONLY(inode) &&
+                     !(EXT3_SB(inode->i_sb)->s_mount_state & EXT3_ERROR_FS));
        /*
         * We give up here if we're reentered, because it might be for a
@@ -1577,6 +1632,7 @@ static int ext3_ordered_writepage(struct page *page,
        if (ext3_journal_current_handle())
                goto out_fail;
+        trace_ext3_ordered_writepage(page);
        if (!page_has_buffers(page)) {
                create_empty_buffers(page, inode->i_sb->s_blocksize,
                                (1 << BH_Dirty)|(1 << BH_Uptodate));
@@ -1642,11 +1698,18 @@ static int ext3_writeback_writepage(struct page *page,
        int err;
        J_ASSERT(PageLocked(page));
-        WARN_ON_ONCE(IS_RDONLY(inode));
+        /*
+         * We don't want to warn for emergency remount. The condition is
+         * ordered to avoid dereferencing inode->i_sb in non-error case to
+         * avoid slow-downs.
+         */
+        WARN_ON_ONCE(IS_RDONLY(inode) &&
+                     !(EXT3_SB(inode->i_sb)->s_mount_state & EXT3_ERROR_FS));
        if (ext3_journal_current_handle())
                goto out_fail;
+        trace_ext3_writeback_writepage(page);
        if (page_has_buffers(page)) {
                if (!walk_page_buffers(NULL, page_buffers(page), 0,
                                      PAGE_CACHE_SIZE, NULL, buffer_unmapped)) {
@@ -1684,11 +1747,18 @@ static int ext3_journalled_writepage(struct page *page,
        int err;
        J_ASSERT(PageLocked(page));
-        WARN_ON_ONCE(IS_RDONLY(inode));
+        /*
+         * We don't want to warn for emergency remount. The condition is
+         * ordered to avoid dereferencing inode->i_sb in non-error case to
+         * avoid slow-downs.
+         */
+        WARN_ON_ONCE(IS_RDONLY(inode) &&
+                     !(EXT3_SB(inode->i_sb)->s_mount_state & EXT3_ERROR_FS));
        if (ext3_journal_current_handle())
                goto no_write;
+        trace_ext3_journalled_writepage(page);
        handle = ext3_journal_start(inode, ext3_writepage_trans_blocks(inode));
        if (IS_ERR(handle)) {
                ret = PTR_ERR(handle);
@@ -1715,6 +1785,8 @@ static int ext3_journalled_writepage(struct page *page,
                if (ret == 0)
                        ret = err;
                ext3_set_inode_state(inode, EXT3_STATE_JDATA);
+                atomic_set(&EXT3_I(inode)->i_datasync_tid,
+                           handle->h_transaction->t_tid);
                unlock_page(page);
        } else {
                /*
@@ -1739,6 +1811,7 @@ out_unlock:
 static int ext3_readpage(struct file *file, struct page *page)
 {
+        trace_ext3_readpage(page);
        return mpage_readpage(page, ext3_get_block);
 }
@@ -1753,6 +1826,8 @@ static void ext3_invalidatepage(struct page *page, unsigned long offset)
 {
        journal_t *journal = EXT3_JOURNAL(page->mapping->host);
+        trace_ext3_invalidatepage(page, offset);
        /*
         * If it's a full truncate we just forget about the pending dirtying
         */
@@ -1766,6 +1841,7 @@ static int ext3_releasepage(struct page *page, gfp_t wait)
 {
        journal_t *journal = EXT3_JOURNAL(page->mapping->host);
+        trace_ext3_releasepage(page);
        WARN_ON(PageChecked(page));
        if (!page_has_buffers(page))
                return 0;
@@ -1794,6 +1870,8 @@ static ssize_t ext3_direct_IO(int rw, struct kiocb *iocb,
        size_t count = iov_length(iov, nr_segs);
        int retries = 0;
+        trace_ext3_direct_IO_enter(inode, offset, iov_length(iov, nr_segs), rw);
        if (rw == WRITE) {
                loff_t final_size = offset + count;
@@ -1816,9 +1894,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,
+        ret = blockdev_direct_IO(rw, iocb, inode, iov, offset, nr_segs,
-                                 offset, nr_segs,
+                                 ext3_get_block);
-                                 ext3_get_block, NULL);
        /*
         * In case of error extending write may have instantiated a few
         * blocks outside i_size. Trim these off again.
@@ -1828,7 +1905,7 @@ retry:
                loff_t end = offset + iov_length(iov, nr_segs);
                if (end > isize)
-                        vmtruncate(inode, isize);
+                        ext3_truncate_failed_direct_write(inode);
        }
        if (ret == -ENOSPC && ext3_should_retry_alloc(inode->i_sb, &retries))
                goto retry;
@@ -1842,7 +1919,7 @@ retry:
                        /* This is really bad luck. We've written the data
                         * but cannot extend i_size. Truncate allocated blocks
                         * and pretend the write failed... */
-                        ext3_truncate(inode);
+                        ext3_truncate_failed_direct_write(inode);
                        ret = PTR_ERR(handle);
                        goto out;
                }
@@ -1868,6 +1945,8 @@ retry:
                        ret = err;
        }
 out:
+        trace_ext3_direct_IO_exit(inode, offset,
+                                iov_length(iov, nr_segs), rw, ret);
        return ret;
 }
@@ -1950,17 +2029,24 @@ void ext3_set_aops(struct inode *inode)
 * This required during truncate. We need to physically zero the tail end
 * of that block so it doesn't yield old data if the file is later grown.
 */
-static int ext3_block_truncate_page(handle_t *handle, struct page *page,
+static int ext3_block_truncate_page(struct inode *inode, loff_t from)
-                struct address_space *mapping, loff_t from)
 {
        ext3_fsblk_t index = from >> PAGE_CACHE_SHIFT;
-        unsigned offset = from & (PAGE_CACHE_SIZE-1);
+        unsigned offset = from & (PAGE_CACHE_SIZE - 1);
        unsigned blocksize, iblock, length, pos;
-        struct inode *inode = mapping->host;
+        struct page *page;
+        handle_t *handle = NULL;
        struct buffer_head *bh;
        int err = 0;
+        /* Truncated on block boundary - nothing to do */
        blocksize = inode->i_sb->s_blocksize;
+        if ((from & (blocksize - 1)) == 0)
+                return 0;
+        page = grab_cache_page(inode->i_mapping, index);
+        if (!page)
+                return -ENOMEM;
        length = blocksize - (offset & (blocksize - 1));
        iblock = index << (PAGE_CACHE_SHIFT - inode->i_sb->s_blocksize_bits);
@@ -2005,11 +2091,23 @@ static int ext3_block_truncate_page(handle_t *handle, struct page *page,
                        goto unlock;
        }
+        /* data=writeback mode doesn't need transaction to zero-out data */
+        if (!ext3_should_writeback_data(inode)) {
+                /* We journal at most one block */
+                handle = ext3_journal_start(inode, 1);
+                if (IS_ERR(handle)) {
+                        clear_highpage(page);
+                        flush_dcache_page(page);
+                        err = PTR_ERR(handle);
+                        goto unlock;
+                }
+        }
        if (ext3_should_journal_data(inode)) {
                BUFFER_TRACE(bh, "get write access");
                err = ext3_journal_get_write_access(handle, bh);
                if (err)
-                        goto unlock;
+                        goto stop;
        }
        zero_user(page, offset, length);
@@ -2023,6 +2121,9 @@ static int ext3_block_truncate_page(handle_t *handle, struct page *page,
                        err = ext3_journal_dirty_data(handle, bh);
                mark_buffer_dirty(bh);
        }
+stop:
+        if (handle)
+                ext3_journal_stop(handle);
 unlock:
        unlock_page(page);
@@ -2391,8 +2492,6 @@ static void ext3_free_branches(handle_t *handle, struct inode *inode,
 int ext3_can_truncate(struct inode *inode)
 {
-        if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
-                return 0;
        if (S_ISREG(inode->i_mode))
                return 1;
        if (S_ISDIR(inode->i_mode))
@@ -2436,7 +2535,6 @@ void ext3_truncate(struct inode *inode)
        struct ext3_inode_info *ei = EXT3_I(inode);
        __le32 *i_data = ei->i_data;
        int addr_per_block = EXT3_ADDR_PER_BLOCK(inode->i_sb);
-        struct address_space *mapping = inode->i_mapping;
        int offsets[4];
        Indirect chain[4];
        Indirect *partial;
@@ -2444,7 +2542,8 @@ void ext3_truncate(struct inode *inode)
        int n;
        long last_block;
        unsigned blocksize = inode->i_sb->s_blocksize;
-        struct page *page;
+        trace_ext3_truncate_enter(inode);
        if (!ext3_can_truncate(inode))
                goto out_notrans;
@@ -2452,37 +2551,12 @@ void ext3_truncate(struct inode *inode)
        if (inode->i_size == 0 && ext3_should_writeback_data(inode))
                ext3_set_inode_state(inode, EXT3_STATE_FLUSH_ON_CLOSE);
-        /*
-         * We have to lock the EOF page here, because lock_page() nests
-         * outside journal_start().
-         */
-        if ((inode->i_size & (blocksize - 1)) == 0) {
-                /* Block boundary? Nothing to do */
-                page = NULL;
-        } else {
-                page = grab_cache_page(mapping,
-                                inode->i_size >> PAGE_CACHE_SHIFT);
-                if (!page)
-                        goto out_notrans;
-        }
        handle = start_transaction(inode);
-        if (IS_ERR(handle)) {
+        if (IS_ERR(handle))
-                if (page) {
-                        clear_highpage(page);
-                        flush_dcache_page(page);
-                        unlock_page(page);
-                        page_cache_release(page);
-                }
                goto out_notrans;
-        }
        last_block = (inode->i_size + blocksize-1)
                                        >> EXT3_BLOCK_SIZE_BITS(inode->i_sb);
-        if (page)
-                ext3_block_truncate_page(handle, page, mapping, inode->i_size);
        n = ext3_block_to_path(inode, last_block, offsets, NULL);
        if (n == 0)
                goto out_stop;  /* error */
@@ -2597,6 +2671,7 @@ out_stop:
                ext3_orphan_del(handle, inode);
        ext3_journal_stop(handle);
+        trace_ext3_truncate_exit(inode);
        return;
 out_notrans:
        /*
@@ -2605,6 +2680,7 @@ out_notrans:
         */
        if (inode->i_nlink)
                ext3_orphan_del(NULL, inode);
+        trace_ext3_truncate_exit(inode);
 }
 static ext3_fsblk_t ext3_get_inode_block(struct super_block *sb,
@@ -2746,9 +2822,10 @@ make_io:
                 * has in-inode xattrs, or we don't have this inode in memory.
                 * Read the block from disk.
                 */
+                trace_ext3_load_inode(inode);
                get_bh(bh);
                bh->b_end_io = end_buffer_read_sync;
-                submit_bh(READ_META, bh);
+                submit_bh(READ | REQ_META | REQ_PRIO, bh);
                wait_on_buffer(bh);
                if (!buffer_uptodate(bh)) {
                        ext3_error(inode->i_sb, "ext3_get_inode_loc",
@@ -3216,6 +3293,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;
@@ -3227,18 +3307,36 @@ int ext3_setattr(struct dentry *dentry, struct iattr *attr)
                }
                error = ext3_orphan_add(handle, inode);
+                if (error) {
+                        ext3_journal_stop(handle);
+                        goto err_out;
+                }
                EXT3_I(inode)->i_disksize = attr->ia_size;
-                rc = ext3_mark_inode_dirty(handle, inode);
+                error = ext3_mark_inode_dirty(handle, inode);
-                if (!error)
-                        error = rc;
                ext3_journal_stop(handle);
+                if (error) {
+                        /* Some hard fs error must have happened. Bail out. */
+                        ext3_orphan_del(NULL, inode);
+                        goto err_out;
+                }
+                rc = ext3_block_truncate_page(inode, attr->ia_size);
+                if (rc) {
+                        /* Cleanup orphan list and exit */
+                        handle = ext3_journal_start(inode, 3);
+                        if (IS_ERR(handle)) {
+                                ext3_orphan_del(NULL, inode);
+                                goto err_out;
+                        }
+                        ext3_orphan_del(handle, inode);
+                        ext3_journal_stop(handle);
+                        goto err_out;
+                }
        }
        if ((attr->ia_valid & ATTR_SIZE) &&
            attr->ia_size != i_size_read(inode)) {
-                rc = vmtruncate(inode, attr->ia_size);
+                truncate_setsize(inode, attr->ia_size);
-                if (rc)
+                ext3_truncate(inode);
-                        goto err_out;
        }
        setattr_copy(inode, attr);
@@ -3372,6 +3470,7 @@ int ext3_mark_inode_dirty(handle_t *handle, struct inode *inode)
        int err;
        might_sleep();
+        trace_ext3_mark_inode_dirty(inode, _RET_IP_);
        err = ext3_reserve_inode_write(handle, inode, &iloc);
        if (!err)
                err = ext3_mark_iloc_dirty(handle, inode, &iloc);
diff --git a/fs/ext3/ioctl.c b/fs/ext3/ioctl.c
index f4090bd2f34..c7f43944f16 100644
--- a/fs/ext3/ioctl.c
+++ b/fs/ext3/ioctl.c
@@ -285,7 +285,7 @@ group_add_out:
                if (!capable(CAP_SYS_ADMIN))
                        return -EPERM;
-                if (copy_from_user(&range, (struct fstrim_range *)arg,
+                if (copy_from_user(&range, (struct fstrim_range __user *)arg,
                                   sizeof(range)))
                        return -EFAULT;
@@ -293,7 +293,7 @@ group_add_out:
                if (ret < 0)
                        return ret;
-                if (copy_to_user((struct fstrim_range *)arg, &range,
+                if (copy_to_user((struct fstrim_range __user *)arg, &range,
                                 sizeof(range)))
                        return -EFAULT;
diff --git a/fs/ext3/namei.c b/fs/ext3/namei.c
index 34b6d9bfc48..0629e09f651 100644
--- a/fs/ext3/namei.c
+++ b/fs/ext3/namei.c
@@ -36,6 +36,7 @@
 #include <linux/quotaops.h>
 #include <linux/buffer_head.h>
 #include <linux/bio.h>
+#include <trace/events/ext3.h>
 #include "namei.h"
 #include "xattr.h"
@@ -287,7 +288,7 @@ static struct stats dx_show_leaf(struct dx_hash_info *hinfo, struct ext3_dir_ent
                                while (len--) printk("%c", *name++);
                                ext3fs_dirhash(de->name, de->name_len, &h);
                                printk(":%x.%u ", h.hash,
-                                       ((char *) de - base));
+                                       (unsigned) ((char *) de - base));
                        }
                        space += EXT3_DIR_REC_LEN(de->name_len);
                        names++;
@@ -921,7 +922,8 @@ restart:
                                bh = ext3_getblk(NULL, dir, b++, 0, &err);
                                bh_use[ra_max] = bh;
                                if (bh)
-                                        ll_rw_block(READ_META, 1, &bh);
+                                        ll_rw_block(READ | REQ_META | REQ_PRIO,
+                                                    1, &bh);
                        }
                }
                if ((bh = bh_use[ra_ptr++]) == NULL)
@@ -1013,7 +1015,7 @@ static struct buffer_head * ext3_dx_find_entry(struct inode *dir,
        *err = -ENOENT;
 errout:
-        dxtrace(printk("%s not found\n", name));
+        dxtrace(printk("%s not found\n", entry->name));
        dx_release (frames);
        return NULL;
 }
@@ -1038,15 +1040,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 (inode == ERR_PTR(-ESTALE)) {
-                        if (PTR_ERR(inode) == -ESTALE) {
+                        ext3_error(dir->i_sb, __func__,
-                                ext3_error(dir->i_sb, __func__,
+                                        "deleted inode referenced: %lu",
-                                                "deleted inode referenced: %lu",
+                                        ino);
-                                                ino);
+                        return ERR_PTR(-EIO);
-                                return ERR_PTR(-EIO);
-                        } else {
-                                return ERR_CAST(inode);
-                        }
                }
        }
        return d_splice_alias(inode, dentry);
@@ -2144,6 +2142,7 @@ static int ext3_unlink(struct inode * dir, struct dentry *dentry)
        struct ext3_dir_entry_2 * de;
        handle_t *handle;
+        trace_ext3_unlink_enter(dir, dentry);
        /* Initialize quotas before so that eventual writes go
         * in separate transaction */
        dquot_initialize(dir);
@@ -2189,6 +2188,7 @@ static int ext3_unlink(struct inode * dir, struct dentry *dentry)
 end_unlink:
        ext3_journal_stop(handle);
        brelse (bh);
+        trace_ext3_unlink_exit(dentry, retval);
        return retval;
 }
@@ -2210,9 +2210,11 @@ static int ext3_symlink (struct inode * dir,
                /*
                 * For non-fast symlinks, we just allocate inode and put it on
                 * orphan list in the first transaction => we need bitmap,
-                 * group descriptor, sb, inode block, quota blocks.
+                 * group descriptor, sb, inode block, quota blocks, and
+                 * possibly selinux xattr blocks.
                 */
-                credits = 4 + EXT3_MAXQUOTAS_INIT_BLOCKS(dir->i_sb);
+                credits = 4 + EXT3_MAXQUOTAS_INIT_BLOCKS(dir->i_sb) +
+                          EXT3_XATTR_TRANS_BLOCKS;
        } else {
                /*
                 * Fast symlink. We have to add entry to directory
@@ -2533,7 +2535,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 = {
@@ -2544,5 +2546,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 aad153ef6b7..7beb69ae001 100644
--- a/fs/ext3/super.c
+++ b/fs/ext3/super.c
@@ -44,6 +44,9 @@
 #include "acl.h"
 #include "namei.h"
+#define CREATE_TRACE_POINTS
+#include <trace/events/ext3.h>
 #ifdef CONFIG_EXT3_DEFAULTS_TO_ORDERED
  #define EXT3_MOUNT_DEFAULT_DATA_MODE EXT3_MOUNT_ORDERED_DATA
 #else
@@ -497,6 +500,14 @@ static struct inode *ext3_alloc_inode(struct super_block *sb)
        return &ei->vfs_inode;
 }
+static int ext3_drop_inode(struct inode *inode)
+{
+        int drop = generic_drop_inode(inode);
+        trace_ext3_drop_inode(inode, drop);
+        return drop;
+}
 static void ext3_i_callback(struct rcu_head *head)
 {
        struct inode *inode = container_of(head, struct inode, i_rcu);
@@ -788,6 +799,7 @@ static const struct super_operations ext3_sops = {
        .destroy_inode  = ext3_destroy_inode,
        .write_inode    = ext3_write_inode,
        .dirty_inode    = ext3_dirty_inode,
+        .drop_inode     = ext3_drop_inode,
        .evict_inode    = ext3_evict_inode,
        .put_super      = ext3_put_super,
        .sync_fs        = ext3_sync_fs,
@@ -1718,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,
@@ -2507,6 +2521,7 @@ static int ext3_sync_fs(struct super_block *sb, int wait)
 {
        tid_t target;
+        trace_ext3_sync_fs(sb, wait);
        if (journal_start_commit(EXT3_SB(sb)->s_journal, &target)) {
                if (wait)
                        log_wait_commit(EXT3_SB(sb)->s_journal, target);
diff --git a/fs/ext3/xattr.c b/fs/ext3/xattr.c
index 32e6cc23bd9..d565759d82e 100644
--- a/fs/ext3/xattr.c
+++ b/fs/ext3/xattr.c
@@ -803,8 +803,16 @@ inserted:
                        /* We need to allocate a new block */
                        ext3_fsblk_t goal = ext3_group_first_block_no(sb,
                                                EXT3_I(inode)->i_block_group);
-                        ext3_fsblk_t block = ext3_new_block(handle, inode,
+                        ext3_fsblk_t block;
-                                                        goal, &error);
+                        /*
+                         * Protect us agaist concurrent allocations to the
+                         * same inode from ext3_..._writepage(). Reservation
+                         * code does not expect racing allocations.
+                         */
+                        mutex_lock(&EXT3_I(inode)->truncate_mutex);
+                        block = ext3_new_block(handle, inode, goal, &error);
+                        mutex_unlock(&EXT3_I(inode)->truncate_mutex);
                        if (error)
                                goto cleanup;
                        ea_idebug(inode, "creating block %d", block);