ldiskfs/kernel_patches/patches/sles12sp2/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 @@ -185,25 +185,17 @@ static int ext4_init_block_bitmap(struct super_block *sb,
  11         struct ext4_sb_info *sbi = EXT4_SB(sb);
  12         ext4_fsblk_t start, tmp;
  13         int flex_bg = 0;
  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 @@ -367,7 +359,6 @@ static void ext4_validate_block_bitmap(struct super_block *sb,
  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 @@ -377,22 +367,19 @@ static void ext4_validate_block_bitmap(struct super_block *sb,
  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 @@ -445,8 +432,6 @@ ext4_read_block_bitmap_nowait(struct super_block *sb, ext4_group_t block_group)
  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 @@ -70,25 +70,15 @@ static unsigned ext4_init_inode_bitmap(struct super_block *sb,
 128                                        ext4_group_t block_group,
 129                                        struct ext4_group_desc *gdp)
 130  {
 131 -       struct ext4_group_info *grp;
 132 -       struct ext4_sb_info *sbi = EXT4_SB(sb);
 133         J_ASSERT_BH(bh, buffer_locked(bh));
 134
 135         /* If checksum is bad mark all blocks and inodes use to prevent
 136          * allocation, essentially implementing a per-group read-only flag. */
 137         if (!ext4_group_desc_csum_verify(sb, block_group, gdp)) {
 138 -               grp = ext4_get_group_info(sb, block_group);
 139 -               if (!EXT4_MB_GRP_BBITMAP_CORRUPT(grp))
 140 -                       percpu_counter_sub(&sbi->s_freeclusters_counter,
 141 -                                          grp->bb_free);
 142 -               set_bit(EXT4_GROUP_INFO_BBITMAP_CORRUPT_BIT, &grp->bb_state);
 143 -               if (!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_corrupted_block_group(sb, block_group,
 151 +                               EXT4_GROUP_INFO_BBITMAP_CORRUPT |
 152 +                               EXT4_GROUP_INFO_IBITMAP_CORRUPT,
 153 +                               "Checksum bad for group %u", block_group);
 154                 return -EFSBADCRC;
 155         }
 156
 157 @@ -193,8 +180,6 @@ verify:
 158                 ext4_unlock_group(sb, block_group);
 159                 unlock_buffer(bh);
 160                 if (err) {
 161 -                       ext4_error(sb, "Failed to init inode bitmap for group "
 162 -                                  "%u: %d", block_group, err);
 163                         goto out;
 164                 }
 165                 return bh;
 166 @@ -337,14 +318,9 @@ out:
 167                 if (!fatal)
 168                         fatal = err;
 169         } else {
 170 -               ext4_error(sb, "bit already cleared for inode %lu", ino);
 171 -               if (gdp && !EXT4_MB_GRP_IBITMAP_CORRUPT(grp)) {
 172 -                       int count;
 173 -                       count = ext4_free_inodes_count(sb, gdp);
 174 -                       percpu_counter_sub(&sbi->s_freeinodes_counter,
 175 -                                          count);
 176 -               }
 177 -               set_bit(EXT4_GROUP_INFO_IBITMAP_CORRUPT_BIT, &grp->bb_state);
 178 +               ext4_corrupted_block_group(sb, block_group,
 179 +                               EXT4_GROUP_INFO_IBITMAP_CORRUPT,
 180 +                               "bit already cleared for inode %lu", ino);
 181         }
 182
 183  error_return:
 184 diff --git a/fs/ext4/mballoc.c b/fs/ext4/mballoc.c
 185 index 7282d07..e6805e6 100644
 186 --- a/fs/ext4/mballoc.c
 187 +++ b/fs/ext4/mballoc.c
 188 @@ -752,10 +752,18 @@ int ext4_mb_generate_buddy(struct super_block *sb,
 189         if (free != grp->bb_free) {
 190                 struct ext4_group_desc *gdp;
 191                 gdp = ext4_get_group_desc(sb, group, NULL);
 192 -               ext4_error(sb, "group %lu: %u blocks in bitmap, %u in bb, "
 193 -                       "%u in gd, %lu pa's\n", (long unsigned int)group,
 194 -                       free, grp->bb_free, ext4_free_group_clusters(sb, gdp),
 195 -                       grp->bb_prealloc_nr);
 196 +
 197 +               ext4_corrupted_block_group(sb, group,
 198 +                               EXT4_GROUP_INFO_BBITMAP_CORRUPT,
 199 +                               "group %lu: %u blocks in bitmap, %u in bb, %u in gd, %lu pa's block bitmap corrupt",
 200 +                               (unsigned long int)group, free, grp->bb_free,
 201 +                               ext4_free_group_clusters(sb, gdp),
 202 +                               grp->bb_prealloc_nr);
 203 +               /*
 204 +                * If we intend to continue, we consider group descriptor
 205 +                * corrupt and update bb_free using bitmap value
 206 +                */
 207 +               grp->bb_free = free;
 208                 return -EIO;
 209         }
 210         mb_set_largest_free_order(sb, grp);
 211 @@ -1101,7 +1109,7 @@ ext4_mb_load_buddy(struct super_block *sb, ext4_group_t group,
 212         int block;
 213         int pnum;
 214         int poff;
 215 -       struct page *page;
 216 +       struct page *page = NULL;
 217         int ret;
 218         struct ext4_group_info *grp;
 219         struct ext4_sb_info *sbi = EXT4_SB(sb);
 220 @@ -1127,7 +1135,7 @@ ext4_mb_load_buddy(struct super_block *sb, ext4_group_t group,
 221                  */
 222                 ret = ext4_mb_init_group(sb, group);
 223                 if (ret)
 224 -                       return ret;
 225 +                       goto err;
 226         }
 227
 228         /*
 229 @@ -1227,6 +1235,7 @@ err:
 230                 page_cache_release(e4b->bd_buddy_page);
 231         e4b->bd_buddy = NULL;
 232         e4b->bd_bitmap = NULL;
 233 +       ext4_warning(sb, "Error loading buddy information for %u", group);
 234         return ret;
 235  }
 236
 237 @@ -3599,9 +3608,11 @@ int ext4_mb_check_ondisk_bitmap(struct super_block *sb, void *bitmap,
 238         }
 239
 240         if (free != ext4_free_group_clusters(sb, gdp)) {
 241 -               ext4_error(sb, "on-disk bitmap for group %d"
 242 -                       "corrupted: %u blocks free in bitmap, %u - in gd\n",
 243 -                       group, free, ext4_free_group_clusters(sb, gdp));
 244 +               ext4_corrupted_block_group(sb, group,
 245 +                               EXT4_GROUP_INFO_BBITMAP_CORRUPT,
 246 +                               "on-disk bitmap for group %d corrupted: %u blocks free in bitmap, %u - in gd\n",
 247 +                               group, free,
 248 +                               ext4_free_group_clusters(sb, gdp));
 249                 return -EIO;
 250         }
 251         return 0;
 252 @@ -3962,16 +3973,8 @@ ext4_mb_release_inode_pa(struct ext4_buddy *e4b, struct buffer_head *bitmap_bh,
 253         /* "free < pa->pa_free" means we maybe double alloc the same blocks,
 254          * otherwise maybe leave some free blocks unavailable, no need to BUG.*/
 255         if ((free > pa->pa_free && !pa->pa_error) || (free < pa->pa_free)) {
 256 -               ext4_error(sb, "pa free mismatch: [pa %p] "
 257 -                               "[phy %lu] [logic %lu] [len %u] [free %u] "
 258 -                               "[error %u] [inode %lu] [freed %u]", pa,
 259 -                               (unsigned long)pa->pa_pstart,
 260 -                               (unsigned long)pa->pa_lstart,
 261 -                               (unsigned)pa->pa_len, (unsigned)pa->pa_free,
 262 -                               (unsigned)pa->pa_error, pa->pa_inode->i_ino,
 263 -                               free);
 264                 ext4_grp_locked_error(sb, group, 0, 0, "free %u, pa_free %u",
 265 -                                       free, pa->pa_free);
 266 +                                     free, pa->pa_free);
 267                 /*
 268                  * pa is already deleted so we use the value obtained
 269                  * from the bitmap and continue.
 270 @@ -4031,14 +4034,11 @@ ext4_mb_discard_group_preallocations(struct super_block *sb,
 271         bitmap_bh = ext4_read_block_bitmap(sb, group);
 272         if (IS_ERR(bitmap_bh)) {
 273                 err = PTR_ERR(bitmap_bh);
 274 -               ext4_error(sb, "Error %d reading block bitmap for %u",
 275 -                          err, group);
 276                 return 0;
 277         }
 278
 279         err = ext4_mb_load_buddy(sb, group, &e4b);
 280         if (err) {
 281 -               ext4_error(sb, "Error loading buddy information for %u", group);
 282                 put_bh(bitmap_bh);
 283                 return 0;
 284         }
 285 @@ -4198,17 +4198,12 @@ repeat:
 286                 group = ext4_get_group_number(sb, pa->pa_pstart);
 287
 288                 err = ext4_mb_load_buddy(sb, group, &e4b);
 289 -               if (err) {
 290 -                       ext4_error(sb, "Error loading buddy information for %u",
 291 -                                       group);
 292 +               if (err)
 293                         return;
 294 -               }
 295
 296                 bitmap_bh = ext4_read_block_bitmap(sb, group);
 297                 if (IS_ERR(bitmap_bh)) {
 298                         err = PTR_ERR(bitmap_bh);
 299 -                       ext4_error(sb, "Error %d reading block bitmap for %u",
 300 -                                       err, group);
 301                         ext4_mb_unload_buddy(&e4b);
 302                         continue;
 303                 }
 304 @@ -4467,11 +4462,8 @@ ext4_mb_discard_lg_preallocations(struct super_block *sb,
 305         list_for_each_entry_safe(pa, tmp, &discard_list, u.pa_tmp_list) {
 306
 307                 group = ext4_get_group_number(sb, pa->pa_pstart);
 308 -               if (ext4_mb_load_buddy(sb, group, &e4b)) {
 309 -                       ext4_error(sb, "Error loading buddy information for %u",
 310 -                                       group);
 311 +               if (ext4_mb_load_buddy(sb, group, &e4b))
 312                         continue;
 313 -               }
 314                 ext4_lock_group(sb, group);
 315                 list_del(&pa->pa_group_list);
 316                 ext4_get_group_info(sb, group)->bb_prealloc_nr--;
 317 @@ -4742,17 +4734,18 @@ errout:
 318                          * been updated or not when fail case. So can
 319                          * not revert pa_free back, just mark pa_error*/
 320                         pa->pa_error++;
 321 -                       ext4_error(sb,
 322 -                               "Updating bitmap error: [err %d] "
 323 -                               "[pa %p] [phy %lu] [logic %lu] "
 324 -                               "[len %u] [free %u] [error %u] "
 325 -                               "[inode %lu]", *errp, pa,
 326 -                               (unsigned long)pa->pa_pstart,
 327 -                               (unsigned long)pa->pa_lstart,
 328 -                               (unsigned)pa->pa_len,
 329 -                               (unsigned)pa->pa_free,
 330 -                               (unsigned)pa->pa_error,
 331 -                               pa->pa_inode ? pa->pa_inode->i_ino : 0);
 332 +                       ext4_corrupted_block_group(sb, 0, 0,
 333 +                                       "Updating bitmap error: [err %d] "
 334 +                                       "[pa %p] [phy %lu] [logic %lu] "
 335 +                                       "[len %u] [free %u] [error %u] "
 336 +                                       "[inode %lu]", *errp, pa,
 337 +                                       (unsigned long)pa->pa_pstart,
 338 +                                       (unsigned long)pa->pa_lstart,
 339 +                                       (unsigned)pa->pa_len,
 340 +                                       (unsigned)pa->pa_free,
 341 +                                       (unsigned)pa->pa_error,
 342 +                                       pa->pa_inode ?
 343 +                                       pa->pa_inode->i_ino : 0);
 344                 }
 345         }
 346         ext4_mb_release_context(ac);
 347 @@ -5037,7 +5030,7 @@ do_more:
 348
 349         err = ext4_mb_load_buddy(sb, block_group, &e4b);
 350         if (err)
 351 -               goto error_return;
 352 +               goto error_brelse;
 353
 354         if ((flags & EXT4_FREE_BLOCKS_METADATA) && ext4_handle_valid(handle)) {
 355                 struct ext4_free_data *new_entry;
 356 @@ -5119,8 +5112,9 @@ do_more:
 357                 goto do_more;
 358         }
 359  error_return:
 360 -       brelse(bitmap_bh);
 361         ext4_std_error(sb, err);
 362 +error_brelse:
 363 +       brelse(bitmap_bh);
 364         return;
 365  }
 366
 367 @@ -5216,7 +5210,7 @@ int ext4_group_add_blocks(handle_t *handle, struct super_block *sb,
 368
 369         err = ext4_mb_load_buddy(sb, block_group, &e4b);
 370         if (err)
 371 -               goto error_return;
 372 +               goto error_brelse;
 373
 374         /*
 375          * need to update group_info->bb_free and bitmap
 376 @@ -5253,8 +5247,9 @@ int ext4_group_add_blocks(handle_t *handle, struct super_block *sb,
 377                 err = ret;
 378
 379  error_return:
 380 -       brelse(bitmap_bh);
 381         ext4_std_error(sb, err);
 382 +error_brelse:
 383 +       brelse(bitmap_bh);
 384         return err;
 385  }
 386
 387 @@ -5329,11 +5324,9 @@ ext4_trim_all_free(struct super_block *sb, ext4_group_t group,
 388         trace_ext4_trim_all_free(sb, group, start, max);
 389
 390         ret = ext4_mb_load_buddy(sb, group, &e4b);
 391 -       if (ret) {
 392 -               ext4_error(sb, "Error in loading buddy "
 393 -                               "information for %u", group);
 394 +       if (ret)
 395                 return ret;
 396 -       }
 397 +
 398         bitmap = e4b.bd_bitmap;
 399
 400         ext4_lock_group(sb, group);
 401 diff --git a/fs/ext4/super.c b/fs/ext4/super.c
 402 index c625960..0de22f2 100644
 403 --- a/fs/ext4/super.c
 404 +++ b/fs/ext4/super.c
 405 @@ -633,6 +633,37 @@ void __ext4_warning(struct super_block *sb, const char *function,
 406         va_end(args);
 407  }
 408
 409 +void __ext4_corrupted_block_group(struct super_block *sb, ext4_group_t group,
 410 +                                 unsigned int flags, const char *function,
 411 +                                 unsigned int line)
 412 +{
 413 +       struct ext4_sb_info *sbi = EXT4_SB(sb);
 414 +       struct ext4_group_info *grp = ext4_get_group_info(sb, group);
 415 +       struct ext4_group_desc *gdp = ext4_get_group_desc(sb, group, NULL);
 416 +
 417 +       if (flags & EXT4_GROUP_INFO_BBITMAP_CORRUPT &&
 418 +           !EXT4_MB_GRP_BBITMAP_CORRUPT(grp)) {
 419 +               percpu_counter_sub(&sbi->s_freeclusters_counter,
 420 +                                       grp->bb_free);
 421 +               set_bit(EXT4_GROUP_INFO_BBITMAP_CORRUPT_BIT,
 422 +                       &grp->bb_state);
 423 +       }
 424 +
 425 +       if (flags & EXT4_GROUP_INFO_IBITMAP_CORRUPT &&
 426 +           !EXT4_MB_GRP_IBITMAP_CORRUPT(grp)) {
 427 +               if (gdp) {
 428 +                       int count;
 429 +
 430 +                       count = ext4_free_inodes_count(sb, gdp);
 431 +                       percpu_counter_sub(&sbi->s_freeinodes_counter,
 432 +                                          count);
 433 +               }
 434 +               set_bit(EXT4_GROUP_INFO_IBITMAP_CORRUPT_BIT,
 435 +                       &grp->bb_state);
 436 +       }
 437 +       save_error_info(sb, function, line);
 438 +}
 439 +
 440  void __ext4_grp_locked_error(const char *function, unsigned int line,
 441                              struct super_block *sb, ext4_group_t grp,
 442                              unsigned long ino, ext4_fsblk_t block,