Ext4: Uninitialized Block Groups

In pass1 of e2fsck, every inode table in the fileystem is scanned and checked,
regardless of whether it is in use.  This is this the most time consuming part
of the filesystem check.  The unintialized block group feature can greatly
reduce e2fsck time by eliminating checking of uninitialized inodes.

With this feature, there is a a high water mark of used inodes for each block
group.  Block and inode bitmaps can be uninitialized on disk via a flag in the
group descriptor to avoid reading or scanning them at e2fsck time.  A checksum
of each group descriptor is used to ensure that corruption in the group
descriptor's bit flags does not cause incorrect operation.

The feature is enabled through a mkfs option

	mke2fs /dev/ -O uninit_groups

A patch adding support for uninitialized block groups to e2fsprogs tools has
been posted to the linux-ext4 mailing list.

The patches have been stress tested with fsstress and fsx.  In performance
tests testing e2fsck time, we have seen that e2fsck time on ext3 grows
linearly with the total number of inodes in the filesytem.  In ext4 with the
uninitialized block groups feature, the e2fsck time is constant, based
solely on the number of used inodes rather than the total inode count.
Since typical ext4 filesystems only use 1-10% of their inodes, this feature can
greatly reduce e2fsck time for users.  With performance improvement of 2-20
times, depending on how full the filesystem is.

The attached graph shows the major improvements in e2fsck times in filesystems
with a large total inode count, but few inodes in use.

In each group descriptor if we have

EXT4_BG_INODE_UNINIT set in bg_flags:
        Inode table is not initialized/used in this group. So we can skip
        the consistency check during fsck.
EXT4_BG_BLOCK_UNINIT set in bg_flags:
        No block in the group is used. So we can skip the block bitmap
        verification for this group.

We also add two new fields to group descriptor as a part of
uninitialized group patch.

        __le16  bg_itable_unused;       /* Unused inodes count */
        __le16  bg_checksum;            /* crc16(sb_uuid+group+desc) */

bg_itable_unused:

If we have EXT4_BG_INODE_UNINIT not set in bg_flags
then bg_itable_unused will give the offset within
the inode table till the inodes are used. This can be
used by fsck to skip list of inodes that are marked unused.

bg_checksum:
Now that we depend on bg_flags and bg_itable_unused to determine
the block and inode usage, we need to make sure group descriptor
is not corrupt. We add checksum to group descriptor to
detect corruption. If the descriptor is found to be corrupt, we
mark all the blocks and inodes in the group used.

Signed-off-by: Avantika Mathur <mathur@us.ibm.com>
Signed-off-by: Andreas Dilger <adilger@clusterfs.com>
Signed-off-by: Mingming Cao <cmm@us.ibm.com>
Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>

1 files changed, 137 insertions, 9 deletions

diff --git a/fs/ext4/ialloc.c b/fs/ext4/ialloc.c
index 38e9a0a705df..c61f37fd3f05 100644
--- a/fs/ext4/ialloc.c
+++ b/fs/ext4/ialloc.c
@@ -28,6 +28,7 @@
 
 #include "xattr.h"
 #include "acl.h"
+#include "group.h"
 
 /*
  * ialloc.c contains the inodes allocation and deallocation routines
@@ -43,6 +44,52 @@
  * the free blocks count in the block.
  */
 
