e2fsck/pass1.c

   1 /*
   2  * pass1.c -- pass #1 of e2fsck: sequential scan of the inode table
   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  * Pass 1 of e2fsck iterates over all the inodes in the filesystems,
  12  * and applies the following tests to each inode:
  13  *
  14  *      - The mode field of the inode must be legal.
  15  *      - The size and block count fields of the inode are correct.
  16  *      - A data block must not be used by another inode
  17  *
  18  * Pass 1 also gathers the collects the following information:
  19  *
  20  *      - A bitmap of which inodes are in use.          (inode_used_map)
  21  *      - A bitmap of which inodes are directories.     (inode_dir_map)
  22  *      - A bitmap of which inodes are regular files.   (inode_reg_map)
  23  *      - A bitmap of which inodes have bad fields.     (inode_bad_map)
  24  *      - A bitmap of which inodes are in bad blocks.   (inode_bb_map)
  25  *      - A bitmap of which inodes are imagic inodes.   (inode_imagic_map)
  26  *      - A bitmap of which blocks are in use.          (block_found_map)
  27  *      - A bitmap of which blocks are in use by two inodes     (block_dup_map)
  28  *      - The data blocks of the directory inodes.      (dir_map)
  29  *
  30  * Pass 1 is designed to stash away enough information so that the
  31  * other passes should not need to read in the inode information
  32  * during the normal course of a filesystem check.  (Althogh if an
  33  * inconsistency is detected, other passes may need to read in an
  34  * inode to fix it.)
  35  *
  36  * Note that pass 1B will be invoked if there are any duplicate blocks
  37  * found.
  38  */
  39
  40 #define _GNU_SOURCE 1 /* get strnlen() */
  41 #include <string.h>
  42 #include <time.h>
  43 #ifdef HAVE_ERRNO_H
  44 #include <errno.h>
  45 #endif
  46
  47 #include "e2fsck.h"
  48 #include <ext2fs/ext2_ext_attr.h>
  49
  50 #include "problem.h"
  51
  52 #ifdef NO_INLINE_FUNCS
  53 #define _INLINE_
  54 #else
  55 #define _INLINE_ inline
  56 #endif
  57
  58 static int process_block(ext2_filsys fs, blk64_t        *blocknr,
  59                          e2_blkcnt_t blockcnt, blk64_t ref_blk,
  60                          int ref_offset, void *priv_data);
  61 static int process_bad_block(ext2_filsys fs, blk64_t *block_nr,
  62                              e2_blkcnt_t blockcnt, blk64_t ref_blk,
  63                              int ref_offset, void *priv_data);
  64 static void check_blocks(e2fsck_t ctx, struct problem_context *pctx,
  65                          char *block_buf);
  66 static void mark_table_blocks(e2fsck_t ctx);
  67 static void alloc_bb_map(e2fsck_t ctx);
  68 static void alloc_imagic_map(e2fsck_t ctx);
  69 static void mark_inode_bad(e2fsck_t ctx, ino_t ino);
  70 static void handle_fs_bad_blocks(e2fsck_t ctx);
  71 static void process_inodes(e2fsck_t ctx, char *block_buf);
  72 static EXT2_QSORT_TYPE process_inode_cmp(const void *a, const void *b);
  73 static errcode_t scan_callback(ext2_filsys fs, ext2_inode_scan scan,
  74                                   dgrp_t group, void * priv_data);
  75 static void adjust_extattr_refcount(e2fsck_t ctx, ext2_refcount_t refcount,
  76                                     char *block_buf, int adjust_sign);
  77 /* static char *describe_illegal_block(ext2_filsys fs, blk64_t block); */
  78
  79 struct process_block_struct {
  80         ext2_ino_t      ino;
  81         unsigned        is_dir:1, is_reg:1, clear:1, suppress:1,
  82                                 fragmented:1, compressed:1, bbcheck:1;
  83         blk64_t         num_blocks;
  84         blk64_t         max_blocks;
  85         e2_blkcnt_t     last_block;
  86         e2_blkcnt_t     last_db_block;
  87         int             num_illegal_blocks;
  88         blk64_t         previous_block;
  89         struct ext2_inode *inode;
  90         struct problem_context *pctx;
  91         ext2fs_block_bitmap fs_meta_blocks;
  92         e2fsck_t        ctx;
  93 };
  94
  95 struct process_inode_block {
  96         ext2_ino_t ino;
  97         struct ext2_inode inode;
  98 };
  99
 100 struct scan_callback_struct {
 101         e2fsck_t        ctx;
 102         char            *block_buf;
 103 };
 104
 105 /*
 106  * For the inodes to process list.
 107  */
 108 static struct process_inode_block *inodes_to_process;
 109 static int process_inode_count;
 110
 111 static __u64 ext2_max_sizes[EXT2_MAX_BLOCK_LOG_SIZE -
 112                             EXT2_MIN_BLOCK_LOG_SIZE + 1];
 113
 114 /*
 115  * Free all memory allocated by pass1 in preparation for restarting
 116  * things.
 117  */
 118 static void unwind_pass1(ext2_filsys fs EXT2FS_ATTR((unused)))
 119 {
 120         ext2fs_free_mem(&inodes_to_process);
 121         inodes_to_process = 0;
 122 }
 123
 124 /*
 125  * Check to make sure a device inode is real.  Returns 1 if the device
 126  * checks out, 0 if not.
 127  *
 128  * Note: this routine is now also used to check FIFO's and Sockets,
 129  * since they have the same requirement; the i_block fields should be
 130  * zero.
 131  */
 132 int e2fsck_pass1_check_device_inode(ext2_filsys fs EXT2FS_ATTR((unused)),
 133                                     struct ext2_inode *inode)
 134 {
 135         int     i;
 136
 137         /*
 138          * If the index flag is set, then this is a bogus
 139          * device/fifo/socket
 140          */
 141         if (inode->i_flags & EXT2_INDEX_FL)
 142                 return 0;
 143
 144         /*
 145          * We should be able to do the test below all the time, but
 146          * because the kernel doesn't forcibly clear the device
 147          * inode's additional i_block fields, there are some rare
 148          * occasions when a legitimate device inode will have non-zero
 149          * additional i_block fields.  So for now, we only complain
 150          * when the immutable flag is set, which should never happen
 151          * for devices.  (And that's when the problem is caused, since
 152          * you can't set or clear immutable flags for devices.)  Once
 153          * the kernel has been fixed we can change this...
 154          */
 155         if (inode->i_flags & (EXT2_IMMUTABLE_FL | EXT2_APPEND_FL)) {
 156                 for (i=4; i < EXT2_N_BLOCKS; i++)
 157                         if (inode->i_block[i])
 158                                 return 0;
 159         }
 160         return 1;
 161 }
 162
 163 /*
 164  * Check to make sure a symlink inode is real.  Returns 1 if the symlink
 165  * checks out, 0 if not.
 166  */
 167 int e2fsck_pass1_check_symlink(ext2_filsys fs, ext2_ino_t ino,
 168                                struct ext2_inode *inode, char *buf)
 169 {
 170         unsigned int len;
 171         int i;
 172         blk64_t blocks;
 173         ext2_extent_handle_t    handle;
 174         struct ext2_extent_info info;
 175         struct ext2fs_extent    extent;
 176
 177         if ((inode->i_size_high || inode->i_size == 0) ||
 178             (inode->i_flags & EXT2_INDEX_FL))
 179                 return 0;
 180
 181         if (inode->i_flags & EXT4_EXTENTS_FL) {
 182                 if (inode->i_size > fs->blocksize)
 183                         return 0;
 184                 if (ext2fs_extent_open2(fs, ino, inode, &handle))
 185                         return 0;
 186                 i = 0;
 187                 if (ext2fs_extent_get_info(handle, &info) ||
 188                     (info.num_entries != 1) ||
 189                     (info.max_depth != 0))
 190                         goto exit_extent;
 191                 if (ext2fs_extent_get(handle, EXT2_EXTENT_ROOT, &extent) ||
 192                     (extent.e_lblk != 0) ||
 193                     (extent.e_len != 1) ||
 194                     (extent.e_pblk < fs->super->s_first_data_block) ||
 195                     (extent.e_pblk >= ext2fs_blocks_count(fs->super)))
 196                         goto exit_extent;
 197                 i = 1;
 198         exit_extent:
 199                 ext2fs_extent_free(handle);
 200                 return i;
 201         }
 202
 203         blocks = ext2fs_inode_data_blocks2(fs, inode);
 204         if (blocks) {
 205                 if ((inode->i_size >= fs->blocksize) ||
 206                     (blocks != fs->blocksize >> 9) ||
 207                     (inode->i_block[0] < fs->super->s_first_data_block) ||
 208                     (inode->i_block[0] >= ext2fs_blocks_count(fs->super)))
 209                         return 0;
 210
 211                 for (i = 1; i < EXT2_N_BLOCKS; i++)
 212                         if (inode->i_block[i])
 213                                 return 0;
 214
 215                 if (io_channel_read_blk64(fs->io, inode->i_block[0], 1, buf))
 216                         return 0;
 217
 218                 len = strnlen(buf, fs->blocksize);
 219                 if (len == fs->blocksize)
 220                         return 0;
 221         } else {
 222                 if (inode->i_size >= sizeof(inode->i_block))
 223                         return 0;
 224
 225                 len = strnlen((char *)inode->i_block, sizeof(inode->i_block));
 226                 if (len == sizeof(inode->i_block))
 227                         return 0;
 228         }
 229         if (len != inode->i_size)
 230                 return 0;
 231         return 1;
 232 }
 233
 234 /*
 235  * If the immutable (or append-only) flag is set on the inode, offer
 236  * to clear it.
 237  */
 238 #define BAD_SPECIAL_FLAGS (EXT2_IMMUTABLE_FL | EXT2_APPEND_FL)
 239 static void check_immutable(e2fsck_t ctx, struct problem_context *pctx)
 240 {
 241         if (!(pctx->inode->i_flags & BAD_SPECIAL_FLAGS))
 242                 return;
 243
 244         if (!fix_problem(ctx, PR_1_SET_IMMUTABLE, pctx))
 245                 return;
 246
 247         pctx->inode->i_flags &= ~BAD_SPECIAL_FLAGS;
 248         e2fsck_write_inode(ctx, pctx->ino, pctx->inode, "pass1");
 249 }
 250
 251 /*
 252  * If device, fifo or socket, check size is zero -- if not offer to
 253  * clear it
 254  */
 255 static void check_size(e2fsck_t ctx, struct problem_context *pctx)
 256 {
 257         struct ext2_inode *inode = pctx->inode;
 258
 259         if ((inode->i_size == 0) && (inode->i_size_high == 0))
 260                 return;
 261
 262         if (!fix_problem(ctx, PR_1_SET_NONZSIZE, pctx))
 263                 return;
 264
 265         inode->i_size = 0;
 266         inode->i_size_high = 0;
 267         e2fsck_write_inode(ctx, pctx->ino, pctx->inode, "pass1");
 268 }
 269
 270 static void check_ea_in_inode(e2fsck_t ctx, struct problem_context *pctx)
 271 {
 272         struct ext2_super_block *sb = ctx->fs->super;
 273         struct ext2_inode_large *inode;
 274         struct ext2_ext_attr_entry *entry;
 275         char *start, *end;
 276         unsigned int storage_size, remain;
 277         int problem = 0;
 278
 279         inode = (struct ext2_inode_large *) pctx->inode;
 280         storage_size = EXT2_INODE_SIZE(ctx->fs->super) - EXT2_GOOD_OLD_INODE_SIZE -
 281                 inode->i_extra_isize;
 282         start = ((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE +
 283                 inode->i_extra_isize + sizeof(__u32);
 284         end = (char *) inode + EXT2_INODE_SIZE(ctx->fs->super);
 285         entry = (struct ext2_ext_attr_entry *) start;
 286
 287         /* scan all entry's headers first */
 288
 289         /* take finish entry 0UL into account */
 290         remain = storage_size - sizeof(__u32);
 291
 292         while (!EXT2_EXT_IS_LAST_ENTRY(entry)) {
 293                 __u32 hash;
 294
 295                 /* header eats this space */
 296                 remain -= sizeof(struct ext2_ext_attr_entry);
 297
 298                 /* is attribute name valid? */
 299                 if (EXT2_EXT_ATTR_SIZE(entry->e_name_len) > remain) {
 300                         pctx->num = entry->e_name_len;
 301                         problem = PR_1_ATTR_NAME_LEN;
 302                         goto fix;
 303                 }
 304
 305                 /* attribute len eats this space */
 306                 remain -= EXT2_EXT_ATTR_SIZE(entry->e_name_len);
 307
 308                 /* check value size */
 309                 if (entry->e_value_size == 0 || entry->e_value_size > remain) {
 310                         pctx->num = entry->e_value_size;
 311                         problem = PR_1_ATTR_VALUE_SIZE;
 312                         goto fix;
 313                 }
 314
 315                 /* e_value_block must be 0 in inode's ea */
 316                 if (entry->e_value_block != 0) {
 317                         pctx->num = entry->e_value_block;
 318                         problem = PR_1_ATTR_VALUE_BLOCK;
 319                         goto fix;
 320                 }
 321
 322                 hash = ext2fs_ext_attr_hash_entry(entry,
 323                                                   start + entry->e_value_offs);
 324
 325                 /* e_hash may be 0 in older inode's ea */
 326                 if (entry->e_hash != 0 && entry->e_hash != hash) {
 327                         pctx->num = entry->e_hash;
 328                         problem = PR_1_ATTR_HASH;
 329                         goto fix;
 330                 }
 331
 332                 remain -= entry->e_value_size;
 333
 334                 entry = EXT2_EXT_ATTR_NEXT(entry);
 335         }
 336 fix:
 337         /*
 338          * it seems like a corruption. it's very unlikely we could repair
 339          * EA(s) in automatic fashion -bzzz
 340          */
 341         if (problem == 0 || !fix_problem(ctx, problem, pctx))
 342                 return;
 343
 344         /* simply remove all possible EA(s) */
 345         *((__u32 *)start) = 0UL;
 346         e2fsck_write_inode_full(ctx, pctx->ino, pctx->inode,
 347                                 EXT2_INODE_SIZE(sb), "pass1");
 348 }
 349
 350 static void check_inode_extra_space(e2fsck_t ctx, struct problem_context *pctx)
 351 {
 352         struct ext2_super_block *sb = ctx->fs->super;
 353         struct ext2_inode_large *inode;
 354         __u32 *eamagic;
 355         int min, max;
 356
 357         inode = (struct ext2_inode_large *) pctx->inode;
 358         if (EXT2_INODE_SIZE(sb) == EXT2_GOOD_OLD_INODE_SIZE) {
 359                 /* this isn't large inode. so, nothing to check */
 360                 return;
 361         }
 362
 363 #if 0
 364         printf("inode #%u, i_extra_size %d\n", pctx->ino,
 365                         inode->i_extra_isize);
 366 #endif
 367         /* i_extra_isize must cover i_extra_isize + i_pad1 at least */
 368         min = sizeof(inode->i_extra_isize) + sizeof(inode->i_pad1);
 369         max = EXT2_INODE_SIZE(sb) - EXT2_GOOD_OLD_INODE_SIZE;
 370         /*
 371          * For now we will allow i_extra_isize to be 0, but really
 372          * implementations should never allow i_extra_isize to be 0
 373          */
 374         if (inode->i_extra_isize &&
 375             (inode->i_extra_isize < min || inode->i_extra_isize > max)) {
 376                 if (!fix_problem(ctx, PR_1_EXTRA_ISIZE, pctx))
 377                         return;
 378                 inode->i_extra_isize = min;
 379                 e2fsck_write_inode_full(ctx, pctx->ino, pctx->inode,
 380                                         EXT2_INODE_SIZE(sb), "pass1");
 381                 return;
 382         }
 383
 384         eamagic = (__u32 *) (((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE +
 385                         inode->i_extra_isize);
 386         if (*eamagic == EXT2_EXT_ATTR_MAGIC) {
 387                 /* it seems inode has an extended attribute(s) in body */
 388                 check_ea_in_inode(ctx, pctx);
 389         }
 390 }
 391
 392 /*
 393  * Check to see if the inode might really be a directory, despite i_mode
 394  *
 395  * This is a lot of complexity for something for which I'm not really
 396  * convinced happens frequently in the wild.  If for any reason this
 397  * causes any problems, take this code out.
 398  * [tytso:20070331.0827EDT]
 399  */
 400 static void check_is_really_dir(e2fsck_t ctx, struct problem_context *pctx,
 401                                 char *buf)
 402 {
 403         struct ext2_inode *inode = pctx->inode;
 404         struct ext2_dir_entry   *dirent;
 405         const char              *old_op;
 406         errcode_t               retval;
 407         blk64_t                 blk;
 408         unsigned int            i, rec_len, not_device = 0;
 409         int                     extent_fs;
 410
 411         /*
 412          * If the mode looks OK, we believe it.  If the first block in
 413          * the i_block array is 0, this cannot be a directory. If the
 414          * inode is extent-mapped, it is still the case that the latter
 415          * cannot be 0 - the magic number in the extent header would make
 416          * it nonzero.
 417          */
 418         if (LINUX_S_ISDIR(inode->i_mode) || LINUX_S_ISREG(inode->i_mode) ||
 419             LINUX_S_ISLNK(inode->i_mode) || inode->i_block[0] == 0)
 420                 return;
 421
 422         /*
 423          * Check the block numbers in the i_block array for validity:
 424          * zero blocks are skipped (but the first one cannot be zero -
 425          * see above), other blocks are checked against the first and
 426          * max data blocks (from the the superblock) and against the
 427          * block bitmap. Any invalid block found means this cannot be
 428          * a directory.
 429          *
 430          * If there are non-zero blocks past the fourth entry, then
 431          * this cannot be a device file: we remember that for the next
 432          * check.
 433          *
 434          * For extent mapped files, we don't do any sanity checking:
 435          * just try to get the phys block of logical block 0 and run
 436          * with it.
 437          */
 438
 439         extent_fs = (ctx->fs->super->s_feature_incompat &
 440                      EXT3_FEATURE_INCOMPAT_EXTENTS);
 441         if (extent_fs && (inode->i_flags & EXT4_EXTENTS_FL)) {
 442                 /* extent mapped */
 443                 if  (ext2fs_bmap2(ctx->fs, pctx->ino, inode, 0, 0, 0, 0,
 444                                  &blk))
 445                         return;
 446                 /* device files are never extent mapped */
 447                 not_device++;
 448         } else {
 449                 for (i=0; i < EXT2_N_BLOCKS; i++) {
 450                         blk = inode->i_block[i];
 451                         if (!blk)
 452                                 continue;
 453                         if (i >= 4)
 454                                 not_device++;
 455
 456                         if (blk < ctx->fs->super->s_first_data_block ||
 457                             blk >= ext2fs_blocks_count(ctx->fs->super) ||
 458                             ext2fs_fast_test_block_bitmap2(ctx->block_found_map,
 459                                                            blk))
 460                                 return; /* Invalid block, can't be dir */
 461                 }
 462                 blk = inode->i_block[0];
 463         }
 464
 465         /*
 466          * If the mode says this is a device file and the i_links_count field
 467          * is sane and we have not ruled it out as a device file previously,
 468          * we declare it a device file, not a directory.
 469          */
 470         if ((LINUX_S_ISCHR(inode->i_mode) || LINUX_S_ISBLK(inode->i_mode)) &&
 471             (inode->i_links_count == 1) && !not_device)
 472                 return;
 473
 474         /* read the first block */
 475         old_op = ehandler_operation(_("reading directory block"));
 476         retval = ext2fs_read_dir_block3(ctx->fs, blk, buf, 0);
 477         ehandler_operation(0);
 478         if (retval)
 479                 return;
 480
 481         dirent = (struct ext2_dir_entry *) buf;
 482         retval = ext2fs_get_rec_len(ctx->fs, dirent, &rec_len);
 483         if (retval)
 484                 return;
 485         if (((dirent->name_len & 0xFF) != 1) ||
 486             (dirent->name[0] != '.') ||
 487             (dirent->inode != pctx->ino) ||
 488             (rec_len < 12) ||
 489             (rec_len % 4) ||
 490             (rec_len >= ctx->fs->blocksize - 12))
 491                 return;
 492
 493         dirent = (struct ext2_dir_entry *) (buf + rec_len);
 494         retval = ext2fs_get_rec_len(ctx->fs, dirent, &rec_len);
 495         if (retval)
 496                 return;
 497         if (((dirent->name_len & 0xFF) != 2) ||
 498             (dirent->name[0] != '.') ||
 499             (dirent->name[1] != '.') ||
 500             (rec_len < 12) ||
 501             (rec_len % 4))
 502                 return;
 503
 504         if (fix_problem(ctx, PR_1_TREAT_AS_DIRECTORY, pctx)) {
 505                 inode->i_mode = (inode->i_mode & 07777) | LINUX_S_IFDIR;
 506                 e2fsck_write_inode_full(ctx, pctx->ino, inode,
 507                                         EXT2_INODE_SIZE(ctx->fs->super),
 508                                         "check_is_really_dir");
 509         }
 510 }
 511
 512 extern void e2fsck_setup_tdb_icount(e2fsck_t ctx, int flags,
 513                                     ext2_icount_t *ret)
 514 {
 515         unsigned int            threshold;
 516         ext2_ino_t              num_dirs;
 517         errcode_t               retval;
 518         char                    *tdb_dir;
 519         int                     enable;
 520
 521         *ret = 0;
 522
 523         profile_get_string(ctx->profile, "scratch_files", "directory", 0, 0,
 524                            &tdb_dir);
 525         profile_get_uint(ctx->profile, "scratch_files",
 526                          "numdirs_threshold", 0, 0, &threshold);
 527         profile_get_boolean(ctx->profile, "scratch_files",
 528                             "icount", 0, 1, &enable);
 529
 530         retval = ext2fs_get_num_dirs(ctx->fs, &num_dirs);
 531         if (retval)
 532                 num_dirs = 1024;        /* Guess */
 533
 534         if (!enable || !tdb_dir || access(tdb_dir, W_OK) ||
 535             (threshold && num_dirs <= threshold))
 536                 return;
 537
 538         retval = ext2fs_create_icount_tdb(ctx->fs, tdb_dir, flags, ret);
 539         if (retval)
 540                 *ret = 0;
 541 }
 542
 543 void e2fsck_pass1(e2fsck_t ctx)
 544 {
 545         int     i;
 546         __u64   max_sizes;
 547         ext2_filsys fs = ctx->fs;
 548         ext2_ino_t      ino;
 549         struct ext2_inode *inode;
 550         ext2_inode_scan scan;
 551         char            *block_buf;
 552 #ifdef RESOURCE_TRACK
 553         struct resource_track   rtrack;
 554 #endif
 555         unsigned char   frag, fsize;
 556         struct          problem_context pctx;
 557         struct          scan_callback_struct scan_struct;
 558         struct ext2_super_block *sb = ctx->fs->super;
 559         const char      *old_op;
 560         int             imagic_fs, extent_fs;
 561         int             busted_fs_time = 0;
 562         int             inode_size;
 563
 564         init_resource_track(&rtrack, ctx->fs->io);
 565         clear_problem_context(&pctx);
 566
 567         if (!(ctx->options & E2F_OPT_PREEN))
 568                 fix_problem(ctx, PR_1_PASS_HEADER, &pctx);
 569
 570         if ((fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_DIR_INDEX) &&
 571             !(ctx->options & E2F_OPT_NO)) {
 572                 if (ext2fs_u32_list_create(&ctx->dirs_to_hash, 50))
 573                         ctx->dirs_to_hash = 0;
 574         }
 575
 576 #ifdef MTRACE
 577         mtrace_print("Pass 1");
 578 #endif
 579
 580 #define EXT2_BPP(bits) (1ULL << ((bits) - 2))
 581
 582         for (i = EXT2_MIN_BLOCK_LOG_SIZE; i <= EXT2_MAX_BLOCK_LOG_SIZE; i++) {
 583                 max_sizes = EXT2_NDIR_BLOCKS + EXT2_BPP(i);
 584                 max_sizes = max_sizes + EXT2_BPP(i) * EXT2_BPP(i);
 585                 max_sizes = max_sizes + EXT2_BPP(i) * EXT2_BPP(i) * EXT2_BPP(i);
 586                 max_sizes = (max_sizes * (1UL << i)) - 1;
 587                 ext2_max_sizes[i - EXT2_MIN_BLOCK_LOG_SIZE] = max_sizes;
 588         }
 589 #undef EXT2_BPP
 590
 591         imagic_fs = (sb->s_feature_compat & EXT2_FEATURE_COMPAT_IMAGIC_INODES);
 592         extent_fs = (sb->s_feature_incompat & EXT3_FEATURE_INCOMPAT_EXTENTS);
 593
 594         /*
 595          * Allocate bitmaps structures
 596          */
 597         pctx.errcode = ext2fs_allocate_inode_bitmap(fs, _("in-use inode map"),
 598                                               &ctx->inode_used_map);
 599         if (pctx.errcode) {
 600                 pctx.num = 1;
 601                 fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx);
 602                 ctx->flags |= E2F_FLAG_ABORT;
 603                 return;
 604         }
 605         pctx.errcode = ext2fs_allocate_inode_bitmap(fs,
 606                                 _("directory inode map"), &ctx->inode_dir_map);
 607         if (pctx.errcode) {
 608                 pctx.num = 2;
 609                 fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx);
 610                 ctx->flags |= E2F_FLAG_ABORT;
 611                 return;
 612         }
 613         pctx.errcode = ext2fs_allocate_inode_bitmap(fs,
 614                         _("regular file inode map"), &ctx->inode_reg_map);
 615         if (pctx.errcode) {
 616                 pctx.num = 6;
 617                 fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx);
 618                 ctx->flags |= E2F_FLAG_ABORT;
 619                 return;
 620         }
 621         pctx.errcode = ext2fs_allocate_subcluster_bitmap(fs,
 622                                                 _("in-use block map"),
 623                                                 &ctx->block_found_map);
 624         if (pctx.errcode) {
 625                 pctx.num = 1;
 626                 fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, &pctx);
 627                 ctx->flags |= E2F_FLAG_ABORT;
 628                 return;
 629         }
 630         e2fsck_setup_tdb_icount(ctx, 0, &ctx->inode_link_info);
 631         if (!ctx->inode_link_info)
 632                 pctx.errcode = ext2fs_create_icount2(fs, 0, 0, 0,
 633                                                      &ctx->inode_link_info);
 634         if (pctx.errcode) {
 635                 fix_problem(ctx, PR_1_ALLOCATE_ICOUNT, &pctx);
 636                 ctx->flags |= E2F_FLAG_ABORT;
 637                 return;
 638         }
 639         inode_size = EXT2_INODE_SIZE(fs->super);
 640         inode = (struct ext2_inode *)
 641                 e2fsck_allocate_memory(ctx, inode_size, "scratch inode");
 642
 643         inodes_to_process = (struct process_inode_block *)
 644                 e2fsck_allocate_memory(ctx,
 645                                        (ctx->process_inode_size *
 646                                         sizeof(struct process_inode_block)),
 647                                        "array of inodes to process");
 648         process_inode_count = 0;
 649
 650         pctx.errcode = ext2fs_init_dblist(fs, 0);
 651         if (pctx.errcode) {
 652                 fix_problem(ctx, PR_1_ALLOCATE_DBCOUNT, &pctx);
 653                 ctx->flags |= E2F_FLAG_ABORT;
 654                 ext2fs_free_mem(&inode);
 655                 return;
 656         }
 657
 658         /*
 659          * If the last orphan field is set, clear it, since the pass1
 660          * processing will automatically find and clear the orphans.
 661          * In the future, we may want to try using the last_orphan
 662          * linked list ourselves, but for now, we clear it so that the
 663          * ext3 mount code won't get confused.
 664          */
 665         if (!(ctx->options & E2F_OPT_READONLY)) {
 666                 if (fs->super->s_last_orphan) {
 667                         fs->super->s_last_orphan = 0;
 668                         ext2fs_mark_super_dirty(fs);
 669                 }
 670         }
 671
 672         mark_table_blocks(ctx);
 673         pctx.errcode = ext2fs_convert_subcluster_bitmap(fs,
 674                                                 &ctx->block_found_map);
 675         if (pctx.errcode) {
 676                 fix_problem(ctx, PR_1_CONVERT_SUBCLUSTER, &pctx);
 677                 ctx->flags |= E2F_FLAG_ABORT;
 678                 ext2fs_free_mem(&inode);
 679                 return;
 680         }
 681         block_buf = (char *) e2fsck_allocate_memory(ctx, fs->blocksize * 3,
 682                                                     "block interate buffer");
 683         e2fsck_use_inode_shortcuts(ctx, 1);
 684         old_op = ehandler_operation(_("opening inode scan"));
 685         pctx.errcode = ext2fs_open_inode_scan(fs, ctx->inode_buffer_blocks,
 686                                               &scan);
 687         ehandler_operation(old_op);
 688         if (pctx.errcode) {
 689                 fix_problem(ctx, PR_1_ISCAN_ERROR, &pctx);
 690                 ctx->flags |= E2F_FLAG_ABORT;
 691                 ext2fs_free_mem(&block_buf);
 692                 ext2fs_free_mem(&inode);
 693                 return;
 694         }
 695         ext2fs_inode_scan_flags(scan, EXT2_SF_SKIP_MISSING_ITABLE, 0);
 696         ctx->stashed_inode = inode;
 697         scan_struct.ctx = ctx;
 698         scan_struct.block_buf = block_buf;
 699         ext2fs_set_inode_callback(scan, scan_callback, &scan_struct);
 700         if (ctx->progress)
 701                 if ((ctx->progress)(ctx, 1, 0, ctx->fs->group_desc_count))
 702                         return;
 703         if ((fs->super->s_wtime < fs->super->s_inodes_count) ||
 704             (fs->super->s_mtime < fs->super->s_inodes_count))
 705                 busted_fs_time = 1;
 706
 707         while (1) {
 708                 old_op = ehandler_operation(_("getting next inode from scan"));
 709                 pctx.errcode = ext2fs_get_next_inode_full(scan, &ino,
 710                                                           inode, inode_size);
 711                 ehandler_operation(old_op);
 712                 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
 713                         return;
 714                 if (pctx.errcode == EXT2_ET_BAD_BLOCK_IN_INODE_TABLE) {
 715                         if (!ctx->inode_bb_map)
 716                                 alloc_bb_map(ctx);
 717                         ext2fs_mark_inode_bitmap2(ctx->inode_bb_map, ino);
 718                         ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino);
 719                         continue;
 720                 }
 721                 if (pctx.errcode) {
 722                         fix_problem(ctx, PR_1_ISCAN_ERROR, &pctx);
 723                         ctx->flags |= E2F_FLAG_ABORT;
 724                         return;
 725                 }
 726                 if (!ino)
 727                         break;
 728                 pctx.ino = ino;
 729                 pctx.inode = inode;
 730                 ctx->stashed_ino = ino;
 731                 if (inode->i_links_count) {
 732                         pctx.errcode = ext2fs_icount_store(ctx->inode_link_info,
 733                                            ino, inode->i_links_count);
 734                         if (pctx.errcode) {
 735                                 pctx.num = inode->i_links_count;
 736                                 fix_problem(ctx, PR_1_ICOUNT_STORE, &pctx);
 737                                 ctx->flags |= E2F_FLAG_ABORT;
 738                                 return;
 739                         }
 740                 }
 741
 742                 /*
 743                  * Test for incorrect extent flag settings.
 744                  *
 745                  * On big-endian machines we must be careful:
 746                  * When the inode is read, the i_block array is not swapped
 747                  * if the extent flag is set.  Therefore if we are testing
 748                  * for or fixing a wrongly-set flag, we must potentially
 749                  * (un)swap before testing, or after fixing.
 750                  */
 751
 752                 /*
 753                  * In this case the extents flag was set when read, so
 754                  * extent_header_verify is ok.  If the inode is cleared,
 755                  * no need to swap... so no extra swapping here.
 756                  */
 757                 if ((inode->i_flags & EXT4_EXTENTS_FL) && !extent_fs &&
 758                     (inode->i_links_count || (ino == EXT2_BAD_INO) ||
 759                      (ino == EXT2_ROOT_INO) || (ino == EXT2_JOURNAL_INO))) {
 760                         if ((ext2fs_extent_header_verify(inode->i_block,
 761                                                  sizeof(inode->i_block)) == 0) &&
 762                             fix_problem(ctx, PR_1_EXTENT_FEATURE, &pctx)) {
 763                                 sb->s_feature_incompat |= EXT3_FEATURE_INCOMPAT_EXTENTS;
 764                                 ext2fs_mark_super_dirty(fs);
 765                                 extent_fs = 1;
 766                         } else if (fix_problem(ctx, PR_1_EXTENTS_SET, &pctx)) {
 767                         clear_inode:
 768                                 e2fsck_clear_inode(ctx, ino, inode, 0, "pass1");
 769                                 if (ino == EXT2_BAD_INO)
 770                                         ext2fs_mark_inode_bitmap2(ctx->inode_used_map,
 771                                                                  ino);
 772                                 continue;
 773                         }
 774                 }
 775
 776                 /*
 777                  * For big-endian machines:
 778                  * If the inode didn't have the extents flag set when it
 779                  * was read, then the i_blocks array was swapped.  To test
 780                  * as an extents header, we must swap it back first.
 781                  * IF we then set the extents flag, the entire i_block
 782                  * array must be un/re-swapped to make it proper extents data.
 783                  */
 784                 if (extent_fs && !(inode->i_flags & EXT4_EXTENTS_FL) &&
 785                     (inode->i_links_count || (ino == EXT2_BAD_INO) ||
 786                      (ino == EXT2_ROOT_INO) || (ino == EXT2_JOURNAL_INO)) &&
 787                     (LINUX_S_ISREG(inode->i_mode) ||
 788                      LINUX_S_ISDIR(inode->i_mode))) {
 789                         void *ehp;
 790 #ifdef WORDS_BIGENDIAN
 791                         __u32 tmp_block[EXT2_N_BLOCKS];
 792
 793                         for (i = 0; i < EXT2_N_BLOCKS; i++)
 794                                 tmp_block[i] = ext2fs_swab32(inode->i_block[i]);
 795                         ehp = tmp_block;
 796 #else
 797                         ehp = inode->i_block;
 798 #endif
 799                         if ((ext2fs_extent_header_verify(ehp,
 800                                          sizeof(inode->i_block)) == 0) &&
 801                             (fix_problem(ctx, PR_1_UNSET_EXTENT_FL, &pctx))) {
 802                                 inode->i_flags |= EXT4_EXTENTS_FL;
 803 #ifdef WORDS_BIGENDIAN
 804                                 memcpy(inode->i_block, tmp_block,
 805                                        sizeof(inode->i_block));
 806 #endif
 807                                 e2fsck_write_inode(ctx, ino, inode, "pass1");
 808                         }
 809                 }
 810
 811                 if (ino == EXT2_BAD_INO) {
 812                         struct process_block_struct pb;
 813
 814                         pctx.errcode = ext2fs_copy_bitmap(ctx->block_found_map,
 815                                                           &pb.fs_meta_blocks);
 816                         if (pctx.errcode) {
 817                                 pctx.num = 4;
 818                                 fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, &pctx);
 819                                 ctx->flags |= E2F_FLAG_ABORT;
 820                                 return;
 821                         }
 822                         pb.ino = EXT2_BAD_INO;
 823                         pb.num_blocks = pb.last_block = 0;
 824                         pb.last_db_block = -1;
 825                         pb.num_illegal_blocks = 0;
 826                         pb.suppress = 0; pb.clear = 0; pb.is_dir = 0;
 827                         pb.is_reg = 0; pb.fragmented = 0; pb.bbcheck = 0;
 828                         pb.inode = inode;
 829                         pb.pctx = &pctx;
 830                         pb.ctx = ctx;
 831                         pctx.errcode = ext2fs_block_iterate3(fs, ino, 0,
 832                                      block_buf, process_bad_block, &pb);
 833                         ext2fs_free_block_bitmap(pb.fs_meta_blocks);
 834                         if (pctx.errcode) {
 835                                 fix_problem(ctx, PR_1_BLOCK_ITERATE, &pctx);
 836                                 ctx->flags |= E2F_FLAG_ABORT;
 837                                 return;
 838                         }
 839                         if (pb.bbcheck)
 840                                 if (!fix_problem(ctx, PR_1_BBINODE_BAD_METABLOCK_PROMPT, &pctx)) {
 841                                 ctx->flags |= E2F_FLAG_ABORT;
 842                                 return;
 843                         }
 844                         ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino);
 845                         clear_problem_context(&pctx);
 846                         continue;
 847                 } else if (ino == EXT2_ROOT_INO) {
 848                         /*
 849                          * Make sure the root inode is a directory; if
 850                          * not, offer to clear it.  It will be
 851                          * regnerated in pass #3.
 852                          */
 853                         if (!LINUX_S_ISDIR(inode->i_mode)) {
 854                                 if (fix_problem(ctx, PR_1_ROOT_NO_DIR, &pctx))
 855                                         goto clear_inode;
 856                         }
 857                         /*
 858                          * If dtime is set, offer to clear it.  mke2fs
 859                          * version 0.2b created filesystems with the
 860                          * dtime field set for the root and lost+found
 861                          * directories.  We won't worry about
 862                          * /lost+found, since that can be regenerated
 863                          * easily.  But we will fix the root directory
 864                          * as a special case.
 865                          */
 866                         if (inode->i_dtime && inode->i_links_count) {
 867                                 if (fix_problem(ctx, PR_1_ROOT_DTIME, &pctx)) {
 868                                         inode->i_dtime = 0;
 869                                         e2fsck_write_inode(ctx, ino, inode,
 870                                                            "pass1");
 871                                 }
 872                         }
 873                 } else if (ino == EXT2_JOURNAL_INO) {
 874                         ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino);
 875                         if (fs->super->s_journal_inum == EXT2_JOURNAL_INO) {
 876                                 if (!LINUX_S_ISREG(inode->i_mode) &&
 877                                     fix_problem(ctx, PR_1_JOURNAL_BAD_MODE,
 878                                                 &pctx)) {
 879                                         inode->i_mode = LINUX_S_IFREG;
 880                                         e2fsck_write_inode(ctx, ino, inode,
 881                                                            "pass1");
 882                                 }
 883                                 check_blocks(ctx, &pctx, block_buf);
 884                                 continue;
 885                         }
 886                         if ((inode->i_links_count ||
 887                              inode->i_blocks || inode->i_block[0]) &&
 888                             fix_problem(ctx, PR_1_JOURNAL_INODE_NOT_CLEAR,
 889                                         &pctx)) {
 890                                 memset(inode, 0, inode_size);
 891                                 ext2fs_icount_store(ctx->inode_link_info,
 892                                                     ino, 0);
 893                                 e2fsck_write_inode_full(ctx, ino, inode,
 894                                                         inode_size, "pass1");
 895                         }
 896                 } else if (ino < EXT2_FIRST_INODE(fs->super)) {
 897                         int     problem = 0;
 898
 899                         ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino);
 900                         if (ino == EXT2_BOOT_LOADER_INO) {
 901                                 if (LINUX_S_ISDIR(inode->i_mode))
 902                                         problem = PR_1_RESERVED_BAD_MODE;
 903                         } else if (ino == EXT2_RESIZE_INO) {
 904                                 if (inode->i_mode &&
 905                                     !LINUX_S_ISREG(inode->i_mode))
 906                                         problem = PR_1_RESERVED_BAD_MODE;
 907                         } else {
 908                                 if (inode->i_mode != 0)
 909                                         problem = PR_1_RESERVED_BAD_MODE;
 910                         }
 911                         if (problem) {
 912                                 if (fix_problem(ctx, problem, &pctx)) {
 913                                         inode->i_mode = 0;
 914                                         e2fsck_write_inode(ctx, ino, inode,
 915                                                            "pass1");
 916                                 }
 917                         }
 918                         check_blocks(ctx, &pctx, block_buf);
 919                         continue;
 920                 }
 921                 /*
 922                  * Check for inodes who might have been part of the
 923                  * orphaned list linked list.  They should have gotten
 924                  * dealt with by now, unless the list had somehow been
 925                  * corrupted.
 926                  *
 927                  * FIXME: In the future, inodes which are still in use
 928                  * (and which are therefore) pending truncation should
 929                  * be handled specially.  Right now we just clear the
 930                  * dtime field, and the normal e2fsck handling of
 931                  * inodes where i_size and the inode blocks are
 932                  * inconsistent is to fix i_size, instead of releasing
 933                  * the extra blocks.  This won't catch the inodes that
 934                  * was at the end of the orphan list, but it's better
 935                  * than nothing.  The right answer is that there
 936                  * shouldn't be any bugs in the orphan list handling.  :-)
 937                  */
 938                 if (inode->i_dtime && !busted_fs_time &&
 939                     inode->i_dtime < ctx->fs->super->s_inodes_count) {
 940                         if (fix_problem(ctx, PR_1_LOW_DTIME, &pctx)) {
 941                                 inode->i_dtime = inode->i_links_count ?
 942                                         0 : ctx->now;
 943                                 e2fsck_write_inode(ctx, ino, inode,
 944                                                    "pass1");
 945                         }
 946                 }
 947
 948                 /*
 949                  * This code assumes that deleted inodes have
 950                  * i_links_count set to 0.
 951                  */
 952                 if (!inode->i_links_count) {
 953                         if (!inode->i_dtime && inode->i_mode) {
 954                                 if (fix_problem(ctx,
 955                                             PR_1_ZERO_DTIME, &pctx)) {
 956                                         inode->i_dtime = ctx->now;
 957                                         e2fsck_write_inode(ctx, ino, inode,
 958                                                            "pass1");
 959                                 }
 960                         }
 961                         continue;
 962                 }
 963                 /*
 964                  * n.b.  0.3c ext2fs code didn't clear i_links_count for
 965                  * deleted files.  Oops.
 966                  *
 967                  * Since all new ext2 implementations get this right,
 968                  * we now assume that the case of non-zero
 969                  * i_links_count and non-zero dtime means that we
 970                  * should keep the file, not delete it.
 971                  *
 972                  */
 973                 if (inode->i_dtime) {
 974                         if (fix_problem(ctx, PR_1_SET_DTIME, &pctx)) {
 975                                 inode->i_dtime = 0;
 976                                 e2fsck_write_inode(ctx, ino, inode, "pass1");
 977                         }
 978                 }
 979
 980                 ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino);
 981                 switch (fs->super->s_creator_os) {
 982                     case EXT2_OS_HURD:
 983                         frag = inode->osd2.hurd2.h_i_frag;
 984                         fsize = inode->osd2.hurd2.h_i_fsize;
 985                         break;
 986                     default:
 987                         frag = fsize = 0;
 988                 }
 989
 990                 if (inode->i_faddr || frag || fsize ||
 991                     (LINUX_S_ISDIR(inode->i_mode) && inode->i_dir_acl))
 992                         mark_inode_bad(ctx, ino);
 993                 if (!(fs->super->s_feature_incompat &
 994                       EXT4_FEATURE_INCOMPAT_64BIT) &&
 995                     inode->osd2.linux2.l_i_file_acl_high != 0)
 996                         mark_inode_bad(ctx, ino);
 997                 if ((fs->super->s_creator_os == EXT2_OS_LINUX) &&
 998                     !(fs->super->s_feature_ro_compat &
 999                       EXT4_FEATURE_RO_COMPAT_HUGE_FILE) &&
1000                     (inode->osd2.linux2.l_i_blocks_hi != 0))
1001                         mark_inode_bad(ctx, ino);
1002                 if (inode->i_flags & EXT2_IMAGIC_FL) {
1003                         if (imagic_fs) {
1004                                 if (!ctx->inode_imagic_map)
1005                                         alloc_imagic_map(ctx);
1006                                 ext2fs_mark_inode_bitmap2(ctx->inode_imagic_map,
1007                                                          ino);
1008                         } else {
1009                                 if (fix_problem(ctx, PR_1_SET_IMAGIC, &pctx)) {
1010                                         inode->i_flags &= ~EXT2_IMAGIC_FL;
1011                                         e2fsck_write_inode(ctx, ino,
1012                                                            inode, "pass1");
1013                                 }
1014                         }
1015                 }
1016
1017                 check_inode_extra_space(ctx, &pctx);
1018                 check_is_really_dir(ctx, &pctx, block_buf);
1019
1020                 /*
1021                  * ext2fs_inode_has_valid_blocks does not actually look
1022                  * at i_block[] values, so not endian-sensitive here.
1023                  */
1024                 if (extent_fs && (inode->i_flags & EXT4_EXTENTS_FL) &&
1025                     LINUX_S_ISLNK(inode->i_mode) &&
1026                     !ext2fs_inode_has_valid_blocks(inode) &&
1027                     fix_problem(ctx, PR_1_FAST_SYMLINK_EXTENT_FL, &pctx)) {
1028                         inode->i_flags &= ~EXT4_EXTENTS_FL;
1029                         e2fsck_write_inode(ctx, ino, inode, "pass1");
1030                 }
1031
1032                 if (LINUX_S_ISDIR(inode->i_mode)) {
1033                         ext2fs_mark_inode_bitmap2(ctx->inode_dir_map, ino);
1034                         e2fsck_add_dir_info(ctx, ino, 0);
1035                         ctx->fs_directory_count++;
1036                 } else if (LINUX_S_ISREG (inode->i_mode)) {
1037                         ext2fs_mark_inode_bitmap2(ctx->inode_reg_map, ino);
1038                         ctx->fs_regular_count++;
1039                 } else if (LINUX_S_ISCHR (inode->i_mode) &&
1040                            e2fsck_pass1_check_device_inode(fs, inode)) {
1041                         check_immutable(ctx, &pctx);
1042                         check_size(ctx, &pctx);
1043                         ctx->fs_chardev_count++;
1044                 } else if (LINUX_S_ISBLK (inode->i_mode) &&
1045                            e2fsck_pass1_check_device_inode(fs, inode)) {
1046                         check_immutable(ctx, &pctx);
1047                         check_size(ctx, &pctx);
1048                         ctx->fs_blockdev_count++;
1049                 } else if (LINUX_S_ISLNK (inode->i_mode) &&
1050                            e2fsck_pass1_check_symlink(fs, ino, inode,
1051                                                       block_buf)) {
1052                         check_immutable(ctx, &pctx);
1053                         ctx->fs_symlinks_count++;
1054                         if (ext2fs_inode_data_blocks(fs, inode) == 0) {
1055                                 ctx->fs_fast_symlinks_count++;
1056                                 check_blocks(ctx, &pctx, block_buf);
1057                                 continue;
1058                         }
1059                 }
1060                 else if (LINUX_S_ISFIFO (inode->i_mode) &&
1061                          e2fsck_pass1_check_device_inode(fs, inode)) {
1062                         check_immutable(ctx, &pctx);
1063                         check_size(ctx, &pctx);
1064                         ctx->fs_fifo_count++;
1065                 } else if ((LINUX_S_ISSOCK (inode->i_mode)) &&
1066                            e2fsck_pass1_check_device_inode(fs, inode)) {
1067                         check_immutable(ctx, &pctx);
1068                         check_size(ctx, &pctx);
1069                         ctx->fs_sockets_count++;
1070                 } else
1071                         mark_inode_bad(ctx, ino);
1072                 if (!(inode->i_flags & EXT4_EXTENTS_FL)) {
1073                         if (inode->i_block[EXT2_IND_BLOCK])
1074                                 ctx->fs_ind_count++;
1075                         if (inode->i_block[EXT2_DIND_BLOCK])
1076                                 ctx->fs_dind_count++;
1077                         if (inode->i_block[EXT2_TIND_BLOCK])
1078                                 ctx->fs_tind_count++;
1079                 }
1080                 if (!(inode->i_flags & EXT4_EXTENTS_FL) &&
1081                     (inode->i_block[EXT2_IND_BLOCK] ||
1082                      inode->i_block[EXT2_DIND_BLOCK] ||
1083                      inode->i_block[EXT2_TIND_BLOCK] ||
1084                      ext2fs_file_acl_block(inode))) {
1085                         inodes_to_process[process_inode_count].ino = ino;
1086                         inodes_to_process[process_inode_count].inode = *inode;
1087                         process_inode_count++;
1088                 } else
1089                         check_blocks(ctx, &pctx, block_buf);
1090
1091                 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
1092                         return;
1093
1094                 if (process_inode_count >= ctx->process_inode_size) {
1095                         process_inodes(ctx, block_buf);
1096
1097                         if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
1098                                 return;
1099                 }
1100         }
1101         process_inodes(ctx, block_buf);
1102         ext2fs_close_inode_scan(scan);
1103
1104         /*
1105          * If any extended attribute blocks' reference counts need to
1106          * be adjusted, either up (ctx->refcount_extra), or down
1107          * (ctx->refcount), then fix them.
1108          */
1109         if (ctx->refcount) {
1110                 adjust_extattr_refcount(ctx, ctx->refcount, block_buf, -1);
1111                 ea_refcount_free(ctx->refcount);
1112                 ctx->refcount = 0;
1113         }
1114         if (ctx->refcount_extra) {
1115                 adjust_extattr_refcount(ctx, ctx->refcount_extra,
1116                                         block_buf, +1);
1117                 ea_refcount_free(ctx->refcount_extra);
1118                 ctx->refcount_extra = 0;
1119         }
1120
1121         if (ctx->invalid_bitmaps)
1122                 handle_fs_bad_blocks(ctx);
1123
1124         /* We don't need the block_ea_map any more */
1125         if (ctx->block_ea_map) {
1126                 ext2fs_free_block_bitmap(ctx->block_ea_map);
1127                 ctx->block_ea_map = 0;
1128         }
1129
1130         if (ctx->flags & E2F_FLAG_RESIZE_INODE) {
1131                 ext2fs_block_bitmap save_bmap;
1132
1133                 save_bmap = fs->block_map;
1134                 fs->block_map = ctx->block_found_map;
1135                 clear_problem_context(&pctx);
1136                 pctx.errcode = ext2fs_create_resize_inode(fs);
1137                 if (pctx.errcode) {
1138                         if (!fix_problem(ctx, PR_1_RESIZE_INODE_CREATE,
1139                                          &pctx)) {
1140                                 ctx->flags |= E2F_FLAG_ABORT;
1141                                 return;
1142                         }
1143                         pctx.errcode = 0;
1144                 }
1145                 if (!pctx.errcode) {
1146                         e2fsck_read_inode(ctx, EXT2_RESIZE_INO, inode,
1147                                           "recreate inode");
1148                         inode->i_mtime = ctx->now;
1149                         e2fsck_write_inode(ctx, EXT2_RESIZE_INO, inode,
1150                                            "recreate inode");
1151                 }
1152                 fs->block_map = save_bmap;
1153                 ctx->flags &= ~E2F_FLAG_RESIZE_INODE;
1154         }
1155
1156         if (ctx->flags & E2F_FLAG_RESTART) {
1157                 /*
1158                  * Only the master copy of the superblock and block
1159                  * group descriptors are going to be written during a
1160                  * restart, so set the superblock to be used to be the
1161                  * master superblock.
1162                  */
1163                 ctx->use_superblock = 0;
1164                 unwind_pass1(fs);
1165                 goto endit;
1166         }
1167
1168         if (ctx->block_dup_map) {
1169                 if (ctx->options & E2F_OPT_PREEN) {
1170                         clear_problem_context(&pctx);
1171                         fix_problem(ctx, PR_1_DUP_BLOCKS_PREENSTOP, &pctx);
1172                 }
1173                 e2fsck_pass1_dupblocks(ctx, block_buf);
1174         }
1175         ext2fs_free_mem(&inodes_to_process);
1176 endit:
1177         e2fsck_use_inode_shortcuts(ctx, 0);
1178
1179         ext2fs_free_mem(&block_buf);
1180         ext2fs_free_mem(&inode);
1181
1182         print_resource_track(ctx, _("Pass 1"), &rtrack, ctx->fs->io);
1183 }
1184
1185 /*
1186  * When the inode_scan routines call this callback at the end of the
1187  * glock group, call process_inodes.
1188  */
1189 static errcode_t scan_callback(ext2_filsys fs,
1190                                ext2_inode_scan scan EXT2FS_ATTR((unused)),
1191                                dgrp_t group, void * priv_data)
1192 {
1193         struct scan_callback_struct *scan_struct;
1194         e2fsck_t ctx;
1195
1196         scan_struct = (struct scan_callback_struct *) priv_data;
1197         ctx = scan_struct->ctx;
1198
1199         process_inodes((e2fsck_t) fs->priv_data, scan_struct->block_buf);
1200
1201         if (ctx->progress)
1202                 if ((ctx->progress)(ctx, 1, group+1,
1203                                     ctx->fs->group_desc_count))
1204                         return EXT2_ET_CANCEL_REQUESTED;
1205
1206         return 0;
1207 }
1208
1209 /*
1210  * Process the inodes in the "inodes to process" list.
1211  */
1212 static void process_inodes(e2fsck_t ctx, char *block_buf)
1213 {
1214         int                     i;
1215         struct ext2_inode       *old_stashed_inode;
1216         ext2_ino_t              old_stashed_ino;
1217         const char              *old_operation;
1218         char                    buf[80];
1219         struct problem_context  pctx;
1220
1221 #if 0
1222         printf("begin process_inodes: ");
1223 #endif
1224         if (process_inode_count == 0)
1225                 return;
1226         old_operation = ehandler_operation(0);
1227         old_stashed_inode = ctx->stashed_inode;
1228         old_stashed_ino = ctx->stashed_ino;
1229         qsort(inodes_to_process, process_inode_count,
1230                       sizeof(struct process_inode_block), process_inode_cmp);
1231         clear_problem_context(&pctx);
1232         for (i=0; i < process_inode_count; i++) {
1233                 pctx.inode = ctx->stashed_inode = &inodes_to_process[i].inode;
1234                 pctx.ino = ctx->stashed_ino = inodes_to_process[i].ino;
1235
1236 #if 0
1237                 printf("%u ", pctx.ino);
1238 #endif
1239                 sprintf(buf, _("reading indirect blocks of inode %u"),
1240                         pctx.ino);
1241                 ehandler_operation(buf);
1242                 check_blocks(ctx, &pctx, block_buf);
1243                 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
1244                         break;
1245         }
1246         ctx->stashed_inode = old_stashed_inode;
1247         ctx->stashed_ino = old_stashed_ino;
1248         process_inode_count = 0;
1249 #if 0
1250         printf("end process inodes\n");
1251 #endif
1252         ehandler_operation(old_operation);
1253 }
1254
1255 static EXT2_QSORT_TYPE process_inode_cmp(const void *a, const void *b)
1256 {
1257         const struct process_inode_block *ib_a =
1258                 (const struct process_inode_block *) a;
1259         const struct process_inode_block *ib_b =
1260                 (const struct process_inode_block *) b;
1261         int     ret;
1262
1263         ret = (ib_a->inode.i_block[EXT2_IND_BLOCK] -
1264                ib_b->inode.i_block[EXT2_IND_BLOCK]);
1265         if (ret == 0)
1266                 ret = ext2fs_file_acl_block(&(ib_a->inode)) -
1267                         ext2fs_file_acl_block(&ib_b->inode);
1268         if (ret == 0)
1269                 ret = ib_a->ino - ib_b->ino;
1270         return ret;
1271 }
1272
1273 /*
1274  * Mark an inode as being bad in some what
1275  */
1276 static void mark_inode_bad(e2fsck_t ctx, ino_t ino)
1277 {
1278         struct          problem_context pctx;
1279
1280         if (!ctx->inode_bad_map) {
1281                 clear_problem_context(&pctx);
1282
1283                 pctx.errcode = ext2fs_allocate_inode_bitmap(ctx->fs,
1284                             _("bad inode map"), &ctx->inode_bad_map);
1285                 if (pctx.errcode) {
1286                         pctx.num = 3;
1287                         fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx);
1288                         /* Should never get here */
1289                         ctx->flags |= E2F_FLAG_ABORT;
1290                         return;
1291                 }
1292         }
1293         ext2fs_mark_inode_bitmap2(ctx->inode_bad_map, ino);
1294 }
1295
1296
1297 /*
1298  * This procedure will allocate the inode "bb" (badblock) map table
1299  */
1300 static void alloc_bb_map(e2fsck_t ctx)
1301 {
1302         struct          problem_context pctx;
1303
1304         clear_problem_context(&pctx);
1305         pctx.errcode = ext2fs_allocate_inode_bitmap(ctx->fs,
1306                                               _("inode in bad block map"),
1307                                               &ctx->inode_bb_map);
1308         if (pctx.errcode) {
1309                 pctx.num = 4;
1310                 fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx);
1311                 /* Should never get here */
1312                 ctx->flags |= E2F_FLAG_ABORT;
1313                 return;
1314         }
1315 }
1316
1317 /*
1318  * This procedure will allocate the inode imagic table
1319  */
1320 static void alloc_imagic_map(e2fsck_t ctx)
1321 {
1322         struct          problem_context pctx;
1323
1324         clear_problem_context(&pctx);
1325         pctx.errcode = ext2fs_allocate_inode_bitmap(ctx->fs,
1326                                               _("imagic inode map"),
1327                                               &ctx->inode_imagic_map);
1328         if (pctx.errcode) {
1329                 pctx.num = 5;
1330                 fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx);
1331                 /* Should never get here */
1332                 ctx->flags |= E2F_FLAG_ABORT;
1333                 return;
1334         }
1335 }
1336
1337 /*
1338  * Marks a block as in use, setting the dup_map if it's been set
1339  * already.  Called by process_block and process_bad_block.
1340  *
1341  * WARNING: Assumes checks have already been done to make sure block
1342  * is valid.  This is true in both process_block and process_bad_block.
1343  */
1344 static _INLINE_ void mark_block_used(e2fsck_t ctx, blk64_t block)
1345 {
1346         struct          problem_context pctx;
1347
1348         clear_problem_context(&pctx);
1349
1350         if (ext2fs_fast_test_block_bitmap2(ctx->block_found_map, block)) {
1351                 if (!ctx->block_dup_map) {
1352                         pctx.errcode = ext2fs_allocate_block_bitmap(ctx->fs,
1353                               _("multiply claimed block map"),
1354                               &ctx->block_dup_map);
1355                         if (pctx.errcode) {
1356                                 pctx.num = 3;
1357                                 fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR,
1358                                             &pctx);
1359                                 /* Should never get here */
1360                                 ctx->flags |= E2F_FLAG_ABORT;
1361                                 return;
1362                         }
1363                 }
1364                 ext2fs_fast_mark_block_bitmap2(ctx->block_dup_map, block);
1365         } else {
1366                 ext2fs_fast_mark_block_bitmap2(ctx->block_found_map, block);
1367         }
1368 }
1369
1370 /*
1371  * Adjust the extended attribute block's reference counts at the end
1372  * of pass 1, either by subtracting out references for EA blocks that
1373  * are still referenced in ctx->refcount, or by adding references for
1374  * EA blocks that had extra references as accounted for in
1375  * ctx->refcount_extra.
1376  */
1377 static void adjust_extattr_refcount(e2fsck_t ctx, ext2_refcount_t refcount,
1378                                     char *block_buf, int adjust_sign)
1379 {
1380         struct ext2_ext_attr_header     *header;
1381         struct problem_context          pctx;
1382         ext2_filsys                     fs = ctx->fs;
1383         blk64_t                         blk;
1384         __u32                           should_be;
1385         int                             count;
1386
1387         clear_problem_context(&pctx);
1388
1389         ea_refcount_intr_begin(refcount);
1390         while (1) {
1391                 if ((blk = ea_refcount_intr_next(refcount, &count)) == 0)
1392                         break;
1393                 pctx.blk = blk;
1394                 pctx.errcode = ext2fs_read_ext_attr2(fs, blk, block_buf);
1395                 if (pctx.errcode) {
1396                         fix_problem(ctx, PR_1_EXTATTR_READ_ABORT, &pctx);
1397                         return;
1398                 }
1399                 header = (struct ext2_ext_attr_header *) block_buf;
1400                 pctx.blkcount = header->h_refcount;
1401                 should_be = header->h_refcount + adjust_sign * count;
1402                 pctx.num = should_be;
1403                 if (fix_problem(ctx, PR_1_EXTATTR_REFCOUNT, &pctx)) {
1404                         header->h_refcount = should_be;
1405                         pctx.errcode = ext2fs_write_ext_attr2(fs, blk,
1406                                                              block_buf);
1407                         if (pctx.errcode) {
1408                                 fix_problem(ctx, PR_1_EXTATTR_WRITE_ABORT,
1409                                             &pctx);
1410                                 continue;
1411                         }
1412                 }
1413         }
1414 }
1415
1416 /*
1417  * Handle processing the extended attribute blocks
1418  */
1419 static int check_ext_attr(e2fsck_t ctx, struct problem_context *pctx,
1420                            char *block_buf)
1421 {
1422         ext2_filsys fs = ctx->fs;
1423         ext2_ino_t      ino = pctx->ino;
1424         struct ext2_inode *inode = pctx->inode;
1425         blk64_t         blk;
1426         char *          end;
1427         struct ext2_ext_attr_header *header;
1428         struct ext2_ext_attr_entry *entry;
1429         int             count;
1430         region_t        region = 0;
1431
1432         blk = ext2fs_file_acl_block(inode);
1433         if (blk == 0)
1434                 return 0;
1435
1436         /*
1437          * If the Extended attribute flag isn't set, then a non-zero
1438          * file acl means that the inode is corrupted.
1439          *
1440          * Or if the extended attribute block is an invalid block,
1441          * then the inode is also corrupted.
1442          */
1443         if (!(fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_EXT_ATTR) ||
1444             (blk < fs->super->s_first_data_block) ||
1445             (blk >= ext2fs_blocks_count(fs->super))) {
1446                 mark_inode_bad(ctx, ino);
1447                 return 0;
1448         }
1449
1450         /* If ea bitmap hasn't been allocated, create it */
1451         if (!ctx->block_ea_map) {
1452                 pctx->errcode = ext2fs_allocate_block_bitmap(fs,
1453                                                       _("ext attr block map"),
1454                                                       &ctx->block_ea_map);
1455                 if (pctx->errcode) {
1456                         pctx->num = 2;
1457                         fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, pctx);
1458                         ctx->flags |= E2F_FLAG_ABORT;
1459                         return 0;
1460                 }
1461         }
1462
1463         /* Create the EA refcount structure if necessary */
1464         if (!ctx->refcount) {
1465                 pctx->errcode = ea_refcount_create(0, &ctx->refcount);
1466                 if (pctx->errcode) {
1467                         pctx->num = 1;
1468                         fix_problem(ctx, PR_1_ALLOCATE_REFCOUNT, pctx);
1469                         ctx->flags |= E2F_FLAG_ABORT;
1470                         return 0;
1471                 }
1472         }
1473
1474 #if 0
1475         /* Debugging text */
1476         printf("Inode %u has EA block %u\n", ino, blk);
1477 #endif
1478
1479         /* Have we seen this EA block before? */
1480         if (ext2fs_fast_test_block_bitmap2(ctx->block_ea_map, blk)) {
1481                 if (ea_refcount_decrement(ctx->refcount, blk, 0) == 0)
1482                         return 1;
1483                 /* Ooops, this EA was referenced more than it stated */
1484                 if (!ctx->refcount_extra) {
1485                         pctx->errcode = ea_refcount_create(0,
1486                                            &ctx->refcount_extra);
1487                         if (pctx->errcode) {
1488                                 pctx->num = 2;
1489                                 fix_problem(ctx, PR_1_ALLOCATE_REFCOUNT, pctx);
1490                                 ctx->flags |= E2F_FLAG_ABORT;
1491                                 return 0;
1492                         }
1493                 }
1494                 ea_refcount_increment(ctx->refcount_extra, blk, 0);
1495                 return 1;
1496         }
1497
1498         /*
1499          * OK, we haven't seen this EA block yet.  So we need to
1500          * validate it
1501          */
1502         pctx->blk = blk;
1503         pctx->errcode = ext2fs_read_ext_attr2(fs, blk, block_buf);
1504         if (pctx->errcode && fix_problem(ctx, PR_1_READ_EA_BLOCK, pctx))
1505                 goto clear_extattr;
1506         header = (struct ext2_ext_attr_header *) block_buf;
1507         pctx->blk = ext2fs_file_acl_block(inode);
1508         if (((ctx->ext_attr_ver == 1) &&
1509              (header->h_magic != EXT2_EXT_ATTR_MAGIC_v1)) ||
1510             ((ctx->ext_attr_ver == 2) &&
1511              (header->h_magic != EXT2_EXT_ATTR_MAGIC))) {
1512                 if (fix_problem(ctx, PR_1_BAD_EA_BLOCK, pctx))
1513                         goto clear_extattr;
1514         }
1515
1516         if (header->h_blocks != 1) {
1517                 if (fix_problem(ctx, PR_1_EA_MULTI_BLOCK, pctx))
1518                         goto clear_extattr;
1519         }
1520
1521         region = region_create(0, fs->blocksize);
1522         if (!region) {
1523                 fix_problem(ctx, PR_1_EA_ALLOC_REGION_ABORT, pctx);
1524                 ctx->flags |= E2F_FLAG_ABORT;
1525                 return 0;
1526         }
1527         if (region_allocate(region, 0, sizeof(struct ext2_ext_attr_header))) {
1528                 if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, pctx))
1529                         goto clear_extattr;
1530         }
1531
1532         entry = (struct ext2_ext_attr_entry *)(header+1);
1533         end = block_buf + fs->blocksize;
1534         while ((char *)entry < end && *(__u32 *)entry) {
1535                 __u32 hash;
1536
1537                 if (region_allocate(region, (char *)entry - (char *)header,
1538                                    EXT2_EXT_ATTR_LEN(entry->e_name_len))) {
1539                         if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, pctx))
1540                                 goto clear_extattr;
1541                         break;
1542                 }
1543                 if ((ctx->ext_attr_ver == 1 &&
1544                      (entry->e_name_len == 0 || entry->e_name_index != 0)) ||
1545                     (ctx->ext_attr_ver == 2 &&
1546                      entry->e_name_index == 0)) {
1547                         if (fix_problem(ctx, PR_1_EA_BAD_NAME, pctx))
1548                                 goto clear_extattr;
1549                         break;
1550                 }
1551                 if (entry->e_value_block != 0) {
1552                         if (fix_problem(ctx, PR_1_EA_BAD_VALUE, pctx))
1553                                 goto clear_extattr;
1554                 }
1555                 if (entry->e_value_offs + entry->e_value_size > fs->blocksize) {
1556                         if (fix_problem(ctx, PR_1_EA_BAD_VALUE, pctx))
1557                                 goto clear_extattr;
1558                         break;
1559                 }
1560                 if (entry->e_value_size &&
1561                     region_allocate(region, entry->e_value_offs,
1562                                     EXT2_EXT_ATTR_SIZE(entry->e_value_size))) {
1563                         if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, pctx))
1564                                 goto clear_extattr;
1565                 }
1566
1567                 hash = ext2fs_ext_attr_hash_entry(entry, block_buf +
1568                                                          entry->e_value_offs);
1569
1570                 if (entry->e_hash != hash) {
1571                         pctx->num = entry->e_hash;
1572                         if (fix_problem(ctx, PR_1_ATTR_HASH, pctx))
1573                                 goto clear_extattr;
1574                         entry->e_hash = hash;
1575                 }
1576
1577                 entry = EXT2_EXT_ATTR_NEXT(entry);
1578         }
1579         if (region_allocate(region, (char *)entry - (char *)header, 4)) {
1580                 if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, pctx))
1581                         goto clear_extattr;
1582         }
1583         region_free(region);
1584
1585         count = header->h_refcount - 1;
1586         if (count)
1587                 ea_refcount_store(ctx->refcount, blk, count);
1588         mark_block_used(ctx, blk);
1589         ext2fs_fast_mark_block_bitmap2(ctx->block_ea_map, blk);
1590         return 1;
1591
1592 clear_extattr:
1593         if (region)
1594                 region_free(region);
1595         ext2fs_file_acl_block_set(inode, 0);
1596         e2fsck_write_inode(ctx, ino, inode, "check_ext_attr");
1597         return 0;
1598 }
1599
1600 /* Returns 1 if bad htree, 0 if OK */
1601 static int handle_htree(e2fsck_t ctx, struct problem_context *pctx,
1602                         ext2_ino_t ino, struct ext2_inode *inode,
1603                         char *block_buf)
1604 {
1605         struct ext2_dx_root_info        *root;
1606         ext2_filsys                     fs = ctx->fs;
1607         errcode_t                       retval;
1608         blk64_t                         blk;
1609
1610         if ((!LINUX_S_ISDIR(inode->i_mode) &&
1611              fix_problem(ctx, PR_1_HTREE_NODIR, pctx)) ||
1612             (!(fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_DIR_INDEX) &&
1613              fix_problem(ctx, PR_1_HTREE_SET, pctx)))
1614                 return 1;
1615
1616         pctx->errcode = ext2fs_bmap2(fs, ino, inode, 0, 0, 0, 0, &blk);
1617
1618         if ((pctx->errcode) ||
1619             (blk == 0) ||
1620             (blk < fs->super->s_first_data_block) ||
1621             (blk >= ext2fs_blocks_count(fs->super))) {
1622                 if (fix_problem(ctx, PR_1_HTREE_BADROOT, pctx))
1623                         return 1;
1624                 else
1625                         return 0;
1626         }
1627
1628         retval = io_channel_read_blk64(fs->io, blk, 1, block_buf);
1629         if (retval && fix_problem(ctx, PR_1_HTREE_BADROOT, pctx))
1630                 return 1;
1631
1632         /* XXX should check that beginning matches a directory */
1633         root = (struct ext2_dx_root_info *) (block_buf + 24);
1634
1635         if ((root->reserved_zero || root->info_length < 8) &&
1636             fix_problem(ctx, PR_1_HTREE_BADROOT, pctx))
1637                 return 1;
1638
1639         pctx->num = root->hash_version;
1640         if ((root->hash_version != EXT2_HASH_LEGACY) &&
1641             (root->hash_version != EXT2_HASH_HALF_MD4) &&
1642             (root->hash_version != EXT2_HASH_TEA) &&
1643             fix_problem(ctx, PR_1_HTREE_HASHV, pctx))
1644                 return 1;
1645
1646         if ((root->unused_flags & EXT2_HASH_FLAG_INCOMPAT) &&
1647             fix_problem(ctx, PR_1_HTREE_INCOMPAT, pctx))
1648                 return 1;
1649
1650         pctx->num = root->indirect_levels;
1651         if ((root->indirect_levels > 1) &&
1652             fix_problem(ctx, PR_1_HTREE_DEPTH, pctx))
1653                 return 1;
1654
1655         return 0;
1656 }
1657
1658 void e2fsck_clear_inode(e2fsck_t ctx, ext2_ino_t ino,
1659                         struct ext2_inode *inode, int restart_flag,
1660                         const char *source)
1661 {
1662         inode->i_flags = 0;
1663         inode->i_links_count = 0;
1664         ext2fs_icount_store(ctx->inode_link_info, ino, 0);
1665         inode->i_dtime = ctx->now;
1666
1667         ext2fs_unmark_inode_bitmap2(ctx->inode_dir_map, ino);
1668         ext2fs_unmark_inode_bitmap2(ctx->inode_used_map, ino);
1669         if (ctx->inode_reg_map)
1670                 ext2fs_unmark_inode_bitmap2(ctx->inode_reg_map, ino);
1671         if (ctx->inode_bad_map)
1672                 ext2fs_unmark_inode_bitmap2(ctx->inode_bad_map, ino);
1673
1674         /*
1675          * If the inode was partially accounted for before processing
1676          * was aborted, we need to restart the pass 1 scan.
1677          */
1678         ctx->flags |= restart_flag;
1679
1680         e2fsck_write_inode(ctx, ino, inode, source);
1681 }
1682
1683 static void scan_extent_node(e2fsck_t ctx, struct problem_context *pctx,
1684                              struct process_block_struct *pb,
1685                              blk64_t start_block,
1686                              ext2_extent_handle_t ehandle)
1687 {
1688         struct ext2fs_extent    extent;
1689         blk64_t                 blk;
1690         e2_blkcnt_t             blockcnt;
1691         unsigned int            i;
1692         int                     is_dir, is_leaf;
1693         errcode_t               problem;
1694         struct ext2_extent_info info;
1695
1696         pctx->errcode = ext2fs_extent_get_info(ehandle, &info);
1697         if (pctx->errcode)
1698                 return;
1699
1700         pctx->errcode = ext2fs_extent_get(ehandle, EXT2_EXTENT_FIRST_SIB,
1701                                           &extent);
1702         while (!pctx->errcode && info.num_entries-- > 0) {
1703                 is_leaf = extent.e_flags & EXT2_EXTENT_FLAGS_LEAF;
1704                 is_dir = LINUX_S_ISDIR(pctx->inode->i_mode);
1705
1706                 problem = 0;
1707                 if (extent.e_pblk == 0 ||
1708                     extent.e_pblk < ctx->fs->super->s_first_data_block ||
1709                     extent.e_pblk >= ext2fs_blocks_count(ctx->fs->super))
1710                         problem = PR_1_EXTENT_BAD_START_BLK;
1711                 else if (extent.e_lblk < start_block)
1712                         problem = PR_1_OUT_OF_ORDER_EXTENTS;
1713                 else if (is_leaf &&
1714                          (extent.e_pblk + extent.e_len) >
1715                          ext2fs_blocks_count(ctx->fs->super))
1716                         problem = PR_1_EXTENT_ENDS_BEYOND;
1717
1718                 if (problem) {
1719                 report_problem:
1720                         pctx->blk = extent.e_pblk;
1721                         pctx->blk2 = extent.e_lblk;
1722                         pctx->num = extent.e_len;
1723                         if (fix_problem(ctx, problem, pctx)) {
1724                                 e2fsck_read_bitmaps(ctx);
1725                                 pctx->errcode =
1726                                         ext2fs_extent_delete(ehandle, 0);
1727                                 if (pctx->errcode) {
1728                                         pctx->str = "ext2fs_extent_delete";
1729                                         return;
1730                                 }
1731                                 pctx->errcode = ext2fs_extent_get(ehandle,
1732                                                                   EXT2_EXTENT_CURRENT,
1733                                                                   &extent);
1734                                 if (pctx->errcode == EXT2_ET_NO_CURRENT_NODE) {
1735                                         pctx->errcode = 0;
1736                                         break;
1737                                 }
1738                                 continue;
1739                         }
1740                         goto next;
1741                 }
1742
1743                 if (!is_leaf) {
1744                         blk = extent.e_pblk;
1745                         pctx->errcode = ext2fs_extent_get(ehandle,
1746                                                   EXT2_EXTENT_DOWN, &extent);
1747                         if (pctx->errcode) {
1748                                 pctx->str = "EXT2_EXTENT_DOWN";
1749                                 problem = PR_1_EXTENT_HEADER_INVALID;
1750                                 if (pctx->errcode == EXT2_ET_EXTENT_HEADER_BAD)
1751                                         goto report_problem;
1752                                 return;
1753                         }
1754                         scan_extent_node(ctx, pctx, pb, extent.e_lblk, ehandle);
1755                         if (pctx->errcode)
1756                                 return;
1757                         pctx->errcode = ext2fs_extent_get(ehandle,
1758                                                   EXT2_EXTENT_UP, &extent);
1759                         if (pctx->errcode) {
1760                                 pctx->str = "EXT2_EXTENT_UP";
1761                                 return;
1762                         }
1763                         mark_block_used(ctx, blk);
1764                         pb->num_blocks++;
1765                         goto next;
1766                 }
1767
1768                 if ((pb->previous_block != 0) &&
1769                     (pb->previous_block+1 != extent.e_pblk)) {
1770                         if (ctx->options & E2F_OPT_FRAGCHECK) {
1771                                 char type = '?';
1772
1773                                 if (pb->is_dir)
1774                                         type = 'd';
1775                                 else if (pb->is_reg)
1776                                         type = 'f';
1777
1778                                 printf(("%6lu(%c): expecting %6lu "
1779                                         "actual extent "
1780                                         "phys %6lu log %lu len %lu\n"),
1781                                        (unsigned long) pctx->ino, type,
1782                                        (unsigned long) pb->previous_block+1,
1783                                        (unsigned long) extent.e_pblk,
1784                                        (unsigned long) extent.e_lblk,
1785                                        (unsigned long) extent.e_len);
1786                         }
1787                         pb->fragmented = 1;
1788                 }
1789                 while (is_dir && ++pb->last_db_block < extent.e_lblk) {
1790                         pctx->errcode = ext2fs_add_dir_block2(ctx->fs->dblist,
1791                                                               pb->ino, 0,
1792                                                               pb->last_db_block);
1793                         if (pctx->errcode) {
1794                                 pctx->blk = 0;
1795                                 pctx->num = pb->last_db_block;
1796                                 goto failed_add_dir_block;
1797                         }
1798                 }
1799                 for (blk = extent.e_pblk, blockcnt = extent.e_lblk, i = 0;
1800                      i < extent.e_len;
1801                      blk++, blockcnt++, i++) {
1802                         if (!(ctx->fs->cluster_ratio_bits &&
1803                               pb->previous_block &&
1804                               (EXT2FS_B2C(ctx->fs, blk) ==
1805                                EXT2FS_B2C(ctx->fs, pb->previous_block)) &&
1806                               (blk & EXT2FS_CLUSTER_MASK(ctx->fs)) ==
1807                               (blockcnt & EXT2FS_CLUSTER_MASK(ctx->fs)))) {
1808                                 mark_block_used(ctx, blk);
1809                                 pb->num_blocks++;
1810                         }
1811
1812                         pb->previous_block = blk;
1813
1814                         if (is_dir) {
1815                                 pctx->errcode = ext2fs_add_dir_block2(ctx->fs->dblist, pctx->ino, blk, blockcnt);
1816                                 if (pctx->errcode) {
1817                                         pctx->blk = blk;
1818                                         pctx->num = blockcnt;
1819                                 failed_add_dir_block:
1820                                         fix_problem(ctx, PR_1_ADD_DBLOCK, pctx);
1821                                         /* Should never get here */
1822                                         ctx->flags |= E2F_FLAG_ABORT;
1823                                         return;
1824                                 }
1825                         }
1826                 }
1827                 if (is_dir && extent.e_len > 0)
1828                         pb->last_db_block = blockcnt - 1;
1829                 pb->previous_block = extent.e_pblk + extent.e_len - 1;
1830                 start_block = pb->last_block = extent.e_lblk + extent.e_len - 1;
1831         next:
1832                 pctx->errcode = ext2fs_extent_get(ehandle,
1833                                                   EXT2_EXTENT_NEXT_SIB,
1834                                                   &extent);
1835         }
1836         if (pctx->errcode == EXT2_ET_EXTENT_NO_NEXT)
1837                 pctx->errcode = 0;
1838 }
1839
1840 static void check_blocks_extents(e2fsck_t ctx, struct problem_context *pctx,
1841                                  struct process_block_struct *pb)
1842 {
1843         struct ext2_extent_info info;
1844         struct ext2_inode       *inode = pctx->inode;
1845         ext2_extent_handle_t    ehandle;
1846         ext2_filsys             fs = ctx->fs;
1847         ext2_ino_t              ino = pctx->ino;
1848         errcode_t               retval;
1849
1850         pctx->errcode = ext2fs_extent_open2(fs, ino, inode, &ehandle);
1851         if (pctx->errcode) {
1852                 if (fix_problem(ctx, PR_1_READ_EXTENT, pctx))
1853                         e2fsck_clear_inode(ctx, ino, inode, 0,
1854                                            "check_blocks_extents");
1855                 pctx->errcode = 0;
1856                 return;
1857         }
1858
1859         retval = ext2fs_extent_get_info(ehandle, &info);
1860         if (retval == 0) {
1861                 if (info.max_depth >= MAX_EXTENT_DEPTH_COUNT)
1862                         info.max_depth = MAX_EXTENT_DEPTH_COUNT-1;
1863                 ctx->extent_depth_count[info.max_depth]++;
1864         }
1865
1866         scan_extent_node(ctx, pctx, pb, 0, ehandle);
1867         if (pctx->errcode &&
1868             fix_problem(ctx, PR_1_EXTENT_ITERATE_FAILURE, pctx)) {
1869                 pb->num_blocks = 0;
1870                 inode->i_blocks = 0;
1871                 e2fsck_clear_inode(ctx, ino, inode, E2F_FLAG_RESTART,
1872                                    "check_blocks_extents");
1873                 pctx->errcode = 0;
1874         }
1875         ext2fs_extent_free(ehandle);
1876 }
1877
1878 /*
1879  * This subroutine is called on each inode to account for all of the
1880  * blocks used by that inode.
1881  */
1882 static void check_blocks(e2fsck_t ctx, struct problem_context *pctx,
1883                          char *block_buf)
1884 {
1885         ext2_filsys fs = ctx->fs;
1886         struct process_block_struct pb;
1887         ext2_ino_t      ino = pctx->ino;
1888         struct ext2_inode *inode = pctx->inode;
1889         int             bad_size = 0;
1890         int             dirty_inode = 0;
1891         int             extent_fs;
1892         __u64           size;
1893
1894         pb.ino = ino;
1895         pb.num_blocks = 0;
1896         pb.last_block = -1;
1897         pb.last_db_block = -1;
1898         pb.num_illegal_blocks = 0;
1899         pb.suppress = 0; pb.clear = 0;
1900         pb.fragmented = 0;
1901         pb.compressed = 0;
1902         pb.previous_block = 0;
1903         pb.is_dir = LINUX_S_ISDIR(inode->i_mode);
1904         pb.is_reg = LINUX_S_ISREG(inode->i_mode);
1905         pb.max_blocks = 1 << (31 - fs->super->s_log_block_size);
1906         pb.inode = inode;
1907         pb.pctx = pctx;
1908         pb.ctx = ctx;
1909         pctx->ino = ino;
1910         pctx->errcode = 0;
1911
1912         extent_fs = (ctx->fs->super->s_feature_incompat &
1913                      EXT3_FEATURE_INCOMPAT_EXTENTS);
1914
1915         if (inode->i_flags & EXT2_COMPRBLK_FL) {
1916                 if (fs->super->s_feature_incompat &
1917                     EXT2_FEATURE_INCOMPAT_COMPRESSION)
1918                         pb.compressed = 1;
1919                 else {
1920                         if (fix_problem(ctx, PR_1_COMPR_SET, pctx)) {
1921                                 inode->i_flags &= ~EXT2_COMPRBLK_FL;
1922                                 dirty_inode++;
1923                         }
1924                 }
1925         }
1926
1927         if (ext2fs_file_acl_block(inode) &&
1928             check_ext_attr(ctx, pctx, block_buf)) {
1929                 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
1930                         goto out;
1931                 pb.num_blocks++;
1932         }
1933
1934         if (ext2fs_inode_has_valid_blocks(inode)) {
1935                 if (extent_fs && (inode->i_flags & EXT4_EXTENTS_FL))
1936                         check_blocks_extents(ctx, pctx, &pb);
1937                 else
1938                         pctx->errcode = ext2fs_block_iterate3(fs, ino,
1939                                                 pb.is_dir ? BLOCK_FLAG_HOLE : 0,
1940                                                 block_buf, process_block, &pb);
1941         }
1942         end_problem_latch(ctx, PR_LATCH_BLOCK);
1943         end_problem_latch(ctx, PR_LATCH_TOOBIG);
1944         if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
1945                 goto out;
1946         if (pctx->errcode)
1947                 fix_problem(ctx, PR_1_BLOCK_ITERATE, pctx);
1948
1949         if (pb.fragmented && pb.num_blocks < fs->super->s_blocks_per_group) {
1950                 if (LINUX_S_ISDIR(inode->i_mode))
1951                         ctx->fs_fragmented_dir++;
1952                 else
1953                         ctx->fs_fragmented++;
1954         }
1955
1956         if (pb.clear) {
1957                 e2fsck_clear_inode(ctx, ino, inode, E2F_FLAG_RESTART,
1958                                    "check_blocks");
1959                 return;
1960         }
1961
1962         if (inode->i_flags & EXT2_INDEX_FL) {
1963                 if (handle_htree(ctx, pctx, ino, inode, block_buf)) {
1964                         inode->i_flags &= ~EXT2_INDEX_FL;
1965                         dirty_inode++;
1966                 } else {
1967 #ifdef ENABLE_HTREE
1968                         e2fsck_add_dx_dir(ctx, ino, pb.last_block+1);
1969 #endif
1970                 }
1971         }
1972
1973         if (!pb.num_blocks && pb.is_dir) {
1974                 if (fix_problem(ctx, PR_1_ZERO_LENGTH_DIR, pctx)) {
1975                         e2fsck_clear_inode(ctx, ino, inode, 0, "check_blocks");
1976                         ctx->fs_directory_count--;
1977                         return;
1978                 }
1979         }
1980
1981         if (!(fs->super->s_feature_ro_compat &
1982               EXT4_FEATURE_RO_COMPAT_HUGE_FILE) ||
1983             !(inode->i_flags & EXT4_HUGE_FILE_FL))
1984                 pb.num_blocks *= (fs->blocksize / 512);
1985         pb.num_blocks *= EXT2FS_CLUSTER_RATIO(fs);
1986 #if 0
1987         printf("inode %u, i_size = %u, last_block = %lld, i_blocks=%llu, num_blocks = %llu\n",
1988                ino, inode->i_size, pb.last_block, ext2fs_inode_i_blocks(fs, inode),
1989                pb.num_blocks);
1990 #endif
1991         if (pb.is_dir) {
1992                 int nblock = inode->i_size >> EXT2_BLOCK_SIZE_BITS(fs->super);
1993                 if (inode->i_size & (fs->blocksize - 1))
1994                         bad_size = 5;
1995                 else if (nblock > (pb.last_block + 1))
1996                         bad_size = 1;
1997                 else if (nblock < (pb.last_block + 1)) {
1998                         if (((pb.last_block + 1) - nblock) >
1999                             fs->super->s_prealloc_dir_blocks)
2000                                 bad_size = 2;
2001                 }
2002         } else {
2003                 e2_blkcnt_t blkpg = ctx->blocks_per_page;
2004
2005                 size = EXT2_I_SIZE(inode);
2006                 if ((pb.last_block >= 0) &&
2007                     /* allow allocated blocks to end of PAGE_SIZE */
2008                     (size < (__u64)pb.last_block * fs->blocksize) &&
2009                     (pb.last_block / blkpg * blkpg != pb.last_block ||
2010                      size < (__u64)(pb.last_block & ~(blkpg-1)) *fs->blocksize) &&
2011                     !(inode->i_flags & EXT4_EOFBLOCKS_FL))
2012                         bad_size = 3;
2013                 else if (!(extent_fs && (inode->i_flags & EXT4_EXTENTS_FL)) &&
2014                          size > ext2_max_sizes[fs->super->s_log_block_size])
2015                         /* too big for a direct/indirect-mapped file */
2016                         bad_size = 4;
2017                 else if ((extent_fs && (inode->i_flags & EXT4_EXTENTS_FL)) &&
2018                          size >
2019                          ((1ULL << (32 + EXT2_BLOCK_SIZE_BITS(fs->super))) - 1))
2020                         /* too big for an extent-based file - 32bit ee_block */
2021                         bad_size = 6;
2022
2023                 /*
2024                  * Check to see if the EOFBLOCKS flag is set where it
2025                  * doesn't need to be.
2026                  */
2027                 if ((inode->i_flags & EXT4_EOFBLOCKS_FL) &&
2028                     (size >= (((__u64)pb.last_block + 1) * fs->blocksize))) {
2029                         pctx->blkcount = pb.last_block;
2030                         if (fix_problem(ctx, PR_1_EOFBLOCKS_FL_SET, pctx)) {
2031                                 inode->i_flags &= ~EXT4_EOFBLOCKS_FL;
2032                                 dirty_inode++;
2033                         }
2034                 }
2035         }
2036         /* i_size for symlinks is checked elsewhere */
2037         if (bad_size && !LINUX_S_ISLNK(inode->i_mode)) {
2038                 pctx->num = (pb.last_block+1) * fs->blocksize;
2039                 pctx->group = bad_size;
2040                 if (fix_problem(ctx, PR_1_BAD_I_SIZE, pctx)) {
2041                         inode->i_size = pctx->num;
2042                         if (!LINUX_S_ISDIR(inode->i_mode))
2043                                 inode->i_size_high = pctx->num >> 32;
2044                         dirty_inode++;
2045                 }
2046                 pctx->num = 0;
2047         }
2048         if (LINUX_S_ISREG(inode->i_mode) &&
2049             (inode->i_size_high || inode->i_size & 0x80000000UL))
2050                 ctx->large_files++;
2051         if ((pb.num_blocks != ext2fs_inode_i_blocks(fs, inode)) ||
2052             ((fs->super->s_feature_ro_compat &
2053               EXT4_FEATURE_RO_COMPAT_HUGE_FILE) &&
2054              (inode->i_flags & EXT4_HUGE_FILE_FL) &&
2055              (inode->osd2.linux2.l_i_blocks_hi != 0))) {
2056                 pctx->num = pb.num_blocks;
2057                 if (fix_problem(ctx, PR_1_BAD_I_BLOCKS, pctx)) {
2058                         inode->i_blocks = pb.num_blocks;
2059                         inode->osd2.linux2.l_i_blocks_hi = pb.num_blocks >> 32;
2060                         dirty_inode++;
2061                 }
2062                 pctx->num = 0;
2063         }
2064
2065         if (ctx->dirs_to_hash && pb.is_dir &&
2066             !(inode->i_flags & EXT2_INDEX_FL) &&
2067             ((inode->i_size / fs->blocksize) >= 3))
2068                 ext2fs_u32_list_add(ctx->dirs_to_hash, ino);
2069
2070 out:
2071         if (dirty_inode)
2072                 e2fsck_write_inode(ctx, ino, inode, "check_blocks");
2073 }
2074
2075 #if 0
2076 /*
2077  * Helper function called by process block when an illegal block is
2078  * found.  It returns a description about why the block is illegal
2079  */
2080 static char *describe_illegal_block(ext2_filsys fs, blk64_t block)
2081 {
2082         blk64_t super;
2083         int     i;
2084         static char     problem[80];
2085
2086         super = fs->super->s_first_data_block;
2087         strcpy(problem, "PROGRAMMING ERROR: Unknown reason for illegal block");
2088         if (block < super) {
2089                 sprintf(problem, "< FIRSTBLOCK (%u)", super);
2090                 return(problem);
2091         } else if (block >= ext2fs_blocks_count(fs->super)) {
2092                 sprintf(problem, "> BLOCKS (%u)", ext2fs_blocks_count(fs->super));
2093                 return(problem);
2094         }
2095         for (i = 0; i < fs->group_desc_count; i++) {
2096                 if (block == super) {
2097                         sprintf(problem, "is the superblock in group %d", i);
2098                         break;
2099                 }
2100                 if (block > super &&
2101                     block <= (super + fs->desc_blocks)) {
2102                         sprintf(problem, "is in the group descriptors "
2103                                 "of group %d", i);
2104                         break;
2105                 }
2106                 if (block == ext2fs_block_bitmap_loc(fs, i)) {
2107                         sprintf(problem, "is the block bitmap of group %d", i);
2108                         break;
2109                 }
2110                 if (block == ext2fs_inode_bitmap_loc(fs, i)) {
2111                         sprintf(problem, "is the inode bitmap of group %d", i);
2112                         break;
2113                 }
2114                 if (block >= ext2fs_inode_table_loc(fs, i) &&
2115                     (block < ext2fs_inode_table_loc(fs, i)
2116                      + fs->inode_blocks_per_group)) {
2117                         sprintf(problem, "is in the inode table of group %d",
2118                                 i);
2119                         break;
2120                 }
2121                 super += fs->super->s_blocks_per_group;
2122         }
2123         return(problem);
2124 }
2125 #endif
2126
2127 /*
2128  * This is a helper function for check_blocks().
2129  */
2130 static int process_block(ext2_filsys fs,
2131                   blk64_t       *block_nr,
2132                   e2_blkcnt_t blockcnt,
2133                   blk64_t ref_block EXT2FS_ATTR((unused)),
2134                   int ref_offset EXT2FS_ATTR((unused)),
2135                   void *priv_data)
2136 {
2137         struct process_block_struct *p;
2138         struct problem_context *pctx;
2139         blk64_t blk = *block_nr;
2140         int     ret_code = 0;
2141         int     problem = 0;
2142         e2fsck_t        ctx;
2143
2144         p = (struct process_block_struct *) priv_data;
2145         pctx = p->pctx;
2146         ctx = p->ctx;
2147
2148         if (p->compressed && (blk == EXT2FS_COMPRESSED_BLKADDR)) {
2149                 /* todo: Check that the comprblk_fl is high, that the
2150                    blkaddr pattern looks right (all non-holes up to
2151                    first EXT2FS_COMPRESSED_BLKADDR, then all
2152                    EXT2FS_COMPRESSED_BLKADDR up to end of cluster),
2153                    that the feature_incompat bit is high, and that the
2154                    inode is a regular file.  If we're doing a "full
2155                    check" (a concept introduced to e2fsck by e2compr,
2156                    meaning that we look at data blocks as well as
2157                    metadata) then call some library routine that
2158                    checks the compressed data.  I'll have to think
2159                    about this, because one particularly important
2160                    problem to be able to fix is to recalculate the
2161                    cluster size if necessary.  I think that perhaps
2162                    we'd better do most/all e2compr-specific checks
2163                    separately, after the non-e2compr checks.  If not
2164                    doing a full check, it may be useful to test that
2165                    the personality is linux; e.g. if it isn't then
2166                    perhaps this really is just an illegal block. */
2167                 return 0;
2168         }
2169
2170         if (blk == 0)
2171                 return 0;
2172
2173 #if 0
2174         printf("Process_block, inode %lu, block %u, #%d\n", p->ino, blk,
2175                blockcnt);
2176 #endif
2177
2178         /*
2179          * Simplistic fragmentation check.  We merely require that the
2180          * file be contiguous.  (Which can never be true for really
2181          * big files that are greater than a block group.)
2182          */
2183         if (!HOLE_BLKADDR(p->previous_block) && p->ino != EXT2_RESIZE_INO) {
2184                 if (p->previous_block+1 != blk) {
2185                         if (ctx->options & E2F_OPT_FRAGCHECK) {
2186                                 char type = '?';
2187
2188                                 if (p->is_dir)
2189                                         type = 'd';
2190                                 else if (p->is_reg)
2191                                         type = 'f';
2192
2193                                 printf(_("%6lu(%c): expecting %6lu "
2194                                          "got phys %6lu (blkcnt %lld)\n"),
2195                                        (unsigned long) pctx->ino, type,
2196                                        (unsigned long) p->previous_block+1,
2197                                        (unsigned long) blk,
2198                                        blockcnt);
2199                         }
2200                         p->fragmented = 1;
2201                 }
2202         }
2203         p->previous_block = blk;
2204
2205         if (p->is_dir && blockcnt > (1 << (21 - fs->super->s_log_block_size)))
2206                 problem = PR_1_TOOBIG_DIR;
2207         if (p->is_reg && p->num_blocks+1 >= p->max_blocks)
2208                 problem = PR_1_TOOBIG_REG;
2209         if (!p->is_dir && !p->is_reg && blockcnt > 0)
2210                 problem = PR_1_TOOBIG_SYMLINK;
2211
2212         if (blk < fs->super->s_first_data_block ||
2213             blk >= ext2fs_blocks_count(fs->super))
2214                 problem = PR_1_ILLEGAL_BLOCK_NUM;
2215
2216         if (problem) {
2217                 p->num_illegal_blocks++;
2218                 if (!p->suppress && (p->num_illegal_blocks % 12) == 0) {
2219                         if (fix_problem(ctx, PR_1_TOO_MANY_BAD_BLOCKS, pctx)) {
2220                                 p->clear = 1;
2221                                 return BLOCK_ABORT;
2222                         }
2223                         if (fix_problem(ctx, PR_1_SUPPRESS_MESSAGES, pctx)) {
2224                                 p->suppress = 1;
2225                                 set_latch_flags(PR_LATCH_BLOCK,
2226                                                 PRL_SUPPRESS, 0);
2227                         }
2228                 }
2229                 pctx->blk = blk;
2230                 pctx->blkcount = blockcnt;
2231                 if (fix_problem(ctx, problem, pctx)) {
2232                         blk = *block_nr = 0;
2233                         ret_code = BLOCK_CHANGED;
2234                         goto mark_dir;
2235                 } else
2236                         return 0;
2237         }
2238
2239         if (p->ino == EXT2_RESIZE_INO) {
2240                 /*
2241                  * The resize inode has already be sanity checked
2242                  * during pass #0 (the superblock checks).  All we
2243                  * have to do is mark the double indirect block as
2244                  * being in use; all of the other blocks are handled
2245                  * by mark_table_blocks()).
2246                  */
2247                 if (blockcnt == BLOCK_COUNT_DIND)
2248                         mark_block_used(ctx, blk);
2249         } else
2250                 mark_block_used(ctx, blk);
2251         p->num_blocks++;
2252         if (blockcnt >= 0)
2253                 p->last_block = blockcnt;
2254 mark_dir:
2255         if (p->is_dir && (blockcnt >= 0)) {
2256                 while (++p->last_db_block < blockcnt) {
2257                         pctx->errcode = ext2fs_add_dir_block2(fs->dblist,
2258                                                               p->ino, 0,
2259                                                               p->last_db_block);
2260                         if (pctx->errcode) {
2261                                 pctx->blk = 0;
2262                                 pctx->num = p->last_db_block;
2263                                 goto failed_add_dir_block;
2264                         }
2265                 }
2266                 pctx->errcode = ext2fs_add_dir_block2(fs->dblist, p->ino,
2267                                                       blk, blockcnt);
2268                 if (pctx->errcode) {
2269                         pctx->blk = blk;
2270                         pctx->num = blockcnt;
2271                 failed_add_dir_block:
2272                         fix_problem(ctx, PR_1_ADD_DBLOCK, pctx);
2273                         /* Should never get here */
2274                         ctx->flags |= E2F_FLAG_ABORT;
2275                         return BLOCK_ABORT;
2276                 }
2277         }
2278         return ret_code;
2279 }
2280
2281 static int process_bad_block(ext2_filsys fs,
2282                       blk64_t *block_nr,
2283                       e2_blkcnt_t blockcnt,
2284                       blk64_t ref_block EXT2FS_ATTR((unused)),
2285                       int ref_offset EXT2FS_ATTR((unused)),
2286                       void *priv_data)
2287 {
2288         struct process_block_struct *p;
2289         blk64_t         blk = *block_nr;
2290         blk64_t         first_block;
2291         dgrp_t          i;
2292         struct problem_context *pctx;
2293         e2fsck_t        ctx;
2294
2295         /*
2296          * Note: This function processes blocks for the bad blocks
2297          * inode, which is never compressed.  So we don't use HOLE_BLKADDR().
2298          */
2299
2300         if (!blk)
2301                 return 0;
2302
2303         p = (struct process_block_struct *) priv_data;
2304         ctx = p->ctx;
2305         pctx = p->pctx;
2306
2307         pctx->ino = EXT2_BAD_INO;
2308         pctx->blk = blk;
2309         pctx->blkcount = blockcnt;
2310
2311         if ((blk < fs->super->s_first_data_block) ||
2312             (blk >= ext2fs_blocks_count(fs->super))) {
2313                 if (fix_problem(ctx, PR_1_BB_ILLEGAL_BLOCK_NUM, pctx)) {
2314                         *block_nr = 0;
2315                         return BLOCK_CHANGED;
2316                 } else
2317                         return 0;
2318         }
2319
2320         if (blockcnt < 0) {
2321                 if (ext2fs_test_block_bitmap2(p->fs_meta_blocks, blk)) {
2322                         p->bbcheck = 1;
2323                         if (fix_problem(ctx, PR_1_BB_FS_BLOCK, pctx)) {
2324                                 *block_nr = 0;
2325                                 return BLOCK_CHANGED;
2326                         }
2327                 } else if (ext2fs_test_block_bitmap2(ctx->block_found_map,
2328                                                     blk)) {
2329                         p->bbcheck = 1;
2330                         if (fix_problem(ctx, PR_1_BBINODE_BAD_METABLOCK,
2331                                         pctx)) {
2332                                 *block_nr = 0;
2333                                 return BLOCK_CHANGED;
2334                         }
2335                         if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
2336                                 return BLOCK_ABORT;
2337                 } else
2338                         mark_block_used(ctx, blk);
2339                 return 0;
2340         }
2341 #if 0
2342         printf ("DEBUG: Marking %u as bad.\n", blk);
2343 #endif
2344         ctx->fs_badblocks_count++;
2345         /*
2346          * If the block is not used, then mark it as used and return.
2347          * If it is already marked as found, this must mean that
2348          * there's an overlap between the filesystem table blocks
2349          * (bitmaps and inode table) and the bad block list.
2350          */
2351         if (!ext2fs_test_block_bitmap2(ctx->block_found_map, blk)) {
2352                 ext2fs_mark_block_bitmap2(ctx->block_found_map, blk);
2353                 return 0;
2354         }
2355         /*
2356          * Try to find the where the filesystem block was used...
2357          */
2358         first_block = fs->super->s_first_data_block;
2359
2360         for (i = 0; i < fs->group_desc_count; i++ ) {
2361                 pctx->group = i;
2362                 pctx->blk = blk;
2363                 if (!ext2fs_bg_has_super(fs, i))
2364                         goto skip_super;
2365                 if (blk == first_block) {
2366                         if (i == 0) {
2367                                 if (fix_problem(ctx,
2368                                                 PR_1_BAD_PRIMARY_SUPERBLOCK,
2369                                                 pctx)) {
2370                                         *block_nr = 0;
2371                                         return BLOCK_CHANGED;
2372                                 }
2373                                 return 0;
2374                         }
2375                         fix_problem(ctx, PR_1_BAD_SUPERBLOCK, pctx);
2376                         return 0;
2377                 }
2378                 if ((blk > first_block) &&
2379                     (blk <= first_block + fs->desc_blocks)) {
2380                         if (i == 0) {
2381                                 pctx->blk = *block_nr;
2382                                 if (fix_problem(ctx,
2383                         PR_1_BAD_PRIMARY_GROUP_DESCRIPTOR, pctx)) {
2384                                         *block_nr = 0;
2385                                         return BLOCK_CHANGED;
2386                                 }
2387                                 return 0;
2388                         }
2389                         fix_problem(ctx, PR_1_BAD_GROUP_DESCRIPTORS, pctx);
2390                         return 0;
2391                 }
2392         skip_super:
2393                 if (blk == ext2fs_block_bitmap_loc(fs, i)) {
2394                         if (fix_problem(ctx, PR_1_BB_BAD_BLOCK, pctx)) {
2395                                 ctx->invalid_block_bitmap_flag[i]++;
2396                                 ctx->invalid_bitmaps++;
2397                         }
2398                         return 0;
2399                 }
2400                 if (blk == ext2fs_inode_bitmap_loc(fs, i)) {
2401                         if (fix_problem(ctx, PR_1_IB_BAD_BLOCK, pctx)) {
2402                                 ctx->invalid_inode_bitmap_flag[i]++;
2403                                 ctx->invalid_bitmaps++;
2404                         }
2405                         return 0;
2406                 }
2407                 if ((blk >= ext2fs_inode_table_loc(fs, i)) &&
2408                     (blk < (ext2fs_inode_table_loc(fs, i) +
2409                             fs->inode_blocks_per_group))) {
2410                         /*
2411                          * If there are bad blocks in the inode table,
2412                          * the inode scan code will try to do
2413                          * something reasonable automatically.
2414                          */
2415                         return 0;
2416                 }
2417                 first_block += fs->super->s_blocks_per_group;
2418         }
2419         /*
2420          * If we've gotten to this point, then the only
2421          * possibility is that the bad block inode meta data
2422          * is using a bad block.
2423          */
2424         if ((blk == p->inode->i_block[EXT2_IND_BLOCK]) ||
2425             (blk == p->inode->i_block[EXT2_DIND_BLOCK]) ||
2426             (blk == p->inode->i_block[EXT2_TIND_BLOCK])) {
2427                 p->bbcheck = 1;
2428                 if (fix_problem(ctx, PR_1_BBINODE_BAD_METABLOCK, pctx)) {
2429                         *block_nr = 0;
2430                         return BLOCK_CHANGED;
2431                 }
2432                 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
2433                         return BLOCK_ABORT;
2434                 return 0;
2435         }
2436
2437         pctx->group = -1;
2438
2439         /* Warn user that the block wasn't claimed */
2440         fix_problem(ctx, PR_1_PROGERR_CLAIMED_BLOCK, pctx);
2441
2442         return 0;
2443 }
2444
2445 static void new_table_block(e2fsck_t ctx, blk_t first_block, int group,
2446                             const char *name, int num, blk64_t *new_block)
2447 {
2448         ext2_filsys fs = ctx->fs;
2449         dgrp_t          last_grp;
2450         blk64_t         old_block = *new_block;
2451         blk64_t         last_block;
2452         int             i, is_flexbg, flexbg, flexbg_size;
2453         char            *buf;
2454         struct problem_context  pctx;
2455
2456         clear_problem_context(&pctx);
2457
2458         pctx.group = group;
2459         pctx.blk = old_block;
2460         pctx.str = name;
2461
2462         /*
2463          * For flex_bg filesystems, first try to allocate the metadata
2464          * within the flex_bg, and if that fails then try finding the
2465          * space anywhere in the filesystem.
2466          */
2467         is_flexbg = EXT2_HAS_INCOMPAT_FEATURE(fs->super,
2468                                               EXT4_FEATURE_INCOMPAT_FLEX_BG);
2469         if (is_flexbg) {
2470                 flexbg_size = 1 << fs->super->s_log_groups_per_flex;
2471                 flexbg = group / flexbg_size;
2472                 first_block = ext2fs_group_first_block2(fs,
2473                                                         flexbg_size * flexbg);
2474                 last_grp = group | (flexbg_size - 1);
2475                 if (last_grp > fs->group_desc_count)
2476                         last_grp = fs->group_desc_count;
2477                 last_block = ext2fs_group_last_block2(fs, last_grp);
2478         } else
2479                 last_block = ext2fs_group_last_block2(fs, group);
2480         pctx.errcode = ext2fs_get_free_blocks2(fs, first_block, last_block,
2481                                                num, ctx->block_found_map,
2482                                                new_block);
2483         if (is_flexbg && (pctx.errcode == EXT2_ET_BLOCK_ALLOC_FAIL))
2484                 pctx.errcode = ext2fs_get_free_blocks2(fs,
2485                                 fs->super->s_first_data_block,
2486                                 ext2fs_blocks_count(fs->super),
2487                                 num, ctx->block_found_map, new_block);
2488         if (pctx.errcode) {
2489                 pctx.num = num;
2490                 fix_problem(ctx, PR_1_RELOC_BLOCK_ALLOCATE, &pctx);
2491                 ext2fs_unmark_valid(fs);
2492                 ctx->flags |= E2F_FLAG_ABORT;
2493                 return;
2494         }
2495         pctx.errcode = ext2fs_get_mem(fs->blocksize, &buf);
2496         if (pctx.errcode) {
2497                 fix_problem(ctx, PR_1_RELOC_MEMORY_ALLOCATE, &pctx);
2498                 ext2fs_unmark_valid(fs);
2499                 ctx->flags |= E2F_FLAG_ABORT;
2500                 return;
2501         }
2502         ext2fs_mark_super_dirty(fs);
2503         fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY;
2504         pctx.blk2 = *new_block;
2505         fix_problem(ctx, (old_block ? PR_1_RELOC_FROM_TO :
2506                           PR_1_RELOC_TO), &pctx);
2507         pctx.blk2 = 0;
2508         for (i = 0; i < num; i++) {
2509                 pctx.blk = i;
2510                 ext2fs_mark_block_bitmap2(ctx->block_found_map, (*new_block)+i);
2511                 if (old_block) {
2512                         pctx.errcode = io_channel_read_blk64(fs->io,
2513                                    old_block + i, 1, buf);
2514                         if (pctx.errcode)
2515                                 fix_problem(ctx, PR_1_RELOC_READ_ERR, &pctx);
2516                 } else
2517                         memset(buf, 0, fs->blocksize);
2518
2519                 pctx.blk = (*new_block) + i;
2520                 pctx.errcode = io_channel_write_blk64(fs->io, pctx.blk,
2521                                               1, buf);
2522                 if (pctx.errcode)
2523                         fix_problem(ctx, PR_1_RELOC_WRITE_ERR, &pctx);
2524         }
2525         ext2fs_free_mem(&buf);
2526 }
2527
2528 /*
2529  * This routine gets called at the end of pass 1 if bad blocks are
2530  * detected in the superblock, group descriptors, inode_bitmaps, or
2531  * block bitmaps.  At this point, all of the blocks have been mapped
2532  * out, so we can try to allocate new block(s) to replace the bad
2533  * blocks.
2534  */
2535 static void handle_fs_bad_blocks(e2fsck_t ctx)
2536 {
2537         ext2_filsys fs = ctx->fs;
2538         dgrp_t          i;
2539         blk64_t         first_block;
2540         blk64_t         new_blk;
2541
2542         for (i = 0; i < fs->group_desc_count; i++) {
2543                 first_block = ext2fs_group_first_block2(fs, i);
2544
2545                 if (ctx->invalid_block_bitmap_flag[i]) {
2546                         new_blk = ext2fs_block_bitmap_loc(fs, i);
2547                         new_table_block(ctx, first_block, i, _("block bitmap"),
2548                                         1, &new_blk);
2549                         ext2fs_block_bitmap_loc_set(fs, i, new_blk);
2550                 }
2551                 if (ctx->invalid_inode_bitmap_flag[i]) {
2552                         new_blk = ext2fs_inode_bitmap_loc(fs, i);
2553                         new_table_block(ctx, first_block, i, _("inode bitmap"),
2554                                         1, &new_blk);
2555                         ext2fs_inode_bitmap_loc_set(fs, i, new_blk);
2556                 }
2557                 if (ctx->invalid_inode_table_flag[i]) {
2558                         new_blk = ext2fs_inode_table_loc(fs, i);
2559                         new_table_block(ctx, first_block, i, _("inode table"),
2560                                         fs->inode_blocks_per_group,
2561                                         &new_blk);
2562                         ext2fs_inode_table_loc_set(fs, i, new_blk);
2563                         ctx->flags |= E2F_FLAG_RESTART;
2564                 }
2565         }
2566         ctx->invalid_bitmaps = 0;
2567 }
2568
2569 /*
2570  * This routine marks all blocks which are used by the superblock,
2571  * group descriptors, inode bitmaps, and block bitmaps.
2572  */
2573 static void mark_table_blocks(e2fsck_t ctx)
2574 {
2575         ext2_filsys fs = ctx->fs;
2576         blk64_t b;
2577         dgrp_t  i;
2578         int     j;
2579         struct problem_context pctx;
2580
2581         clear_problem_context(&pctx);
2582
2583         for (i = 0; i < fs->group_desc_count; i++) {
2584                 pctx.group = i;
2585
2586                 ext2fs_reserve_super_and_bgd(fs, i, ctx->block_found_map);
2587
2588                 /*
2589                  * Mark the blocks used for the inode table
2590                  */
2591                 if (ext2fs_inode_table_loc(fs, i)) {
2592                         for (j = 0, b = ext2fs_inode_table_loc(fs, i);
2593                              j < fs->inode_blocks_per_group;
2594                              j++, b++) {
2595                                 if (ext2fs_test_block_bitmap2(ctx->block_found_map,
2596                                                              b)) {
2597                                         pctx.blk = b;
2598                                         if (!ctx->invalid_inode_table_flag[i] &&
2599                                             fix_problem(ctx,
2600                                                 PR_1_ITABLE_CONFLICT, &pctx)) {
2601                                                 ctx->invalid_inode_table_flag[i]++;
2602                                                 ctx->invalid_bitmaps++;
2603                                         }
2604                                 } else {
2605                                     ext2fs_mark_block_bitmap2(ctx->block_found_map,
2606                                                              b);
2607                                 }
2608                         }
2609                 }
2610
2611                 /*
2612                  * Mark block used for the block bitmap
2613                  */
2614                 if (ext2fs_block_bitmap_loc(fs, i)) {
2615                         if (ext2fs_test_block_bitmap2(ctx->block_found_map,
2616                                      ext2fs_block_bitmap_loc(fs, i))) {
2617                                 pctx.blk = ext2fs_block_bitmap_loc(fs, i);
2618                                 if (fix_problem(ctx, PR_1_BB_CONFLICT, &pctx)) {
2619                                         ctx->invalid_block_bitmap_flag[i]++;
2620                                         ctx->invalid_bitmaps++;
2621                                 }
2622                         } else {
2623                             ext2fs_mark_block_bitmap2(ctx->block_found_map,
2624                                      ext2fs_block_bitmap_loc(fs, i));
2625                     }
2626
2627                 }
2628                 /*
2629                  * Mark block used for the inode bitmap
2630                  */
2631                 if (ext2fs_inode_bitmap_loc(fs, i)) {
2632                         if (ext2fs_test_block_bitmap2(ctx->block_found_map,
2633                                      ext2fs_inode_bitmap_loc(fs, i))) {
2634                                 pctx.blk = ext2fs_inode_bitmap_loc(fs, i);
2635                                 if (fix_problem(ctx, PR_1_IB_CONFLICT, &pctx)) {
2636                                         ctx->invalid_inode_bitmap_flag[i]++;
2637                                         ctx->invalid_bitmaps++;
2638                                 }
2639                         } else {
2640                             ext2fs_mark_block_bitmap2(ctx->block_found_map,
2641                                      ext2fs_inode_bitmap_loc(fs, i));
2642                         }
2643                 }
2644         }
2645 }
2646
2647 /*
2648  * Thes subroutines short circuits ext2fs_get_blocks and
2649  * ext2fs_check_directory; we use them since we already have the inode
2650  * structure, so there's no point in letting the ext2fs library read
2651  * the inode again.
2652  */
2653 static errcode_t pass1_get_blocks(ext2_filsys fs, ext2_ino_t ino,
2654                                   blk_t *blocks)
2655 {
2656         e2fsck_t ctx = (e2fsck_t) fs->priv_data;
2657         int     i;
2658
2659         if ((ino != ctx->stashed_ino) || !ctx->stashed_inode)
2660                 return EXT2_ET_CALLBACK_NOTHANDLED;
2661
2662         for (i=0; i < EXT2_N_BLOCKS; i++)
2663                 blocks[i] = ctx->stashed_inode->i_block[i];
2664         return 0;
2665 }
2666
2667 static errcode_t pass1_read_inode(ext2_filsys fs, ext2_ino_t ino,
2668                                   struct ext2_inode *inode)
2669 {
2670         e2fsck_t ctx = (e2fsck_t) fs->priv_data;
2671
2672         if ((ino != ctx->stashed_ino) || !ctx->stashed_inode)
2673                 return EXT2_ET_CALLBACK_NOTHANDLED;
2674         *inode = *ctx->stashed_inode;
2675         return 0;
2676 }
2677
2678 static errcode_t pass1_write_inode(ext2_filsys fs, ext2_ino_t ino,
2679                             struct ext2_inode *inode)
2680 {
2681         e2fsck_t ctx = (e2fsck_t) fs->priv_data;
2682
2683         if ((ino == ctx->stashed_ino) && ctx->stashed_inode &&
2684                 (inode != ctx->stashed_inode))
2685                 *ctx->stashed_inode = *inode;
2686         return EXT2_ET_CALLBACK_NOTHANDLED;
2687 }
2688
2689 static errcode_t pass1_check_directory(ext2_filsys fs, ext2_ino_t ino)
2690 {
2691         e2fsck_t ctx = (e2fsck_t) fs->priv_data;
2692
2693         if ((ino != ctx->stashed_ino) || !ctx->stashed_inode)
2694                 return EXT2_ET_CALLBACK_NOTHANDLED;
2695
2696         if (!LINUX_S_ISDIR(ctx->stashed_inode->i_mode))
2697                 return EXT2_ET_NO_DIRECTORY;
2698         return 0;
2699 }
2700
2701 static errcode_t e2fsck_get_alloc_block(ext2_filsys fs, blk64_t goal,
2702                                         blk64_t *ret)
2703 {
2704         e2fsck_t ctx = (e2fsck_t) fs->priv_data;
2705         errcode_t       retval;
2706         blk64_t         new_block;
2707
2708         if (ctx->block_found_map) {
2709                 retval = ext2fs_new_block2(fs, goal, ctx->block_found_map,
2710                                            &new_block);
2711                 if (retval)
2712                         return retval;
2713                 if (fs->block_map) {
2714                         ext2fs_mark_block_bitmap2(fs->block_map, new_block);
2715                         ext2fs_mark_bb_dirty(fs);
2716                 }
2717         } else {
2718                 if (!fs->block_map) {
2719                         retval = ext2fs_read_block_bitmap(fs);
2720                         if (retval)
2721                                 return retval;
2722                 }
2723
2724                 retval = ext2fs_new_block2(fs, goal, 0, &new_block);
2725                 if (retval)
2726                         return retval;
2727         }
2728
2729         *ret = new_block;
2730         return (0);
2731 }
2732
2733 static void e2fsck_block_alloc_stats(ext2_filsys fs, blk64_t blk, int inuse)
2734 {
2735         e2fsck_t ctx = (e2fsck_t) fs->priv_data;
2736
2737         if (ctx->block_found_map) {
2738                 if (inuse > 0)
2739                         ext2fs_mark_block_bitmap2(ctx->block_found_map, blk);
2740                 else
2741                         ext2fs_unmark_block_bitmap2(ctx->block_found_map, blk);
2742         }
2743 }
2744
2745 void e2fsck_use_inode_shortcuts(e2fsck_t ctx, int bool)
2746 {
2747         ext2_filsys fs = ctx->fs;
2748
2749         if (bool) {
2750                 fs->get_blocks = pass1_get_blocks;
2751                 fs->check_directory = pass1_check_directory;
2752                 fs->read_inode = pass1_read_inode;
2753                 fs->write_inode = pass1_write_inode;
2754                 ctx->stashed_ino = 0;
2755                 ext2fs_set_alloc_block_callback(fs, e2fsck_get_alloc_block,
2756                                                 0);
2757                 ext2fs_set_block_alloc_stats_callback(fs,
2758                                                       e2fsck_block_alloc_stats,
2759                                                       0);
2760         } else {
2761                 fs->get_blocks = 0;
2762                 fs->check_directory = 0;
2763                 fs->read_inode = 0;
2764                 fs->write_inode = 0;
2765         }
2766 }