e2fsck/pass1.c

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