+/*
+ * To avoid calling the atomic setbit hundreds or thousands of times, we only
+ * need to use it within a single byte (to ensure we get endianness right).
+ * We can use memset for the rest of the bitmap as there are no other users.
+ */
+void mark_bitmap_end(int start_bit, int end_bit, char *bitmap)
+{
+        int i;
+
+        if (start_bit >= end_bit)
+                return;
+
+        ext4_debug("mark end bits +%d through +%d used\n", start_bit, end_bit);
+        for (i = start_bit; i < ((start_bit + 7) & ~7UL); i++)
+                ext4_set_bit(i, bitmap);
+        if (i < end_bit)
+                memset(bitmap + (i >> 3), 0xff, (end_bit - i) >> 3);
+}
+
+/* Initializes an uninitialized inode bitmap */
+unsigned ext4_init_inode_bitmap(struct super_block *sb,
+                                struct buffer_head *bh, int block_group,
+                                struct ext4_group_desc *gdp)
+{
+        struct ext4_sb_info *sbi = EXT4_SB(sb);
+
+        J_ASSERT_BH(bh, buffer_locked(bh));
+
+        /* If checksum is bad mark all blocks and inodes use to prevent
+         * allocation, essentially implementing a per-group read-only flag. */
+        if (!ext4_group_desc_csum_verify(sbi, block_group, gdp)) {
+                ext4_error(sb, __FUNCTION__, "Checksum bad for group %u\n",
+                           block_group);
+                gdp->bg_free_blocks_count = 0;
+                gdp->bg_free_inodes_count = 0;
+                gdp->bg_itable_unused = 0;
+                memset(bh->b_data, 0xff, sb->s_blocksize);
+                return 0;
+        }
+
+        memset(bh->b_data, 0, (EXT4_INODES_PER_GROUP(sb) + 7) / 8);
+        mark_bitmap_end(EXT4_INODES_PER_GROUP(sb), EXT4_BLOCKS_PER_GROUP(sb),
+                        bh->b_data);
+
+        return EXT4_INODES_PER_GROUP(sb);
+}
 
 /*
  * Read the inode allocation bitmap for a given block_group, reading
@@ -59,8 +106,20 @@ read_inode_bitmap(struct super_block * sb, unsigned long block_group)
         desc = ext4_get_group_desc(sb, block_group, NULL);
         if (!desc)
                 goto error_out;
-
-        bh = sb_bread(sb, ext4_inode_bitmap(sb, desc));
+        if (desc->bg_flags & cpu_to_le16(EXT4_BG_INODE_UNINIT)) {
+                bh = sb_getblk(sb, ext4_inode_bitmap(sb, desc));
+                if (!buffer_uptodate(bh)) {
+                        lock_buffer(bh);
+                        if (!buffer_uptodate(bh)) {
+                                ext4_init_inode_bitmap(sb, bh, block_group,
+                                                       desc);
+                                set_buffer_uptodate(bh);
+                        }
+                        unlock_buffer(bh);
+                }
+        } else {
+                bh = sb_bread(sb, ext4_inode_bitmap(sb, desc));
+        }
         if (!bh)
                 ext4_error(sb, "read_inode_bitmap",
                             "Cannot read inode bitmap - "
@@ -169,6 +228,8 @@ void ext4_free_inode (handle_t *handle, struct inode * inode)
                         if (is_directory)
                                 gdp->bg_used_dirs_count = cpu_to_le16(
                                   le16_to_cpu(gdp->bg_used_dirs_count) - 1);
+                        gdp->bg_checksum = ext4_group_desc_csum(sbi,
+                                                        block_group, gdp);
                         spin_unlock(sb_bgl_lock(sbi, block_group));
                         percpu_counter_inc(&sbi->s_freeinodes_counter);
                         if (is_directory)
@@ -435,7 +496,7 @@ struct inode *ext4_new_inode(handle_t *handle, struct inode * dir, int mode)
         struct ext4_sb_info *sbi;
         int err = 0;
         struct inode *ret;
-        int i;
+        int i, free = 0;
 
         /* Cannot create files in a deleted directory */
         if (!dir || !dir->i_nlink)
@@ -517,11 +578,13 @@ repeat_in_this_group:
         goto out;
 
 got:
