ext4: add a function which updates the super block during online resizing

This patch adds a function named ext4_update_super() which updates
super block so the newly created block groups are visible to the file
system.  This code is copied from ext4_group_add().

The function will be used by new resize implementation.

Signed-off-by: Yongqiang Yang <xiaoqiangnk@gmail.com>
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>

1 files changed, 94 insertions, 0 deletions

diff --git a/fs/ext4/resize.c b/fs/ext4/resize.c
index 098bdb8e97cb..eb0aebcca55f 100644
--- a/fs/ext4/resize.c
+++ b/fs/ext4/resize.c
@@ -1142,6 +1142,100 @@ static int ext4_setup_new_descs(handle_t *handle, struct super_block *sb,
         return err;
 }
 
+/*
+ * ext4_update_super() updates the super block so that the newly added
+ * groups can be seen by the filesystem.
+ *
+ * @sb: super block
+ * @flex_gd: new added groups
+ */
+static void ext4_update_super(struct super_block *sb,
+                             struct ext4_new_flex_group_data *flex_gd)
+{
+        ext4_fsblk_t blocks_count = 0;
+        ext4_fsblk_t free_blocks = 0;
+        ext4_fsblk_t reserved_blocks = 0;
+        struct ext4_new_group_data *group_data = flex_gd->groups;
+        struct ext4_sb_info *sbi = EXT4_SB(sb);
+        struct ext4_super_block *es = sbi->s_es;
+        int i;
+
+        BUG_ON(flex_gd->count == 0 || group_data == NULL);
+        /*
+         * Make the new blocks and inodes valid next.  We do this before
+         * increasing the group count so that once the group is enabled,
+         * all of its blocks and inodes are already valid.
+         *
+         * We always allocate group-by-group, then block-by-block or
+         * inode-by-inode within a group, so enabling these
+         * blocks/inodes before the group is live won't actually let us
+         * allocate the new space yet.
+         */
+        for (i = 0; i < flex_gd->count; i++) {
+                blocks_count += group_data[i].blocks_count;
+                free_blocks += group_data[i].free_blocks_count;
+        }
+
+        reserved_blocks = ext4_r_blocks_count(es) * 100;
+        do_div(reserved_blocks, ext4_blocks_count(es));
+        reserved_blocks *= blocks_count;
+        do_div(reserved_blocks, 100);
+
+        ext4_blocks_count_set(es, ext4_blocks_count(es) + blocks_count);
+        le32_add_cpu(&es->s_inodes_count, EXT4_INODES_PER_GROUP(sb) *
+                     flex_gd->count);
+
+        /*
+         * We need to protect s_groups_count against other CPUs seeing
+         * inconsistent state in the superblock.
+         *
+         * The precise rules we use are:
+         *
+         * * Writers must perform a smp_wmb() after updating all
+         *   dependent data and before modifying the groups count
+         *
+         * * Readers must perform an smp_rmb() after reading the groups
+         *   count and before reading any dependent data.
+         *
+         * NB. These rules can be relaxed when checking the group count
+         * while freeing data, as we can only allocate from a block
+         * group after serialising against the group count, and we can
+         * only then free after serialising in turn against that
+         * allocation.
+         */
+        smp_wmb();
+
+        /* Update the global fs size fields */
+        sbi->s_groups_count += flex_gd->count;
+
+        /* Update the reserved block counts only once the new group is
+         * active. */
+        ext4_r_blocks_count_set(es, ext4_r_blocks_count(es) +
+                                reserved_blocks);
+
+        /* Update the free space counts */
+        percpu_counter_add(&sbi->s_freeclusters_counter,
+                           EXT4_B2C(sbi, free_blocks));
+        percpu_counter_add(&sbi->s_freeinodes_counter,
+                           EXT4_INODES_PER_GROUP(sb) * flex_gd->count);
+
+        if (EXT4_HAS_INCOMPAT_FEATURE(sb,
+                                      EXT4_FEATURE_INCOMPAT_FLEX_BG) &&
+            sbi->s_log_groups_per_flex) {
+                ext4_group_t flex_group;
+                flex_group = ext4_flex_group(sbi, group_data[0].group);
+                atomic_add(EXT4_B2C(sbi, free_blocks),
+                           &sbi->s_flex_groups[flex_group].free_clusters);
+                atomic_add(EXT4_INODES_PER_GROUP(sb) * flex_gd->count,
+                           &sbi->s_flex_groups[flex_group].free_inodes);
+        }
+
+        if (test_opt(sb, DEBUG))
+                printk(KERN_DEBUG "EXT4-fs: added group %u:"
+                       "%llu blocks(%llu free %llu reserved)\n", flex_gd->count,
+                       blocks_count, free_blocks, reserved_blocks);
+}
+
 /* Add group descriptor data to an existing or new group descriptor block.
  * Ensure we handle all possible error conditions _before_ we start modifying
  * the filesystem, because we cannot abort the transaction and not have it