new-ext4_mark_group_bitmap_corrupted-helper

   1 ext4: add new ext4_mark_group_bitmap_corrupted() helper
   2
   3 From: Wang Shilong <wshilong@ddn.com>
   4
   5 Since there are many places to set inode/block bitmap
   6 corrupt bit, add a new helper for it, which will make
   7 codes more clear.
   8
   9 Signed-off-by: Wang Shilong <wshilong@ddn.com>
  10 Signed-off-by: Theodore Ts'o <tytso@mit.edu>
  11 Reviewed-by: Andreas Dilger <adilger@dilger.ca>
  12 ---
  13  fs/ext4/balloc.c  | 29 +++++++----------------------
  14  fs/ext4/ext4.h    |  7 +++++++
  15  fs/ext4/ialloc.c  | 20 ++++----------------
  16  fs/ext4/mballoc.c | 14 ++++----------
  17  fs/ext4/super.c   | 30 ++++++++++++++++++++++++++++++
  18  5 files changed, 52 insertions(+), 48 deletions(-)
  19
  20 diff --git a/fs/ext4/balloc.c b/fs/ext4/balloc.c
  21 index a33d8fb1bf2a..0ac442aff7b8 100644
  22 --- a/fs/ext4/balloc.c
  23 +++ b/fs/ext4/balloc.c
  24 @@ -185,25 +185,15 @@ static int ext4_init_block_bitmap(struct super_block *sb,
  25         struct ext4_sb_info *sbi = EXT4_SB(sb);
  26         ext4_fsblk_t start, tmp;
  27         int flex_bg = 0;
  28 -       struct ext4_group_info *grp;
  29
  30         J_ASSERT_BH(bh, buffer_locked(bh));
  31
  32         /* If checksum is bad mark all blocks used to prevent allocation
  33          * essentially implementing a per-group read-only flag. */
  34         if (!ext4_group_desc_csum_verify(sb, block_group, gdp)) {
  35 -               grp = ext4_get_group_info(sb, block_group);
  36 -               if (!EXT4_MB_GRP_BBITMAP_CORRUPT(grp))
  37 -                       percpu_counter_sub(&sbi->s_freeclusters_counter,
  38 -                                          grp->bb_free);
  39 -               set_bit(EXT4_GROUP_INFO_BBITMAP_CORRUPT_BIT, &grp->bb_state);
  40 -               if (!EXT4_MB_GRP_IBITMAP_CORRUPT(grp)) {
  41 -                       int count;
  42 -                       count = ext4_free_inodes_count(sb, gdp);
  43 -                       percpu_counter_sub(&sbi->s_freeinodes_counter,
  44 -                                          count);
  45 -               }
  46 -               set_bit(EXT4_GROUP_INFO_IBITMAP_CORRUPT_BIT, &grp->bb_state);
  47 +               ext4_mark_group_bitmap_corrupted(sb, block_group,
  48 +                                       EXT4_GROUP_INFO_BBITMAP_CORRUPT |
  49 +                                       EXT4_GROUP_INFO_IBITMAP_CORRUPT);
  50                 return -EFSBADCRC;
  51         }
  52         memset(bh->b_data, 0, sb->s_blocksize);
  53 @@ -374,7 +364,6 @@ static int ext4_validate_block_bitmap(struct super_block *sb,
  54  {
  55         ext4_fsblk_t    blk;
  56         struct ext4_group_info *grp = ext4_get_group_info(sb, block_group);
  57 -       struct ext4_sb_info *sbi = EXT4_SB(sb);
  58
  59         if (buffer_verified(bh))
  60                 return 0;
  61 @@ -386,10 +375,8 @@ static int ext4_validate_block_bitmap(struct super_block *sb,
  62                         desc, bh))) {
  63                 ext4_unlock_group(sb, block_group);
  64                 ext4_error(sb, "bg %u: bad block bitmap checksum", block_group);
  65 -               if (!EXT4_MB_GRP_BBITMAP_CORRUPT(grp))
  66 -                       percpu_counter_sub(&sbi->s_freeclusters_counter,
  67 -                                          grp->bb_free);
  68 -               set_bit(EXT4_GROUP_INFO_BBITMAP_CORRUPT_BIT, &grp->bb_state);
  69 +               ext4_mark_group_bitmap_corrupted(sb, block_group,
  70 +                                       EXT4_GROUP_INFO_BBITMAP_CORRUPT);
  71                 return -EFSBADCRC;
  72         }
  73         blk = ext4_valid_block_bitmap(sb, desc, block_group, bh);
  74 @@ -397,10 +384,8 @@ static int ext4_validate_block_bitmap(struct super_block *sb,
  75                 ext4_unlock_group(sb, block_group);
  76                 ext4_error(sb, "bg %u: block %llu: invalid block bitmap",
  77                            block_group, blk);
  78 -               if (!EXT4_MB_GRP_BBITMAP_CORRUPT(grp))
  79 -                       percpu_counter_sub(&sbi->s_freeclusters_counter,
  80 -                                          grp->bb_free);
  81 -               set_bit(EXT4_GROUP_INFO_BBITMAP_CORRUPT_BIT, &grp->bb_state);
  82 +               ext4_mark_group_bitmap_corrupted(sb, block_group,
  83 +                                       EXT4_GROUP_INFO_BBITMAP_CORRUPT);
  84                 return -EFSCORRUPTED;
  85         }
  86         set_buffer_verified(bh);
  87 diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h
  88 index a42e71203e53..fa52b7dd4542 100644
  89 --- a/fs/ext4/ext4.h
  90 +++ b/fs/ext4/ext4.h
  91 @@ -2530,6 +2530,9 @@ extern int ext4_alloc_flex_bg_array(struct super_block *sb,
  92                                     ext4_group_t ngroup);
  93  extern const char *ext4_decode_error(struct super_block *sb, int errno,
  94                                      char nbuf[16]);
  95 +extern void ext4_mark_group_bitmap_corrupted(struct super_block *sb,
  96 +                                            ext4_group_t block_group,
  97 +                                            unsigned int flags);
  98
  99  extern __printf(4, 5)
 100  void __ext4_error(struct super_block *, const char *, unsigned int,
 101 @@ -2857,6 +2860,10 @@ struct ext4_group_info {
 102  #define EXT4_GROUP_INFO_WAS_TRIMMED_BIT                1
 103  #define EXT4_GROUP_INFO_BBITMAP_CORRUPT_BIT    2
 104  #define EXT4_GROUP_INFO_IBITMAP_CORRUPT_BIT    3
 105 +#define EXT4_GROUP_INFO_BBITMAP_CORRUPT                \
 106 +       (1 << EXT4_GROUP_INFO_BBITMAP_CORRUPT_BIT)
 107 +#define EXT4_GROUP_INFO_IBITMAP_CORRUPT                \
 108 +       (1 << EXT4_GROUP_INFO_IBITMAP_CORRUPT_BIT)
 109
 110  #define EXT4_MB_GRP_NEED_INIT(grp)     \
 111         (test_bit(EXT4_GROUP_INFO_NEED_INIT_BIT, &((grp)->bb_state)))
 112 diff --git a/fs/ext4/ialloc.c b/fs/ext4/ialloc.c
 113 index 33a2c98ce1ff..95611cf9f552 100644
 114 --- a/fs/ext4/ialloc.c
 115 +++ b/fs/ext4/ialloc.c
 116 @@ -83,7 +83,6 @@ static int ext4_validate_inode_bitmap(struct super_block *sb,
 117  {
 118         ext4_fsblk_t    blk;
 119         struct ext4_group_info *grp = ext4_get_group_info(sb, block_group);
 120 -       struct ext4_sb_info *sbi = EXT4_SB(sb);
 121
 122         if (buffer_verified(bh))
 123                 return 0;
 124 @@ -97,14 +96,8 @@ static int ext4_validate_inode_bitmap(struct super_block *sb,
 125                 ext4_unlock_group(sb, block_group);
 126                 ext4_error(sb, "Corrupt inode bitmap - block_group = %u, "
 127                            "inode_bitmap = %llu", block_group, blk);
 128 -               grp = ext4_get_group_info(sb, block_group);
 129 -               if (!EXT4_MB_GRP_IBITMAP_CORRUPT(grp)) {
 130 -                       int count;
 131 -                       count = ext4_free_inodes_count(sb, desc);
 132 -                       percpu_counter_sub(&sbi->s_freeinodes_counter,
 133 -                                          count);
 134 -               }
 135 -               set_bit(EXT4_GROUP_INFO_IBITMAP_CORRUPT_BIT, &grp->bb_state);
 136 +               ext4_mark_group_bitmap_corrupted(sb, block_group,
 137 +                                       EXT4_GROUP_INFO_IBITMAP_CORRUPT);
 138                 return -EFSBADCRC;
 139         }
 140         set_buffer_verified(bh);
 141 @@ -337,13 +330,8 @@ void ext4_free_inode(handle_t *handle, struct inode *inode)
 142                         fatal = err;
 143         } else {
 144                 ext4_error(sb, "bit already cleared for inode %lu", ino);
 145 -               if (gdp && !EXT4_MB_GRP_IBITMAP_CORRUPT(grp)) {
 146 -                       int count;
 147 -                       count = ext4_free_inodes_count(sb, gdp);
 148 -                       percpu_counter_sub(&sbi->s_freeinodes_counter,
 149 -                                          count);
 150 -               }
 151 -               set_bit(EXT4_GROUP_INFO_IBITMAP_CORRUPT_BIT, &grp->bb_state);
 152 +               ext4_mark_group_bitmap_corrupted(sb, block_group,
 153 +                                       EXT4_GROUP_INFO_IBITMAP_CORRUPT);
 154         }
 155
 156  error_return:
 157 diff --git a/fs/ext4/mballoc.c b/fs/ext4/mballoc.c
 158 index 769a62708b1c..bc2d1eb9fd5d 100644
 159 --- a/fs/ext4/mballoc.c
 160 +++ b/fs/ext4/mballoc.c
 161 @@ -747,10 +747,8 @@ void ext4_mb_generate_buddy(struct super_block *sb,
 162                  * corrupt and update bb_free using bitmap value
 163                  */
 164                 grp->bb_free = free;
 165 -               if (!EXT4_MB_GRP_BBITMAP_CORRUPT(grp))
 166 -                       percpu_counter_sub(&sbi->s_freeclusters_counter,
 167 -                                          grp->bb_free);
 168 -               set_bit(EXT4_GROUP_INFO_BBITMAP_CORRUPT_BIT, &grp->bb_state);
 169 +               ext4_mark_group_bitmap_corrupted(sb, group,
 170 +                                       EXT4_GROUP_INFO_BBITMAP_CORRUPT);
 171         }
 172         mb_set_largest_free_order(sb, grp);
 173
 174 @@ -1454,12 +1452,8 @@ static void mb_free_blocks(struct inode *inode, struct ext4_buddy *e4b,
 175                                       "freeing already freed block "
 176                                       "(bit %u); block bitmap corrupt.",
 177                                       block);
 178 -               if (!EXT4_MB_GRP_BBITMAP_CORRUPT(e4b->bd_info))
 179 -                       percpu_counter_sub(&sbi->s_freeclusters_counter,
 180 -                                          e4b->bd_info->bb_free);
 181 -               /* Mark the block group as corrupt. */
 182 -               set_bit(EXT4_GROUP_INFO_BBITMAP_CORRUPT_BIT,
 183 -                       &e4b->bd_info->bb_state);
 184 +               ext4_mark_group_bitmap_corrupted(sb, e4b->bd_group,
 185 +                               EXT4_GROUP_INFO_BBITMAP_CORRUPT);
 186                 mb_regenerate_buddy(e4b);
 187                 goto done;
 188         }
 189 diff --git a/fs/ext4/super.c b/fs/ext4/super.c
 190 index 185f7e61f4cf..f5e9a1af067a 100644
 191 --- a/fs/ext4/super.c
 192 +++ b/fs/ext4/super.c
 193 @@ -763,6 +763,36 @@ __acquires(bitlock)
 194         return;
 195  }
 196
 197 +void ext4_mark_group_bitmap_corrupted(struct super_block *sb,
 198 +                                    ext4_group_t group,
 199 +                                    unsigned int flags)
 200 +{
 201 +       struct ext4_sb_info *sbi = EXT4_SB(sb);
 202 +       struct ext4_group_info *grp = ext4_get_group_info(sb, group);
 203 +       struct ext4_group_desc *gdp = ext4_get_group_desc(sb, group, NULL);
 204 +
 205 +       if ((flags & EXT4_GROUP_INFO_BBITMAP_CORRUPT) &&
 206 +           !EXT4_MB_GRP_BBITMAP_CORRUPT(grp)) {
 207 +               percpu_counter_sub(&sbi->s_freeclusters_counter,
 208 +                                       grp->bb_free);
 209 +               set_bit(EXT4_GROUP_INFO_BBITMAP_CORRUPT_BIT,
 210 +                       &grp->bb_state);
 211 +       }
 212 +
 213 +       if ((flags & EXT4_GROUP_INFO_IBITMAP_CORRUPT) &&
 214 +           !EXT4_MB_GRP_IBITMAP_CORRUPT(grp)) {
 215 +               if (gdp) {
 216 +                       int count;
 217 +
 218 +                       count = ext4_free_inodes_count(sb, gdp);
 219 +                       percpu_counter_sub(&sbi->s_freeinodes_counter,
 220 +                                          count);
 221 +               }
 222 +               set_bit(EXT4_GROUP_INFO_IBITMAP_CORRUPT_BIT,
 223 +                       &grp->bb_state);
 224 +       }
 225 +}
 226 +
 227  void ext4_update_dynamic_rev(struct super_block *sb)
 228  {
 229         struct ext4_super_block *es = EXT4_SB(sb)->s_es;
 230 --
 231 2.14.3
 232
 233