ldiskfs/kernel_patches/patches/suse15/ext4-corrupted-inode-block-bitmaps-handling-patches.patch

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