ext4: New inode allocation for FLEX_BG meta-data groups.

This patch mostly controls the way inode are allocated in order to
make ialloc aware of flex_bg block group grouping.  It achieves this
by bypassing the Orlov allocator when block group meta-data are packed
toghether through mke2fs.  Since the impact on the block allocator is
minimal, this patch should have little or no effect on other block
allocation algorithms. By controlling the inode allocation, it can
basically control where the initial search for new block begins and
thus indirectly manipulate the block allocator.

This allocator favors data and meta-data locality so the disk will
gradually be filled from block group zero upward.  This helps improve
performance by reducing seek time.  Since the group of inode tables
within one flex_bg are treated as one giant inode table, uninitialized
block groups would not need to partially initialize as many inode
table as with Orlov which would help fsck time as the filesystem usage
goes up.

Signed-off-by: Jose R. Santos <jrs@us.ibm.com>
Signed-off-by: Valerie Clement <valerie.clement@bull.net>
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>

1 files changed, 57 insertions, 0 deletions

diff --git a/fs/ext4/super.c b/fs/ext4/super.c
index 588cfb408642..b9ad3d852061 100644
--- a/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@ -517,6 +517,7 @@ static void ext4_put_super (struct super_block * sb)
         for (i = 0; i < sbi->s_gdb_count; i++)
                 brelse(sbi->s_group_desc[i]);
         kfree(sbi->s_group_desc);
+        kfree(sbi->s_flex_groups);
         percpu_counter_destroy(&sbi->s_freeblocks_counter);
         percpu_counter_destroy(&sbi->s_freeinodes_counter);
         percpu_counter_destroy(&sbi->s_dirs_counter);
@@ -1442,6 +1443,54 @@ static int ext4_setup_super(struct super_block *sb, struct ext4_super_block *es,
         return res;
 }
 
+static int ext4_fill_flex_info(struct super_block *sb)
+{
+        struct ext4_sb_info *sbi = EXT4_SB(sb);
+        struct ext4_group_desc *gdp = NULL;
+        struct buffer_head *bh;
+        ext4_group_t flex_group_count;
+        ext4_group_t flex_group;
+        int groups_per_flex = 0;
+        __u64 block_bitmap = 0;
+        int i;
+
+        if (!sbi->s_es->s_log_groups_per_flex) {
+                sbi->s_log_groups_per_flex = 0;
+                return 1;
+        }
+
+        sbi->s_log_groups_per_flex = sbi->s_es->s_log_groups_per_flex;
+        groups_per_flex = 1 << sbi->s_log_groups_per_flex;
+
+        flex_group_count = (sbi->s_groups_count + groups_per_flex - 1) /
+                groups_per_flex;
+        sbi->s_flex_groups = kmalloc(flex_group_count *
+                                     sizeof(struct flex_groups), GFP_KERNEL);
+        if (sbi->s_flex_groups == NULL) {
+                printk(KERN_ERR "EXT4-fs: not enough memory\n");
+                goto failed;
+        }
+        memset(sbi->s_flex_groups, 0, flex_group_count *
+               sizeof(struct flex_groups));
+
+        gdp = ext4_get_group_desc(sb, 1, &bh);
+        block_bitmap = ext4_block_bitmap(sb, gdp) - 1;
+
+        for (i = 0; i < sbi->s_groups_count; i++) {
+                gdp = ext4_get_group_desc(sb, i, &bh);
+
+                flex_group = ext4_flex_group(sbi, i);
+                sbi->s_flex_groups[flex_group].free_inodes +=
+                        le16_to_cpu(gdp->bg_free_inodes_count);
+                sbi->s_flex_groups[flex_group].free_blocks +=
+                        le16_to_cpu(gdp->bg_free_blocks_count);
+        }
+
+        return 1;
+failed:
+        return 0;
+}
+
 __le16 ext4_group_desc_csum(struct ext4_sb_info *sbi, __u32 block_group,
                             struct ext4_group_desc *gdp)
 {
@@ -2137,6 +2186,14 @@ static int ext4_fill_super (struct super_block *sb, void *data, int silent)
                 printk(KERN_ERR "EXT4-fs: group descriptors corrupted!\n");
                 goto failed_mount2;
         }
+        if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_FLEX_BG))
+                if (!ext4_fill_flex_info(sb)) {
+                        printk(KERN_ERR
+                               "EXT4-fs: unable to initialize "
+                               "flex_bg meta info!\n");
+                        goto failed_mount2;
+                }
+
         sbi->s_gdb_count = db_count;
         get_random_bytes(&sbi->s_next_generation, sizeof(u32));
         spin_lock_init(&sbi->s_next_gen_lock);