Merge tag 'ext4_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tytso/ext4

Pull Ext4 updates from Theodore Ts'o:
 "The major new feature added in this update is Darrick J Wong's
  metadata checksum feature, which adds crc32 checksums to ext4's
  metadata fields.

  There is also the usual set of cleanups and bug fixes."

* tag 'ext4_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tytso/ext4: (44 commits)
  ext4: hole-punch use truncate_pagecache_range
  jbd2: use kmem_cache_zalloc wrapper instead of flag
  ext4: remove mb_groups before tearing down the buddy_cache
  ext4: add ext4_mb_unload_buddy in the error path
  ext4: don't trash state flags in EXT4_IOC_SETFLAGS
  ext4: let getattr report the right blocks in delalloc+bigalloc
  ext4: add missing save_error_info() to ext4_error()
  ext4: add debugging trigger for ext4_error()
  ext4: protect group inode free counting with group lock
  ext4: use consistent ssize_t type in ext4_file_write()
  ext4: fix format flag in ext4_ext_binsearch_idx()
  ext4: cleanup in ext4_discard_allocated_blocks()
  ext4: return ENOMEM when mounts fail due to lack of memory
  ext4: remove redundundant "(char *) bh->b_data" casts
  ext4: disallow hard-linked directory in ext4_lookup
  ext4: fix potential integer overflow in alloc_flex_gd()
  ext4: remove needs_recovery in ext4_mb_init()
  ext4: force ro mount if ext4_setup_super() fails
  ext4: fix potential NULL dereference in ext4_free_inodes_counts()
  ext4/jbd2: add metadata checksumming to the list of supported features
  ...

1 files changed, 63 insertions, 8 deletions

diff --git a/fs/ext4/resize.c b/fs/ext4/resize.c
index 59fa0be27251..7ea6cbb44121 100644
--- a/fs/ext4/resize.c
+++ b/fs/ext4/resize.c
@@ -161,6 +161,8 @@ static struct ext4_new_flex_group_data *alloc_flex_gd(unsigned long flexbg_size)
         if (flex_gd == NULL)
                 goto out3;
 
