rearrange-initialization-for-EXT4FS_DEBUG

   1 ext4: rearrange initialization to fix EXT4FS_DEBUG
   2
   3 The EXT4FS_DEBUG is a *very* developer specific #ifdef designed for
   4 ext4 developers only.  (You have to modify fs/ext4/ext4.h to enable
   5 it.)
   6
   7 Rearrange how we initialize data structures to avoid calling
   8 ext4_count_free_clusters() until the multiblock allocator has been
   9 initialized.
  10
  11 This also allows us to only call ext4_count_free_clusters() once, and
  12 simplifies the code somewhat.
  13
  14 (Thanks to Chen Gang <gang.chen.5i5j@gmail.com> for pointing out a
  15 !CONFIG_SMP compile breakage in the original patch.)
  16
  17 Signed-off-by: Theodore Ts'o <tytso@mit.edu>
  18 Reviewed-by: Lukas Czerner <lczerner@redhat.com>
  19
  20 ---
  21  fs/ext4/super.c | 88 ++++++++++++++++++++++++++++++++++++---------------------------------------------
  22  1 file changed, 39 insertions(+), 49 deletions(-)
  23
  24 diff --git a/fs/ext4/super.c b/fs/ext4/super.c
  25 index 6df7bc6..32b43ad 100644
  26 --- a/fs/ext4/super.c
  27 +++ b/fs/ext4/super.c
  28 @@ -2142,10 +2142,6 @@ static int ext4_check_descriptors(struct super_block *sb,
  29         }
  30         if (NULL != first_not_zeroed)
  31                 *first_not_zeroed = grp;
  32 -
  33 -       ext4_free_blocks_count_set(sbi->s_es,
  34 -                                  EXT4_C2B(sbi, ext4_count_free_clusters(sb)));
  35 -       sbi->s_es->s_free_inodes_count =cpu_to_le32(ext4_count_free_inodes(sb));
  36         return 1;
  37  }
  38
  39 @@ -3883,13 +3879,6 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
  40                 ext4_msg(sb, KERN_ERR, "group descriptors corrupted!");
  41                 goto failed_mount2;
  42         }
  43 -       if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_FLEX_BG))
  44 -               if (!ext4_fill_flex_info(sb)) {
  45 -                       ext4_msg(sb, KERN_ERR,
  46 -                              "unable to initialize "
  47 -                              "flex_bg meta info!");
  48 -                       goto failed_mount2;
  49 -               }
  50
  51         sbi->s_gdb_count = db_count;
  52         get_random_bytes(&sbi->s_next_generation, sizeof(u32));
  53 @@ -3902,23 +3891,7 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
  54         /* Register extent status tree shrinker */
  55         ext4_es_register_shrinker(sbi);
  56
  57 -       err = percpu_counter_init(&sbi->s_freeclusters_counter,
  58 -                       ext4_count_free_clusters(sb));
  59 -       if (!err) {
  60 -               err = percpu_counter_init(&sbi->s_freeinodes_counter,
  61 -                               ext4_count_free_inodes(sb));
  62 -       }
  63 -       if (!err) {
  64 -               err = percpu_counter_init(&sbi->s_dirs_counter,
  65 -                               ext4_count_dirs(sb));
  66 -       }
  67 -       if (!err) {
  68 -               err = percpu_counter_init(&sbi->s_dirtyclusters_counter, 0);
  69 -       }
  70 -       if (!err) {
  71 -               err = percpu_counter_init(&sbi->s_extent_cache_cnt, 0);
  72 -       }
  73 -       if (err) {
  74 +       if ((err = percpu_counter_init(&sbi->s_extent_cache_cnt, 0)) != 0) {
  75                 ext4_msg(sb, KERN_ERR, "insufficient memory");
  76                 goto failed_mount3;
  77         }
  78 @@ -4022,18 +3995,6 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
  79
  80         sbi->s_journal->j_commit_callback = ext4_journal_commit_callback;
  81
  82 -       /*
  83 -        * The journal may have updated the bg summary counts, so we
  84 -        * need to update the global counters.
  85 -        */
  86 -       percpu_counter_set(&sbi->s_freeclusters_counter,
  87 -                          ext4_count_free_clusters(sb));
  88 -       percpu_counter_set(&sbi->s_freeinodes_counter,
  89 -                          ext4_count_free_inodes(sb));
  90 -       percpu_counter_set(&sbi->s_dirs_counter,
  91 -                          ext4_count_dirs(sb));
  92 -       percpu_counter_set(&sbi->s_dirtyclusters_counter, 0);
  93 -
  94  no_journal:
  95         if (ext4_mballoc_ready) {
  96                 sbi->s_mb_cache = ext4_xattr_create_cache(sb->s_id);
  97 @@ -4141,6 +4102,33 @@ no_journal:
  98                 goto failed_mount5;
  99         }
 100
 101 +       block = ext4_count_free_clusters(sb);
 102 +       ext4_free_blocks_count_set(sbi->s_es,
 103 +                                  EXT4_C2B(sbi, block));
 104 +       err = percpu_counter_init(&sbi->s_freeclusters_counter, block);
 105 +       if (!err) {
 106 +               unsigned long freei = ext4_count_free_inodes(sb);
 107 +               sbi->s_es->s_free_inodes_count = cpu_to_le32(freei);
 108 +               err = percpu_counter_init(&sbi->s_freeinodes_counter, freei);
 109 +       }
 110 +       if (!err)
 111 +               err = percpu_counter_init(&sbi->s_dirs_counter,
 112 +                                         ext4_count_dirs(sb));
 113 +       if (!err)
 114 +               err = percpu_counter_init(&sbi->s_dirtyclusters_counter, 0);
 115 +       if (err) {
 116 +               ext4_msg(sb, KERN_ERR, "insufficient memory");
 117 +               goto failed_mount6;
 118 +       }
 119 +
 120 +       if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_FLEX_BG))
 121 +               if (!ext4_fill_flex_info(sb)) {
 122 +                       ext4_msg(sb, KERN_ERR,
 123 +                              "unable to initialize "
 124 +                              "flex_bg meta info!");
 125 +                       goto failed_mount6;
 126 +               }
 127 +
 128         err = ext4_register_li_request(sb, first_not_zeroed);
 129         if (err)
 130                 goto failed_mount6;
 131 @@ -4215,6 +4203,12 @@ failed_mount7:
 132         ext4_unregister_li_request(sb);
 133  failed_mount6:
 134         ext4_mb_release(sb);
 135 +       if (sbi->s_flex_groups)
 136 +               ext4_kvfree(sbi->s_flex_groups);
 137 +       percpu_counter_destroy(&sbi->s_freeclusters_counter);
 138 +       percpu_counter_destroy(&sbi->s_freeinodes_counter);
 139 +       percpu_counter_destroy(&sbi->s_dirs_counter);
 140 +       percpu_counter_destroy(&sbi->s_dirtyclusters_counter);
 141  failed_mount5:
 142         ext4_ext_release(sb);
 143         ext4_release_system_zone(sb);
 144 @@ -4233,12 +4227,6 @@ failed_mount_wq:
 145  failed_mount3:
 146         ext4_es_unregister_shrinker(sbi);
 147         del_timer_sync(&sbi->s_err_report);
 148 -       if (sbi->s_flex_groups)
 149 -               ext4_kvfree(sbi->s_flex_groups);
 150 -       percpu_counter_destroy(&sbi->s_freeclusters_counter);
 151 -       percpu_counter_destroy(&sbi->s_freeinodes_counter);
 152 -       percpu_counter_destroy(&sbi->s_dirs_counter);
 153 -       percpu_counter_destroy(&sbi->s_dirtyclusters_counter);
 154         percpu_counter_destroy(&sbi->s_extent_cache_cnt);
 155         if (sbi->s_mmp_tsk)
 156                 kthread_stop(sbi->s_mmp_tsk);
 157 @@ -4556,11 +4544,13 @@ static int ext4_commit_super(struct super_block *sb, int sync)
 158         else
 159                 es->s_kbytes_written =
 160                         cpu_to_le64(EXT4_SB(sb)->s_kbytes_written);
 161 -       ext4_free_blocks_count_set(es,
 162 +       if (percpu_counter_initialized(&EXT4_SB(sb)->s_freeclusters_counter))
 163 +               ext4_free_blocks_count_set(es,
 164                         EXT4_C2B(EXT4_SB(sb), percpu_counter_sum_positive(
 165                                 &EXT4_SB(sb)->s_freeclusters_counter)));
 166 -       es->s_free_inodes_count =
 167 -               cpu_to_le32(percpu_counter_sum_positive(
 168 +       if (percpu_counter_initialized(&EXT4_SB(sb)->s_freeinodes_counter))
 169 +               es->s_free_inodes_count =
 170 +                       cpu_to_le32(percpu_counter_sum_positive(
 171                                 &EXT4_SB(sb)->s_freeinodes_counter));
 172         BUFFER_TRACE(sbh, "marking dirty");
 173         ext4_superblock_csum_set(sb);