-        ino += group * EXT4_INODES_PER_GROUP(sb) + 1;
-        if (ino < EXT4_FIRST_INO(sb) || ino > le32_to_cpu(es->s_inodes_count)) {
-                ext4_error (sb, "ext4_new_inode",
-                            "reserved inode or inode > inodes count - "
-                            "block_group = %d, inode=%lu", group, ino);
+        ino++;
+        if ((group == 0 && ino < EXT4_FIRST_INO(sb)) ||
+            ino > EXT4_INODES_PER_GROUP(sb)) {
+                ext4_error(sb, __FUNCTION__,
+                           "reserved inode or inode > inodes count - "
+                           "block_group = %d, inode=%lu", group,
+                           ino + group * EXT4_INODES_PER_GROUP(sb));
                 err = -EIO;
                 goto fail;
         }
@@ -529,13 +592,78 @@ got:
         BUFFER_TRACE(bh2, "get_write_access");
         err = ext4_journal_get_write_access(handle, bh2);
         if (err) goto fail;
+
+        /* We may have to initialize the block bitmap if it isn't already */
+        if (EXT4_HAS_RO_COMPAT_FEATURE(sb, EXT4_FEATURE_RO_COMPAT_GDT_CSUM) &&
+            gdp->bg_flags & cpu_to_le16(EXT4_BG_BLOCK_UNINIT)) {
+                struct buffer_head *block_bh = read_block_bitmap(sb, group);
+
+                BUFFER_TRACE(block_bh, "get block bitmap access");
+                err = ext4_journal_get_write_access(handle, block_bh);
+                if (err) {
+                        brelse(block_bh);
+                        goto fail;
+                }
+
+                free = 0;
+                spin_lock(sb_bgl_lock(sbi, group));
+                /* recheck and clear flag under lock if we still need to */
+                if (gdp->bg_flags & cpu_to_le16(EXT4_BG_BLOCK_UNINIT)) {
+                        gdp->bg_flags &= cpu_to_le16(~EXT4_BG_BLOCK_UNINIT);
+                        free = ext4_free_blocks_after_init(sb, group, gdp);
+                        gdp->bg_free_blocks_count = cpu_to_le16(free);
+                }
+                spin_unlock(sb_bgl_lock(sbi, group));
+
+                /* Don't need to dirty bitmap block if we didn't change it */
+                if (free) {
+                        BUFFER_TRACE(block_bh, "dirty block bitmap");
+                        err = ext4_journal_dirty_metadata(handle, block_bh);
+                }
+
+                brelse(block_bh);
+                if (err)
+                        goto fail;
+        }
+
         spin_lock(sb_bgl_lock(sbi, group));
+        /* If we didn't allocate from within the initialized part of the inode
+         * table then we need to initialize up to this inode. */
+        if (EXT4_HAS_RO_COMPAT_FEATURE(sb, EXT4_FEATURE_RO_COMPAT_GDT_CSUM)) {
+                if (gdp->bg_flags & cpu_to_le16(EXT4_BG_INODE_UNINIT)) {
+                        gdp->bg_flags &= cpu_to_le16(~EXT4_BG_INODE_UNINIT);
+
+                        /* When marking the block group with
+                         * ~EXT4_BG_INODE_UNINIT we don't want to depend
+                         * on the value of bg_itable_unsed even though
+                         * mke2fs could have initialized the same for us.
+                         * Instead we calculated the value below
+                         */
+
+                        free = 0;
+                } else {
+                        free = EXT4_INODES_PER_GROUP(sb) -
+                                le16_to_cpu(gdp->bg_itable_unused);
+                }
+
+                /*
+                 * Check the relative inode number against the last used
+                 * relative inode number in this group. if it is greater
+                 * we need to  update the bg_itable_unused count
+                 *
+                 */
+                if (ino > free)
+                        gdp->bg_itable_unused =
+                                cpu_to_le16(EXT4_INODES_PER_GROUP(sb) - ino);
+        }
+
         gdp->bg_free_inodes_count =
                 cpu_to_le16(le16_to_cpu(gdp->bg_free_inodes_count) - 1);
         if (S_ISDIR(mode)) {
                 gdp->bg_used_dirs_count =
                         cpu_to_le16(le16_to_cpu(gdp->bg_used_dirs_count) + 1);
         }
+        gdp->bg_checksum = ext4_group_desc_csum(sbi, group, gdp);
         spin_unlock(sb_bgl_lock(sbi, group));
         BUFFER_TRACE(bh2, "call ext4_journal_dirty_metadata");
         err = ext4_journal_dirty_metadata(handle, bh2);
@@ -557,7 +685,7 @@ got:
                 inode->i_gid = current->fsgid;
         inode->i_mode = mode;
 
-        inode->i_ino = ino;
+        inode->i_ino = ino + group * EXT4_INODES_PER_GROUP(sb);
         /* This is the optimal IO size (for stat), not the fs block size */
         inode->i_blocks = 0;
         inode->i_mtime = inode->i_atime = inode->i_ctime = ei->i_crtime =