+        if (flexbg_size >= UINT_MAX / sizeof(struct ext4_new_flex_group_data))
+                goto out2;
         flex_gd->count = flexbg_size;
 
         flex_gd->groups = kmalloc(sizeof(struct ext4_new_group_data) *
@@ -796,7 +798,7 @@ static int add_new_gdb(handle_t *handle, struct inode *inode,
         ext4_kvfree(o_group_desc);
 
         le16_add_cpu(&es->s_reserved_gdt_blocks, -1);
-        err = ext4_handle_dirty_metadata(handle, NULL, EXT4_SB(sb)->s_sbh);
+        err = ext4_handle_dirty_super_now(handle, sb);
         if (err)
                 ext4_std_error(sb, err);
 
@@ -968,6 +970,8 @@ static void update_backups(struct super_block *sb,
                 goto exit_err;
         }
 
+        ext4_superblock_csum_set(sb, (struct ext4_super_block *)data);
+
         while ((group = ext4_list_backups(sb, &three, &five, &seven)) < last) {
                 struct buffer_head *bh;
 
@@ -1067,6 +1071,54 @@ static int ext4_add_new_descs(handle_t *handle, struct super_block *sb,
         return err;
 }
 
+static struct buffer_head *ext4_get_bitmap(struct super_block *sb, __u64 block)
+{
+        struct buffer_head *bh = sb_getblk(sb, block);
+        if (!bh)
+                return NULL;
+
+        if (bitmap_uptodate(bh))
+                return bh;
+
+        lock_buffer(bh);
+        if (bh_submit_read(bh) < 0) {
+                unlock_buffer(bh);
+                brelse(bh);
+                return NULL;
+        }
+        unlock_buffer(bh);
+
+        return bh;
+}
+
+static int ext4_set_bitmap_checksums(struct super_block *sb,
+                                     ext4_group_t group,
+                                     struct ext4_group_desc *gdp,
+                                     struct ext4_new_group_data *group_data)
+{
+        struct buffer_head *bh;
+
+        if (!EXT4_HAS_RO_COMPAT_FEATURE(sb,
+                                        EXT4_FEATURE_RO_COMPAT_METADATA_CSUM))
+                return 0;
+
+        bh = ext4_get_bitmap(sb, group_data->inode_bitmap);
+        if (!bh)
+                return -EIO;
+        ext4_inode_bitmap_csum_set(sb, group, gdp, bh,
+                                   EXT4_INODES_PER_GROUP(sb) / 8);
+        brelse(bh);
+
+        bh = ext4_get_bitmap(sb, group_data->block_bitmap);
+        if (!bh)
+                return -EIO;
+        ext4_block_bitmap_csum_set(sb, group, gdp, bh,
+                                   EXT4_BLOCKS_PER_GROUP(sb) / 8);
+        brelse(bh);
+
+        return 0;
+}
+
 /*
  * ext4_setup_new_descs() will set up the group descriptor descriptors of a flex bg
  */
@@ -1093,18 +1145,24 @@ static int ext4_setup_new_descs(handle_t *handle, struct super_block *sb,
                  */
                 gdb_bh = sbi->s_group_desc[gdb_num];
                 /* Update group descriptor block for new group */
-                gdp = (struct ext4_group_desc *)((char *)gdb_bh->b_data +
+                gdp = (struct ext4_group_desc *)(gdb_bh->b_data +
                                                  gdb_off * EXT4_DESC_SIZE(sb));
 
                 memset(gdp, 0, EXT4_DESC_SIZE(sb));
                 ext4_block_bitmap_set(sb, gdp, group_data->block_bitmap);
                 ext4_inode_bitmap_set(sb, gdp, group_data->inode_bitmap);
+                err = ext4_set_bitmap_checksums(sb, group, gdp, group_data);
+                if (err) {
+                        ext4_std_error(sb, err);
+                        break;
+                }
+
                 ext4_inode_table_set(sb, gdp, group_data->inode_table);
                 ext4_free_group_clusters_set(sb, gdp,
                                              EXT4_B2C(sbi, group_data->free_blocks_count));
                 ext4_free_inodes_set(sb, gdp, EXT4_INODES_PER_GROUP(sb));
                 gdp->bg_flags = cpu_to_le16(*bg_flags);
-                gdp->bg_checksum = ext4_group_desc_csum(sbi, group, gdp);
+                ext4_group_desc_csum_set(sb, group, gdp);
 
                 err = ext4_handle_dirty_metadata(handle, NULL, gdb_bh);
                 if (unlikely(err)) {
@@ -1343,17 +1401,14 @@ static int ext4_setup_next_flex_gd(struct super_block *sb,
                            (1 + ext4_bg_num_gdb(sb, group + i) +
                             le16_to_cpu(es->s_reserved_gdt_blocks)) : 0;
                 group_data[i].free_blocks_count = blocks_per_group - overhead;
-                if (EXT4_HAS_RO_COMPAT_FEATURE(sb,
-                                               EXT4_FEATURE_RO_COMPAT_GDT_CSUM))
+                if (ext4_has_group_desc_csum(sb))
                         flex_gd->bg_flags[i] = EXT4_BG_BLOCK_UNINIT |
                                                EXT4_BG_INODE_UNINIT;
                 else
                         flex_gd->bg_flags[i] = EXT4_BG_INODE_ZEROED;
         }
 
-        if (last_group == n_group &&
-            EXT4_HAS_RO_COMPAT_FEATURE(sb,
-                                       EXT4_FEATURE_RO_COMPAT_GDT_CSUM))
+        if (last_group == n_group && ext4_has_group_desc_csum(sb))
                 /* We need to initialize block bitmap of last group. */
                 flex_gd->bg_flags[i - 1] &= ~EXT4_BG_BLOCK_UNINIT;