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