Merge branch 'next' of git://git.kernel.org/pub/scm/linux/kernel/git/tytso/ext4

* 'next' of git://git.kernel.org/pub/scm/linux/kernel/git/tytso/ext4: (40 commits)
  ext4: Adding error check after calling ext4_mb_regular_allocator()
  ext4: Fix dirtying of journalled buffers in data=journal mode
  ext4: re-inline ext4_rec_len_(to|from)_disk functions
  jbd2: Remove t_handle_lock from start_this_handle()
  jbd2: Change j_state_lock to be a rwlock_t
  jbd2: Use atomic variables to avoid taking t_handle_lock in jbd2_journal_stop
  ext4: Add mount options in superblock
  ext4: force block allocation on quota_off
  ext4: fix freeze deadlock under IO
  ext4: drop inode from orphan list if ext4_delete_inode() fails
  ext4: check to make make sure bd_dev is set before dereferencing it
  jbd2: Make barrier messages less scary
  ext4: don't print scary messages for allocation failures post-abort
  ext4: fix EFBIG edge case when writing to large non-extent file
  ext4: fix ext4_get_blocks references
  ext4: Always journal quota file modifications
  ext4: Fix potential memory leak in ext4_fill_super
  ext4: Don't error out the fs if the user tries to make a file too big
  ext4: allocate stripe-multiple IOs on stripe boundaries
  ext4: move aio completion after unwritten extent conversion
  ...

Fix up conflicts in fs/ext4/inode.c as per Ted.

Fix up xfs conflicts as per earlier xfs merge.

1 files changed, 76 insertions, 77 deletions

diff --git a/fs/ext4/mballoc.c b/fs/ext4/mballoc.c
index 0e83dfd351d5..4b4ad4b7ce57 100644
--- a/fs/ext4/mballoc.c
+++ b/fs/ext4/mballoc.c
@@ -446,10 +446,11 @@ static void mb_free_blocks_double(struct inode *inode, struct ext4_buddy *e4b,
                         blocknr = ext4_group_first_block_no(sb, e4b->bd_group);
                         blocknr += first + i;
                         ext4_grp_locked_error(sb, e4b->bd_group,
-                                   __func__, "double-free of inode"
-                                   " %lu's block %llu(bit %u in group %u)",
-                                   inode ? inode->i_ino : 0, blocknr,
-                                   first + i, e4b->bd_group);
+                                              inode ? inode->i_ino : 0,
+                                              blocknr,
+                                              "freeing block already freed "
+                                              "(bit %u)",
+                                              first + i);
                 }
                 mb_clear_bit(first + i, e4b->bd_info->bb_bitmap);
         }
