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_open2(fs, ino, inode, &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         retval = ext2fs_get_rec_len(ctx->fs, dirent, &rec_len);
 438         if (retval)
 439                 return;
 440         if (((dirent->name_len & 0xFF) != 1) ||
 441             (dirent->name[0] != '.') ||
 442             (dirent->inode != pctx->ino) ||
 443             (rec_len < 12) ||
 444             (rec_len % 4) ||
 445             (rec_len >= ctx->fs->blocksize - 12))
 446                 return;
 447
 448         dirent = (struct ext2_dir_entry *) (buf + rec_len);
 449         retval = ext2fs_get_rec_len(ctx->fs, dirent, &rec_len);
 450         if (retval)
 451                 return;
 452         if (((dirent->name_len & 0xFF) != 2) ||
 453             (dirent->name[0] != '.') ||
 454             (dirent->name[1] != '.') ||
 455             (rec_len < 12) ||
 456             (rec_len % 4))
 457                 return;
 458
 459         if (fix_problem(ctx, PR_1_TREAT_AS_DIRECTORY, pctx)) {
 460                 inode->i_mode = (inode->i_mode & 07777) | LINUX_S_IFDIR;
 461                 e2fsck_write_inode_full(ctx, pctx->ino, inode,
 462                                         EXT2_INODE_SIZE(ctx->fs->super),
 463                                         "check_is_really_dir");
 464         }
 465 }
 466
 467 extern void e2fsck_setup_tdb_icount(e2fsck_t ctx, int flags,
 468                                     ext2_icount_t *ret)
 469 {
 470         unsigned int            threshold;
 471         ext2_ino_t              num_dirs;
 472         errcode_t               retval;
 473         char                    *tdb_dir;
 474         int                     enable;
 475
 476         *ret = 0;
 477
 478         profile_get_string(ctx->profile, "scratch_files", "directory", 0, 0,
 479                            &tdb_dir);
 480         profile_get_uint(ctx->profile, "scratch_files",
 481                          "numdirs_threshold", 0, 0, &threshold);
 482         profile_get_boolean(ctx->profile, "scratch_files",
 483                             "icount", 0, 1, &enable);
 484
 485         retval = ext2fs_get_num_dirs(ctx->fs, &num_dirs);
 486         if (retval)
 487                 num_dirs = 1024;        /* Guess */
 488
 489         if (!enable || !tdb_dir || access(tdb_dir, W_OK) ||
 490             (threshold && num_dirs <= threshold))
 491                 return;
 492
 493         retval = ext2fs_create_icount_tdb(ctx->fs, tdb_dir, flags, ret);
 494         if (retval)
 495                 *ret = 0;
 496 }
 497
 498 void e2fsck_pass1(e2fsck_t ctx)
 499 {
 500         int     i;
 501         __u64   max_sizes;
 502         ext2_filsys fs = ctx->fs;
 503         ext2_ino_t      ino;
 504         struct ext2_inode *inode;
 505         ext2_inode_scan scan;
 506         char            *block_buf;
 507 #ifdef RESOURCE_TRACK
 508         struct resource_track   rtrack;
 509 #endif
 510         unsigned char   frag, fsize;
 511         struct          problem_context pctx;
 512         struct          scan_callback_struct scan_struct;
 513         struct ext2_super_block *sb = ctx->fs->super;
 514         const char      *old_op;
 515         int             imagic_fs, extent_fs;
 516         int             busted_fs_time = 0;
 517         int             inode_size;
 518
 519         init_resource_track(&rtrack, ctx->fs->io);
 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_feature_incompat &
 939                       EXT4_FEATURE_INCOMPAT_64BIT) &&
 940                     inode->osd2.linux2.l_i_file_acl_high != 0)
 941                         mark_inode_bad(ctx, ino);
 942                 if ((fs->super->s_creator_os == EXT2_OS_LINUX) &&
 943                     !(fs->super->s_feature_ro_compat &
 944                       EXT4_FEATURE_RO_COMPAT_HUGE_FILE) &&
 945                     (inode->osd2.linux2.l_i_blocks_hi != 0))
 946                         mark_inode_bad(ctx, ino);
 947                 if (inode->i_flags & EXT2_IMAGIC_FL) {
 948                         if (imagic_fs) {
 949                                 if (!ctx->inode_imagic_map)
 950                                         alloc_imagic_map(ctx);
 951                                 ext2fs_mark_inode_bitmap(ctx->inode_imagic_map,
 952                                                          ino);
 953                         } else {
 954                                 if (fix_problem(ctx, PR_1_SET_IMAGIC, &pctx)) {
 955                                         inode->i_flags &= ~EXT2_IMAGIC_FL;
 956                                         e2fsck_write_inode(ctx, ino,
 957                                                            inode, "pass1");
 958                                 }
 959                         }
 960                 }
 961
 962                 check_inode_extra_space(ctx, &pctx);
 963                 check_is_really_dir(ctx, &pctx, block_buf);
 964
 965                 /*
 966                  * ext2fs_inode_has_valid_blocks does not actually look
 967                  * at i_block[] values, so not endian-sensitive here.
 968                  */
 969                 if (extent_fs && (inode->i_flags & EXT4_EXTENTS_FL) &&
 970                     LINUX_S_ISLNK(inode->i_mode) &&
 971                     !ext2fs_inode_has_valid_blocks(inode) &&
 972                     fix_problem(ctx, PR_1_FAST_SYMLINK_EXTENT_FL, &pctx)) {
 973                         inode->i_flags &= ~EXT4_EXTENTS_FL;
 974                         e2fsck_write_inode(ctx, ino, inode, "pass1");
 975                 }
 976
 977                 if (LINUX_S_ISDIR(inode->i_mode)) {
 978                         ext2fs_mark_inode_bitmap(ctx->inode_dir_map, ino);
 979                         e2fsck_add_dir_info(ctx, ino, 0);
 980                         ctx->fs_directory_count++;
 981                 } else if (LINUX_S_ISREG (inode->i_mode)) {
 982                         ext2fs_mark_inode_bitmap(ctx->inode_reg_map, ino);
 983                         ctx->fs_regular_count++;
 984                 } else if (LINUX_S_ISCHR (inode->i_mode) &&
 985                            e2fsck_pass1_check_device_inode(fs, inode)) {
 986                         check_immutable(ctx, &pctx);
 987                         check_size(ctx, &pctx);
 988                         ctx->fs_chardev_count++;
 989                 } else if (LINUX_S_ISBLK (inode->i_mode) &&
 990                            e2fsck_pass1_check_device_inode(fs, inode)) {
 991                         check_immutable(ctx, &pctx);
 992                         check_size(ctx, &pctx);
 993                         ctx->fs_blockdev_count++;
 994                 } else if (LINUX_S_ISLNK (inode->i_mode) &&
 995                            e2fsck_pass1_check_symlink(fs, ino, inode,
 996                                                       block_buf)) {
 997                         check_immutable(ctx, &pctx);
 998                         ctx->fs_symlinks_count++;
 999                         if (ext2fs_inode_data_blocks(fs, inode) == 0) {
1000                                 ctx->fs_fast_symlinks_count++;
1001                                 check_blocks(ctx, &pctx, block_buf);
1002                                 continue;
1003                         }
1004                 }
1005                 else if (LINUX_S_ISFIFO (inode->i_mode) &&
1006                          e2fsck_pass1_check_device_inode(fs, inode)) {
1007                         check_immutable(ctx, &pctx);
1008                         check_size(ctx, &pctx);
1009                         ctx->fs_fifo_count++;
1010                 } else if ((LINUX_S_ISSOCK (inode->i_mode)) &&
1011                            e2fsck_pass1_check_device_inode(fs, inode)) {
1012                         check_immutable(ctx, &pctx);
1013                         check_size(ctx, &pctx);
1014                         ctx->fs_sockets_count++;
1015                 } else
1016                         mark_inode_bad(ctx, ino);
1017                 if (!(inode->i_flags & EXT4_EXTENTS_FL)) {
1018                         if (inode->i_block[EXT2_IND_BLOCK])
1019                                 ctx->fs_ind_count++;
1020                         if (inode->i_block[EXT2_DIND_BLOCK])
1021                                 ctx->fs_dind_count++;
1022                         if (inode->i_block[EXT2_TIND_BLOCK])
1023                                 ctx->fs_tind_count++;
1024                 }
1025                 if (!(inode->i_flags & EXT4_EXTENTS_FL) &&
1026                     (inode->i_block[EXT2_IND_BLOCK] ||
1027                      inode->i_block[EXT2_DIND_BLOCK] ||
1028                      inode->i_block[EXT2_TIND_BLOCK] ||
1029                      inode->i_file_acl)) {
1030                         inodes_to_process[process_inode_count].ino = ino;
1031                         inodes_to_process[process_inode_count].inode = *inode;
1032                         process_inode_count++;
1033                 } else
1034                         check_blocks(ctx, &pctx, block_buf);
1035
1036                 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
1037                         return;
1038
1039                 if (process_inode_count >= ctx->process_inode_size) {
1040                         process_inodes(ctx, block_buf);
1041
1042                         if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
1043                                 return;
1044                 }
1045         }
1046         process_inodes(ctx, block_buf);
1047         ext2fs_close_inode_scan(scan);
1048
1049         /*
1050          * If any extended attribute blocks' reference counts need to
1051          * be adjusted, either up (ctx->refcount_extra), or down
1052          * (ctx->refcount), then fix them.
1053          */
1054         if (ctx->refcount) {
1055                 adjust_extattr_refcount(ctx, ctx->refcount, block_buf, -1);
1056                 ea_refcount_free(ctx->refcount);
1057                 ctx->refcount = 0;
1058         }
1059         if (ctx->refcount_extra) {
1060                 adjust_extattr_refcount(ctx, ctx->refcount_extra,
1061                                         block_buf, +1);
1062                 ea_refcount_free(ctx->refcount_extra);
1063                 ctx->refcount_extra = 0;
1064         }
1065
1066         if (ctx->invalid_bitmaps)
1067                 handle_fs_bad_blocks(ctx);
1068
1069         /* We don't need the block_ea_map any more */
1070         if (ctx->block_ea_map) {
1071                 ext2fs_free_block_bitmap(ctx->block_ea_map);
1072                 ctx->block_ea_map = 0;
1073         }
1074
1075         if (ctx->flags & E2F_FLAG_RESIZE_INODE) {
1076                 ext2fs_block_bitmap save_bmap;
1077
1078                 save_bmap = fs->block_map;
1079                 fs->block_map = ctx->block_found_map;
1080                 clear_problem_context(&pctx);
1081                 pctx.errcode = ext2fs_create_resize_inode(fs);
1082                 if (pctx.errcode) {
1083                         fix_problem(ctx, PR_1_RESIZE_INODE_CREATE, &pctx);
1084                         /* Should never get here */
1085                         ctx->flags |= E2F_FLAG_ABORT;
1086                         return;
1087                 }
1088                 e2fsck_read_inode(ctx, EXT2_RESIZE_INO, inode,
1089                                   "recreate inode");
1090                 inode->i_mtime = ctx->now;
1091                 e2fsck_write_inode(ctx, EXT2_RESIZE_INO, inode,
1092                                    "recreate inode");
1093                 fs->block_map = save_bmap;
1094                 ctx->flags &= ~E2F_FLAG_RESIZE_INODE;
1095         }
1096
1097         if (ctx->flags & E2F_FLAG_RESTART) {
1098                 /*
1099                  * Only the master copy of the superblock and block
1100                  * group descriptors are going to be written during a
1101                  * restart, so set the superblock to be used to be the
1102                  * master superblock.
1103                  */
1104                 ctx->use_superblock = 0;
1105                 unwind_pass1(fs);
1106                 goto endit;
1107         }
1108
1109         if (ctx->block_dup_map) {
1110                 if (ctx->options & E2F_OPT_PREEN) {
1111                         clear_problem_context(&pctx);
1112                         fix_problem(ctx, PR_1_DUP_BLOCKS_PREENSTOP, &pctx);
1113                 }
1114                 e2fsck_pass1_dupblocks(ctx, block_buf);
1115         }
1116         ext2fs_free_mem(&inodes_to_process);
1117 endit:
1118         e2fsck_use_inode_shortcuts(ctx, 0);
1119
1120         ext2fs_free_mem(&block_buf);
1121         ext2fs_free_mem(&inode);
1122
1123         print_resource_track(ctx, _("Pass 1"), &rtrack, ctx->fs->io);
1124 }
1125
1126 /*
1127  * When the inode_scan routines call this callback at the end of the
1128  * glock group, call process_inodes.
1129  */
1130 static errcode_t scan_callback(ext2_filsys fs,
1131                                ext2_inode_scan scan EXT2FS_ATTR((unused)),
1132                                dgrp_t group, void * priv_data)
1133 {
1134         struct scan_callback_struct *scan_struct;
1135         e2fsck_t ctx;
1136
1137         scan_struct = (struct scan_callback_struct *) priv_data;
1138         ctx = scan_struct->ctx;
1139
1140         process_inodes((e2fsck_t) fs->priv_data, scan_struct->block_buf);
1141
1142         if (ctx->progress)
1143                 if ((ctx->progress)(ctx, 1, group+1,
1144                                     ctx->fs->group_desc_count))
1145                         return EXT2_ET_CANCEL_REQUESTED;
1146
1147         return 0;
1148 }
1149
1150 /*
1151  * Process the inodes in the "inodes to process" list.
1152  */
1153 static void process_inodes(e2fsck_t ctx, char *block_buf)
1154 {
1155         int                     i;
1156         struct ext2_inode       *old_stashed_inode;
1157         ext2_ino_t              old_stashed_ino;
1158         const char              *old_operation;
1159         char                    buf[80];
1160         struct problem_context  pctx;
1161
1162 #if 0
1163         printf("begin process_inodes: ");
1164 #endif
1165         if (process_inode_count == 0)
1166                 return;
1167         old_operation = ehandler_operation(0);
1168         old_stashed_inode = ctx->stashed_inode;
1169         old_stashed_ino = ctx->stashed_ino;
1170         qsort(inodes_to_process, process_inode_count,
1171                       sizeof(struct process_inode_block), process_inode_cmp);
1172         clear_problem_context(&pctx);
1173         for (i=0; i < process_inode_count; i++) {
1174                 pctx.inode = ctx->stashed_inode = &inodes_to_process[i].inode;
1175                 pctx.ino = ctx->stashed_ino = inodes_to_process[i].ino;
1176
1177 #if 0
1178                 printf("%u ", pctx.ino);
1179 #endif
1180                 sprintf(buf, _("reading indirect blocks of inode %u"),
1181                         pctx.ino);
1182                 ehandler_operation(buf);
1183                 check_blocks(ctx, &pctx, block_buf);
1184                 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
1185                         break;
1186         }
1187         ctx->stashed_inode = old_stashed_inode;
1188         ctx->stashed_ino = old_stashed_ino;
1189         process_inode_count = 0;
1190 #if 0
1191         printf("end process inodes\n");
1192 #endif
1193         ehandler_operation(old_operation);
1194 }
1195
1196 static EXT2_QSORT_TYPE process_inode_cmp(const void *a, const void *b)
1197 {
1198         const struct process_inode_block *ib_a =
1199                 (const struct process_inode_block *) a;
1200         const struct process_inode_block *ib_b =
1201                 (const struct process_inode_block *) b;
1202         int     ret;
1203
1204         ret = (ib_a->inode.i_block[EXT2_IND_BLOCK] -
1205                ib_b->inode.i_block[EXT2_IND_BLOCK]);
1206         if (ret == 0)
1207                 ret = ib_a->inode.i_file_acl - ib_b->inode.i_file_acl;
1208         if (ret == 0)
1209                 ret = ib_a->ino - ib_b->ino;
1210         return ret;
1211 }
1212
1213 /*
1214  * Mark an inode as being bad in some what
1215  */
1216 static void mark_inode_bad(e2fsck_t ctx, ino_t ino)
1217 {
1218         struct          problem_context pctx;
1219
1220         if (!ctx->inode_bad_map) {
1221                 clear_problem_context(&pctx);
1222
1223                 pctx.errcode = ext2fs_allocate_inode_bitmap(ctx->fs,
1224                             _("bad inode map"), &ctx->inode_bad_map);
1225                 if (pctx.errcode) {
1226                         pctx.num = 3;
1227                         fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx);
1228                         /* Should never get here */
1229                         ctx->flags |= E2F_FLAG_ABORT;
1230                         return;
1231                 }
1232         }
1233         ext2fs_mark_inode_bitmap(ctx->inode_bad_map, ino);
1234 }
1235
1236
1237 /*
1238  * This procedure will allocate the inode "bb" (badblock) map table
1239  */
1240 static void alloc_bb_map(e2fsck_t ctx)
1241 {
1242         struct          problem_context pctx;
1243
1244         clear_problem_context(&pctx);
1245         pctx.errcode = ext2fs_allocate_inode_bitmap(ctx->fs,
1246                                               _("inode in bad block map"),
1247                                               &ctx->inode_bb_map);
1248         if (pctx.errcode) {
1249                 pctx.num = 4;
1250                 fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx);
1251                 /* Should never get here */
1252                 ctx->flags |= E2F_FLAG_ABORT;
1253                 return;
1254         }
1255 }
1256
1257 /*
1258  * This procedure will allocate the inode imagic table
1259  */
1260 static void alloc_imagic_map(e2fsck_t ctx)
1261 {
1262         struct          problem_context pctx;
1263
1264         clear_problem_context(&pctx);
1265         pctx.errcode = ext2fs_allocate_inode_bitmap(ctx->fs,
1266                                               _("imagic inode map"),
1267                                               &ctx->inode_imagic_map);
1268         if (pctx.errcode) {
1269                 pctx.num = 5;
1270                 fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx);
1271                 /* Should never get here */
1272                 ctx->flags |= E2F_FLAG_ABORT;
1273                 return;
1274         }
1275 }
1276
1277 /*
1278  * Marks a block as in use, setting the dup_map if it's been set
1279  * already.  Called by process_block and process_bad_block.
1280  *
1281  * WARNING: Assumes checks have already been done to make sure block
1282  * is valid.  This is true in both process_block and process_bad_block.
1283  */
1284 static _INLINE_ void mark_block_used(e2fsck_t ctx, blk_t block)
1285 {
1286         struct          problem_context pctx;
1287
1288         clear_problem_context(&pctx);
1289
1290         if (ext2fs_fast_test_block_bitmap(ctx->block_found_map, block)) {
1291                 if (!ctx->block_dup_map) {
1292                         pctx.errcode = ext2fs_allocate_block_bitmap(ctx->fs,
1293                               _("multiply claimed block map"),
1294                               &ctx->block_dup_map);
1295                         if (pctx.errcode) {
1296                                 pctx.num = 3;
1297                                 fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR,
1298                                             &pctx);
1299                                 /* Should never get here */
1300                                 ctx->flags |= E2F_FLAG_ABORT;
1301                                 return;
1302                         }
1303                 }
1304                 ext2fs_fast_mark_block_bitmap(ctx->block_dup_map, block);
1305         } else {
1306                 ext2fs_fast_mark_block_bitmap(ctx->block_found_map, block);
1307         }
1308 }
1309
1310 /*
1311  * Adjust the extended attribute block's reference counts at the end
1312  * of pass 1, either by subtracting out references for EA blocks that
1313  * are still referenced in ctx->refcount, or by adding references for
1314  * EA blocks that had extra references as accounted for in
1315  * ctx->refcount_extra.
1316  */
1317 static void adjust_extattr_refcount(e2fsck_t ctx, ext2_refcount_t refcount,
1318                                     char *block_buf, int adjust_sign)
1319 {
1320         struct ext2_ext_attr_header     *header;
1321         struct problem_context          pctx;
1322         ext2_filsys                     fs = ctx->fs;
1323         blk_t                           blk;
1324         __u32                           should_be;
1325         int                             count;
1326
1327         clear_problem_context(&pctx);
1328
1329         ea_refcount_intr_begin(refcount);
1330         while (1) {
1331                 if ((blk = ea_refcount_intr_next(refcount, &count)) == 0)
1332                         break;
1333                 pctx.blk = blk;
1334                 pctx.errcode = ext2fs_read_ext_attr(fs, blk, block_buf);
1335                 if (pctx.errcode) {
1336                         fix_problem(ctx, PR_1_EXTATTR_READ_ABORT, &pctx);
1337                         return;
1338                 }
1339                 header = (struct ext2_ext_attr_header *) block_buf;
1340                 pctx.blkcount = header->h_refcount;
1341                 should_be = header->h_refcount + adjust_sign * count;
1342                 pctx.num = should_be;
1343                 if (fix_problem(ctx, PR_1_EXTATTR_REFCOUNT, &pctx)) {
1344                         header->h_refcount = should_be;
1345                         pctx.errcode = ext2fs_write_ext_attr(fs, blk,
1346                                                              block_buf);
1347                         if (pctx.errcode) {
1348                                 fix_problem(ctx, PR_1_EXTATTR_WRITE, &pctx);
1349                                 continue;
1350                         }
1351                 }
1352         }
1353 }
1354
1355 /*
1356  * Handle processing the extended attribute blocks
1357  */
1358 static int check_ext_attr(e2fsck_t ctx, struct problem_context *pctx,
1359                            char *block_buf)
1360 {
1361         ext2_filsys fs = ctx->fs;
1362         ext2_ino_t      ino = pctx->ino;
1363         struct ext2_inode *inode = pctx->inode;
1364         blk_t           blk;
1365         char *          end;
1366         struct ext2_ext_attr_header *header;
1367         struct ext2_ext_attr_entry *entry;
1368         int             count;
1369         region_t        region = 0;
1370
1371         blk = inode->i_file_acl;
1372         if (blk == 0)
1373                 return 0;
1374
1375         /*
1376          * If the Extended attribute flag isn't set, then a non-zero
1377          * file acl means that the inode is corrupted.
1378          *
1379          * Or if the extended attribute block is an invalid block,
1380          * then the inode is also corrupted.
1381          */
1382         if (!(fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_EXT_ATTR) ||
1383             (blk < fs->super->s_first_data_block) ||
1384             (blk >= fs->super->s_blocks_count)) {
1385                 mark_inode_bad(ctx, ino);
1386                 return 0;
1387         }
1388
1389         /* If ea bitmap hasn't been allocated, create it */
1390         if (!ctx->block_ea_map) {
1391                 pctx->errcode = ext2fs_allocate_block_bitmap(fs,
1392                                                       _("ext attr block map"),
1393                                                       &ctx->block_ea_map);
1394                 if (pctx->errcode) {
1395                         pctx->num = 2;
1396                         fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, pctx);
1397                         ctx->flags |= E2F_FLAG_ABORT;
1398                         return 0;
1399                 }
1400         }
1401
1402         /* Create the EA refcount structure if necessary */
1403         if (!ctx->refcount) {
1404                 pctx->errcode = ea_refcount_create(0, &ctx->refcount);
1405                 if (pctx->errcode) {
1406                         pctx->num = 1;
1407                         fix_problem(ctx, PR_1_ALLOCATE_REFCOUNT, pctx);
1408                         ctx->flags |= E2F_FLAG_ABORT;
1409                         return 0;
1410                 }
1411         }
1412
1413 #if 0
1414         /* Debugging text */
1415         printf("Inode %u has EA block %u\n", ino, blk);
1416 #endif
1417
1418         /* Have we seen this EA block before? */
1419         if (ext2fs_fast_test_block_bitmap(ctx->block_ea_map, blk)) {
1420                 if (ea_refcount_decrement(ctx->refcount, blk, 0) == 0)
1421                         return 1;
1422                 /* Ooops, this EA was referenced more than it stated */
1423                 if (!ctx->refcount_extra) {
1424                         pctx->errcode = ea_refcount_create(0,
1425                                            &ctx->refcount_extra);
1426                         if (pctx->errcode) {
1427                                 pctx->num = 2;
1428                                 fix_problem(ctx, PR_1_ALLOCATE_REFCOUNT, pctx);
1429                                 ctx->flags |= E2F_FLAG_ABORT;
1430                                 return 0;
1431                         }
1432                 }
1433                 ea_refcount_increment(ctx->refcount_extra, blk, 0);
1434                 return 1;
1435         }
1436
1437         /*
1438          * OK, we haven't seen this EA block yet.  So we need to
1439          * validate it
1440          */
1441         pctx->blk = blk;
1442         pctx->errcode = ext2fs_read_ext_attr(fs, blk, block_buf);
1443         if (pctx->errcode && fix_problem(ctx, PR_1_READ_EA_BLOCK, pctx))
1444                 goto clear_extattr;
1445         header = (struct ext2_ext_attr_header *) block_buf;
1446         pctx->blk = inode->i_file_acl;
1447         if (((ctx->ext_attr_ver == 1) &&
1448              (header->h_magic != EXT2_EXT_ATTR_MAGIC_v1)) ||
1449             ((ctx->ext_attr_ver == 2) &&
1450              (header->h_magic != EXT2_EXT_ATTR_MAGIC))) {
1451                 if (fix_problem(ctx, PR_1_BAD_EA_BLOCK, pctx))
1452                         goto clear_extattr;
1453         }
1454
1455         if (header->h_blocks != 1) {
1456                 if (fix_problem(ctx, PR_1_EA_MULTI_BLOCK, pctx))
1457                         goto clear_extattr;
1458         }
1459
1460         region = region_create(0, fs->blocksize);
1461         if (!region) {
1462                 fix_problem(ctx, PR_1_EA_ALLOC_REGION, pctx);
1463                 ctx->flags |= E2F_FLAG_ABORT;
1464                 return 0;
1465         }
1466         if (region_allocate(region, 0, sizeof(struct ext2_ext_attr_header))) {
1467                 if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, pctx))
1468                         goto clear_extattr;
1469         }
1470
1471         entry = (struct ext2_ext_attr_entry *)(header+1);
1472         end = block_buf + fs->blocksize;
1473         while ((char *)entry < end && *(__u32 *)entry) {
1474                 __u32 hash;
1475
1476                 if (region_allocate(region, (char *)entry - (char *)header,
1477                                    EXT2_EXT_ATTR_LEN(entry->e_name_len))) {
1478                         if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, pctx))
1479                                 goto clear_extattr;
1480                         break;
1481                 }
1482                 if ((ctx->ext_attr_ver == 1 &&
1483                      (entry->e_name_len == 0 || entry->e_name_index != 0)) ||
1484                     (ctx->ext_attr_ver == 2 &&
1485                      entry->e_name_index == 0)) {
1486                         if (fix_problem(ctx, PR_1_EA_BAD_NAME, pctx))
1487                                 goto clear_extattr;
1488                         break;
1489                 }
1490                 if (entry->e_value_block != 0) {
1491                         if (fix_problem(ctx, PR_1_EA_BAD_VALUE, pctx))
1492                                 goto clear_extattr;
1493                 }
1494                 if (entry->e_value_offs + entry->e_value_size > fs->blocksize) {
1495                         if (fix_problem(ctx, PR_1_EA_BAD_VALUE, pctx))
1496                                 goto clear_extattr;
1497                         break;
1498                 }
1499                 if (entry->e_value_size &&
1500                     region_allocate(region, entry->e_value_offs,
1501                                     EXT2_EXT_ATTR_SIZE(entry->e_value_size))) {
1502                         if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, pctx))
1503                                 goto clear_extattr;
1504                 }
1505
1506                 hash = ext2fs_ext_attr_hash_entry(entry, block_buf +
1507                                                          entry->e_value_offs);
1508
1509                 if (entry->e_hash != hash) {
1510                         pctx->num = entry->e_hash;
1511                         if (fix_problem(ctx, PR_1_ATTR_HASH, pctx))
1512                                 goto clear_extattr;
1513                         entry->e_hash = hash;
1514                 }
1515
1516                 entry = EXT2_EXT_ATTR_NEXT(entry);
1517         }
1518         if (region_allocate(region, (char *)entry - (char *)header, 4)) {
1519                 if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, pctx))
1520                         goto clear_extattr;
1521         }
1522         region_free(region);
1523
1524         count = header->h_refcount - 1;
1525         if (count)
1526                 ea_refcount_store(ctx->refcount, blk, count);
1527         mark_block_used(ctx, blk);
1528         ext2fs_fast_mark_block_bitmap(ctx->block_ea_map, blk);
1529         return 1;
1530
1531 clear_extattr:
1532         if (region)
1533                 region_free(region);
1534         inode->i_file_acl = 0;
1535         e2fsck_write_inode(ctx, ino, inode, "check_ext_attr");
1536         return 0;
1537 }
1538
1539 /* Returns 1 if bad htree, 0 if OK */
1540 static int handle_htree(e2fsck_t ctx, struct problem_context *pctx,
1541                         ext2_ino_t ino, struct ext2_inode *inode,
1542                         char *block_buf)
1543 {
1544         struct ext2_dx_root_info        *root;
1545         ext2_filsys                     fs = ctx->fs;
1546         errcode_t                       retval;
1547         blk_t                           blk;
1548
1549         if ((!LINUX_S_ISDIR(inode->i_mode) &&
1550              fix_problem(ctx, PR_1_HTREE_NODIR, pctx)) ||
1551             (!(fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_DIR_INDEX) &&
1552              fix_problem(ctx, PR_1_HTREE_SET, pctx)))
1553                 return 1;
1554
1555         pctx->errcode = ext2fs_bmap(fs, ino, inode, 0, 0, 0, &blk);
1556
1557         if ((pctx->errcode) ||
1558             (blk == 0) ||
1559             (blk < fs->super->s_first_data_block) ||
1560             (blk >= fs->super->s_blocks_count)) {
1561                 if (fix_problem(ctx, PR_1_HTREE_BADROOT, pctx))
1562                         return 1;
1563                 else
1564                         return 0;
1565         }
1566
1567         retval = io_channel_read_blk(fs->io, blk, 1, block_buf);
1568         if (retval && fix_problem(ctx, PR_1_HTREE_BADROOT, pctx))
1569                 return 1;
1570
1571         /* XXX should check that beginning matches a directory */
1572         root = (struct ext2_dx_root_info *) (block_buf + 24);
1573
1574         if ((root->reserved_zero || root->info_length < 8) &&
1575             fix_problem(ctx, PR_1_HTREE_BADROOT, pctx))
1576                 return 1;
1577
1578         pctx->num = root->hash_version;
1579         if ((root->hash_version != EXT2_HASH_LEGACY) &&
1580             (root->hash_version != EXT2_HASH_HALF_MD4) &&
1581             (root->hash_version != EXT2_HASH_TEA) &&
1582             fix_problem(ctx, PR_1_HTREE_HASHV, pctx))
1583                 return 1;
1584
1585         if ((root->unused_flags & EXT2_HASH_FLAG_INCOMPAT) &&
1586             fix_problem(ctx, PR_1_HTREE_INCOMPAT, pctx))
1587                 return 1;
1588
1589         pctx->num = root->indirect_levels;
1590         if ((root->indirect_levels > 1) &&
1591             fix_problem(ctx, PR_1_HTREE_DEPTH, pctx))
1592                 return 1;
1593
1594         return 0;
1595 }
1596
1597 void e2fsck_clear_inode(e2fsck_t ctx, ext2_ino_t ino,
1598                         struct ext2_inode *inode, int restart_flag,
1599                         const char *source)
1600 {
1601         inode->i_flags = 0;
1602         inode->i_links_count = 0;
1603         ext2fs_icount_store(ctx->inode_link_info, ino, 0);
1604         inode->i_dtime = ctx->now;
1605
1606         ext2fs_unmark_inode_bitmap(ctx->inode_dir_map, ino);
1607         ext2fs_unmark_inode_bitmap(ctx->inode_used_map, ino);
1608         if (ctx->inode_reg_map)
1609                 ext2fs_unmark_inode_bitmap(ctx->inode_reg_map, ino);
1610         if (ctx->inode_bad_map)
1611                 ext2fs_unmark_inode_bitmap(ctx->inode_bad_map, ino);
1612
1613         /*
1614          * If the inode was partially accounted for before processing
1615          * was aborted, we need to restart the pass 1 scan.
1616          */
1617         ctx->flags |= restart_flag;
1618
1619         e2fsck_write_inode(ctx, ino, inode, source);
1620 }
1621
1622 static void scan_extent_node(e2fsck_t ctx, struct problem_context *pctx,
1623                              struct process_block_struct *pb,
1624                              blk64_t start_block,
1625                              ext2_extent_handle_t ehandle)
1626 {
1627         struct ext2fs_extent    extent;
1628         blk_t                   blk;
1629         e2_blkcnt_t             blockcnt;
1630         unsigned int            i;
1631         int                     is_dir, is_leaf;
1632         errcode_t               problem;
1633         struct ext2_extent_info info;
1634
1635         pctx->errcode = ext2fs_extent_get_info(ehandle, &info);
1636         if (pctx->errcode)
1637                 return;
1638
1639         pctx->errcode = ext2fs_extent_get(ehandle, EXT2_EXTENT_FIRST_SIB,
1640                                           &extent);
1641         while (!pctx->errcode && info.num_entries-- > 0) {
1642                 is_leaf = extent.e_flags & EXT2_EXTENT_FLAGS_LEAF;
1643                 is_dir = LINUX_S_ISDIR(pctx->inode->i_mode);
1644
1645                 problem = 0;
1646                 if (extent.e_pblk < ctx->fs->super->s_first_data_block ||
1647                     extent.e_pblk >= ctx->fs->super->s_blocks_count)
1648                         problem = PR_1_EXTENT_BAD_START_BLK;
1649                 else if (extent.e_lblk < start_block)
1650                         problem = PR_1_OUT_OF_ORDER_EXTENTS;
1651                 else if (is_leaf &&
1652                          (extent.e_pblk + extent.e_len) >
1653                          ctx->fs->super->s_blocks_count)
1654                         problem = PR_1_EXTENT_ENDS_BEYOND;
1655
1656                 if (problem) {
1657                 report_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                                         pctx->str = "ext2fs_extent_delete";
1666                                         return;
1667                                 }
1668                                 pctx->errcode = ext2fs_extent_get(ehandle,
1669                                                                   EXT2_EXTENT_CURRENT,
1670                                                                   &extent);
1671                                 if (pctx->errcode == EXT2_ET_NO_CURRENT_NODE) {
1672                                         pctx->errcode = 0;
1673                                         break;
1674                                 }
1675                                 continue;
1676                         }
1677                         goto next;
1678                 }
1679
1680                 if (!is_leaf) {
1681                         blk = extent.e_pblk;
1682                         pctx->errcode = ext2fs_extent_get(ehandle,
1683                                                   EXT2_EXTENT_DOWN, &extent);
1684                         if (pctx->errcode) {
1685                                 pctx->str = "EXT2_EXTENT_DOWN";
1686                                 problem = PR_1_EXTENT_HEADER_INVALID;
1687                                 if (pctx->errcode == EXT2_ET_EXTENT_HEADER_BAD)
1688                                         goto report_problem;
1689                                 return;
1690                         }
1691                         scan_extent_node(ctx, pctx, pb, extent.e_lblk, ehandle);
1692                         if (pctx->errcode)
1693                                 return;
1694                         pctx->errcode = ext2fs_extent_get(ehandle,
1695                                                   EXT2_EXTENT_UP, &extent);
1696                         if (pctx->errcode) {
1697                                 pctx->str = "EXT2_EXTENT_UP";
1698                                 return;
1699                         }
1700                         mark_block_used(ctx, blk);
1701                         pb->num_blocks++;
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_open2(fs, ino, inode, &ehandle);
1768         if (pctx->errcode) {
1769                 if (fix_problem(ctx, PR_1_READ_EXTENT, pctx))
1770                         e2fsck_clear_inode(ctx, ino, inode, 0,
1771                                            "check_blocks_extents");
1772                 pctx->errcode = 0;
1773                 return;
1774         }
1775
1776         retval = ext2fs_extent_get_info(ehandle, &info);
1777         if (retval == 0) {
1778                 if (info.max_depth >= MAX_EXTENT_DEPTH_COUNT)
1779                         info.max_depth = MAX_EXTENT_DEPTH_COUNT-1;
1780                 ctx->extent_depth_count[info.max_depth]++;
1781         }
1782
1783         scan_extent_node(ctx, pctx, pb, 0, ehandle);
1784         if (pctx->errcode &&
1785             fix_problem(ctx, PR_1_EXTENT_ITERATE_FAILURE, pctx)) {
1786                 pb->num_blocks = 0;
1787                 inode->i_blocks = 0;
1788                 e2fsck_clear_inode(ctx, ino, inode, E2F_FLAG_RESTART,
1789                                    "check_blocks_extents");
1790                 pctx->errcode = 0;
1791         }
1792         ext2fs_extent_free(ehandle);
1793 }
1794
1795 /*
1796  * This subroutine is called on each inode to account for all of the
1797  * blocks used by that inode.
1798  */
1799 static void check_blocks(e2fsck_t ctx, struct problem_context *pctx,
1800                          char *block_buf)
1801 {
1802         ext2_filsys fs = ctx->fs;
1803         struct process_block_struct pb;
1804         ext2_ino_t      ino = pctx->ino;
1805         struct ext2_inode *inode = pctx->inode;
1806         int             bad_size = 0;
1807         int             dirty_inode = 0;
1808         int             extent_fs;
1809         __u64           size;
1810
1811         pb.ino = ino;
1812         pb.num_blocks = 0;
1813         pb.last_block = -1;
1814         pb.num_illegal_blocks = 0;
1815         pb.suppress = 0; pb.clear = 0;
1816         pb.fragmented = 0;
1817         pb.compressed = 0;
1818         pb.previous_block = 0;
1819         pb.is_dir = LINUX_S_ISDIR(inode->i_mode);
1820         pb.is_reg = LINUX_S_ISREG(inode->i_mode);
1821         pb.max_blocks = 1 << (31 - fs->super->s_log_block_size);
1822         pb.inode = inode;
1823         pb.pctx = pctx;
1824         pb.ctx = ctx;
1825         pctx->ino = ino;
1826         pctx->errcode = 0;
1827
1828         extent_fs = (ctx->fs->super->s_feature_incompat &
1829                      EXT3_FEATURE_INCOMPAT_EXTENTS);
1830
1831         if (inode->i_flags & EXT2_COMPRBLK_FL) {
1832                 if (fs->super->s_feature_incompat &
1833                     EXT2_FEATURE_INCOMPAT_COMPRESSION)
1834                         pb.compressed = 1;
1835                 else {
1836                         if (fix_problem(ctx, PR_1_COMPR_SET, pctx)) {
1837                                 inode->i_flags &= ~EXT2_COMPRBLK_FL;
1838                                 dirty_inode++;
1839                         }
1840                 }
1841         }
1842
1843         if (inode->i_file_acl && check_ext_attr(ctx, pctx, block_buf)) {
1844                 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
1845                         goto out;
1846                 pb.num_blocks++;
1847         }
1848
1849         if (ext2fs_inode_has_valid_blocks(inode)) {
1850                 if (extent_fs && (inode->i_flags & EXT4_EXTENTS_FL))
1851                         check_blocks_extents(ctx, pctx, &pb);
1852                 else
1853                         pctx->errcode = ext2fs_block_iterate2(fs, ino,
1854                                                 pb.is_dir ? BLOCK_FLAG_HOLE : 0,
1855                                                 block_buf, process_block, &pb);
1856         }
1857         end_problem_latch(ctx, PR_LATCH_BLOCK);
1858         end_problem_latch(ctx, PR_LATCH_TOOBIG);
1859         if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
1860                 goto out;
1861         if (pctx->errcode)
1862                 fix_problem(ctx, PR_1_BLOCK_ITERATE, pctx);
1863
1864         if (pb.fragmented && pb.num_blocks < fs->super->s_blocks_per_group) {
1865                 if (LINUX_S_ISDIR(inode->i_mode))
1866                         ctx->fs_fragmented_dir++;
1867                 else
1868                         ctx->fs_fragmented++;
1869         }
1870
1871         if (pb.clear) {
1872                 e2fsck_clear_inode(ctx, ino, inode, E2F_FLAG_RESTART,
1873                                    "check_blocks");
1874                 return;
1875         }
1876
1877         if (pb.is_dir) {
1878                 while (1) {
1879                         struct ext2_db_entry *entry;
1880
1881                         if (ext2fs_dblist_get_last(fs->dblist, &entry) ||
1882                             (entry->ino != ino) ||
1883                             (entry->blk != 0) ||
1884                             (entry->blockcnt == 0))
1885                                 break;
1886                         /* printf("Dropping ino %lu blk %lu blockcnt %d\n",
1887                                   entry->ino, entry->blk, entry->blockcnt); */
1888                         ext2fs_dblist_drop_last(fs->dblist);
1889                         if (ext2fs_dblist_get_last(fs->dblist, &entry) ||
1890                             (entry->ino != ino))
1891                                 pb.last_block--;
1892                         else
1893                                 pb.last_block = entry->blockcnt;
1894                 }
1895         }
1896
1897         if (inode->i_flags & EXT2_INDEX_FL) {
1898                 if (handle_htree(ctx, pctx, ino, inode, block_buf)) {
1899                         inode->i_flags &= ~EXT2_INDEX_FL;
1900                         dirty_inode++;
1901                 } else {
1902 #ifdef ENABLE_HTREE
1903                         e2fsck_add_dx_dir(ctx, ino, pb.last_block+1);
1904 #endif
1905                 }
1906         }
1907         if (ctx->dirs_to_hash && pb.is_dir &&
1908             !(inode->i_flags & EXT2_INDEX_FL) &&
1909             ((inode->i_size / fs->blocksize) >= 3))
1910                 ext2fs_u32_list_add(ctx->dirs_to_hash, ino);
1911
1912         if (!pb.num_blocks && pb.is_dir) {
1913                 if (fix_problem(ctx, PR_1_ZERO_LENGTH_DIR, pctx)) {
1914                         e2fsck_clear_inode(ctx, ino, inode, 0, "check_blocks");
1915                         ctx->fs_directory_count--;
1916                         return;
1917                 }
1918         }
1919
1920         if (!(fs->super->s_feature_ro_compat &
1921               EXT4_FEATURE_RO_COMPAT_HUGE_FILE) ||
1922             !(inode->i_flags & EXT4_HUGE_FILE_FL))
1923                 pb.num_blocks *= (fs->blocksize / 512);
1924 #if 0
1925         printf("inode %u, i_size = %lu, last_block = %lld, i_blocks=%lu, num_blocks = %lu\n",
1926                ino, inode->i_size, pb.last_block, inode->i_blocks,
1927                pb.num_blocks);
1928 #endif
1929         if (pb.is_dir) {
1930                 int nblock = inode->i_size >> EXT2_BLOCK_SIZE_BITS(fs->super);
1931                 if (inode->i_size & (fs->blocksize - 1))
1932                         bad_size = 5;
1933                 else if (nblock > (pb.last_block + 1))
1934                         bad_size = 1;
1935                 else if (nblock < (pb.last_block + 1)) {
1936                         if (((pb.last_block + 1) - nblock) >
1937                             fs->super->s_prealloc_dir_blocks)
1938                                 bad_size = 2;
1939                 }
1940         } else {
1941                 e2_blkcnt_t blkpg = ctx->blocks_per_page;
1942
1943                 size = EXT2_I_SIZE(inode);
1944                 if ((pb.last_block >= 0) &&
1945                     /* allow allocated blocks to end of PAGE_SIZE */
1946                     (size < (__u64)pb.last_block * fs->blocksize) &&
1947                     (pb.last_block / blkpg * blkpg != pb.last_block ||
1948                      size < (__u64)(pb.last_block & ~(blkpg-1)) *fs->blocksize))
1949                         bad_size = 3;
1950                 else if (!(extent_fs && (inode->i_flags & EXT4_EXTENTS_FL)) &&
1951                          size > ext2_max_sizes[fs->super->s_log_block_size])
1952                         /* too big for a direct/indirect-mapped file */
1953                         bad_size = 4;
1954                 else if ((extent_fs && (inode->i_flags & EXT4_EXTENTS_FL)) &&
1955                          size >
1956                          ((1ULL << (32 + EXT2_BLOCK_SIZE_BITS(fs->super))) - 1))
1957                         /* too big for an extent-based file - 32bit ee_block */
1958                         bad_size = 6;
1959         }
1960         /* i_size for symlinks is checked elsewhere */
1961         if (bad_size && !LINUX_S_ISLNK(inode->i_mode)) {
1962                 pctx->num = (pb.last_block+1) * fs->blocksize;
1963                 pctx->group = bad_size;
1964                 if (fix_problem(ctx, PR_1_BAD_I_SIZE, pctx)) {
1965                         inode->i_size = pctx->num;
1966                         if (!LINUX_S_ISDIR(inode->i_mode))
1967                                 inode->i_size_high = pctx->num >> 32;
1968                         dirty_inode++;
1969                 }
1970                 pctx->num = 0;
1971         }
1972         if (LINUX_S_ISREG(inode->i_mode) &&
1973             (inode->i_size_high || inode->i_size & 0x80000000UL))
1974                 ctx->large_files++;
1975         if ((pb.num_blocks != inode->i_blocks) ||
1976             ((fs->super->s_feature_ro_compat &
1977               EXT4_FEATURE_RO_COMPAT_HUGE_FILE) &&
1978              (inode->i_flags & EXT4_HUGE_FILE_FL) &&
1979              (inode->osd2.linux2.l_i_blocks_hi != 0))) {
1980                 pctx->num = pb.num_blocks;
1981                 if (fix_problem(ctx, PR_1_BAD_I_BLOCKS, pctx)) {
1982                         inode->i_blocks = pb.num_blocks;
1983                         inode->osd2.linux2.l_i_blocks_hi = 0;
1984                         dirty_inode++;
1985                 }
1986                 pctx->num = 0;
1987         }
1988 out:
1989         if (dirty_inode)
1990                 e2fsck_write_inode(ctx, ino, inode, "check_blocks");
1991 }
1992
1993 #if 0
1994 /*
1995  * Helper function called by process block when an illegal block is
1996  * found.  It returns a description about why the block is illegal
1997  */
1998 static char *describe_illegal_block(ext2_filsys fs, blk_t block)
1999 {
2000         blk_t   super;
2001         int     i;
2002         static char     problem[80];
2003
2004         super = fs->super->s_first_data_block;
2005         strcpy(problem, "PROGRAMMING ERROR: Unknown reason for illegal block");
2006         if (block < super) {
2007                 sprintf(problem, "< FIRSTBLOCK (%u)", super);
2008                 return(problem);
2009         } else if (block >= fs->super->s_blocks_count) {
2010                 sprintf(problem, "> BLOCKS (%u)", fs->super->s_blocks_count);
2011                 return(problem);
2012         }
2013         for (i = 0; i < fs->group_desc_count; i++) {
2014                 if (block == super) {
2015                         sprintf(problem, "is the superblock in group %d", i);
2016                         break;
2017                 }
2018                 if (block > super &&
2019                     block <= (super + fs->desc_blocks)) {
2020                         sprintf(problem, "is in the group descriptors "
2021                                 "of group %d", i);
2022                         break;
2023                 }
2024                 if (block == fs->group_desc[i].bg_block_bitmap) {
2025                         sprintf(problem, "is the block bitmap of group %d", i);
2026                         break;
2027                 }
2028                 if (block == fs->group_desc[i].bg_inode_bitmap) {
2029                         sprintf(problem, "is the inode bitmap of group %d", i);
2030                         break;
2031                 }
2032                 if (block >= fs->group_desc[i].bg_inode_table &&
2033                     (block < fs->group_desc[i].bg_inode_table
2034                      + fs->inode_blocks_per_group)) {
2035                         sprintf(problem, "is in the inode table of group %d",
2036                                 i);
2037                         break;
2038                 }
2039                 super += fs->super->s_blocks_per_group;
2040         }
2041         return(problem);
2042 }
2043 #endif
2044
2045 /*
2046  * This is a helper function for check_blocks().
2047  */
2048 static int process_block(ext2_filsys fs,
2049                   blk_t *block_nr,
2050                   e2_blkcnt_t blockcnt,
2051                   blk_t ref_block EXT2FS_ATTR((unused)),
2052                   int ref_offset EXT2FS_ATTR((unused)),
2053                   void *priv_data)
2054 {
2055         struct process_block_struct *p;
2056         struct problem_context *pctx;
2057         blk_t   blk = *block_nr;
2058         int     ret_code = 0;
2059         int     problem = 0;
2060         e2fsck_t        ctx;
2061
2062         p = (struct process_block_struct *) priv_data;
2063         pctx = p->pctx;
2064         ctx = p->ctx;
2065
2066         if (p->compressed && (blk == EXT2FS_COMPRESSED_BLKADDR)) {
2067                 /* todo: Check that the comprblk_fl is high, that the
2068                    blkaddr pattern looks right (all non-holes up to
2069                    first EXT2FS_COMPRESSED_BLKADDR, then all
2070                    EXT2FS_COMPRESSED_BLKADDR up to end of cluster),
2071                    that the feature_incompat bit is high, and that the
2072                    inode is a regular file.  If we're doing a "full
2073                    check" (a concept introduced to e2fsck by e2compr,
2074                    meaning that we look at data blocks as well as
2075                    metadata) then call some library routine that
2076                    checks the compressed data.  I'll have to think
2077                    about this, because one particularly important
2078                    problem to be able to fix is to recalculate the
2079                    cluster size if necessary.  I think that perhaps
2080                    we'd better do most/all e2compr-specific checks
2081                    separately, after the non-e2compr checks.  If not
2082                    doing a full check, it may be useful to test that
2083                    the personality is linux; e.g. if it isn't then
2084                    perhaps this really is just an illegal block. */
2085                 return 0;
2086         }
2087
2088         if (blk == 0) {
2089                 if (p->is_dir == 0) {
2090                         /*
2091                          * Should never happen, since only directories
2092                          * get called with BLOCK_FLAG_HOLE
2093                          */
2094 #if DEBUG_E2FSCK
2095                         printf("process_block() called with blk == 0, "
2096                                "blockcnt=%d, inode %lu???\n",
2097                                blockcnt, p->ino);
2098 #endif
2099                         return 0;
2100                 }
2101                 if (blockcnt < 0)
2102                         return 0;
2103                 if (blockcnt * fs->blocksize < p->inode->i_size) {
2104 #if 0
2105                         printf("Missing block (#%d) in directory inode %lu!\n",
2106                                blockcnt, p->ino);
2107 #endif
2108                         p->last_block = blockcnt;
2109                         goto mark_dir;
2110                 }
2111                 return 0;
2112         }
2113
2114 #if 0
2115         printf("Process_block, inode %lu, block %u, #%d\n", p->ino, blk,
2116                blockcnt);
2117 #endif
2118
2119         /*
2120          * Simplistic fragmentation check.  We merely require that the
2121          * file be contiguous.  (Which can never be true for really
2122          * big files that are greater than a block group.)
2123          */
2124         if (!HOLE_BLKADDR(p->previous_block) && p->ino != EXT2_RESIZE_INO) {
2125                 if (p->previous_block+1 != blk) {
2126                         if (ctx->options & E2F_OPT_FRAGCHECK) {
2127                                 char type = '?';
2128
2129                                 if (p->is_dir)
2130                                         type = 'd';
2131                                 else if (p->is_reg)
2132                                         type = 'f';
2133
2134                                 printf(_("%6lu(%c): expecting %6lu "
2135                                          "got phys %6lu (blkcnt %lld)\n"),
2136                                        (unsigned long) pctx->ino, type,
2137                                        (unsigned long) p->previous_block+1,
2138                                        (unsigned long) blk,
2139                                        blockcnt);
2140                         }
2141                         p->fragmented = 1;
2142                 }
2143         }
2144         p->previous_block = blk;
2145
2146         if (p->is_dir && blockcnt > (1 << (21 - fs->super->s_log_block_size)))
2147                 problem = PR_1_TOOBIG_DIR;
2148         if (p->is_reg && p->num_blocks+1 >= p->max_blocks)
2149                 problem = PR_1_TOOBIG_REG;
2150         if (!p->is_dir && !p->is_reg && blockcnt > 0)
2151                 problem = PR_1_TOOBIG_SYMLINK;
2152
2153         if (blk < fs->super->s_first_data_block ||
2154             blk >= fs->super->s_blocks_count)
2155                 problem = PR_1_ILLEGAL_BLOCK_NUM;
2156
2157         if (problem) {
2158                 p->num_illegal_blocks++;
2159                 if (!p->suppress && (p->num_illegal_blocks % 12) == 0) {
2160                         if (fix_problem(ctx, PR_1_TOO_MANY_BAD_BLOCKS, pctx)) {
2161                                 p->clear = 1;
2162                                 return BLOCK_ABORT;
2163                         }
2164                         if (fix_problem(ctx, PR_1_SUPPRESS_MESSAGES, pctx)) {
2165                                 p->suppress = 1;
2166                                 set_latch_flags(PR_LATCH_BLOCK,
2167                                                 PRL_SUPPRESS, 0);
2168                         }
2169                 }
2170                 pctx->blk = blk;
2171                 pctx->blkcount = blockcnt;
2172                 if (fix_problem(ctx, problem, pctx)) {
2173                         blk = *block_nr = 0;
2174                         ret_code = BLOCK_CHANGED;
2175                         goto mark_dir;
2176                 } else
2177                         return 0;
2178         }
2179
2180         if (p->ino == EXT2_RESIZE_INO) {
2181                 /*
2182                  * The resize inode has already be sanity checked
2183                  * during pass #0 (the superblock checks).  All we
2184                  * have to do is mark the double indirect block as
2185                  * being in use; all of the other blocks are handled
2186                  * by mark_table_blocks()).
2187                  */
2188                 if (blockcnt == BLOCK_COUNT_DIND)
2189                         mark_block_used(ctx, blk);
2190         } else
2191                 mark_block_used(ctx, blk);
2192         p->num_blocks++;
2193         if (blockcnt >= 0)
2194                 p->last_block = blockcnt;
2195 mark_dir:
2196         if (p->is_dir && (blockcnt >= 0)) {
2197                 pctx->errcode = ext2fs_add_dir_block(fs->dblist, p->ino,
2198                                                     blk, blockcnt);
2199                 if (pctx->errcode) {
2200                         pctx->blk = blk;
2201                         pctx->num = blockcnt;
2202                         fix_problem(ctx, PR_1_ADD_DBLOCK, pctx);
2203                         /* Should never get here */
2204                         ctx->flags |= E2F_FLAG_ABORT;
2205                         return BLOCK_ABORT;
2206                 }
2207         }
2208         return ret_code;
2209 }
2210
2211 static int process_bad_block(ext2_filsys fs,
2212                       blk_t *block_nr,
2213                       e2_blkcnt_t blockcnt,
2214                       blk_t ref_block EXT2FS_ATTR((unused)),
2215                       int ref_offset EXT2FS_ATTR((unused)),
2216                       void *priv_data)
2217 {
2218         struct process_block_struct *p;
2219         blk_t           blk = *block_nr;
2220         blk_t           first_block;
2221         dgrp_t          i;
2222         struct problem_context *pctx;
2223         e2fsck_t        ctx;
2224
2225         /*
2226          * Note: This function processes blocks for the bad blocks
2227          * inode, which is never compressed.  So we don't use HOLE_BLKADDR().
2228          */
2229
2230         if (!blk)
2231                 return 0;
2232
2233         p = (struct process_block_struct *) priv_data;
2234         ctx = p->ctx;
2235         pctx = p->pctx;
2236
2237         pctx->ino = EXT2_BAD_INO;
2238         pctx->blk = blk;
2239         pctx->blkcount = blockcnt;
2240
2241         if ((blk < fs->super->s_first_data_block) ||
2242             (blk >= fs->super->s_blocks_count)) {
2243                 if (fix_problem(ctx, PR_1_BB_ILLEGAL_BLOCK_NUM, pctx)) {
2244                         *block_nr = 0;
2245                         return BLOCK_CHANGED;
2246                 } else
2247                         return 0;
2248         }
2249
2250         if (blockcnt < 0) {
2251                 if (ext2fs_test_block_bitmap(p->fs_meta_blocks, blk)) {
2252                         p->bbcheck = 1;
2253                         if (fix_problem(ctx, PR_1_BB_FS_BLOCK, pctx)) {
2254                                 *block_nr = 0;
2255                                 return BLOCK_CHANGED;
2256                         }
2257                 } else if (ext2fs_test_block_bitmap(ctx->block_found_map,
2258                                                     blk)) {
2259                         p->bbcheck = 1;
2260                         if (fix_problem(ctx, PR_1_BBINODE_BAD_METABLOCK,
2261                                         pctx)) {
2262                                 *block_nr = 0;
2263                                 return BLOCK_CHANGED;
2264                         }
2265                         if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
2266                                 return BLOCK_ABORT;
2267                 } else
2268                         mark_block_used(ctx, blk);
2269                 return 0;
2270         }
2271 #if 0
2272         printf ("DEBUG: Marking %u as bad.\n", blk);
2273 #endif
2274         ctx->fs_badblocks_count++;
2275         /*
2276          * If the block is not used, then mark it as used and return.
2277          * If it is already marked as found, this must mean that
2278          * there's an overlap between the filesystem table blocks
2279          * (bitmaps and inode table) and the bad block list.
2280          */
2281         if (!ext2fs_test_block_bitmap(ctx->block_found_map, blk)) {
2282                 ext2fs_mark_block_bitmap(ctx->block_found_map, blk);
2283                 return 0;
2284         }
2285         /*
2286          * Try to find the where the filesystem block was used...
2287          */
2288         first_block = fs->super->s_first_data_block;
2289
2290         for (i = 0; i < fs->group_desc_count; i++ ) {
2291                 pctx->group = i;
2292                 pctx->blk = blk;
2293                 if (!ext2fs_bg_has_super(fs, i))
2294                         goto skip_super;
2295                 if (blk == first_block) {
2296                         if (i == 0) {
2297                                 if (fix_problem(ctx,
2298                                                 PR_1_BAD_PRIMARY_SUPERBLOCK,
2299                                                 pctx)) {
2300                                         *block_nr = 0;
2301                                         return BLOCK_CHANGED;
2302                                 }
2303                                 return 0;
2304                         }
2305                         fix_problem(ctx, PR_1_BAD_SUPERBLOCK, pctx);
2306                         return 0;
2307                 }
2308                 if ((blk > first_block) &&
2309                     (blk <= first_block + fs->desc_blocks)) {
2310                         if (i == 0) {
2311                                 pctx->blk = *block_nr;
2312                                 if (fix_problem(ctx,
2313                         PR_1_BAD_PRIMARY_GROUP_DESCRIPTOR, pctx)) {
2314                                         *block_nr = 0;
2315                                         return BLOCK_CHANGED;
2316                                 }
2317                                 return 0;
2318                         }
2319                         fix_problem(ctx, PR_1_BAD_GROUP_DESCRIPTORS, pctx);
2320                         return 0;
2321                 }
2322         skip_super:
2323                 if (blk == fs->group_desc[i].bg_block_bitmap) {
2324                         if (fix_problem(ctx, PR_1_BB_BAD_BLOCK, pctx)) {
2325                                 ctx->invalid_block_bitmap_flag[i]++;
2326                                 ctx->invalid_bitmaps++;
2327                         }
2328                         return 0;
2329                 }
2330                 if (blk == fs->group_desc[i].bg_inode_bitmap) {
2331                         if (fix_problem(ctx, PR_1_IB_BAD_BLOCK, pctx)) {
2332                                 ctx->invalid_inode_bitmap_flag[i]++;
2333                                 ctx->invalid_bitmaps++;
2334                         }
2335                         return 0;
2336                 }
2337                 if ((blk >= fs->group_desc[i].bg_inode_table) &&
2338                     (blk < (fs->group_desc[i].bg_inode_table +
2339                             fs->inode_blocks_per_group))) {
2340                         /*
2341                          * If there are bad blocks in the inode table,
2342                          * the inode scan code will try to do
2343                          * something reasonable automatically.
2344                          */
2345                         return 0;
2346                 }
2347                 first_block += fs->super->s_blocks_per_group;
2348         }
2349         /*
2350          * If we've gotten to this point, then the only
2351          * possibility is that the bad block inode meta data
2352          * is using a bad block.
2353          */
2354         if ((blk == p->inode->i_block[EXT2_IND_BLOCK]) ||
2355             (blk == p->inode->i_block[EXT2_DIND_BLOCK]) ||
2356             (blk == p->inode->i_block[EXT2_TIND_BLOCK])) {
2357                 p->bbcheck = 1;
2358                 if (fix_problem(ctx, PR_1_BBINODE_BAD_METABLOCK, pctx)) {
2359                         *block_nr = 0;
2360                         return BLOCK_CHANGED;
2361                 }
2362                 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
2363                         return BLOCK_ABORT;
2364                 return 0;
2365         }
2366
2367         pctx->group = -1;
2368
2369         /* Warn user that the block wasn't claimed */
2370         fix_problem(ctx, PR_1_PROGERR_CLAIMED_BLOCK, pctx);
2371
2372         return 0;
2373 }
2374
2375 static void new_table_block(e2fsck_t ctx, blk_t first_block, int group,
2376                             const char *name, int num, blk_t *new_block)
2377 {
2378         ext2_filsys fs = ctx->fs;
2379         blk_t           old_block = *new_block;
2380         blk_t           last_block;
2381         int             i;
2382         char            *buf;
2383         struct problem_context  pctx;
2384
2385         clear_problem_context(&pctx);
2386
2387         pctx.group = group;
2388         pctx.blk = old_block;
2389         pctx.str = name;
2390
2391         last_block = ext2fs_group_last_block(fs, group);
2392         pctx.errcode = ext2fs_get_free_blocks(fs, first_block, last_block,
2393                                         num, ctx->block_found_map, new_block);
2394         if (pctx.errcode) {
2395                 pctx.num = num;
2396                 fix_problem(ctx, PR_1_RELOC_BLOCK_ALLOCATE, &pctx);
2397                 ext2fs_unmark_valid(fs);
2398                 return;
2399         }
2400         pctx.errcode = ext2fs_get_mem(fs->blocksize, &buf);
2401         if (pctx.errcode) {
2402                 fix_problem(ctx, PR_1_RELOC_MEMORY_ALLOCATE, &pctx);
2403                 ext2fs_unmark_valid(fs);
2404                 return;
2405         }
2406         ext2fs_mark_super_dirty(fs);
2407         fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY;
2408         pctx.blk2 = *new_block;
2409         fix_problem(ctx, (old_block ? PR_1_RELOC_FROM_TO :
2410                           PR_1_RELOC_TO), &pctx);
2411         pctx.blk2 = 0;
2412         for (i = 0; i < num; i++) {
2413                 pctx.blk = i;
2414                 ext2fs_mark_block_bitmap(ctx->block_found_map, (*new_block)+i);
2415                 if (old_block) {
2416                         pctx.errcode = io_channel_read_blk(fs->io,
2417                                    old_block + i, 1, buf);
2418                         if (pctx.errcode)
2419                                 fix_problem(ctx, PR_1_RELOC_READ_ERR, &pctx);
2420                 } else
2421                         memset(buf, 0, fs->blocksize);
2422
2423                 pctx.blk = (*new_block) + i;
2424                 pctx.errcode = io_channel_write_blk(fs->io, pctx.blk,
2425                                               1, buf);
2426                 if (pctx.errcode)
2427                         fix_problem(ctx, PR_1_RELOC_WRITE_ERR, &pctx);
2428         }
2429         ext2fs_free_mem(&buf);
2430 }
2431
2432 /*
2433  * This routine gets called at the end of pass 1 if bad blocks are
2434  * detected in the superblock, group descriptors, inode_bitmaps, or
2435  * block bitmaps.  At this point, all of the blocks have been mapped
2436  * out, so we can try to allocate new block(s) to replace the bad
2437  * blocks.
2438  */
2439 static void handle_fs_bad_blocks(e2fsck_t ctx)
2440 {
2441         ext2_filsys fs = ctx->fs;
2442         dgrp_t          i;
2443         blk_t           first_block;
2444
2445         for (i = 0; i < fs->group_desc_count; i++) {
2446                 first_block = ext2fs_group_first_block(fs, i);
2447
2448                 if (ctx->invalid_block_bitmap_flag[i]) {
2449                         new_table_block(ctx, first_block, i, _("block bitmap"),
2450                                         1, &fs->group_desc[i].bg_block_bitmap);
2451                 }
2452                 if (ctx->invalid_inode_bitmap_flag[i]) {
2453                         new_table_block(ctx, first_block, i, _("inode bitmap"),
2454                                         1, &fs->group_desc[i].bg_inode_bitmap);
2455                 }
2456                 if (ctx->invalid_inode_table_flag[i]) {
2457                         new_table_block(ctx, first_block, i, _("inode table"),
2458                                         fs->inode_blocks_per_group,
2459                                         &fs->group_desc[i].bg_inode_table);
2460                         ctx->flags |= E2F_FLAG_RESTART;
2461                 }
2462         }
2463         ctx->invalid_bitmaps = 0;
2464 }
2465
2466 /*
2467  * This routine marks all blocks which are used by the superblock,
2468  * group descriptors, inode bitmaps, and block bitmaps.
2469  */
2470 static void mark_table_blocks(e2fsck_t ctx)
2471 {
2472         ext2_filsys fs = ctx->fs;
2473         blk_t   b;
2474         dgrp_t  i;
2475         int     j;
2476         struct problem_context pctx;
2477
2478         clear_problem_context(&pctx);
2479
2480         for (i = 0; i < fs->group_desc_count; i++) {
2481                 pctx.group = i;
2482
2483                 ext2fs_reserve_super_and_bgd(fs, i, ctx->block_found_map);
2484
2485                 /*
2486                  * Mark the blocks used for the inode table
2487                  */
2488                 if (fs->group_desc[i].bg_inode_table) {
2489                         for (j = 0, b = fs->group_desc[i].bg_inode_table;
2490                              j < fs->inode_blocks_per_group;
2491                              j++, b++) {
2492                                 if (ext2fs_test_block_bitmap(ctx->block_found_map,
2493                                                              b)) {
2494                                         pctx.blk = b;
2495                                         if (fix_problem(ctx,
2496                                                 PR_1_ITABLE_CONFLICT, &pctx)) {
2497                                                 ctx->invalid_inode_table_flag[i]++;
2498                                                 ctx->invalid_bitmaps++;
2499                                         }
2500                                 } else {
2501                                     ext2fs_mark_block_bitmap(ctx->block_found_map,
2502                                                              b);
2503                                 }
2504                         }
2505                 }
2506
2507                 /*
2508                  * Mark block used for the block bitmap
2509                  */
2510                 if (fs->group_desc[i].bg_block_bitmap) {
2511                         if (ext2fs_test_block_bitmap(ctx->block_found_map,
2512                                      fs->group_desc[i].bg_block_bitmap)) {
2513                                 pctx.blk = fs->group_desc[i].bg_block_bitmap;
2514                                 if (fix_problem(ctx, PR_1_BB_CONFLICT, &pctx)) {
2515                                         ctx->invalid_block_bitmap_flag[i]++;
2516                                         ctx->invalid_bitmaps++;
2517                                 }
2518                         } else {
2519                             ext2fs_mark_block_bitmap(ctx->block_found_map,
2520                                      fs->group_desc[i].bg_block_bitmap);
2521                     }
2522
2523                 }
2524                 /*
2525                  * Mark block used for the inode bitmap
2526                  */
2527                 if (fs->group_desc[i].bg_inode_bitmap) {
2528                         if (ext2fs_test_block_bitmap(ctx->block_found_map,
2529                                      fs->group_desc[i].bg_inode_bitmap)) {
2530                                 pctx.blk = fs->group_desc[i].bg_inode_bitmap;
2531                                 if (fix_problem(ctx, PR_1_IB_CONFLICT, &pctx)) {
2532                                         ctx->invalid_inode_bitmap_flag[i]++;
2533                                         ctx->invalid_bitmaps++;
2534                                 }
2535                         } else {
2536                             ext2fs_mark_block_bitmap(ctx->block_found_map,
2537                                      fs->group_desc[i].bg_inode_bitmap);
2538                         }
2539                 }
2540         }
2541 }
2542
2543 /*
2544  * Thes subroutines short circuits ext2fs_get_blocks and
2545  * ext2fs_check_directory; we use them since we already have the inode
2546  * structure, so there's no point in letting the ext2fs library read
2547  * the inode again.
2548  */
2549 static errcode_t pass1_get_blocks(ext2_filsys fs, ext2_ino_t ino,
2550                                   blk_t *blocks)
2551 {
2552         e2fsck_t ctx = (e2fsck_t) fs->priv_data;
2553         int     i;
2554
2555         if ((ino != ctx->stashed_ino) || !ctx->stashed_inode)
2556                 return EXT2_ET_CALLBACK_NOTHANDLED;
2557
2558         for (i=0; i < EXT2_N_BLOCKS; i++)
2559                 blocks[i] = ctx->stashed_inode->i_block[i];
2560         return 0;
2561 }
2562
2563 static errcode_t pass1_read_inode(ext2_filsys fs, ext2_ino_t ino,
2564                                   struct ext2_inode *inode)
2565 {
2566         e2fsck_t ctx = (e2fsck_t) fs->priv_data;
2567
2568         if ((ino != ctx->stashed_ino) || !ctx->stashed_inode)
2569                 return EXT2_ET_CALLBACK_NOTHANDLED;
2570         *inode = *ctx->stashed_inode;
2571         return 0;
2572 }
2573
2574 static errcode_t pass1_write_inode(ext2_filsys fs, ext2_ino_t ino,
2575                             struct ext2_inode *inode)
2576 {
2577         e2fsck_t ctx = (e2fsck_t) fs->priv_data;
2578
2579         if ((ino == ctx->stashed_ino) && ctx->stashed_inode &&
2580                 (inode != ctx->stashed_inode))
2581                 *ctx->stashed_inode = *inode;
2582         return EXT2_ET_CALLBACK_NOTHANDLED;
2583 }
2584
2585 static errcode_t pass1_check_directory(ext2_filsys fs, ext2_ino_t ino)
2586 {
2587         e2fsck_t ctx = (e2fsck_t) fs->priv_data;
2588
2589         if ((ino != ctx->stashed_ino) || !ctx->stashed_inode)
2590                 return EXT2_ET_CALLBACK_NOTHANDLED;
2591
2592         if (!LINUX_S_ISDIR(ctx->stashed_inode->i_mode))
2593                 return EXT2_ET_NO_DIRECTORY;
2594         return 0;
2595 }
2596
2597 static errcode_t e2fsck_get_alloc_block(ext2_filsys fs, blk64_t goal,
2598                                         blk64_t *ret)
2599 {
2600         e2fsck_t ctx = (e2fsck_t) fs->priv_data;
2601         errcode_t       retval;
2602         blk_t           new_block;
2603
2604         if (ctx->block_found_map) {
2605                 retval = ext2fs_new_block(fs, (blk_t) goal,
2606                                           ctx->block_found_map, &new_block);
2607                 if (retval)
2608                         return retval;
2609         } else {
2610                 if (!fs->block_map) {
2611                         retval = ext2fs_read_block_bitmap(fs);
2612                         if (retval)
2613                                 return retval;
2614                 }
2615
2616                 retval = ext2fs_new_block(fs, (blk_t) goal, 0, &new_block);
2617                 if (retval)
2618                         return retval;
2619         }
2620
2621         *ret = new_block;
2622         return (0);
2623 }
2624
2625 static void e2fsck_block_alloc_stats(ext2_filsys fs, blk64_t blk, int inuse)
2626 {
2627         e2fsck_t ctx = (e2fsck_t) fs->priv_data;
2628
2629         if (ctx->block_found_map) {
2630                 if (inuse > 0)
2631                         ext2fs_mark_block_bitmap(ctx->block_found_map,
2632                                                  (blk_t) blk);
2633                 else
2634                         ext2fs_unmark_block_bitmap(ctx->block_found_map,
2635                                                    (blk_t) blk);
2636         }
2637 }
2638
2639 void e2fsck_use_inode_shortcuts(e2fsck_t ctx, int bool)
2640 {
2641         ext2_filsys fs = ctx->fs;
2642
2643         if (bool) {
2644                 fs->get_blocks = pass1_get_blocks;
2645                 fs->check_directory = pass1_check_directory;
2646                 fs->read_inode = pass1_read_inode;
2647                 fs->write_inode = pass1_write_inode;
2648                 ctx->stashed_ino = 0;
2649                 ext2fs_set_alloc_block_callback(fs, e2fsck_get_alloc_block,
2650                                                 0);
2651                 ext2fs_set_block_alloc_stats_callback(fs,
2652                                                       e2fsck_block_alloc_stats,
2653                                                       0);
2654         } else {
2655                 fs->get_blocks = 0;
2656                 fs->check_directory = 0;
2657                 fs->read_inode = 0;
2658                 fs->write_inode = 0;
2659         }
2660 }