e2fsck/pass5.c

   1 /*
   2  * pass5.c --- check block and inode bitmaps against on-disk bitmaps
   3  *
   4  * Copyright (C) 1993, 1994, 1995, 1996, 1997 Theodore Ts'o.
   5  *
   6  * %Begin-Header%
   7  * This file may be redistributed under the terms of the GNU Public
   8  * License.
   9  * %End-Header%
  10  *
  11  */
  12
  13 #include "config.h"
  14 #include <stdint.h>
  15 #include <sys/types.h>
  16 #include <sys/stat.h>
  17 #include <sys/ioctl.h>
  18 #include <fcntl.h>
  19 #include <errno.h>
  20
  21 #include "e2fsck.h"
  22 #include "problem.h"
  23
  24 #define DIV_ROUND_UP(n,d) (((n) + (d) - 1) / (d))
  25
  26 static void check_block_bitmaps(e2fsck_t ctx);
  27 static void check_inode_bitmaps(e2fsck_t ctx);
  28 static void check_inode_end(e2fsck_t ctx);
  29 static void check_block_end(e2fsck_t ctx);
  30
  31 void e2fsck_pass5(e2fsck_t ctx)
  32 {
  33 #ifdef RESOURCE_TRACK
  34         struct resource_track   rtrack;
  35 #endif
  36         struct problem_context  pctx;
  37
  38 #ifdef MTRACE
  39         mtrace_print("Pass 5");
  40 #endif
  41
  42         init_resource_track(&rtrack, ctx->fs->io);
  43         clear_problem_context(&pctx);
  44
  45         if (!(ctx->options & E2F_OPT_PREEN))
  46                 fix_problem(ctx, PR_5_PASS_HEADER, &pctx);
  47
  48         if (ctx->progress)
  49                 if ((ctx->progress)(ctx, 5, 0, ctx->fs->group_desc_count*2))
  50                         return;
  51
  52         e2fsck_read_bitmaps(ctx);
  53
  54         check_block_bitmaps(ctx);
  55         if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
  56                 return;
  57         check_inode_bitmaps(ctx);
  58         if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
  59                 return;
  60         check_inode_end(ctx);
  61         if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
  62                 return;
  63         check_block_end(ctx);
  64         if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
  65                 return;
  66
  67         ext2fs_free_inode_bitmap(ctx->inode_used_map);
  68         ctx->inode_used_map = 0;
  69         ext2fs_free_inode_bitmap(ctx->inode_dir_map);
  70         ctx->inode_dir_map = 0;
  71         ext2fs_free_block_bitmap(ctx->block_found_map);
  72         ctx->block_found_map = 0;
  73
  74         print_resource_track(ctx, _("Pass 5"), &rtrack, ctx->fs->io);
  75 }
  76
  77 static void e2fsck_discard_blocks(e2fsck_t ctx, blk64_t start,
  78                                   blk64_t count)
  79 {
  80         ext2_filsys fs = ctx->fs;
  81
  82         /*
  83          * If the filesystem has changed it means that there was an corruption
  84          * which should be repaired, but in some cases just one e2fsck run is
  85          * not enough to fix the problem, hence it is not safe to run discard
  86          * in this case.
  87          */
  88         if (ext2fs_test_changed(fs))
  89                 ctx->options &= ~E2F_OPT_DISCARD;
  90
  91         if ((ctx->options & E2F_OPT_DISCARD) &&
  92             (io_channel_discard(fs->io, start, count)))
  93                 ctx->options &= ~E2F_OPT_DISCARD;
  94 }
  95
  96 /*
  97  * This will try to discard number 'count' inodes starting at
  98  * inode number 'start' within the 'group'. Note that 'start'
  99  * is 1-based, it means that we need to adjust it by -1 in this
 100  * function to compute right offset in the particular inode table.
 101  */
 102 static void e2fsck_discard_inodes(e2fsck_t ctx, dgrp_t group,
 103                                   ext2_ino_t start, int count)
 104 {
 105         ext2_filsys fs = ctx->fs;
 106         blk64_t blk, num;
 107
 108         /*
 109          * Sanity check for 'start'
 110          */
 111         if ((start < 1) || (start > EXT2_INODES_PER_GROUP(fs->super))) {
 112                 printf("PROGRAMMING ERROR: Got start %d outside of group %d!"
 113                        " Disabling discard\n",
 114                         start, group);
 115                 ctx->options &= ~E2F_OPT_DISCARD;
 116         }
 117
 118         /*
 119          * Do not attempt to discard if E2F_OPT_DISCARD is not set. And also
 120          * skip the discard on this group if discard does not zero data.
 121          * The reason is that if the inode table is not zeroed discard would
 122          * no help us since we need to zero it anyway, or if the inode table
 123          * is zeroed then the read after discard would not be deterministic
 124          * anyway and we would not be able to assume that this inode table
 125          * was zeroed anymore so we would have to zero it again, which does
 126          * not really make sense.
 127          */
 128         if (!(ctx->options & E2F_OPT_DISCARD) ||
 129             !io_channel_discard_zeroes_data(fs->io))
 130                 return;
 131
 132         /*
 133          * Start is inode number within the group which starts
 134          * counting from 1, so we need to adjust it.
 135          */
 136         start -= 1;
 137
 138         /*
 139          * We can discard only blocks containing only unused
 140          * inodes in the table.
 141          */
 142         blk = DIV_ROUND_UP(start,
 143                 EXT2_INODES_PER_BLOCK(fs->super));
 144         count -= (blk * EXT2_INODES_PER_BLOCK(fs->super) - start);
 145         blk += ext2fs_inode_table_loc(fs, group);
 146         num = count / EXT2_INODES_PER_BLOCK(fs->super);
 147
 148         if (num > 0)
 149                 e2fsck_discard_blocks(ctx, blk, num);
 150 }
 151
 152 #define NO_BLK ((blk64_t) -1)
 153
 154 static void print_bitmap_problem(e2fsck_t ctx, problem_t problem,
 155                             struct problem_context *pctx)
 156 {
 157         switch (problem) {
 158         case PR_5_BLOCK_UNUSED:
 159                 if (pctx->blk == pctx->blk2)
 160                         pctx->blk2 = 0;
 161                 else
 162                         problem = PR_5_BLOCK_RANGE_UNUSED;
 163                 break;
 164         case PR_5_BLOCK_USED:
 165                 if (pctx->blk == pctx->blk2)
 166                         pctx->blk2 = 0;
 167                 else
 168                         problem = PR_5_BLOCK_RANGE_USED;
 169                 break;
 170         case PR_5_INODE_UNUSED:
 171                 if (pctx->ino == pctx->ino2)
 172                         pctx->ino2 = 0;
 173                 else
 174                         problem = PR_5_INODE_RANGE_UNUSED;
 175                 break;
 176         case PR_5_INODE_USED:
 177                 if (pctx->ino == pctx->ino2)
 178                         pctx->ino2 = 0;
 179                 else
 180                         problem = PR_5_INODE_RANGE_USED;
 181                 break;
 182         }
 183         fix_problem(ctx, problem, pctx);
 184         pctx->blk = pctx->blk2 = NO_BLK;
 185         pctx->ino = pctx->ino2 = 0;
 186 }
 187
 188 /* Just to be more succint */
 189 #define B2C(x)  EXT2FS_B2C(fs, (x))
 190 #define EQ_CLSTR(x, y) (B2C(x) == B2C(y))
 191 #define LE_CLSTR(x, y) (B2C(x) <= B2C(y))
 192 #define GE_CLSTR(x, y) (B2C(x) >= B2C(y))
 193
 194 static void check_block_bitmaps(e2fsck_t ctx)
 195 {
 196         ext2_filsys fs = ctx->fs;
 197         blk64_t i;
 198         unsigned int    *free_array;
 199         dgrp_t          g, group = 0;
 200         unsigned int    blocks = 0;
 201         blk64_t free_blocks = 0;
 202         blk64_t first_free = ext2fs_blocks_count(fs->super);
 203         unsigned int    group_free = 0;
 204         int     actual, bitmap;
 205         struct problem_context  pctx;
 206         problem_t       problem, save_problem;
 207         int             fixit, had_problem;
 208         errcode_t       retval;
 209         int     old_desc_blocks = 0;
 210         int     count = 0;
 211         int     cmp_block = 0;
 212         int     redo_flag = 0;
 213         blk64_t super_blk, old_desc_blk, new_desc_blk;
 214         char *actual_buf, *bitmap_buf;
 215
 216         actual_buf = (char *) e2fsck_allocate_memory(ctx, fs->blocksize,
 217                                                      "actual bitmap buffer");
 218         bitmap_buf = (char *) e2fsck_allocate_memory(ctx, fs->blocksize,
 219                                                      "bitmap block buffer");
 220
 221         clear_problem_context(&pctx);
 222         free_array = (unsigned int *) e2fsck_allocate_memory(ctx,
 223             fs->group_desc_count * sizeof(unsigned int), "free block count array");
 224
 225         if ((B2C(fs->super->s_first_data_block) <
 226              ext2fs_get_block_bitmap_start2(ctx->block_found_map)) ||
 227             (B2C(ext2fs_blocks_count(fs->super)-1) >
 228              ext2fs_get_block_bitmap_end2(ctx->block_found_map))) {
 229                 pctx.num = 1;
 230                 pctx.blk = B2C(fs->super->s_first_data_block);
 231                 pctx.blk2 = B2C(ext2fs_blocks_count(fs->super) - 1);
 232                 pctx.ino = ext2fs_get_block_bitmap_start2(ctx->block_found_map);
 233                 pctx.ino2 = ext2fs_get_block_bitmap_end2(ctx->block_found_map);
 234                 fix_problem(ctx, PR_5_BMAP_ENDPOINTS, &pctx);
 235
 236                 ctx->flags |= E2F_FLAG_ABORT; /* fatal */
 237                 goto errout;
 238         }
 239
 240         if ((B2C(fs->super->s_first_data_block) <
 241              ext2fs_get_block_bitmap_start2(fs->block_map)) ||
 242             (B2C(ext2fs_blocks_count(fs->super)-1) >
 243              ext2fs_get_block_bitmap_end2(fs->block_map))) {
 244                 pctx.num = 2;
 245                 pctx.blk = B2C(fs->super->s_first_data_block);
 246                 pctx.blk2 = B2C(ext2fs_blocks_count(fs->super) - 1);
 247                 pctx.ino = ext2fs_get_block_bitmap_start2(fs->block_map);
 248                 pctx.ino2 = ext2fs_get_block_bitmap_end2(fs->block_map);
 249                 fix_problem(ctx, PR_5_BMAP_ENDPOINTS, &pctx);
 250
 251                 ctx->flags |= E2F_FLAG_ABORT; /* fatal */
 252                 goto errout;
 253         }
 254
 255 redo_counts:
 256         had_problem = 0;
 257         save_problem = 0;
 258         pctx.blk = pctx.blk2 = NO_BLK;
 259         for (i = B2C(fs->super->s_first_data_block);
 260              i < ext2fs_blocks_count(fs->super);
 261              i += EXT2FS_CLUSTER_RATIO(fs)) {
 262                 int first_block_in_bg = (B2C(i) -
 263                                          B2C(fs->super->s_first_data_block)) %
 264                         fs->super->s_clusters_per_group == 0;
 265                 int n, nbytes = fs->super->s_clusters_per_group / 8;
 266
 267                 actual = ext2fs_fast_test_block_bitmap2(ctx->block_found_map, i);
 268
 269                 /*
 270                  * Try to optimize pass5 by extracting a bitmap block
 271                  * as expected from what we have on disk, and then
 272                  * comparing the two.  If they are identical, then
 273                  * update the free block counts and go on to the next
 274                  * block group.  This is much faster than doing the
 275                  * individual bit-by-bit comparison.  The one downside
 276                  * is that this doesn't work if we are asking e2fsck
 277                  * to do a discard operation.
 278                  */
 279                 if (!first_block_in_bg ||
 280                     (group == (int)fs->group_desc_count - 1) ||
 281                     (ctx->options & E2F_OPT_DISCARD))
 282                         goto no_optimize;
 283
 284                 retval = ext2fs_get_block_bitmap_range2(ctx->block_found_map,
 285                                 B2C(i), fs->super->s_clusters_per_group,
 286                                 actual_buf);
 287                 if (retval)
 288                         goto no_optimize;
 289                 retval = ext2fs_get_block_bitmap_range2(fs->block_map,
 290                                 B2C(i), fs->super->s_clusters_per_group,
 291                                 bitmap_buf);
 292                 if (retval)
 293                         goto no_optimize;
 294                 if (memcmp(actual_buf, bitmap_buf, nbytes) != 0)
 295                         goto no_optimize;
 296                 n = ext2fs_bitcount(actual_buf, nbytes);
 297                 group_free = fs->super->s_clusters_per_group - n;
 298                 free_blocks += group_free;
 299                 i += EXT2FS_C2B(fs, fs->super->s_clusters_per_group - 1);
 300                 goto next_group;
 301         no_optimize:
 302
 303                 if (redo_flag)
 304                         bitmap = actual;
 305                 else
 306                         bitmap = ext2fs_fast_test_block_bitmap2(fs->block_map, i);
 307
 308                 if (!actual == !bitmap)
 309                         goto do_counts;
 310
 311                 if (!actual && bitmap) {
 312                         /*
 313                          * Block not used, but marked in use in the bitmap.
 314                          */
 315                         problem = PR_5_BLOCK_UNUSED;
 316                 } else {
 317                         /*
 318                          * Block used, but not marked in use in the bitmap.
 319                          */
 320                         problem = PR_5_BLOCK_USED;
 321
 322                         if (ext2fs_bg_flags_test(fs, group,
 323                                                  EXT2_BG_BLOCK_UNINIT)) {
 324                                 struct problem_context pctx2;
 325                                 pctx2.blk = i;
 326                                 pctx2.group = group;
 327                                 if (fix_problem(ctx, PR_5_BLOCK_UNINIT,
 328                                                 &pctx2))
 329                                         ext2fs_bg_flags_clear(fs, group,
 330                                                         EXT2_BG_BLOCK_UNINIT);
 331                         }
 332                 }
 333                 if (pctx.blk == NO_BLK) {
 334                         pctx.blk = pctx.blk2 = i;
 335                         save_problem = problem;
 336                 } else {
 337                         if ((problem == save_problem) &&
 338                             (pctx.blk2 == i - EXT2FS_CLUSTER_RATIO(fs)))
 339                                 pctx.blk2 += EXT2FS_CLUSTER_RATIO(fs);
 340                         else {
 341                                 print_bitmap_problem(ctx, save_problem, &pctx);
 342                                 pctx.blk = pctx.blk2 = i;
 343                                 save_problem = problem;
 344                         }
 345                 }
 346                 ctx->flags |= E2F_FLAG_PROG_SUPPRESS;
 347                 had_problem++;
 348
 349                 /*
 350                  * If there a problem we should turn off the discard so we
 351                  * do not compromise the filesystem.
 352                  */
 353                 ctx->options &= ~E2F_OPT_DISCARD;
 354
 355         do_counts:
 356                 if (!bitmap) {
 357                         group_free++;
 358                         free_blocks++;
 359                         if (first_free > i)
 360                                 first_free = i;
 361                 } else if (i > first_free) {
 362                         e2fsck_discard_blocks(ctx, first_free,
 363                                               (i - first_free));
 364                         first_free = ext2fs_blocks_count(fs->super);
 365                 }
 366                 blocks ++;
 367                 if ((blocks == fs->super->s_clusters_per_group) ||
 368                     (EXT2FS_B2C(fs, i) ==
 369                      EXT2FS_B2C(fs, ext2fs_blocks_count(fs->super)-1))) {
 370                         /*
 371                          * If the last block of this group is free, then we can
 372                          * discard it as well.
 373                          */
 374                         if (!bitmap && i >= first_free)
 375                                 e2fsck_discard_blocks(ctx, first_free,
 376                                                       (i - first_free) + 1);
 377                 next_group:
 378                         first_free = ext2fs_blocks_count(fs->super);
 379
 380                         free_array[group] = group_free;
 381                         group ++;
 382                         blocks = 0;
 383                         group_free = 0;
 384                         if (ctx->progress)
 385                                 if ((ctx->progress)(ctx, 5, group,
 386                                                     fs->group_desc_count*2))
 387                                         goto errout;
 388                 }
 389         }
 390         if (pctx.blk != NO_BLK)
 391                 print_bitmap_problem(ctx, save_problem, &pctx);
 392         if (had_problem)
 393                 fixit = end_problem_latch(ctx, PR_LATCH_BBITMAP);
 394         else
 395                 fixit = -1;
 396         ctx->flags &= ~E2F_FLAG_PROG_SUPPRESS;
 397
 398         if (fixit == 1) {
 399                 ext2fs_free_block_bitmap(fs->block_map);
 400                 retval = ext2fs_copy_bitmap(ctx->block_found_map,
 401                                                   &fs->block_map);
 402                 if (retval) {
 403                         clear_problem_context(&pctx);
 404                         fix_problem(ctx, PR_5_COPY_BBITMAP_ERROR, &pctx);
 405                         ctx->flags |= E2F_FLAG_ABORT;
 406                         goto errout;
 407                 }
 408                 ext2fs_set_bitmap_padding(fs->block_map);
 409                 ext2fs_mark_bb_dirty(fs);
 410
 411                 /* Redo the counts */
 412                 blocks = 0; free_blocks = 0; group_free = 0; group = 0;
 413                 memset(free_array, 0, fs->group_desc_count * sizeof(int));
 414                 redo_flag++;
 415                 goto redo_counts;
 416         } else if (fixit == 0)
 417                 ext2fs_unmark_valid(fs);
 418
 419         for (g = 0; g < fs->group_desc_count; g++) {
 420                 if (free_array[g] != ext2fs_bg_free_blocks_count(fs, g)) {
 421                         pctx.group = g;
 422                         pctx.blk = ext2fs_bg_free_blocks_count(fs, g);
 423                         pctx.blk2 = free_array[g];
 424
 425                         if (fix_problem(ctx, PR_5_FREE_BLOCK_COUNT_GROUP,
 426                                         &pctx)) {
 427                                 ext2fs_bg_free_blocks_count_set(fs, g, free_array[g]);
 428                                 ext2fs_mark_super_dirty(fs);
 429                         } else
 430                                 ext2fs_unmark_valid(fs);
 431                 }
 432         }
 433         free_blocks = EXT2FS_C2B(fs, free_blocks);
 434         if (free_blocks != ext2fs_free_blocks_count(fs->super)) {
 435                 pctx.group = 0;
 436                 pctx.blk = ext2fs_free_blocks_count(fs->super);
 437                 pctx.blk2 = free_blocks;
 438
 439                 if (fix_problem(ctx, PR_5_FREE_BLOCK_COUNT, &pctx)) {
 440                         ext2fs_free_blocks_count_set(fs->super, free_blocks);
 441                         ext2fs_mark_super_dirty(fs);
 442                 }
 443         }
 444 errout:
 445         ext2fs_free_mem(&free_array);
 446         ext2fs_free_mem(&actual_buf);
 447         ext2fs_free_mem(&bitmap_buf);
 448 }
 449
 450 static void check_inode_bitmaps(e2fsck_t ctx)
 451 {
 452         ext2_filsys fs = ctx->fs;
 453         ext2_ino_t      i;
 454         unsigned int    free_inodes = 0;
 455         int             group_free = 0;
 456         int             dirs_count = 0;
 457         dgrp_t          group = 0;
 458         unsigned int    inodes = 0;
 459         ext2_ino_t      *free_array;
 460         ext2_ino_t      *dir_array;
 461         int             actual, bitmap;
 462         errcode_t       retval;
 463         struct problem_context  pctx;
 464         problem_t       problem, save_problem;
 465         int             fixit, had_problem;
 466         int             csum_flag;
 467         int             skip_group = 0;
 468         int             redo_flag = 0;
 469         ext2_ino_t              first_free = fs->super->s_inodes_per_group + 1;
 470
 471         clear_problem_context(&pctx);
 472         free_array = (ext2_ino_t *) e2fsck_allocate_memory(ctx,
 473             fs->group_desc_count * sizeof(ext2_ino_t), "free inode count array");
 474
 475         dir_array = (ext2_ino_t *) e2fsck_allocate_memory(ctx,
 476            fs->group_desc_count * sizeof(ext2_ino_t), "directory count array");
 477
 478         if ((1 < ext2fs_get_inode_bitmap_start2(ctx->inode_used_map)) ||
 479             (fs->super->s_inodes_count >
 480              ext2fs_get_inode_bitmap_end2(ctx->inode_used_map))) {
 481                 pctx.num = 3;
 482                 pctx.blk = 1;
 483                 pctx.blk2 = fs->super->s_inodes_count;
 484                 pctx.ino = ext2fs_get_inode_bitmap_start2(ctx->inode_used_map);
 485                 pctx.ino2 = ext2fs_get_inode_bitmap_end2(ctx->inode_used_map);
 486                 fix_problem(ctx, PR_5_BMAP_ENDPOINTS, &pctx);
 487
 488                 ctx->flags |= E2F_FLAG_ABORT; /* fatal */
 489                 goto errout;
 490         }
 491         if ((1 < ext2fs_get_inode_bitmap_start2(fs->inode_map)) ||
 492             (fs->super->s_inodes_count >
 493              ext2fs_get_inode_bitmap_end2(fs->inode_map))) {
 494                 pctx.num = 4;
 495                 pctx.blk = 1;
 496                 pctx.blk2 = fs->super->s_inodes_count;
 497                 pctx.ino = ext2fs_get_inode_bitmap_start2(fs->inode_map);
 498                 pctx.ino2 = ext2fs_get_inode_bitmap_end2(fs->inode_map);
 499                 fix_problem(ctx, PR_5_BMAP_ENDPOINTS, &pctx);
 500
 501                 ctx->flags |= E2F_FLAG_ABORT; /* fatal */
 502                 goto errout;
 503         }
 504
 505         csum_flag = EXT2_HAS_RO_COMPAT_FEATURE(fs->super,
 506                                                EXT4_FEATURE_RO_COMPAT_GDT_CSUM);
 507 redo_counts:
 508         had_problem = 0;
 509         save_problem = 0;
 510         pctx.ino = pctx.ino2 = 0;
 511         if (csum_flag &&
 512             (ext2fs_bg_flags_test(fs, group, EXT2_BG_INODE_UNINIT)))
 513                 skip_group++;
 514
 515         /* Protect loop from wrap-around if inodes_count is maxed */
 516         for (i = 1; i <= fs->super->s_inodes_count && i > 0; i++) {
 517                 bitmap = 0;
 518                 if (skip_group &&
 519                     i % fs->super->s_inodes_per_group == 1) {
 520                         /*
 521                          * Current inode is the first inode
 522                          * in the current block group.
 523                          */
 524                         if (ext2fs_test_inode_bitmap_range(
 525                                     ctx->inode_used_map, i,
 526                                     fs->super->s_inodes_per_group)) {
 527                                 /*
 528                                  * When the compared inodes in inodes bitmap
 529                                  * are 0, count the free inode,
 530                                  * skip the current block group.
 531                                  */
 532                                 first_free = 1;
 533                                 inodes = fs->super->s_inodes_per_group - 1;
 534                                 group_free = inodes;
 535                                 free_inodes += inodes;
 536                                 i += inodes;
 537                                 skip_group = 0;
 538                                 goto do_counts;
 539                         }
 540                 }
 541
 542                 actual = ext2fs_fast_test_inode_bitmap2(ctx->inode_used_map, i);
 543                 if (redo_flag)
 544                         bitmap = actual;
 545                 else if (!skip_group)
 546                         bitmap = ext2fs_fast_test_inode_bitmap2(fs->inode_map, i);
 547                 if (!actual == !bitmap)
 548                         goto do_counts;
 549
 550                 if (!actual && bitmap) {
 551                         /*
 552                          * Inode wasn't used, but marked in bitmap
 553                          */
 554                         problem = PR_5_INODE_UNUSED;
 555                 } else /* if (actual && !bitmap) */ {
 556                         /*
 557                          * Inode used, but not in bitmap
 558                          */
 559                         problem = PR_5_INODE_USED;
 560
 561                         /* We should never hit this, because it means that
 562                          * inodes were marked in use that weren't noticed
 563                          * in pass1 or pass 2. It is easier to fix the problem
 564                          * than to kill e2fsck and leave the user stuck. */
 565                         if (skip_group) {
 566                                 struct problem_context pctx2;
 567                                 pctx2.blk = i;
 568                                 pctx2.group = group;
 569                                 if (fix_problem(ctx, PR_5_INODE_UNINIT,&pctx2)){
 570                                         ext2fs_bg_flags_clear(fs, group, EXT2_BG_INODE_UNINIT);
 571                                         skip_group = 0;
 572                                 }
 573                         }
 574                 }
 575                 if (pctx.ino == 0) {
 576                         pctx.ino = pctx.ino2 = i;
 577                         save_problem = problem;
 578                 } else {
 579                         if ((problem == save_problem) &&
 580                             (pctx.ino2 == i-1))
 581                                 pctx.ino2++;
 582                         else {
 583                                 print_bitmap_problem(ctx, save_problem, &pctx);
 584                                 pctx.ino = pctx.ino2 = i;
 585                                 save_problem = problem;
 586                         }
 587                 }
 588                 ctx->flags |= E2F_FLAG_PROG_SUPPRESS;
 589                 had_problem++;
 590                 /*
 591                  * If there a problem we should turn off the discard so we
 592                  * do not compromise the filesystem.
 593                  */
 594                 ctx->options &= ~E2F_OPT_DISCARD;
 595
 596 do_counts:
 597                 inodes++;
 598                 if (bitmap) {
 599                         if (ext2fs_test_inode_bitmap2(ctx->inode_dir_map, i))
 600                                 dirs_count++;
 601                         if (inodes > first_free) {
 602                                 e2fsck_discard_inodes(ctx, group, first_free,
 603                                                       inodes - first_free);
 604                                 first_free = fs->super->s_inodes_per_group + 1;
 605                         }
 606                 } else {
 607                         group_free++;
 608                         free_inodes++;
 609                         if (first_free > inodes)
 610                                 first_free = inodes;
 611                 }
 612
 613                 if ((inodes == fs->super->s_inodes_per_group) ||
 614                     (i == fs->super->s_inodes_count)) {
 615                         /*
 616                          * If the last inode is free, we can discard it as well.
 617                          */
 618                         if (!bitmap && inodes >= first_free)
 619                                 e2fsck_discard_inodes(ctx, group, first_free,
 620                                                       inodes - first_free + 1);
 621                         /*
 622                          * If discard zeroes data and the group inode table
 623                          * was not zeroed yet, set itable as zeroed
 624                          */
 625                         if ((ctx->options & E2F_OPT_DISCARD) &&
 626                             io_channel_discard_zeroes_data(fs->io) &&
 627                             !(ext2fs_bg_flags_test(fs, group,
 628                                                    EXT2_BG_INODE_ZEROED))) {
 629                                 ext2fs_bg_flags_set(fs, group,
 630                                                     EXT2_BG_INODE_ZEROED);
 631                                 ext2fs_group_desc_csum_set(fs, group);
 632                         }
 633
 634                         first_free = fs->super->s_inodes_per_group + 1;
 635                         free_array[group] = group_free;
 636                         dir_array[group] = dirs_count;
 637                         group ++;
 638                         inodes = 0;
 639                         skip_group = 0;
 640                         group_free = 0;
 641                         dirs_count = 0;
 642                         if (ctx->progress)
 643                                 if ((ctx->progress)(ctx, 5,
 644                                             group + fs->group_desc_count,
 645                                             fs->group_desc_count*2))
 646                                         goto errout;
 647                         if (csum_flag &&
 648                             (i != fs->super->s_inodes_count) &&
 649                             (ext2fs_bg_flags_test(fs, group, EXT2_BG_INODE_UNINIT)
 650                              ))
 651                                 skip_group++;
 652                 }
 653         }
 654         if (pctx.ino)
 655                 print_bitmap_problem(ctx, save_problem, &pctx);
 656
 657         if (had_problem)
 658                 fixit = end_problem_latch(ctx, PR_LATCH_IBITMAP);
 659         else
 660                 fixit = -1;
 661         ctx->flags &= ~E2F_FLAG_PROG_SUPPRESS;
 662
 663         if (fixit == 1) {
 664                 ext2fs_free_inode_bitmap(fs->inode_map);
 665                 retval = ext2fs_copy_bitmap(ctx->inode_used_map,
 666                                                   &fs->inode_map);
 667                 if (retval) {
 668                         clear_problem_context(&pctx);
 669                         fix_problem(ctx, PR_5_COPY_IBITMAP_ERROR, &pctx);
 670                         ctx->flags |= E2F_FLAG_ABORT;
 671                         goto errout;
 672                 }
 673                 ext2fs_set_bitmap_padding(fs->inode_map);
 674                 ext2fs_mark_ib_dirty(fs);
 675
 676                 /* redo counts */
 677                 inodes = 0; free_inodes = 0; group_free = 0;
 678                 dirs_count = 0; group = 0;
 679                 memset(free_array, 0, fs->group_desc_count * sizeof(int));
 680                 memset(dir_array, 0, fs->group_desc_count * sizeof(int));
 681                 redo_flag++;
 682                 goto redo_counts;
 683         } else if (fixit == 0)
 684                 ext2fs_unmark_valid(fs);
 685
 686         for (i = 0; i < fs->group_desc_count; i++) {
 687                 if (free_array[i] != ext2fs_bg_free_inodes_count(fs, i)) {
 688                         pctx.group = i;
 689                         pctx.ino = ext2fs_bg_free_inodes_count(fs, i);
 690                         pctx.ino2 = free_array[i];
 691                         if (fix_problem(ctx, PR_5_FREE_INODE_COUNT_GROUP,
 692                                         &pctx)) {
 693                                 ext2fs_bg_free_inodes_count_set(fs, i, free_array[i]);
 694                                 ext2fs_mark_super_dirty(fs);
 695                         } else
 696                                 ext2fs_unmark_valid(fs);
 697                 }
 698                 if (dir_array[i] != ext2fs_bg_used_dirs_count(fs, i)) {
 699                         pctx.group = i;
 700                         pctx.ino = ext2fs_bg_used_dirs_count(fs, i);
 701                         pctx.ino2 = dir_array[i];
 702
 703                         if (fix_problem(ctx, PR_5_FREE_DIR_COUNT_GROUP,
 704                                         &pctx)) {
 705                                 ext2fs_bg_used_dirs_count_set(fs, i, dir_array[i]);
 706                                 ext2fs_mark_super_dirty(fs);
 707                         } else
 708                                 ext2fs_unmark_valid(fs);
 709                 }
 710         }
 711         if (free_inodes != fs->super->s_free_inodes_count) {
 712                 pctx.group = -1;
 713                 pctx.ino = fs->super->s_free_inodes_count;
 714                 pctx.ino2 = free_inodes;
 715
 716                 if (fix_problem(ctx, PR_5_FREE_INODE_COUNT, &pctx)) {
 717                         fs->super->s_free_inodes_count = free_inodes;
 718                         ext2fs_mark_super_dirty(fs);
 719                 }
 720         }
 721 errout:
 722         ext2fs_free_mem(&free_array);
 723         ext2fs_free_mem(&dir_array);
 724 }
 725
 726 static void check_inode_end(e2fsck_t ctx)
 727 {
 728         ext2_filsys fs = ctx->fs;
 729         ext2_ino_t      end, save_inodes_count, i;
 730         struct problem_context  pctx;
 731
 732         clear_problem_context(&pctx);
 733
 734         end = EXT2_INODES_PER_GROUP(fs->super) * fs->group_desc_count;
 735         pctx.errcode = ext2fs_fudge_inode_bitmap_end(fs->inode_map, end,
 736                                                      &save_inodes_count);
 737         if (pctx.errcode) {
 738                 pctx.num = 1;
 739                 fix_problem(ctx, PR_5_FUDGE_BITMAP_ERROR, &pctx);
 740                 ctx->flags |= E2F_FLAG_ABORT; /* fatal */
 741                 return;
 742         }
 743         if (save_inodes_count == end)
 744                 return;
 745
 746         /* protect loop from wrap-around if end is maxed */
 747         for (i = save_inodes_count + 1; i <= end && i > save_inodes_count; i++) {
 748                 if (!ext2fs_test_inode_bitmap(fs->inode_map, i)) {
 749                         if (fix_problem(ctx, PR_5_INODE_BMAP_PADDING, &pctx)) {
 750                                 for (; i <= end; i++)
 751                                         ext2fs_mark_inode_bitmap(fs->inode_map,
 752                                                                  i);
 753                                 ext2fs_mark_ib_dirty(fs);
 754                         } else
 755                                 ext2fs_unmark_valid(fs);
 756                         break;
 757                 }
 758         }
 759
 760         pctx.errcode = ext2fs_fudge_inode_bitmap_end(fs->inode_map,
 761                                                      save_inodes_count, 0);
 762         if (pctx.errcode) {
 763                 pctx.num = 2;
 764                 fix_problem(ctx, PR_5_FUDGE_BITMAP_ERROR, &pctx);
 765                 ctx->flags |= E2F_FLAG_ABORT; /* fatal */
 766                 return;
 767         }
 768 }
 769
 770 static void check_block_end(e2fsck_t ctx)
 771 {
 772         ext2_filsys fs = ctx->fs;
 773         blk64_t end, save_blocks_count, i;
 774         struct problem_context  pctx;
 775
 776         clear_problem_context(&pctx);
 777
 778         end = ext2fs_get_block_bitmap_start2(fs->block_map) +
 779                 ((blk64_t)EXT2_CLUSTERS_PER_GROUP(fs->super) * fs->group_desc_count) - 1;
 780         pctx.errcode = ext2fs_fudge_block_bitmap_end2(fs->block_map, end,
 781                                                      &save_blocks_count);
 782         if (pctx.errcode) {
 783                 pctx.num = 3;
 784                 fix_problem(ctx, PR_5_FUDGE_BITMAP_ERROR, &pctx);
 785                 ctx->flags |= E2F_FLAG_ABORT; /* fatal */
 786                 return;
 787         }
 788         if (save_blocks_count == end)
 789                 return;
 790
 791         /* Protect loop from wrap-around if end is maxed */
 792         for (i = save_blocks_count + 1; i <= end && i > save_blocks_count; i++) {
 793                 if (!ext2fs_test_block_bitmap2(fs->block_map,
 794                                                EXT2FS_C2B(fs, i))) {
 795                         if (fix_problem(ctx, PR_5_BLOCK_BMAP_PADDING, &pctx)) {
 796                                 for (; i <= end; i++)
 797                                         ext2fs_mark_block_bitmap2(fs->block_map,
 798                                                         EXT2FS_C2B(fs, i));
 799                                 ext2fs_mark_bb_dirty(fs);
 800                         } else
 801                                 ext2fs_unmark_valid(fs);
 802                         break;
 803                 }
 804         }
 805
 806         pctx.errcode = ext2fs_fudge_block_bitmap_end2(fs->block_map,
 807                                                      save_blocks_count, 0);
 808         if (pctx.errcode) {
 809                 pctx.num = 4;
 810                 fix_problem(ctx, PR_5_FUDGE_BITMAP_ERROR, &pctx);
 811                 ctx->flags |= E2F_FLAG_ABORT; /* fatal */
 812                 return;
 813         }
 814 }
 815
 816
 817