e2fsck/pass1.c

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