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

   1 Since we could skip corrupt block groups, this patch
   2 use ext4_warning() intead of ext4_error() to make FS not
   3 emount RO in default, also fix a leftover from upstream
   4 commit 163a203ddb36c36d4a1c942
   5 ---
   6 diff --git a/fs/ext4/balloc.c b/fs/ext4/balloc.c
   7 index e069155..692b5e4 100644
   8 --- a/fs/ext4/balloc.c
   9 +++ b/fs/ext4/balloc.c
  10 @@ -183,25 +183,17 @@ static int ext4_init_block_bitmap(struct
  11         unsigned int bit, bit_max;
  12         struct ext4_sb_info *sbi = EXT4_SB(sb);
  13         ext4_fsblk_t start, tmp;
  14 -       struct ext4_group_info *grp;
  15
  16         J_ASSERT_BH(bh, buffer_locked(bh));
  17
  18         /* If checksum is bad mark all blocks used to prevent allocation
  19          * essentially implementing a per-group read-only flag. */
  20         if (!ext4_group_desc_csum_verify(sb, block_group, gdp)) {
  21 -               grp = ext4_get_group_info(sb, block_group);
  22 -               if (!EXT4_MB_GRP_BBITMAP_CORRUPT(grp))
  23 -                       percpu_counter_sub(&sbi->s_freeclusters_counter,
  24 -                                          grp->bb_free);
  25 -               set_bit(EXT4_GROUP_INFO_BBITMAP_CORRUPT_BIT, &grp->bb_state);
  26 -               if (!EXT4_MB_GRP_IBITMAP_CORRUPT(grp)) {
  27 -                       int count;
  28 -                       count = ext4_free_inodes_count(sb, gdp);
  29 -                       percpu_counter_sub(&sbi->s_freeinodes_counter,
  30 -                                          count);
  31 -               }
  32 -               set_bit(EXT4_GROUP_INFO_IBITMAP_CORRUPT_BIT, &grp->bb_state);
  33 +               ext4_corrupted_block_group(sb, block_group,
  34 +                               EXT4_GROUP_INFO_BBITMAP_CORRUPT |
  35 +                               EXT4_GROUP_INFO_IBITMAP_CORRUPT,
  36 +                               "Checksum bad for group %u",
  37 +                               block_group);
  38                 return -EFSBADCRC;
  39         }
  40         memset(bh->b_data, 0, sb->s_blocksize);
  41 @@ -370,7 +362,6 @@ static int ext4_validate_block_bitmap(st
  42  {
  43         ext4_fsblk_t    blk;
  44         struct ext4_group_info *grp = ext4_get_group_info(sb, block_group);
  45 -       struct ext4_sb_info *sbi = EXT4_SB(sb);
  46
  47         if (buffer_verified(bh))
  48                 return 0;
  49 @@ -381,22 +372,19 @@ static int ext4_validate_block_bitmap(st
  50         if (unlikely(!ext4_block_bitmap_csum_verify(sb, block_group,
  51                         desc, bh))) {
  52                 ext4_unlock_group(sb, block_group);
  53 -               ext4_error(sb, "bg %u: bad block bitmap checksum", block_group);
  54 -               if (!EXT4_MB_GRP_BBITMAP_CORRUPT(grp))
  55 -                       percpu_counter_sub(&sbi->s_freeclusters_counter,
  56 -                                          grp->bb_free);
  57 -               set_bit(EXT4_GROUP_INFO_BBITMAP_CORRUPT_BIT, &grp->bb_state);
  58 +               ext4_corrupted_block_group(sb, block_group,
  59 +                               EXT4_GROUP_INFO_BBITMAP_CORRUPT,
  60 +                               "bg %u: bad block bitmap checksum",
  61 +                               block_group);
  62                 return -EFSBADCRC;
  63         }
  64         blk = ext4_valid_block_bitmap(sb, desc, block_group, bh);
  65         if (unlikely(blk != 0)) {
  66                 ext4_unlock_group(sb, block_group);
  67 -               ext4_error(sb, "bg %u: block %llu: invalid block bitmap",
  68 -                          block_group, blk);
  69 -               if (!EXT4_MB_GRP_BBITMAP_CORRUPT(grp))
  70 -                       percpu_counter_sub(&sbi->s_freeclusters_counter,
  71 -                                          grp->bb_free);
  72 -               set_bit(EXT4_GROUP_INFO_BBITMAP_CORRUPT_BIT, &grp->bb_state);
  73 +               ext4_corrupted_block_group(sb, block_group,
  74 +                               EXT4_GROUP_INFO_BBITMAP_CORRUPT,
  75 +                               "bg %u: block %llu: invalid block bitmap",
  76 +                               block_group, blk);
  77                 return -EFSCORRUPTED;
  78         }
  79         set_buffer_verified(bh);
  80 @@ -467,8 +455,6 @@ ext4_read_block_bitmap_nowait(struct sup
  81                 ext4_unlock_group(sb, block_group);
  82                 unlock_buffer(bh);
  83                 if (err) {
  84 -                       ext4_error(sb, "Failed to init block bitmap for group "
  85 -                                  "%u: %d", block_group, err);
  86                         goto out;
  87                 }
  88                 goto verify;
  89 diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h
  90 index 3c41773..63a63b6 100644
  91 --- a/fs/ext4/ext4.h
  92 +++ b/fs/ext4/ext4.h
  93 @@ -91,6 +91,17 @@ typedef __u32 ext4_lblk_t;
  94  /* data type for block group number */
  95  typedef unsigned int ext4_group_t;
  96
  97 +void __ext4_corrupted_block_group(struct super_block *sb,
  98 +                                 ext4_group_t group, unsigned int flags,
  99 +                                 const char *function, unsigned int line);
 100 +
 101 +#define ext4_corrupted_block_group(sb, group, flags, fmt, ...)         \
 102 +       do {                                                            \
 103 +               __ext4_warning(sb, __func__, __LINE__, fmt,             \
 104 +                               ##__VA_ARGS__);                         \
 105 +               __ext4_corrupted_block_group(sb, group, flags,          \
 106 +                                       __func__, __LINE__);            \
 107 +       } while (0)
 108  /*
 109   * Flags used in mballoc's allocation_context flags field.
 110   *
 111 @@ -2673,7 +2684,11 @@ struct ext4_group_info {
 112  #define EXT4_GROUP_INFO_NEED_INIT_BIT          0
 113  #define EXT4_GROUP_INFO_WAS_TRIMMED_BIT                1
 114  #define EXT4_GROUP_INFO_BBITMAP_CORRUPT_BIT    2
 115 +#define EXT4_GROUP_INFO_BBITMAP_CORRUPT                \
 116 +       (1 << EXT4_GROUP_INFO_BBITMAP_CORRUPT_BIT)
 117  #define EXT4_GROUP_INFO_IBITMAP_CORRUPT_BIT    3
 118 +#define EXT4_GROUP_INFO_IBITMAP_CORRUPT                \
 119 +       (1 << EXT4_GROUP_INFO_IBITMAP_CORRUPT_BIT)
 120
 121  #define EXT4_MB_GRP_NEED_INIT(grp)     \
 122         (test_bit(EXT4_GROUP_INFO_NEED_INIT_BIT, &((grp)->bb_state)))
 123 diff --git a/fs/ext4/ialloc.c b/fs/ext4/ialloc.c
 124 index fc65310..92bcc8d 100644
 125 --- a/fs/ext4/ialloc.c
 126 +++ b/fs/ext4/ialloc.c
 127 @@ -337,14 +318,9 @@ out:
 128                 if (!fatal)
 129                         fatal = err;
 130         } else {
 131 -               ext4_error(sb, "bit already cleared for inode %lu", ino);
 132 -               if (gdp && !EXT4_MB_GRP_IBITMAP_CORRUPT(grp)) {
 133 -                       int count;
 134 -                       count = ext4_free_inodes_count(sb, gdp);
 135 -                       percpu_counter_sub(&sbi->s_freeinodes_counter,
 136 -                                          count);
 137 -               }
 138 -               set_bit(EXT4_GROUP_INFO_IBITMAP_CORRUPT_BIT, &grp->bb_state);
 139 +               ext4_corrupted_block_group(sb, block_group,
 140 +                               EXT4_GROUP_INFO_IBITMAP_CORRUPT,
 141 +                               "bit already cleared for inode %lu", ino);
 142         }
 143
 144  error_return:
 145 diff --git a/fs/ext4/mballoc.c b/fs/ext4/mballoc.c
 146 index 7282d07..e6805e6 100644
 147 --- a/fs/ext4/mballoc.c
 148 +++ b/fs/ext4/mballoc.c
 149 @@ -752,10 +752,18 @@ int ext4_mb_generate_buddy(struct super_block *sb,
 150         if (free != grp->bb_free) {
 151                 struct ext4_group_desc *gdp;
 152                 gdp = ext4_get_group_desc(sb, group, NULL);
 153 -               ext4_error(sb, "group %lu: %u blocks in bitmap, %u in bb, "
 154 -                       "%u in gd, %lu pa's\n", (long unsigned int)group,
 155 -                       free, grp->bb_free, ext4_free_group_clusters(sb, gdp),
 156 -                       grp->bb_prealloc_nr);
 157 +
 158 +               ext4_corrupted_block_group(sb, group,
 159 +                               EXT4_GROUP_INFO_BBITMAP_CORRUPT,
 160 +                               "group %lu: %u blocks in bitmap, %u in bb, %u in gd, %lu pa's block bitmap corrupt",
 161 +                               (unsigned long int)group, free, grp->bb_free,
 162 +                               ext4_free_group_clusters(sb, gdp),
 163 +                               grp->bb_prealloc_nr);
 164 +               /*
 165 +                * If we intend to continue, we consider group descriptor
 166 +                * corrupt and update bb_free using bitmap value
 167 +                */
 168 +               grp->bb_free = free;
 169                 return -EIO;
 170         }
 171         mb_set_largest_free_order(sb, grp);
 172 @@ -1101,7 +1109,7 @@ ext4_mb_load_buddy(struct super_block *sb, ext4_group_t group,
 173         int block;
 174         int pnum;
 175         int poff;
 176 -       struct page *page;
 177 +       struct page *page = NULL;
 178         int ret;
 179         struct ext4_group_info *grp;
 180         struct ext4_sb_info *sbi = EXT4_SB(sb);
 181 @@ -1127,7 +1135,7 @@ ext4_mb_load_buddy(struct super_block *sb, ext4_group_t group,
 182                  */
 183                 ret = ext4_mb_init_group(sb, group);
 184                 if (ret)
 185 -                       return ret;
 186 +                       goto err;
 187         }
 188
 189         /*
 190 @@ -1227,6 +1235,7 @@ err:
 191                 page_cache_release(e4b->bd_buddy_page);
 192         e4b->bd_buddy = NULL;
 193         e4b->bd_bitmap = NULL;
 194 +       ext4_warning(sb, "Error loading buddy information for %u", group);
 195         return ret;
 196  }
 197
 198 @@ -3599,9 +3608,11 @@ int ext4_mb_check_ondisk_bitmap(struct super_block *sb, void *bitmap,
 199         }
 200
 201         if (free != free_in_gdp) {
 202 -               ext4_error(sb, "on-disk bitmap for group %d"
 203 -                       "corrupted: %u blocks free in bitmap, %u - in gd\n",
 204 -                       group, free, free_in_gdp);
 205 +               ext4_corrupted_block_group(sb, group,
 206 +                               EXT4_GROUP_INFO_BBITMAP_CORRUPT,
 207 +                               "on-disk bitmap for group %d corrupted: %u blocks free in bitmap, %u - in gd\n",
 208 +                               group, free,
 209 +                               free_in_gdp);
 210                 return -EIO;
 211         }
 212         return 0;
 213 @@ -3962,16 +3973,8 @@ ext4_mb_release_inode_pa(struct ext4_buddy *e4b, struct buffer_head *bitmap_bh,
 214         /* "free < pa->pa_free" means we maybe double alloc the same blocks,
 215          * otherwise maybe leave some free blocks unavailable, no need to BUG.*/
 216         if ((free > pa->pa_free && !pa->pa_error) || (free < pa->pa_free)) {
 217 -               ext4_error(sb, "pa free mismatch: [pa %p] "
 218 -                               "[phy %lu] [logic %lu] [len %u] [free %u] "
 219 -                               "[error %u] [inode %lu] [freed %u]", pa,
 220 -                               (unsigned long)pa->pa_pstart,
 221 -                               (unsigned long)pa->pa_lstart,
 222 -                               (unsigned)pa->pa_len, (unsigned)pa->pa_free,
 223 -                               (unsigned)pa->pa_error, pa->pa_inode->i_ino,
 224 -                               free);
 225                 ext4_grp_locked_error(sb, group, 0, 0, "free %u, pa_free %u",
 226 -                                       free, pa->pa_free);
 227 +                                     free, pa->pa_free);
 228                 /*
 229                  * pa is already deleted so we use the value obtained
 230                  * from the bitmap and continue.
 231 @@ -4031,15 +4034,11 @@ ext4_mb_discard_group_preallocations(struct super_block *sb,
 232         bitmap_bh = ext4_read_block_bitmap(sb, group);
 233         if (IS_ERR(bitmap_bh)) {
 234                 err = PTR_ERR(bitmap_bh);
 235 -               ext4_error(sb, "Error %d reading block bitmap for %u",
 236 -                          err, group);
 237                 return 0;
 238         }
 239
 240         err = ext4_mb_load_buddy(sb, group, &e4b);
 241         if (err) {
 242 -               ext4_warning(sb, "Error %d loading buddy information for %u",
 243 -                            err, group);
 244                 put_bh(bitmap_bh);
 245                 return 0;
 246         }
 247 @@ -4198,17 +4198,12 @@ repeat:
 248
 249                 err = ext4_mb_load_buddy_gfp(sb, group, &e4b,
 250                                              GFP_NOFS|__GFP_NOFAIL);
 251 -               if (err) {
 252 -                       ext4_error(sb, "Error %d loading buddy information for %u",
 253 -                                  err, group);
 254 +               if (err)
 255                         return;
 256 -               }
 257
 258                 bitmap_bh = ext4_read_block_bitmap(sb, group);
 259                 if (IS_ERR(bitmap_bh)) {
 260                         err = PTR_ERR(bitmap_bh);
 261 -                       ext4_error(sb, "Error %d reading block bitmap for %u",
 262 -                                       err, group);
 263                         ext4_mb_unload_buddy(&e4b);
 264                         continue;
 265                 }
 266 @@ -4467,11 +4462,8 @@ ext4_mb_discard_lg_preallocations(struct super_block *sb,
 267
 268                 err = ext4_mb_load_buddy_gfp(sb, group, &e4b,
 269                                              GFP_NOFS|__GFP_NOFAIL);
 270 -               if (err) {
 271 -                       ext4_error(sb, "Error %d loading buddy information for %u",
 272 -                                  err, group);
 273 +               if (err)
 274                         continue;
 275 -               }
 276                 ext4_lock_group(sb, group);
 277                 list_del(&pa->pa_group_list);
 278                 ext4_get_group_info(sb, group)->bb_prealloc_nr--;
 279 @@ -4742,17 +4734,18 @@ errout:
 280                          * been updated or not when fail case. So can
 281                          * not revert pa_free back, just mark pa_error*/
 282                         pa->pa_error++;
 283 -                       ext4_error(sb,
 284 -                               "Updating bitmap error: [err %d] "
 285 -                               "[pa %p] [phy %lu] [logic %lu] "
 286 -                               "[len %u] [free %u] [error %u] "
 287 -                               "[inode %lu]", *errp, pa,
 288 -                               (unsigned long)pa->pa_pstart,
 289 -                               (unsigned long)pa->pa_lstart,
 290 -                               (unsigned)pa->pa_len,
 291 -                               (unsigned)pa->pa_free,
 292 -                               (unsigned)pa->pa_error,
 293 -                               pa->pa_inode ? pa->pa_inode->i_ino : 0);
 294 +                       ext4_corrupted_block_group(sb, 0, 0,
 295 +                                       "Updating bitmap error: [err %d] "
 296 +                                       "[pa %p] [phy %lu] [logic %lu] "
 297 +                                       "[len %u] [free %u] [error %u] "
 298 +                                       "[inode %lu]", *errp, pa,
 299 +                                       (unsigned long)pa->pa_pstart,
 300 +                                       (unsigned long)pa->pa_lstart,
 301 +                                       (unsigned)pa->pa_len,
 302 +                                       (unsigned)pa->pa_free,
 303 +                                       (unsigned)pa->pa_error,
 304 +                                       pa->pa_inode ?
 305 +                                       pa->pa_inode->i_ino : 0);
 306                 }
 307         }
 308         ext4_mb_release_context(ac);
 309 @@ -5037,7 +5030,7 @@ do_more:
 310
 311         err = ext4_mb_load_buddy(sb, block_group, &e4b);
 312         if (err)
 313 -               goto error_return;
 314 +               goto error_brelse;
 315
 316         if ((flags & EXT4_FREE_BLOCKS_METADATA) && ext4_handle_valid(handle)) {
 317                 struct ext4_free_data *new_entry;
 318 @@ -5119,8 +5112,9 @@ do_more:
 319                 goto do_more;
 320         }
 321  error_return:
 322 -       brelse(bitmap_bh);
 323         ext4_std_error(sb, err);
 324 +error_brelse:
 325 +       brelse(bitmap_bh);
 326         return;
 327  }
 328
 329 @@ -5216,7 +5210,7 @@ int ext4_group_add_blocks(handle_t *handle, struct super_block *sb,
 330
 331         err = ext4_mb_load_buddy(sb, block_group, &e4b);
 332         if (err)
 333 -               goto error_return;
 334 +               goto error_brelse;
 335
 336         /*
 337          * need to update group_info->bb_free and bitmap
 338 @@ -5253,8 +5247,9 @@ int ext4_group_add_blocks(handle_t *handle, struct super_block *sb,
 339                 err = ret;
 340
 341  error_return:
 342 -       brelse(bitmap_bh);
 343         ext4_std_error(sb, err);
 344 +error_brelse:
 345 +       brelse(bitmap_bh);
 346         return err;
 347  }
 348
 349 @@ -5329,11 +5324,9 @@ ext4_trim_all_free(struct super_block *sb, ext4_group_t group,
 350         trace_ext4_trim_all_free(sb, group, start, max);
 351
 352         ret = ext4_mb_load_buddy(sb, group, &e4b);
 353 -       if (ret) {
 354 -               ext4_warning(sb, "Error %d loading buddy information for %u",
 355 -                            ret, group);
 356 +       if (ret)
 357                 return ret;
 358 -       }
 359 +
 360         bitmap = e4b.bd_bitmap;
 361
 362         ext4_lock_group(sb, group);
 363 diff --git a/fs/ext4/super.c b/fs/ext4/super.c
 364 index c625960..0de22f2 100644
 365 --- a/fs/ext4/super.c
 366 +++ b/fs/ext4/super.c
 367 @@ -633,6 +633,37 @@ void __ext4_warning(struct super_block *sb, const char *function,
 368         va_end(args);
 369  }
 370
 371 +void __ext4_corrupted_block_group(struct super_block *sb, ext4_group_t group,
 372 +                                 unsigned int flags, const char *function,
 373 +                                 unsigned int line)
 374 +{
 375 +       struct ext4_sb_info *sbi = EXT4_SB(sb);
 376 +       struct ext4_group_info *grp = ext4_get_group_info(sb, group);
 377 +       struct ext4_group_desc *gdp = ext4_get_group_desc(sb, group, NULL);
 378 +
 379 +       if (flags & EXT4_GROUP_INFO_BBITMAP_CORRUPT &&
 380 +           !EXT4_MB_GRP_BBITMAP_CORRUPT(grp)) {
 381 +               percpu_counter_sub(&sbi->s_freeclusters_counter,
 382 +                                       grp->bb_free);
 383 +               set_bit(EXT4_GROUP_INFO_BBITMAP_CORRUPT_BIT,
 384 +                       &grp->bb_state);
 385 +       }
 386 +
 387 +       if (flags & EXT4_GROUP_INFO_IBITMAP_CORRUPT &&
 388 +           !EXT4_MB_GRP_IBITMAP_CORRUPT(grp)) {
 389 +               if (gdp) {
 390 +                       int count;
 391 +
 392 +                       count = ext4_free_inodes_count(sb, gdp);
 393 +                       percpu_counter_sub(&sbi->s_freeinodes_counter,
 394 +                                          count);
 395 +               }
 396 +               set_bit(EXT4_GROUP_INFO_IBITMAP_CORRUPT_BIT,
 397 +                       &grp->bb_state);
 398 +       }
 399 +       save_error_info(sb, function, line);
 400 +}
 401 +
 402  void __ext4_grp_locked_error(const char *function, unsigned int line,
 403                              struct super_block *sb, ext4_group_t grp,
 404                              unsigned long ino, ext4_fsblk_t block,