@@ -712,9 +713,9 @@ void ext4_mb_generate_buddy(struct super_block *sb,
         grp->bb_fragments = fragments;
 
         if (free != grp->bb_free) {
-                ext4_grp_locked_error(sb, group,  __func__,
-                        "EXT4-fs: group %u: %u blocks in bitmap, %u in gd",
-                        group, free, grp->bb_free);
+                ext4_grp_locked_error(sb, group, 0, 0,
+                                      "%u blocks in bitmap, %u in gd",
+                                      free, grp->bb_free);
                 /*
                  * If we intent to continue, we consider group descritor
                  * corrupt and update bb_free using bitmap value
@@ -1296,10 +1297,10 @@ static void mb_free_blocks(struct inode *inode, struct ext4_buddy *e4b,
                         blocknr = ext4_group_first_block_no(sb, e4b->bd_group);
                         blocknr += block;
                         ext4_grp_locked_error(sb, e4b->bd_group,
-                                   __func__, "double-free of inode"
-                                   " %lu's block %llu(bit %u in group %u)",
-                                   inode ? inode->i_ino : 0, blocknr, block,
-                                   e4b->bd_group);
+                                              inode ? inode->i_ino : 0,
+                                              blocknr,
+                                              "freeing already freed block "
+                                              "(bit %u)", block);
                 }
                 mb_clear_bit(block, EXT4_MB_BITMAP(e4b));
                 e4b->bd_info->bb_counters[order]++;
@@ -1788,8 +1789,8 @@ void ext4_mb_complex_scan_group(struct ext4_allocation_context *ac,
                          * free blocks even though group info says we
                          * we have free blocks
                          */
-                        ext4_grp_locked_error(sb, e4b->bd_group,
-                                        __func__, "%d free blocks as per "
+                        ext4_grp_locked_error(sb, e4b->bd_group, 0, 0,
+                                        "%d free blocks as per "
                                         "group info. But bitmap says 0",
                                         free);
                         break;
@@ -1798,8 +1799,8 @@ void ext4_mb_complex_scan_group(struct ext4_allocation_context *ac,
                 mb_find_extent(e4b, 0, i, ac->ac_g_ex.fe_len, &ex);
                 BUG_ON(ex.fe_len <= 0);
                 if (free < ex.fe_len) {
-                        ext4_grp_locked_error(sb, e4b->bd_group,
-                                        __func__, "%d free blocks as per "
+                        ext4_grp_locked_error(sb, e4b->bd_group, 0, 0,
+                                        "%d free blocks as per "
                                         "group info. But got %d blocks",
                                         free, ex.fe_len);
                         /*
@@ -1821,8 +1822,7 @@ void ext4_mb_complex_scan_group(struct ext4_allocation_context *ac,
 
 /*
  * This is a special case for storages like raid5
- * we try to find stripe-aligned chunks for stripe-size requests
- * XXX should do so at least for multiples of stripe size as well
+ * we try to find stripe-aligned chunks for stripe-size-multiple requests
  */
 static noinline_for_stack
 void ext4_mb_scan_aligned(struct ext4_allocation_context *ac,
@@ -1999,7 +1999,6 @@ ext4_mb_regular_allocator(struct ext4_allocation_context *ac)
         ext4_group_t ngroups, group, i;
         int cr;
         int err = 0;
-        int bsbits;
         struct ext4_sb_info *sbi;
         struct super_block *sb;
         struct ext4_buddy e4b;
@@ -2041,8 +2040,6 @@ ext4_mb_regular_allocator(struct ext4_allocation_context *ac)
                         ac->ac_2order = i - 1;
         }
 
-        bsbits = ac->ac_sb->s_blocksize_bits;
-
         /* if stream allocation is enabled, use global goal */
         if (ac->ac_flags & EXT4_MB_STREAM_ALLOC) {
                 /* TBD: may be hot point */
@@ -2094,8 +2091,8 @@ repeat:
                         ac->ac_groups_scanned++;
                         if (cr == 0)
                                 ext4_mb_simple_scan_group(ac, &e4b);
-                        else if (cr == 1 &&
-                                        ac->ac_g_ex.fe_len == sbi->s_stripe)
+                        else if (cr == 1 && sbi->s_stripe &&
+                                        !(ac->ac_g_ex.fe_len % sbi->s_stripe))
                                 ext4_mb_scan_aligned(ac, &e4b);
                         else
                                 ext4_mb_complex_scan_group(ac, &e4b);
@@ -2221,7 +2218,7 @@ static int ext4_mb_seq_groups_open(struct inode *inode, struct file *file)
 
         rc = seq_open(file, &ext4_mb_seq_groups_ops);
         if (rc == 0) {
-                struct seq_file *m = (struct seq_file *)file->private_data;
+                struct seq_file *m = file->private_data;
                 m->private = sb;
         }
         return rc;
@@ -2560,6 +2557,22 @@ int ext4_mb_release(struct super_block *sb)
         return 0;
 }
 
+static inline void ext4_issue_discard(struct super_block *sb,
+                ext4_group_t block_group, ext4_grpblk_t block, int count)
+{
+        int ret;
+        ext4_fsblk_t discard_block;
+
+        discard_block = block + ext4_group_first_block_no(sb, block_group);
+        trace_ext4_discard_blocks(sb,
+                        (unsigned long long) discard_block, count);
+        ret = sb_issue_discard(sb, discard_block, count);
+        if (ret == EOPNOTSUPP) {
+                ext4_warning(sb, "discard not supported, disabling");
+                clear_opt(EXT4_SB(sb)->s_mount_opt, DISCARD);
+        }
+}
+
 /*
  * This function is called by the jbd2 layer once the commit has finished,
  * so we know we can free the blocks that were released with that commit.
@@ -2579,22 +2592,9 @@ static void release_blocks_on_commit(journal_t *journal, transaction_t *txn)
                 mb_debug(1, "gonna free %u blocks in group %u (0x%p):",
                          entry->count, entry->group, entry);
 
-                if (test_opt(sb, DISCARD)) {
-                        int ret;
-                        ext4_fsblk_t discard_block;
-
-                        discard_block = entry->start_blk +
-                                ext4_group_first_block_no(sb, entry->group);
-                        trace_ext4_discard_blocks(sb,
-                                        (unsigned long long)discard_block,
-                                        entry->count);
-                        ret = sb_issue_discard(sb, discard_block, entry->count);
-                        if (ret == EOPNOTSUPP) {
-                                ext4_warning(sb,
-                                        "discard not supported, disabling");
-                                clear_opt(EXT4_SB(sb)->s_mount_opt, DISCARD);
-                        }
-                }
+                if (test_opt(sb, DISCARD))
+                        ext4_issue_discard(sb, entry->group,
+                                        entry->start_blk, entry->count);
 
                 err = ext4_mb_load_buddy(sb, entry->group, &e4b);
                 /* we expect to find existing buddy because it's pinned */
@@ -2712,7 +2712,6 @@ ext4_mb_mark_diskspace_used(struct ext4_allocation_context *ac,
                                 handle_t *handle, unsigned int reserv_blks)
 {
         struct buffer_head *bitmap_bh = NULL;
-        struct ext4_super_block *es;
         struct ext4_group_desc *gdp;
         struct buffer_head *gdp_bh;
         struct ext4_sb_info *sbi;
@@ -2725,8 +2724,6 @@ ext4_mb_mark_diskspace_used(struct ext4_allocation_context *ac,
 
         sb = ac->ac_sb;
         sbi = EXT4_SB(sb);
-        es = sbi->s_es;
-
 
         err = -EIO;
         bitmap_bh = ext4_read_block_bitmap(sb, ac->ac_b_ex.fe_group);
@@ -2812,7 +2809,7 @@ ext4_mb_mark_diskspace_used(struct ext4_allocation_context *ac,
         err = ext4_handle_dirty_metadata(handle, NULL, gdp_bh);
 
 out_err:
-        sb->s_dirt = 1;
+        ext4_mark_super_dirty(sb);
         brelse(bitmap_bh);
         return err;
 }
@@ -2850,7 +2847,7 @@ ext4_mb_normalize_request(struct ext4_allocation_context *ac,
         int bsbits, max;
         ext4_lblk_t end;
         loff_t size, orig_size, start_off;
-        ext4_lblk_t start, orig_start;
+        ext4_lblk_t start;
         struct ext4_inode_info *ei = EXT4_I(ac->ac_inode);
         struct ext4_prealloc_space *pa;
 
@@ -2881,6 +2878,7 @@ ext4_mb_normalize_request(struct ext4_allocation_context *ac,
         size = size << bsbits;
         if (size < i_size_read(ac->ac_inode))
                 size = i_size_read(ac->ac_inode);
+        orig_size = size;
 
         /* max size of free chunks */
         max = 2 << bsbits;
@@ -2922,8 +2920,8 @@ ext4_mb_normalize_request(struct ext4_allocation_context *ac,
                 start_off = (loff_t)ac->ac_o_ex.fe_logical << bsbits;
                 size      = ac->ac_o_ex.fe_len << bsbits;
         }
-        orig_size = size = size >> bsbits;
-        orig_start = start = start_off >> bsbits;
+        size = size >> bsbits;
+        start = start_off >> bsbits;
 
         /* don't cover already allocated blocks in selected range */
         if (ar->pleft && start <= ar->lleft) {
@@ -3547,7 +3545,6 @@ ext4_mb_release_inode_pa(struct ext4_buddy *e4b, struct buffer_head *bitmap_bh,
         ext4_group_t group;
         ext4_grpblk_t bit;
         unsigned long long grp_blk_start;
-        sector_t start;
         int err = 0;
         int free = 0;
 
@@ -3567,10 +3564,9 @@ ext4_mb_release_inode_pa(struct ext4_buddy *e4b, struct buffer_head *bitmap_bh,
                 if (bit >= end)
                         break;
                 next = mb_find_next_bit(bitmap_bh->b_data, end, bit);
-                start = ext4_group_first_block_no(sb, group) + bit;
                 mb_debug(1, "    free preallocated %u/%u in group %u\n",
-                                (unsigned) start, (unsigned) next - bit,
-                                (unsigned) group);
+                         (unsigned) ext4_group_first_block_no(sb, group) + bit,
+                         (unsigned) next - bit, (unsigned) group);
                 free += next - bit;
 
                 if (ac) {
@@ -3581,7 +3577,7 @@ ext4_mb_release_inode_pa(struct ext4_buddy *e4b, struct buffer_head *bitmap_bh,
                         trace_ext4_mballoc_discard(ac);
                 }
 
-                trace_ext4_mb_release_inode_pa(ac, pa, grp_blk_start + bit,
+                trace_ext4_mb_release_inode_pa(sb, ac, pa, grp_blk_start + bit,
                                                next - bit);
                 mb_free_blocks(pa->pa_inode, e4b, bit, next - bit);
                 bit = next + 1;
@@ -3591,8 +3587,7 @@ ext4_mb_release_inode_pa(struct ext4_buddy *e4b, struct buffer_head *bitmap_bh,
                         pa, (unsigned long) pa->pa_lstart,
                         (unsigned long) pa->pa_pstart,
                         (unsigned long) pa->pa_len);
-                ext4_grp_locked_error(sb, group,
-                                        __func__, "free %u, pa_free %u",
+                ext4_grp_locked_error(sb, group, 0, 0, "free %u, pa_free %u",
                                         free, pa->pa_free);
                 /*
                  * pa is already deleted so we use the value obtained
@@ -3613,7 +3608,7 @@ ext4_mb_release_group_pa(struct ext4_buddy *e4b,
         ext4_group_t group;
         ext4_grpblk_t bit;
 
-        trace_ext4_mb_release_group_pa(ac, pa);
+        trace_ext4_mb_release_group_pa(sb, ac, pa);
         BUG_ON(pa->pa_deleted == 0);
         ext4_get_group_no_and_offset(sb, pa->pa_pstart, &group, &bit);
         BUG_ON(group != e4b->bd_group && pa->pa_len != 0);
@@ -3889,6 +3884,9 @@ static void ext4_mb_show_ac(struct ext4_allocation_context *ac)
         struct super_block *sb = ac->ac_sb;
         ext4_group_t ngroups, i;
 
+        if (EXT4_SB(sb)->s_mount_flags & EXT4_MF_FS_ABORTED)
+                return;
+
         printk(KERN_ERR "EXT4-fs: Can't allocate:"
                         " Allocation context details:\n");
         printk(KERN_ERR "EXT4-fs: status %d flags %d\n",
@@ -4255,7 +4253,7 @@ static int ext4_mb_discard_preallocations(struct super_block *sb, int needed)
  * to usual allocation
  */
 ext4_fsblk_t ext4_mb_new_blocks(handle_t *handle,
-                                 struct ext4_allocation_request *ar, int *errp)
+                                struct ext4_allocation_request *ar, int *errp)
 {
         int freed;
         struct ext4_allocation_context *ac = NULL;
@@ -4299,7 +4297,7 @@ ext4_fsblk_t ext4_mb_new_blocks(handle_t *handle,
                 inquota = ar->len;
                 if (ar->len == 0) {
                         *errp = -EDQUOT;
-                        goto out3;
+                        goto out;
                 }
         }
 
@@ -4307,13 +4305,13 @@ ext4_fsblk_t ext4_mb_new_blocks(handle_t *handle,
         if (!ac) {
                 ar->len = 0;
                 *errp = -ENOMEM;
-                goto out1;
+                goto out;
         }
 
         *errp = ext4_mb_initialize_context(ac, ar);
         if (*errp) {
                 ar->len = 0;
-                goto out2;
+                goto out;
         }
 
         ac->ac_op = EXT4_MB_HISTORY_PREALLOC;
@@ -4322,7 +4320,9 @@ ext4_fsblk_t ext4_mb_new_blocks(handle_t *handle,
                 ext4_mb_normalize_request(ac, ar);
 repeat:
                 /* allocate space in core */
-                ext4_mb_regular_allocator(ac);
+                *errp = ext4_mb_regular_allocator(ac);
+                if (*errp)
+                        goto errout;
 
                 /* as we've just preallocated more space than
                  * user requested orinally, we store allocated
@@ -4333,7 +4333,7 @@ repeat:
         }
         if (likely(ac->ac_status == AC_STATUS_FOUND)) {
                 *errp = ext4_mb_mark_diskspace_used(ac, handle, reserv_blks);
-                if (*errp ==  -EAGAIN) {
+                if (*errp == -EAGAIN) {
                         /*
                          * drop the reference that we took
                          * in ext4_mb_use_best_found
@@ -4344,12 +4344,10 @@ repeat:
                         ac->ac_b_ex.fe_len = 0;
                         ac->ac_status = AC_STATUS_CONTINUE;
                         goto repeat;
-                } else if (*errp) {
+                } else if (*errp)
+                errout:
                         ext4_discard_allocated_blocks(ac);
-                        ac->ac_b_ex.fe_len = 0;
-                        ar->len = 0;
-                        ext4_mb_show_ac(ac);
-                } else {
+                else {
                         block = ext4_grp_offs_to_block(sb, &ac->ac_b_ex);
                         ar->len = ac->ac_b_ex.fe_len;
                 }
@@ -4358,19 +4356,19 @@ repeat:
                 if (freed)
                         goto repeat;
                 *errp = -ENOSPC;
+        }
+
+        if (*errp) {
                 ac->ac_b_ex.fe_len = 0;
                 ar->len = 0;
                 ext4_mb_show_ac(ac);
         }
-
         ext4_mb_release_context(ac);
-
-out2:
-        kmem_cache_free(ext4_ac_cachep, ac);
-out1:
+out:
+        if (ac)
+                kmem_cache_free(ext4_ac_cachep, ac);
         if (inquota && ar->len < inquota)
                 dquot_free_block(ar->inode, inquota - ar->len);
-out3:
         if (!ar->len) {
                 if (!EXT4_I(ar->inode)->i_delalloc_reserved_flag)
                         /* release all the reserved blocks if non delalloc */
@@ -4402,6 +4400,7 @@ static noinline_for_stack int
 ext4_mb_free_metadata(handle_t *handle, struct ext4_buddy *e4b,
                       struct ext4_free_data *new_entry)
 {
+        ext4_group_t group = e4b->bd_group;
         ext4_grpblk_t block;
         struct ext4_free_data *entry;
         struct ext4_group_info *db = e4b->bd_info;
@@ -4434,9 +4433,9 @@ ext4_mb_free_metadata(handle_t *handle, struct ext4_buddy *e4b,
                 else if (block >= (entry->start_blk + entry->count))
                         n = &(*n)->rb_right;
                 else {
-                        ext4_grp_locked_error(sb, e4b->bd_group, __func__,
-                                        "Double free of blocks %d (%d %d)",
-                                        block, entry->start_blk, entry->count);
+                        ext4_grp_locked_error(sb, group, 0,
+                                ext4_group_first_block_no(sb, group) + block,
+                                "Block already on to-be-freed list");
                         return 0;
                 }
         }
@@ -4494,7 +4493,6 @@ void ext4_free_blocks(handle_t *handle, struct inode *inode,
         struct super_block *sb = inode->i_sb;
         struct ext4_allocation_context *ac = NULL;
         struct ext4_group_desc *gdp;
-        struct ext4_super_block *es;
         unsigned long freed = 0;
         unsigned int overflow;
         ext4_grpblk_t bit;
@@ -4513,7 +4511,6 @@ void ext4_free_blocks(handle_t *handle, struct inode *inode,
         }
 
         sbi = EXT4_SB(sb);
-        es = EXT4_SB(sb)->s_es;
         if (!(flags & EXT4_FREE_BLOCKS_VALIDATED) &&
             !ext4_data_block_valid(sbi, block, count)) {
                 ext4_error(sb, "Freeing blocks not in datazone - "
@@ -4647,6 +4644,8 @@ do_more:
                 mb_clear_bits(bitmap_bh->b_data, bit, count);
                 mb_free_blocks(inode, &e4b, bit, count);
                 ext4_mb_return_to_preallocation(inode, &e4b, block, count);
+                if (test_opt(sb, DISCARD))
+                        ext4_issue_discard(sb, block_group, bit, count);
         }
 
         ret = ext4_free_blks_count(sb, gdp) + count;
@@ -4680,7 +4679,7 @@ do_more:
                 put_bh(bitmap_bh);
                 goto do_more;
         }
-        sb->s_dirt = 1;
+        ext4_mark_super_dirty(sb);
 error_return:
         if (freed)
                 dquot_free_block(inode, freed);