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