2 * pass1.c -- pass #1 of e2fsck: sequential scan of the inode table
4 * Copyright (C) 1993, 1994, 1995, 1996, 1997 Theodore Ts'o.
7 * This file may be redistributed under the terms of the GNU Public
11 * Pass 1 of e2fsck iterates over all the inodes in the filesystems,
12 * and applies the following tests to each inode:
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
18 * Pass 1 also gathers the collects the following information:
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)
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
36 * Note that pass 1B will be invoked if there are any duplicate blocks
40 #define _GNU_SOURCE 1 /* get strnlen() */
49 #include <ext2fs/ext2_ext_attr.h>
53 #ifdef NO_INLINE_FUNCS
56 #define _INLINE_ inline
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,
67 static void mark_table_blocks(e2fsck_t ctx);
68 static void alloc_bb_map(e2fsck_t ctx);
69 static void alloc_imagic_map(e2fsck_t ctx);
70 static void mark_inode_bad(e2fsck_t ctx, ino_t ino);
71 static void handle_fs_bad_blocks(e2fsck_t ctx);
72 static void process_inodes(e2fsck_t ctx, char *block_buf);
73 static EXT2_QSORT_TYPE process_inode_cmp(const void *a, const void *b);
74 static errcode_t scan_callback(ext2_filsys fs, ext2_inode_scan scan,
75 dgrp_t group, void * priv_data);
76 static void adjust_extattr_refcount(e2fsck_t ctx, ext2_refcount_t refcount,
77 char *block_buf, int adjust_sign);
78 /* static char *describe_illegal_block(ext2_filsys fs, blk64_t block); */
80 struct process_block_struct {
82 unsigned is_dir:1, is_reg:1, clear:1, suppress:1,
83 fragmented:1, compressed:1, bbcheck:1,
87 e2_blkcnt_t last_block;
88 e2_blkcnt_t last_init_lblock;
89 e2_blkcnt_t last_db_block;
90 int num_illegal_blocks;
91 blk64_t previous_block;
92 struct ext2_inode *inode;
93 struct problem_context *pctx;
94 ext2fs_block_bitmap fs_meta_blocks;
98 struct process_inode_block {
100 struct ext2_inode inode;
103 struct scan_callback_struct {
109 * For the inodes to process list.
111 static struct process_inode_block *inodes_to_process;
112 static int process_inode_count;
114 static __u64 ext2_max_sizes[EXT2_MAX_BLOCK_LOG_SIZE -
115 EXT2_MIN_BLOCK_LOG_SIZE + 1];
118 * Free all memory allocated by pass1 in preparation for restarting
121 static void unwind_pass1(ext2_filsys fs EXT2FS_ATTR((unused)))
123 ext2fs_free_mem(&inodes_to_process);
124 inodes_to_process = 0;
128 * Check to make sure a device inode is real. Returns 1 if the device
129 * checks out, 0 if not.
131 * Note: this routine is now also used to check FIFO's and Sockets,
132 * since they have the same requirement; the i_block fields should be
135 int e2fsck_pass1_check_device_inode(ext2_filsys fs EXT2FS_ATTR((unused)),
136 struct ext2_inode *inode)
141 * If the index flag is set, then this is a bogus
144 if (inode->i_flags & EXT2_INDEX_FL)
148 * We should be able to do the test below all the time, but
149 * because the kernel doesn't forcibly clear the device
150 * inode's additional i_block fields, there are some rare
151 * occasions when a legitimate device inode will have non-zero
152 * additional i_block fields. So for now, we only complain
153 * when the immutable flag is set, which should never happen
154 * for devices. (And that's when the problem is caused, since
155 * you can't set or clear immutable flags for devices.) Once
156 * the kernel has been fixed we can change this...
158 if (inode->i_flags & (EXT2_IMMUTABLE_FL | EXT2_APPEND_FL)) {
159 for (i=4; i < EXT2_N_BLOCKS; i++)
160 if (inode->i_block[i])
167 * Check to make sure a symlink inode is real. Returns 1 if the symlink
168 * checks out, 0 if not.
170 int e2fsck_pass1_check_symlink(ext2_filsys fs, ext2_ino_t ino,
171 struct ext2_inode *inode, char *buf)
176 ext2_extent_handle_t handle;
177 struct ext2_extent_info info;
178 struct ext2fs_extent extent;
180 if ((inode->i_size_high || inode->i_size == 0) ||
181 (inode->i_flags & EXT2_INDEX_FL))
184 if (inode->i_flags & EXT4_EXTENTS_FL) {
185 if (inode->i_size > fs->blocksize)
187 if (ext2fs_extent_open2(fs, ino, inode, &handle))
190 if (ext2fs_extent_get_info(handle, &info) ||
191 (info.num_entries != 1) ||
192 (info.max_depth != 0))
194 if (ext2fs_extent_get(handle, EXT2_EXTENT_ROOT, &extent) ||
195 (extent.e_lblk != 0) ||
196 (extent.e_len != 1) ||
197 (extent.e_pblk < fs->super->s_first_data_block) ||
198 (extent.e_pblk >= ext2fs_blocks_count(fs->super)))
202 ext2fs_extent_free(handle);
206 blocks = ext2fs_inode_data_blocks2(fs, inode);
208 if ((inode->i_size >= fs->blocksize) ||
209 (blocks != fs->blocksize >> 9) ||
210 (inode->i_block[0] < fs->super->s_first_data_block) ||
211 (inode->i_block[0] >= ext2fs_blocks_count(fs->super)))
214 for (i = 1; i < EXT2_N_BLOCKS; i++)
215 if (inode->i_block[i])
218 if (io_channel_read_blk64(fs->io, inode->i_block[0], 1, buf))
221 len = strnlen(buf, fs->blocksize);
222 if (len == fs->blocksize)
225 if (inode->i_size >= sizeof(inode->i_block))
228 len = strnlen((char *)inode->i_block, sizeof(inode->i_block));
229 if (len == sizeof(inode->i_block))
232 if (len != inode->i_size)
238 * If the immutable (or append-only) flag is set on the inode, offer
241 #define BAD_SPECIAL_FLAGS (EXT2_IMMUTABLE_FL | EXT2_APPEND_FL)
242 static void check_immutable(e2fsck_t ctx, struct problem_context *pctx)
244 if (!(pctx->inode->i_flags & BAD_SPECIAL_FLAGS))
247 if (!fix_problem(ctx, PR_1_SET_IMMUTABLE, pctx))
250 pctx->inode->i_flags &= ~BAD_SPECIAL_FLAGS;
251 e2fsck_write_inode(ctx, pctx->ino, pctx->inode, "pass1");
255 * If device, fifo or socket, check size is zero -- if not offer to
258 static void check_size(e2fsck_t ctx, struct problem_context *pctx)
260 struct ext2_inode *inode = pctx->inode;
262 if (EXT2_I_SIZE(inode) == 0)
265 if (!fix_problem(ctx, PR_1_SET_NONZSIZE, pctx))
269 inode->i_size_high = 0;
270 e2fsck_write_inode(ctx, pctx->ino, pctx->inode, "pass1");
273 static void check_ea_in_inode(e2fsck_t ctx, struct problem_context *pctx)
275 struct ext2_super_block *sb = ctx->fs->super;
276 struct ext2_inode_large *inode;
277 struct ext2_ext_attr_entry *entry;
279 unsigned int storage_size, remain;
280 problem_t problem = 0;
282 inode = (struct ext2_inode_large *) pctx->inode;
283 storage_size = EXT2_INODE_SIZE(ctx->fs->super) - EXT2_GOOD_OLD_INODE_SIZE -
284 inode->i_extra_isize;
285 start = ((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE +
286 inode->i_extra_isize + sizeof(__u32);
287 entry = (struct ext2_ext_attr_entry *) start;
289 /* scan all entry's headers first */
291 /* take finish entry 0UL into account */
292 remain = storage_size - sizeof(__u32);
294 while (!EXT2_EXT_IS_LAST_ENTRY(entry)) {
297 /* header eats this space */
298 remain -= sizeof(struct ext2_ext_attr_entry);
300 /* is attribute name valid? */
301 if (EXT2_EXT_ATTR_SIZE(entry->e_name_len) > remain) {
302 pctx->num = entry->e_name_len;
303 problem = PR_1_ATTR_NAME_LEN;
307 /* attribute len eats this space */
308 remain -= EXT2_EXT_ATTR_SIZE(entry->e_name_len);
310 /* check value size */
311 if (entry->e_value_size > remain) {
312 pctx->num = entry->e_value_size;
313 problem = PR_1_ATTR_VALUE_SIZE;
317 /* e_value_block must be 0 in inode's ea */
318 if (entry->e_value_block != 0) {
319 pctx->num = entry->e_value_block;
320 problem = PR_1_ATTR_VALUE_BLOCK;
324 hash = ext2fs_ext_attr_hash_entry(entry,
325 start + entry->e_value_offs);
327 /* e_hash may be 0 in older inode's ea */
328 if (entry->e_hash != 0 && entry->e_hash != hash) {
329 pctx->num = entry->e_hash;
330 problem = PR_1_ATTR_HASH;
334 remain -= entry->e_value_size;
336 entry = EXT2_EXT_ATTR_NEXT(entry);
340 * it seems like a corruption. it's very unlikely we could repair
341 * EA(s) in automatic fashion -bzzz
343 if (problem == 0 || !fix_problem(ctx, problem, pctx))
346 /* simply remove all possible EA(s) */
347 *((__u32 *)start) = 0UL;
348 e2fsck_write_inode_full(ctx, pctx->ino, pctx->inode,
349 EXT2_INODE_SIZE(sb), "pass1");
352 static void check_inode_extra_space(e2fsck_t ctx, struct problem_context *pctx)
354 struct ext2_super_block *sb = ctx->fs->super;
355 struct ext2_inode_large *inode;
359 inode = (struct ext2_inode_large *) pctx->inode;
360 if (EXT2_INODE_SIZE(sb) == EXT2_GOOD_OLD_INODE_SIZE) {
361 /* this isn't large inode. so, nothing to check */
366 printf("inode #%u, i_extra_size %d\n", pctx->ino,
367 inode->i_extra_isize);
369 /* i_extra_isize must cover i_extra_isize + i_checksum_hi at least */
370 min = sizeof(inode->i_extra_isize) + sizeof(inode->i_checksum_hi);
371 max = EXT2_INODE_SIZE(sb) - EXT2_GOOD_OLD_INODE_SIZE;
373 * For now we will allow i_extra_isize to be 0, but really
374 * implementations should never allow i_extra_isize to be 0
376 if (inode->i_extra_isize &&
377 (inode->i_extra_isize < min || inode->i_extra_isize > max)) {
378 if (!fix_problem(ctx, PR_1_EXTRA_ISIZE, pctx))
380 inode->i_extra_isize = min;
381 e2fsck_write_inode_full(ctx, pctx->ino, pctx->inode,
382 EXT2_INODE_SIZE(sb), "pass1");
386 eamagic = (__u32 *) (((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE +
387 inode->i_extra_isize);
388 if (*eamagic == EXT2_EXT_ATTR_MAGIC) {
389 /* it seems inode has an extended attribute(s) in body */
390 check_ea_in_inode(ctx, pctx);
395 * Check to see if the inode might really be a directory, despite i_mode
397 * This is a lot of complexity for something for which I'm not really
398 * convinced happens frequently in the wild. If for any reason this
399 * causes any problems, take this code out.
400 * [tytso:20070331.0827EDT]
402 static void check_is_really_dir(e2fsck_t ctx, struct problem_context *pctx,
405 struct ext2_inode *inode = pctx->inode;
406 struct ext2_dir_entry *dirent;
409 unsigned int i, rec_len, not_device = 0;
413 * If the mode looks OK, we believe it. If the first block in
414 * the i_block array is 0, this cannot be a directory. If the
415 * inode is extent-mapped, it is still the case that the latter
416 * cannot be 0 - the magic number in the extent header would make
419 if (LINUX_S_ISDIR(inode->i_mode) || LINUX_S_ISREG(inode->i_mode) ||
420 LINUX_S_ISLNK(inode->i_mode) || inode->i_block[0] == 0)
424 * Check the block numbers in the i_block array for validity:
425 * zero blocks are skipped (but the first one cannot be zero -
426 * see above), other blocks are checked against the first and
427 * max data blocks (from the the superblock) and against the
428 * block bitmap. Any invalid block found means this cannot be
431 * If there are non-zero blocks past the fourth entry, then
432 * this cannot be a device file: we remember that for the next
435 * For extent mapped files, we don't do any sanity checking:
436 * just try to get the phys block of logical block 0 and run
440 extent_fs = (ctx->fs->super->s_feature_incompat &
441 EXT3_FEATURE_INCOMPAT_EXTENTS);
442 if (extent_fs && (inode->i_flags & EXT4_EXTENTS_FL)) {
444 if (ext2fs_bmap2(ctx->fs, pctx->ino, inode, 0, 0, 0, 0,
447 /* device files are never extent mapped */
450 for (i=0; i < EXT2_N_BLOCKS; i++) {
451 blk = inode->i_block[i];
457 if (blk < ctx->fs->super->s_first_data_block ||
458 blk >= ext2fs_blocks_count(ctx->fs->super) ||
459 ext2fs_fast_test_block_bitmap2(ctx->block_found_map,
461 return; /* Invalid block, can't be dir */
463 blk = inode->i_block[0];
467 * If the mode says this is a device file and the i_links_count field
468 * is sane and we have not ruled it out as a device file previously,
469 * we declare it a device file, not a directory.
471 if ((LINUX_S_ISCHR(inode->i_mode) || LINUX_S_ISBLK(inode->i_mode)) &&
472 (inode->i_links_count == 1) && !not_device)
475 /* read the first block */
476 ehandler_operation(_("reading directory block"));
477 retval = ext2fs_read_dir_block3(ctx->fs, blk, buf, 0);
478 ehandler_operation(0);
482 dirent = (struct ext2_dir_entry *) buf;
483 retval = ext2fs_get_rec_len(ctx->fs, dirent, &rec_len);
486 if (((dirent->name_len & 0xFF) != 1) ||
487 (dirent->name[0] != '.') ||
488 (dirent->inode != pctx->ino) ||
491 (rec_len >= ctx->fs->blocksize - 12))
494 dirent = (struct ext2_dir_entry *) (buf + rec_len);
495 retval = ext2fs_get_rec_len(ctx->fs, dirent, &rec_len);
498 if (((dirent->name_len & 0xFF) != 2) ||
499 (dirent->name[0] != '.') ||
500 (dirent->name[1] != '.') ||
505 if (fix_problem(ctx, PR_1_TREAT_AS_DIRECTORY, pctx)) {
506 inode->i_mode = (inode->i_mode & 07777) | LINUX_S_IFDIR;
507 e2fsck_write_inode_full(ctx, pctx->ino, inode,
508 EXT2_INODE_SIZE(ctx->fs->super),
509 "check_is_really_dir");
513 void e2fsck_setup_tdb_icount(e2fsck_t ctx, int flags,
516 unsigned int threshold;
524 profile_get_string(ctx->profile, "scratch_files", "directory", 0, 0,
526 profile_get_uint(ctx->profile, "scratch_files",
527 "numdirs_threshold", 0, 0, &threshold);
528 profile_get_boolean(ctx->profile, "scratch_files",
529 "icount", 0, 1, &enable);
531 retval = ext2fs_get_num_dirs(ctx->fs, &num_dirs);
533 num_dirs = 1024; /* Guess */
535 if (!enable || !tdb_dir || access(tdb_dir, W_OK) ||
536 (threshold && num_dirs <= threshold))
539 retval = ext2fs_create_icount_tdb(ctx->fs, tdb_dir, flags, ret);
544 void e2fsck_pass1(e2fsck_t ctx)
548 ext2_filsys fs = ctx->fs;
550 struct ext2_inode *inode = NULL;
551 ext2_inode_scan scan = NULL;
552 char *block_buf = NULL;
553 #ifdef RESOURCE_TRACK
554 struct resource_track rtrack;
556 unsigned char frag, fsize;
557 struct problem_context pctx;
558 struct scan_callback_struct scan_struct;
559 struct ext2_super_block *sb = ctx->fs->super;
561 unsigned int save_type;
562 int imagic_fs, extent_fs;
563 int low_dtime_check = 1;
566 init_resource_track(&rtrack, ctx->fs->io);
567 clear_problem_context(&pctx);
569 if (!(ctx->options & E2F_OPT_PREEN))
570 fix_problem(ctx, PR_1_PASS_HEADER, &pctx);
572 if ((fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_DIR_INDEX) &&
573 !(ctx->options & E2F_OPT_NO)) {
574 if (ext2fs_u32_list_create(&ctx->dirs_to_hash, 50))
575 ctx->dirs_to_hash = 0;
579 mtrace_print("Pass 1");
582 #define EXT2_BPP(bits) (1ULL << ((bits) - 2))
584 for (i = EXT2_MIN_BLOCK_LOG_SIZE; i <= EXT2_MAX_BLOCK_LOG_SIZE; i++) {
585 max_sizes = EXT2_NDIR_BLOCKS + EXT2_BPP(i);
586 max_sizes = max_sizes + EXT2_BPP(i) * EXT2_BPP(i);
587 max_sizes = max_sizes + EXT2_BPP(i) * EXT2_BPP(i) * EXT2_BPP(i);
588 max_sizes = (max_sizes * (1UL << i));
589 ext2_max_sizes[i - EXT2_MIN_BLOCK_LOG_SIZE] = max_sizes;
593 imagic_fs = (sb->s_feature_compat & EXT2_FEATURE_COMPAT_IMAGIC_INODES);
594 extent_fs = (sb->s_feature_incompat & EXT3_FEATURE_INCOMPAT_EXTENTS);
597 * Allocate bitmaps structures
599 pctx.errcode = e2fsck_allocate_inode_bitmap(fs, _("in-use inode map"),
600 EXT2FS_BMAP64_RBTREE,
602 &ctx->inode_used_map);
605 fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx);
606 ctx->flags |= E2F_FLAG_ABORT;
609 pctx.errcode = e2fsck_allocate_inode_bitmap(fs,
610 _("directory inode map"),
611 EXT2FS_BMAP64_AUTODIR,
612 "inode_dir_map", &ctx->inode_dir_map);
615 fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx);
616 ctx->flags |= E2F_FLAG_ABORT;
619 pctx.errcode = e2fsck_allocate_inode_bitmap(fs,
620 _("regular file inode map"), EXT2FS_BMAP64_RBTREE,
621 "inode_reg_map", &ctx->inode_reg_map);
624 fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx);
625 ctx->flags |= E2F_FLAG_ABORT;
628 pctx.errcode = e2fsck_allocate_subcluster_bitmap(fs,
629 _("in-use block map"), EXT2FS_BMAP64_RBTREE,
630 "block_found_map", &ctx->block_found_map);
633 fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, &pctx);
634 ctx->flags |= E2F_FLAG_ABORT;
637 e2fsck_setup_tdb_icount(ctx, 0, &ctx->inode_link_info);
638 if (!ctx->inode_link_info) {
639 e2fsck_set_bitmap_type(fs, EXT2FS_BMAP64_RBTREE,
640 "inode_link_info", &save_type);
641 pctx.errcode = ext2fs_create_icount2(fs, 0, 0, 0,
642 &ctx->inode_link_info);
643 fs->default_bitmap_type = save_type;
647 fix_problem(ctx, PR_1_ALLOCATE_ICOUNT, &pctx);
648 ctx->flags |= E2F_FLAG_ABORT;
651 inode_size = EXT2_INODE_SIZE(fs->super);
652 inode = (struct ext2_inode *)
653 e2fsck_allocate_memory(ctx, inode_size, "scratch inode");
655 inodes_to_process = (struct process_inode_block *)
656 e2fsck_allocate_memory(ctx,
657 (ctx->process_inode_size *
658 sizeof(struct process_inode_block)),
659 "array of inodes to process");
660 process_inode_count = 0;
662 pctx.errcode = ext2fs_init_dblist(fs, 0);
664 fix_problem(ctx, PR_1_ALLOCATE_DBCOUNT, &pctx);
665 ctx->flags |= E2F_FLAG_ABORT;
670 * If the last orphan field is set, clear it, since the pass1
671 * processing will automatically find and clear the orphans.
672 * In the future, we may want to try using the last_orphan
673 * linked list ourselves, but for now, we clear it so that the
674 * ext3 mount code won't get confused.
676 if (!(ctx->options & E2F_OPT_READONLY)) {
677 if (fs->super->s_last_orphan) {
678 fs->super->s_last_orphan = 0;
679 ext2fs_mark_super_dirty(fs);
683 mark_table_blocks(ctx);
684 pctx.errcode = ext2fs_convert_subcluster_bitmap(fs,
685 &ctx->block_found_map);
687 fix_problem(ctx, PR_1_CONVERT_SUBCLUSTER, &pctx);
688 ctx->flags |= E2F_FLAG_ABORT;
691 block_buf = (char *) e2fsck_allocate_memory(ctx, fs->blocksize * 3,
692 "block interate buffer");
693 e2fsck_use_inode_shortcuts(ctx, 1);
694 e2fsck_intercept_block_allocations(ctx);
695 old_op = ehandler_operation(_("opening inode scan"));
696 pctx.errcode = ext2fs_open_inode_scan(fs, ctx->inode_buffer_blocks,
698 ehandler_operation(old_op);
700 fix_problem(ctx, PR_1_ISCAN_ERROR, &pctx);
701 ctx->flags |= E2F_FLAG_ABORT;
704 ext2fs_inode_scan_flags(scan, EXT2_SF_SKIP_MISSING_ITABLE, 0);
705 ctx->stashed_inode = inode;
706 scan_struct.ctx = ctx;
707 scan_struct.block_buf = block_buf;
708 ext2fs_set_inode_callback(scan, scan_callback, &scan_struct);
709 if (ctx->progress && ((ctx->progress)(ctx, 1, 0,
710 ctx->fs->group_desc_count)))
712 if ((fs->super->s_wtime < fs->super->s_inodes_count) ||
713 (fs->super->s_mtime < fs->super->s_inodes_count) ||
714 (fs->super->s_mkfs_time &&
715 fs->super->s_mkfs_time < fs->super->s_inodes_count))
718 if ((fs->super->s_feature_incompat & EXT4_FEATURE_INCOMPAT_MMP) &&
719 fs->super->s_mmp_block > fs->super->s_first_data_block &&
720 fs->super->s_mmp_block < ext2fs_blocks_count(fs->super))
721 ext2fs_mark_block_bitmap2(ctx->block_found_map,
722 fs->super->s_mmp_block);
725 if (ino % (fs->super->s_inodes_per_group * 4) == 1) {
726 if (e2fsck_mmp_update(fs))
729 old_op = ehandler_operation(_("getting next inode from scan"));
730 pctx.errcode = ext2fs_get_next_inode_full(scan, &ino,
732 ehandler_operation(old_op);
733 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
735 if (pctx.errcode == EXT2_ET_BAD_BLOCK_IN_INODE_TABLE) {
736 if (!ctx->inode_bb_map)
738 ext2fs_mark_inode_bitmap2(ctx->inode_bb_map, ino);
739 ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino);
743 fix_problem(ctx, PR_1_ISCAN_ERROR, &pctx);
744 ctx->flags |= E2F_FLAG_ABORT;
751 ctx->stashed_ino = ino;
752 if (inode->i_links_count) {
753 pctx.errcode = ext2fs_icount_store(ctx->inode_link_info,
754 ino, inode->i_links_count);
756 pctx.num = inode->i_links_count;
757 fix_problem(ctx, PR_1_ICOUNT_STORE, &pctx);
758 ctx->flags |= E2F_FLAG_ABORT;
764 * Test for incorrect extent flag settings.
766 * On big-endian machines we must be careful:
767 * When the inode is read, the i_block array is not swapped
768 * if the extent flag is set. Therefore if we are testing
769 * for or fixing a wrongly-set flag, we must potentially
770 * (un)swap before testing, or after fixing.
774 * In this case the extents flag was set when read, so
775 * extent_header_verify is ok. If the inode is cleared,
776 * no need to swap... so no extra swapping here.
778 if ((inode->i_flags & EXT4_EXTENTS_FL) && !extent_fs &&
779 (inode->i_links_count || (ino == EXT2_BAD_INO) ||
780 (ino == EXT2_ROOT_INO) || (ino == EXT2_JOURNAL_INO))) {
781 if ((ext2fs_extent_header_verify(inode->i_block,
782 sizeof(inode->i_block)) == 0) &&
783 fix_problem(ctx, PR_1_EXTENT_FEATURE, &pctx)) {
784 sb->s_feature_incompat |= EXT3_FEATURE_INCOMPAT_EXTENTS;
785 ext2fs_mark_super_dirty(fs);
787 } else if (fix_problem(ctx, PR_1_EXTENTS_SET, &pctx)) {
789 e2fsck_clear_inode(ctx, ino, inode, 0, "pass1");
790 if (ino == EXT2_BAD_INO)
791 ext2fs_mark_inode_bitmap2(ctx->inode_used_map,
798 * For big-endian machines:
799 * If the inode didn't have the extents flag set when it
800 * was read, then the i_blocks array was swapped. To test
801 * as an extents header, we must swap it back first.
802 * IF we then set the extents flag, the entire i_block
803 * array must be un/re-swapped to make it proper extents data.
805 if (extent_fs && !(inode->i_flags & EXT4_EXTENTS_FL) &&
806 (inode->i_links_count || (ino == EXT2_BAD_INO) ||
807 (ino == EXT2_ROOT_INO) || (ino == EXT2_JOURNAL_INO)) &&
808 (LINUX_S_ISREG(inode->i_mode) ||
809 LINUX_S_ISDIR(inode->i_mode))) {
811 #ifdef WORDS_BIGENDIAN
812 __u32 tmp_block[EXT2_N_BLOCKS];
814 for (i = 0; i < EXT2_N_BLOCKS; i++)
815 tmp_block[i] = ext2fs_swab32(inode->i_block[i]);
818 ehp = inode->i_block;
820 if ((ext2fs_extent_header_verify(ehp,
821 sizeof(inode->i_block)) == 0) &&
822 (fix_problem(ctx, PR_1_UNSET_EXTENT_FL, &pctx))) {
823 inode->i_flags |= EXT4_EXTENTS_FL;
824 #ifdef WORDS_BIGENDIAN
825 memcpy(inode->i_block, tmp_block,
826 sizeof(inode->i_block));
828 e2fsck_write_inode(ctx, ino, inode, "pass1");
832 if (ino == EXT2_BAD_INO) {
833 struct process_block_struct pb;
835 if ((inode->i_mode || inode->i_uid || inode->i_gid ||
836 inode->i_links_count || inode->i_file_acl) &&
837 fix_problem(ctx, PR_1_INVALID_BAD_INODE, &pctx)) {
838 memset(inode, 0, sizeof(struct ext2_inode));
839 e2fsck_write_inode(ctx, ino, inode,
843 pctx.errcode = ext2fs_copy_bitmap(ctx->block_found_map,
847 fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, &pctx);
848 ctx->flags |= E2F_FLAG_ABORT;
851 pb.ino = EXT2_BAD_INO;
852 pb.num_blocks = pb.last_block = 0;
853 pb.last_db_block = -1;
854 pb.num_illegal_blocks = 0;
855 pb.suppress = 0; pb.clear = 0; pb.is_dir = 0;
856 pb.is_reg = 0; pb.fragmented = 0; pb.bbcheck = 0;
860 pctx.errcode = ext2fs_block_iterate3(fs, ino, 0,
861 block_buf, process_bad_block, &pb);
862 ext2fs_free_block_bitmap(pb.fs_meta_blocks);
864 fix_problem(ctx, PR_1_BLOCK_ITERATE, &pctx);
865 ctx->flags |= E2F_FLAG_ABORT;
869 if (!fix_problem(ctx, PR_1_BBINODE_BAD_METABLOCK_PROMPT, &pctx)) {
870 ctx->flags |= E2F_FLAG_ABORT;
873 ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino);
874 clear_problem_context(&pctx);
876 } else if (ino == EXT2_ROOT_INO) {
878 * Make sure the root inode is a directory; if
879 * not, offer to clear it. It will be
880 * regnerated in pass #3.
882 if (!LINUX_S_ISDIR(inode->i_mode)) {
883 if (fix_problem(ctx, PR_1_ROOT_NO_DIR, &pctx))
887 * If dtime is set, offer to clear it. mke2fs
888 * version 0.2b created filesystems with the
889 * dtime field set for the root and lost+found
890 * directories. We won't worry about
891 * /lost+found, since that can be regenerated
892 * easily. But we will fix the root directory
895 if (inode->i_dtime && inode->i_links_count) {
896 if (fix_problem(ctx, PR_1_ROOT_DTIME, &pctx)) {
898 e2fsck_write_inode(ctx, ino, inode,
902 } else if (ino == EXT2_JOURNAL_INO) {
903 ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino);
904 if (fs->super->s_journal_inum == EXT2_JOURNAL_INO) {
905 if (!LINUX_S_ISREG(inode->i_mode) &&
906 fix_problem(ctx, PR_1_JOURNAL_BAD_MODE,
908 inode->i_mode = LINUX_S_IFREG;
909 e2fsck_write_inode(ctx, ino, inode,
912 check_blocks(ctx, &pctx, block_buf);
915 if ((inode->i_links_count ||
916 inode->i_blocks || inode->i_block[0]) &&
917 fix_problem(ctx, PR_1_JOURNAL_INODE_NOT_CLEAR,
919 memset(inode, 0, inode_size);
920 ext2fs_icount_store(ctx->inode_link_info,
922 e2fsck_write_inode_full(ctx, ino, inode,
923 inode_size, "pass1");
925 } else if ((ino == EXT4_USR_QUOTA_INO) ||
926 (ino == EXT4_GRP_QUOTA_INO)) {
927 ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino);
928 if ((fs->super->s_feature_ro_compat &
929 EXT4_FEATURE_RO_COMPAT_QUOTA) &&
930 ((fs->super->s_usr_quota_inum == ino) ||
931 (fs->super->s_grp_quota_inum == ino))) {
932 if (!LINUX_S_ISREG(inode->i_mode) &&
933 fix_problem(ctx, PR_1_QUOTA_BAD_MODE,
935 inode->i_mode = LINUX_S_IFREG;
936 e2fsck_write_inode(ctx, ino, inode,
939 check_blocks(ctx, &pctx, block_buf);
942 if ((inode->i_links_count ||
943 inode->i_blocks || inode->i_block[0]) &&
944 fix_problem(ctx, PR_1_QUOTA_INODE_NOT_CLEAR,
946 memset(inode, 0, inode_size);
947 ext2fs_icount_store(ctx->inode_link_info,
949 e2fsck_write_inode_full(ctx, ino, inode,
950 inode_size, "pass1");
952 } else if (ino < EXT2_FIRST_INODE(fs->super)) {
953 problem_t problem = 0;
955 ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino);
956 if (ino == EXT2_BOOT_LOADER_INO) {
957 if (LINUX_S_ISDIR(inode->i_mode))
958 problem = PR_1_RESERVED_BAD_MODE;
959 } else if (ino == EXT2_RESIZE_INO) {
961 !LINUX_S_ISREG(inode->i_mode))
962 problem = PR_1_RESERVED_BAD_MODE;
964 if (inode->i_mode != 0)
965 problem = PR_1_RESERVED_BAD_MODE;
968 if (fix_problem(ctx, problem, &pctx)) {
970 e2fsck_write_inode(ctx, ino, inode,
974 check_blocks(ctx, &pctx, block_buf);
979 * Check for inodes who might have been part of the
980 * orphaned list linked list. They should have gotten
981 * dealt with by now, unless the list had somehow been
984 * FIXME: In the future, inodes which are still in use
985 * (and which are therefore) pending truncation should
986 * be handled specially. Right now we just clear the
987 * dtime field, and the normal e2fsck handling of
988 * inodes where i_size and the inode blocks are
989 * inconsistent is to fix i_size, instead of releasing
990 * the extra blocks. This won't catch the inodes that
991 * was at the end of the orphan list, but it's better
992 * than nothing. The right answer is that there
993 * shouldn't be any bugs in the orphan list handling. :-)
995 if (inode->i_dtime && low_dtime_check &&
996 inode->i_dtime < ctx->fs->super->s_inodes_count) {
997 if (fix_problem(ctx, PR_1_LOW_DTIME, &pctx)) {
998 inode->i_dtime = inode->i_links_count ?
1000 e2fsck_write_inode(ctx, ino, inode,
1006 * This code assumes that deleted inodes have
1007 * i_links_count set to 0.
1009 if (!inode->i_links_count) {
1010 if (!inode->i_dtime && inode->i_mode) {
1011 if (fix_problem(ctx,
1012 PR_1_ZERO_DTIME, &pctx)) {
1013 inode->i_dtime = ctx->now;
1014 e2fsck_write_inode(ctx, ino, inode,
1021 * n.b. 0.3c ext2fs code didn't clear i_links_count for
1022 * deleted files. Oops.
1024 * Since all new ext2 implementations get this right,
1025 * we now assume that the case of non-zero
1026 * i_links_count and non-zero dtime means that we
1027 * should keep the file, not delete it.
1030 if (inode->i_dtime) {
1031 if (fix_problem(ctx, PR_1_SET_DTIME, &pctx)) {
1033 e2fsck_write_inode(ctx, ino, inode, "pass1");
1037 ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino);
1038 switch (fs->super->s_creator_os) {
1040 frag = inode->osd2.hurd2.h_i_frag;
1041 fsize = inode->osd2.hurd2.h_i_fsize;
1047 if (inode->i_faddr || frag || fsize ||
1048 (LINUX_S_ISDIR(inode->i_mode) && inode->i_dir_acl))
1049 mark_inode_bad(ctx, ino);
1050 if (!(fs->super->s_feature_incompat &
1051 EXT4_FEATURE_INCOMPAT_64BIT) &&
1052 inode->osd2.linux2.l_i_file_acl_high != 0)
1053 mark_inode_bad(ctx, ino);
1054 if ((fs->super->s_creator_os == EXT2_OS_LINUX) &&
1055 !(fs->super->s_feature_ro_compat &
1056 EXT4_FEATURE_RO_COMPAT_HUGE_FILE) &&
1057 (inode->osd2.linux2.l_i_blocks_hi != 0))
1058 mark_inode_bad(ctx, ino);
1059 if (inode->i_flags & EXT2_IMAGIC_FL) {
1061 if (!ctx->inode_imagic_map)
1062 alloc_imagic_map(ctx);
1063 ext2fs_mark_inode_bitmap2(ctx->inode_imagic_map,
1066 if (fix_problem(ctx, PR_1_SET_IMAGIC, &pctx)) {
1067 inode->i_flags &= ~EXT2_IMAGIC_FL;
1068 e2fsck_write_inode(ctx, ino,
1074 check_inode_extra_space(ctx, &pctx);
1075 check_is_really_dir(ctx, &pctx, block_buf);
1078 * ext2fs_inode_has_valid_blocks2 does not actually look
1079 * at i_block[] values, so not endian-sensitive here.
1081 if (extent_fs && (inode->i_flags & EXT4_EXTENTS_FL) &&
1082 LINUX_S_ISLNK(inode->i_mode) &&
1083 !ext2fs_inode_has_valid_blocks2(fs, inode) &&
1084 fix_problem(ctx, PR_1_FAST_SYMLINK_EXTENT_FL, &pctx)) {
1085 inode->i_flags &= ~EXT4_EXTENTS_FL;
1086 e2fsck_write_inode(ctx, ino, inode, "pass1");
1089 if (LINUX_S_ISDIR(inode->i_mode)) {
1090 ext2fs_mark_inode_bitmap2(ctx->inode_dir_map, ino);
1091 e2fsck_add_dir_info(ctx, ino, 0);
1092 ctx->fs_directory_count++;
1093 } else if (LINUX_S_ISREG (inode->i_mode)) {
1094 ext2fs_mark_inode_bitmap2(ctx->inode_reg_map, ino);
1095 ctx->fs_regular_count++;
1096 } else if (LINUX_S_ISCHR (inode->i_mode) &&
1097 e2fsck_pass1_check_device_inode(fs, inode)) {
1098 check_immutable(ctx, &pctx);
1099 check_size(ctx, &pctx);
1100 ctx->fs_chardev_count++;
1101 } else if (LINUX_S_ISBLK (inode->i_mode) &&
1102 e2fsck_pass1_check_device_inode(fs, inode)) {
1103 check_immutable(ctx, &pctx);
1104 check_size(ctx, &pctx);
1105 ctx->fs_blockdev_count++;
1106 } else if (LINUX_S_ISLNK (inode->i_mode) &&
1107 e2fsck_pass1_check_symlink(fs, ino, inode,
1109 check_immutable(ctx, &pctx);
1110 ctx->fs_symlinks_count++;
1111 if (ext2fs_inode_data_blocks(fs, inode) == 0) {
1112 ctx->fs_fast_symlinks_count++;
1113 check_blocks(ctx, &pctx, block_buf);
1117 else if (LINUX_S_ISFIFO (inode->i_mode) &&
1118 e2fsck_pass1_check_device_inode(fs, inode)) {
1119 check_immutable(ctx, &pctx);
1120 check_size(ctx, &pctx);
1121 ctx->fs_fifo_count++;
1122 } else if ((LINUX_S_ISSOCK (inode->i_mode)) &&
1123 e2fsck_pass1_check_device_inode(fs, inode)) {
1124 check_immutable(ctx, &pctx);
1125 check_size(ctx, &pctx);
1126 ctx->fs_sockets_count++;
1128 mark_inode_bad(ctx, ino);
1129 if (!(inode->i_flags & EXT4_EXTENTS_FL)) {
1130 if (inode->i_block[EXT2_IND_BLOCK])
1131 ctx->fs_ind_count++;
1132 if (inode->i_block[EXT2_DIND_BLOCK])
1133 ctx->fs_dind_count++;
1134 if (inode->i_block[EXT2_TIND_BLOCK])
1135 ctx->fs_tind_count++;
1137 if (!(inode->i_flags & EXT4_EXTENTS_FL) &&
1138 (inode->i_block[EXT2_IND_BLOCK] ||
1139 inode->i_block[EXT2_DIND_BLOCK] ||
1140 inode->i_block[EXT2_TIND_BLOCK] ||
1141 ext2fs_file_acl_block(fs, inode))) {
1142 inodes_to_process[process_inode_count].ino = ino;
1143 inodes_to_process[process_inode_count].inode = *inode;
1144 process_inode_count++;
1146 check_blocks(ctx, &pctx, block_buf);
1148 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
1151 if (process_inode_count >= ctx->process_inode_size) {
1152 process_inodes(ctx, block_buf);
1154 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
1158 process_inodes(ctx, block_buf);
1159 ext2fs_close_inode_scan(scan);
1163 * If any extended attribute blocks' reference counts need to
1164 * be adjusted, either up (ctx->refcount_extra), or down
1165 * (ctx->refcount), then fix them.
1167 if (ctx->refcount) {
1168 adjust_extattr_refcount(ctx, ctx->refcount, block_buf, -1);
1169 ea_refcount_free(ctx->refcount);
1172 if (ctx->refcount_extra) {
1173 adjust_extattr_refcount(ctx, ctx->refcount_extra,
1175 ea_refcount_free(ctx->refcount_extra);
1176 ctx->refcount_extra = 0;
1179 if (ctx->invalid_bitmaps)
1180 handle_fs_bad_blocks(ctx);
1182 /* We don't need the block_ea_map any more */
1183 if (ctx->block_ea_map) {
1184 ext2fs_free_block_bitmap(ctx->block_ea_map);
1185 ctx->block_ea_map = 0;
1188 if (ctx->flags & E2F_FLAG_RESIZE_INODE) {
1189 clear_problem_context(&pctx);
1190 pctx.errcode = ext2fs_create_resize_inode(fs);
1192 if (!fix_problem(ctx, PR_1_RESIZE_INODE_CREATE,
1194 ctx->flags |= E2F_FLAG_ABORT;
1199 if (!pctx.errcode) {
1200 e2fsck_read_inode(ctx, EXT2_RESIZE_INO, inode,
1202 inode->i_mtime = ctx->now;
1203 e2fsck_write_inode(ctx, EXT2_RESIZE_INO, inode,
1206 ctx->flags &= ~E2F_FLAG_RESIZE_INODE;
1209 if (ctx->flags & E2F_FLAG_RESTART) {
1211 * Only the master copy of the superblock and block
1212 * group descriptors are going to be written during a
1213 * restart, so set the superblock to be used to be the
1214 * master superblock.
1216 ctx->use_superblock = 0;
1221 if (ctx->block_dup_map) {
1222 if (ctx->options & E2F_OPT_PREEN) {
1223 clear_problem_context(&pctx);
1224 fix_problem(ctx, PR_1_DUP_BLOCKS_PREENSTOP, &pctx);
1226 e2fsck_pass1_dupblocks(ctx, block_buf);
1228 ext2fs_free_mem(&inodes_to_process);
1230 e2fsck_use_inode_shortcuts(ctx, 0);
1233 ext2fs_close_inode_scan(scan);
1235 ext2fs_free_mem(&block_buf);
1237 ext2fs_free_mem(&inode);
1239 if ((ctx->flags & E2F_FLAG_SIGNAL_MASK) == 0)
1240 print_resource_track(ctx, _("Pass 1"), &rtrack, ctx->fs->io);
1244 * When the inode_scan routines call this callback at the end of the
1245 * glock group, call process_inodes.
1247 static errcode_t scan_callback(ext2_filsys fs,
1248 ext2_inode_scan scan EXT2FS_ATTR((unused)),
1249 dgrp_t group, void * priv_data)
1251 struct scan_callback_struct *scan_struct;
1254 scan_struct = (struct scan_callback_struct *) priv_data;
1255 ctx = scan_struct->ctx;
1257 process_inodes((e2fsck_t) fs->priv_data, scan_struct->block_buf);
1260 if ((ctx->progress)(ctx, 1, group+1,
1261 ctx->fs->group_desc_count))
1262 return EXT2_ET_CANCEL_REQUESTED;
1268 * Process the inodes in the "inodes to process" list.
1270 static void process_inodes(e2fsck_t ctx, char *block_buf)
1273 struct ext2_inode *old_stashed_inode;
1274 ext2_ino_t old_stashed_ino;
1275 const char *old_operation;
1277 struct problem_context pctx;
1280 printf("begin process_inodes: ");
1282 if (process_inode_count == 0)
1284 old_operation = ehandler_operation(0);
1285 old_stashed_inode = ctx->stashed_inode;
1286 old_stashed_ino = ctx->stashed_ino;
1287 qsort(inodes_to_process, process_inode_count,
1288 sizeof(struct process_inode_block), process_inode_cmp);
1289 clear_problem_context(&pctx);
1290 for (i=0; i < process_inode_count; i++) {
1291 pctx.inode = ctx->stashed_inode = &inodes_to_process[i].inode;
1292 pctx.ino = ctx->stashed_ino = inodes_to_process[i].ino;
1295 printf("%u ", pctx.ino);
1297 sprintf(buf, _("reading indirect blocks of inode %u"),
1299 ehandler_operation(buf);
1300 check_blocks(ctx, &pctx, block_buf);
1301 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
1304 ctx->stashed_inode = old_stashed_inode;
1305 ctx->stashed_ino = old_stashed_ino;
1306 process_inode_count = 0;
1308 printf("end process inodes\n");
1310 ehandler_operation(old_operation);
1313 static EXT2_QSORT_TYPE process_inode_cmp(const void *a, const void *b)
1315 const struct process_inode_block *ib_a =
1316 (const struct process_inode_block *) a;
1317 const struct process_inode_block *ib_b =
1318 (const struct process_inode_block *) b;
1321 ret = (ib_a->inode.i_block[EXT2_IND_BLOCK] -
1322 ib_b->inode.i_block[EXT2_IND_BLOCK]);
1325 * We only call process_inodes() for non-extent
1326 * inodes, so it's OK to pass NULL to
1327 * ext2fs_file_acl_block() here.
1329 ret = ext2fs_file_acl_block(0, &(ib_a->inode)) -
1330 ext2fs_file_acl_block(0, &(ib_b->inode));
1332 ret = ib_a->ino - ib_b->ino;
1337 * Mark an inode as being bad in some what
1339 static void mark_inode_bad(e2fsck_t ctx, ino_t ino)
1341 struct problem_context pctx;
1343 if (!ctx->inode_bad_map) {
1344 clear_problem_context(&pctx);
1346 pctx.errcode = e2fsck_allocate_inode_bitmap(ctx->fs,
1347 _("bad inode map"), EXT2FS_BMAP64_RBTREE,
1348 "inode_bad_map", &ctx->inode_bad_map);
1351 fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx);
1352 /* Should never get here */
1353 ctx->flags |= E2F_FLAG_ABORT;
1357 ext2fs_mark_inode_bitmap2(ctx->inode_bad_map, ino);
1362 * This procedure will allocate the inode "bb" (badblock) map table
1364 static void alloc_bb_map(e2fsck_t ctx)
1366 struct problem_context pctx;
1368 clear_problem_context(&pctx);
1369 pctx.errcode = e2fsck_allocate_inode_bitmap(ctx->fs,
1370 _("inode in bad block map"), EXT2FS_BMAP64_RBTREE,
1371 "inode_bb_map", &ctx->inode_bb_map);
1374 fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx);
1375 /* Should never get here */
1376 ctx->flags |= E2F_FLAG_ABORT;
1382 * This procedure will allocate the inode imagic table
1384 static void alloc_imagic_map(e2fsck_t ctx)
1386 struct problem_context pctx;
1388 clear_problem_context(&pctx);
1389 pctx.errcode = e2fsck_allocate_inode_bitmap(ctx->fs,
1390 _("imagic inode map"), EXT2FS_BMAP64_RBTREE,
1391 "inode_imagic_map", &ctx->inode_imagic_map);
1394 fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx);
1395 /* Should never get here */
1396 ctx->flags |= E2F_FLAG_ABORT;
1402 * Marks a block as in use, setting the dup_map if it's been set
1403 * already. Called by process_block and process_bad_block.
1405 * WARNING: Assumes checks have already been done to make sure block
1406 * is valid. This is true in both process_block and process_bad_block.
1408 static _INLINE_ void mark_block_used(e2fsck_t ctx, blk64_t block)
1410 struct problem_context pctx;
1412 clear_problem_context(&pctx);
1414 if (ext2fs_fast_test_block_bitmap2(ctx->block_found_map, block)) {
1415 if (!ctx->block_dup_map) {
1416 pctx.errcode = e2fsck_allocate_block_bitmap(ctx->fs,
1417 _("multiply claimed block map"),
1418 EXT2FS_BMAP64_RBTREE, "block_dup_map",
1419 &ctx->block_dup_map);
1422 fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR,
1424 /* Should never get here */
1425 ctx->flags |= E2F_FLAG_ABORT;
1429 ext2fs_fast_mark_block_bitmap2(ctx->block_dup_map, block);
1431 ext2fs_fast_mark_block_bitmap2(ctx->block_found_map, block);
1435 static _INLINE_ void mark_blocks_used(e2fsck_t ctx, blk64_t block,
1438 if (ext2fs_test_block_bitmap_range2(ctx->block_found_map, block, num))
1439 ext2fs_mark_block_bitmap_range2(ctx->block_found_map, block, num);
1442 mark_block_used(ctx, block++);
1446 * Adjust the extended attribute block's reference counts at the end
1447 * of pass 1, either by subtracting out references for EA blocks that
1448 * are still referenced in ctx->refcount, or by adding references for
1449 * EA blocks that had extra references as accounted for in
1450 * ctx->refcount_extra.
1452 static void adjust_extattr_refcount(e2fsck_t ctx, ext2_refcount_t refcount,
1453 char *block_buf, int adjust_sign)
1455 struct ext2_ext_attr_header *header;
1456 struct problem_context pctx;
1457 ext2_filsys fs = ctx->fs;
1462 clear_problem_context(&pctx);
1464 ea_refcount_intr_begin(refcount);
1466 if ((blk = ea_refcount_intr_next(refcount, &count)) == 0)
1469 pctx.errcode = ext2fs_read_ext_attr2(fs, blk, block_buf);
1471 fix_problem(ctx, PR_1_EXTATTR_READ_ABORT, &pctx);
1474 header = (struct ext2_ext_attr_header *) block_buf;
1475 pctx.blkcount = header->h_refcount;
1476 should_be = header->h_refcount + adjust_sign * count;
1477 pctx.num = should_be;
1478 if (fix_problem(ctx, PR_1_EXTATTR_REFCOUNT, &pctx)) {
1479 header->h_refcount = should_be;
1480 pctx.errcode = ext2fs_write_ext_attr2(fs, blk,
1483 fix_problem(ctx, PR_1_EXTATTR_WRITE_ABORT,
1492 * Handle processing the extended attribute blocks
1494 static int check_ext_attr(e2fsck_t ctx, struct problem_context *pctx,
1497 ext2_filsys fs = ctx->fs;
1498 ext2_ino_t ino = pctx->ino;
1499 struct ext2_inode *inode = pctx->inode;
1502 struct ext2_ext_attr_header *header;
1503 struct ext2_ext_attr_entry *entry;
1505 region_t region = 0;
1507 blk = ext2fs_file_acl_block(fs, inode);
1512 * If the Extended attribute flag isn't set, then a non-zero
1513 * file acl means that the inode is corrupted.
1515 * Or if the extended attribute block is an invalid block,
1516 * then the inode is also corrupted.
1518 if (!(fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_EXT_ATTR) ||
1519 (blk < fs->super->s_first_data_block) ||
1520 (blk >= ext2fs_blocks_count(fs->super))) {
1521 mark_inode_bad(ctx, ino);
1525 /* If ea bitmap hasn't been allocated, create it */
1526 if (!ctx->block_ea_map) {
1527 pctx->errcode = e2fsck_allocate_block_bitmap(fs,
1528 _("ext attr block map"),
1529 EXT2FS_BMAP64_RBTREE, "block_ea_map",
1530 &ctx->block_ea_map);
1531 if (pctx->errcode) {
1533 fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, pctx);
1534 ctx->flags |= E2F_FLAG_ABORT;
1539 /* Create the EA refcount structure if necessary */
1540 if (!ctx->refcount) {
1541 pctx->errcode = ea_refcount_create(0, &ctx->refcount);
1542 if (pctx->errcode) {
1544 fix_problem(ctx, PR_1_ALLOCATE_REFCOUNT, pctx);
1545 ctx->flags |= E2F_FLAG_ABORT;
1551 /* Debugging text */
1552 printf("Inode %u has EA block %u\n", ino, blk);
1555 /* Have we seen this EA block before? */
1556 if (ext2fs_fast_test_block_bitmap2(ctx->block_ea_map, blk)) {
1557 if (ea_refcount_decrement(ctx->refcount, blk, 0) == 0)
1559 /* Ooops, this EA was referenced more than it stated */
1560 if (!ctx->refcount_extra) {
1561 pctx->errcode = ea_refcount_create(0,
1562 &ctx->refcount_extra);
1563 if (pctx->errcode) {
1565 fix_problem(ctx, PR_1_ALLOCATE_REFCOUNT, pctx);
1566 ctx->flags |= E2F_FLAG_ABORT;
1570 ea_refcount_increment(ctx->refcount_extra, blk, 0);
1575 * OK, we haven't seen this EA block yet. So we need to
1579 pctx->errcode = ext2fs_read_ext_attr2(fs, blk, block_buf);
1580 if (pctx->errcode && fix_problem(ctx, PR_1_READ_EA_BLOCK, pctx))
1582 header = (struct ext2_ext_attr_header *) block_buf;
1583 pctx->blk = ext2fs_file_acl_block(fs, inode);
1584 if (((ctx->ext_attr_ver == 1) &&
1585 (header->h_magic != EXT2_EXT_ATTR_MAGIC_v1)) ||
1586 ((ctx->ext_attr_ver == 2) &&
1587 (header->h_magic != EXT2_EXT_ATTR_MAGIC))) {
1588 if (fix_problem(ctx, PR_1_BAD_EA_BLOCK, pctx))
1592 if (header->h_blocks != 1) {
1593 if (fix_problem(ctx, PR_1_EA_MULTI_BLOCK, pctx))
1597 region = region_create(0, fs->blocksize);
1599 fix_problem(ctx, PR_1_EA_ALLOC_REGION_ABORT, pctx);
1600 ctx->flags |= E2F_FLAG_ABORT;
1603 if (region_allocate(region, 0, sizeof(struct ext2_ext_attr_header))) {
1604 if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, pctx))
1608 entry = (struct ext2_ext_attr_entry *)(header+1);
1609 end = block_buf + fs->blocksize;
1610 while ((char *)entry < end && *(__u32 *)entry) {
1613 if (region_allocate(region, (char *)entry - (char *)header,
1614 EXT2_EXT_ATTR_LEN(entry->e_name_len))) {
1615 if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, pctx))
1619 if ((ctx->ext_attr_ver == 1 &&
1620 (entry->e_name_len == 0 || entry->e_name_index != 0)) ||
1621 (ctx->ext_attr_ver == 2 &&
1622 entry->e_name_index == 0)) {
1623 if (fix_problem(ctx, PR_1_EA_BAD_NAME, pctx))
1627 if (entry->e_value_block != 0) {
1628 if (fix_problem(ctx, PR_1_EA_BAD_VALUE, pctx))
1631 if (entry->e_value_offs + entry->e_value_size > fs->blocksize) {
1632 if (fix_problem(ctx, PR_1_EA_BAD_VALUE, pctx))
1636 if (entry->e_value_size &&
1637 region_allocate(region, entry->e_value_offs,
1638 EXT2_EXT_ATTR_SIZE(entry->e_value_size))) {
1639 if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, pctx))
1643 hash = ext2fs_ext_attr_hash_entry(entry, block_buf +
1644 entry->e_value_offs);
1646 if (entry->e_hash != hash) {
1647 pctx->num = entry->e_hash;
1648 if (fix_problem(ctx, PR_1_ATTR_HASH, pctx))
1650 entry->e_hash = hash;
1653 entry = EXT2_EXT_ATTR_NEXT(entry);
1655 if (region_allocate(region, (char *)entry - (char *)header, 4)) {
1656 if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, pctx))
1659 region_free(region);
1661 count = header->h_refcount - 1;
1663 ea_refcount_store(ctx->refcount, blk, count);
1664 mark_block_used(ctx, blk);
1665 ext2fs_fast_mark_block_bitmap2(ctx->block_ea_map, blk);
1670 region_free(region);
1671 ext2fs_file_acl_block_set(fs, inode, 0);
1672 e2fsck_write_inode(ctx, ino, inode, "check_ext_attr");
1676 /* Returns 1 if bad htree, 0 if OK */
1677 static int handle_htree(e2fsck_t ctx, struct problem_context *pctx,
1678 ext2_ino_t ino, struct ext2_inode *inode,
1681 struct ext2_dx_root_info *root;
1682 ext2_filsys fs = ctx->fs;
1686 if ((!LINUX_S_ISDIR(inode->i_mode) &&
1687 fix_problem(ctx, PR_1_HTREE_NODIR, pctx)) ||
1688 (!(fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_DIR_INDEX) &&
1689 fix_problem(ctx, PR_1_HTREE_SET, pctx)))
1692 pctx->errcode = ext2fs_bmap2(fs, ino, inode, 0, 0, 0, 0, &blk);
1694 if ((pctx->errcode) ||
1696 (blk < fs->super->s_first_data_block) ||
1697 (blk >= ext2fs_blocks_count(fs->super))) {
1698 if (fix_problem(ctx, PR_1_HTREE_BADROOT, pctx))
1704 retval = io_channel_read_blk64(fs->io, blk, 1, block_buf);
1705 if (retval && fix_problem(ctx, PR_1_HTREE_BADROOT, pctx))
1708 /* XXX should check that beginning matches a directory */
1709 root = (struct ext2_dx_root_info *) (block_buf + 24);
1711 if ((root->reserved_zero || root->info_length < 8) &&
1712 fix_problem(ctx, PR_1_HTREE_BADROOT, pctx))
1715 pctx->num = root->hash_version;
1716 if ((root->hash_version != EXT2_HASH_LEGACY) &&
1717 (root->hash_version != EXT2_HASH_HALF_MD4) &&
1718 (root->hash_version != EXT2_HASH_TEA) &&
1719 fix_problem(ctx, PR_1_HTREE_HASHV, pctx))
1722 if ((root->unused_flags & EXT2_HASH_FLAG_INCOMPAT) &&
1723 fix_problem(ctx, PR_1_HTREE_INCOMPAT, pctx))
1726 pctx->num = root->indirect_levels;
1727 if ((root->indirect_levels > 1) &&
1728 fix_problem(ctx, PR_1_HTREE_DEPTH, pctx))
1734 void e2fsck_clear_inode(e2fsck_t ctx, ext2_ino_t ino,
1735 struct ext2_inode *inode, int restart_flag,
1739 inode->i_links_count = 0;
1740 ext2fs_icount_store(ctx->inode_link_info, ino, 0);
1741 inode->i_dtime = ctx->now;
1743 ext2fs_unmark_inode_bitmap2(ctx->inode_dir_map, ino);
1744 ext2fs_unmark_inode_bitmap2(ctx->inode_used_map, ino);
1745 if (ctx->inode_reg_map)
1746 ext2fs_unmark_inode_bitmap2(ctx->inode_reg_map, ino);
1747 if (ctx->inode_bad_map)
1748 ext2fs_unmark_inode_bitmap2(ctx->inode_bad_map, ino);
1751 * If the inode was partially accounted for before processing
1752 * was aborted, we need to restart the pass 1 scan.
1754 ctx->flags |= restart_flag;
1756 if (ino == EXT2_BAD_INO)
1757 memset(inode, 0, sizeof(struct ext2_inode));
1759 e2fsck_write_inode(ctx, ino, inode, source);
1762 static void scan_extent_node(e2fsck_t ctx, struct problem_context *pctx,
1763 struct process_block_struct *pb,
1764 blk64_t start_block, blk64_t end_block,
1766 ext2_extent_handle_t ehandle)
1768 struct ext2fs_extent extent;
1769 blk64_t blk, last_lblk;
1770 e2_blkcnt_t blockcnt;
1772 int is_dir, is_leaf;
1774 struct ext2_extent_info info;
1776 pctx->errcode = ext2fs_extent_get_info(ehandle, &info);
1780 pctx->errcode = ext2fs_extent_get(ehandle, EXT2_EXTENT_FIRST_SIB,
1782 while (!pctx->errcode && info.num_entries-- > 0) {
1783 is_leaf = extent.e_flags & EXT2_EXTENT_FLAGS_LEAF;
1784 is_dir = LINUX_S_ISDIR(pctx->inode->i_mode);
1785 last_lblk = extent.e_lblk + extent.e_len - 1;
1788 if (extent.e_pblk == 0 ||
1789 extent.e_pblk < ctx->fs->super->s_first_data_block ||
1790 extent.e_pblk >= ext2fs_blocks_count(ctx->fs->super))
1791 problem = PR_1_EXTENT_BAD_START_BLK;
1792 else if (extent.e_lblk < start_block)
1793 problem = PR_1_OUT_OF_ORDER_EXTENTS;
1794 else if ((end_block && last_lblk > end_block) &&
1795 (!(extent.e_flags & EXT2_EXTENT_FLAGS_UNINIT &&
1796 last_lblk > eof_block)))
1797 problem = PR_1_EXTENT_END_OUT_OF_BOUNDS;
1798 else if (is_leaf && extent.e_len == 0)
1799 problem = PR_1_EXTENT_LENGTH_ZERO;
1801 (extent.e_pblk + extent.e_len) >
1802 ext2fs_blocks_count(ctx->fs->super))
1803 problem = PR_1_EXTENT_ENDS_BEYOND;
1804 else if (is_leaf && is_dir &&
1805 ((extent.e_lblk + extent.e_len) >
1806 (1 << (21 - ctx->fs->super->s_log_block_size))))
1807 problem = PR_1_TOOBIG_DIR;
1811 pctx->blk = extent.e_pblk;
1812 pctx->blk2 = extent.e_lblk;
1813 pctx->num = extent.e_len;
1814 pctx->blkcount = extent.e_lblk + extent.e_len;
1815 if (fix_problem(ctx, problem, pctx)) {
1816 if (ctx->invalid_bitmaps) {
1818 * If fsck knows the bitmaps are bad,
1819 * skip to the next extent and
1820 * try to clear this extent again
1821 * after fixing the bitmaps, by
1824 pctx->errcode = ext2fs_extent_get(
1826 EXT2_EXTENT_NEXT_SIB,
1828 ctx->flags |= E2F_FLAG_RESTART_LATER;
1829 if (pctx->errcode ==
1830 EXT2_ET_NO_CURRENT_NODE) {
1836 e2fsck_read_bitmaps(ctx);
1837 pb->inode_modified = 1;
1839 ext2fs_extent_delete(ehandle, 0);
1840 if (pctx->errcode) {
1841 pctx->str = "ext2fs_extent_delete";
1844 pctx->errcode = ext2fs_extent_fix_parents(ehandle);
1845 if (pctx->errcode &&
1846 pctx->errcode != EXT2_ET_NO_CURRENT_NODE) {
1847 pctx->str = "ext2fs_extent_fix_parents";
1850 pctx->errcode = ext2fs_extent_get(ehandle,
1851 EXT2_EXTENT_CURRENT,
1853 if (pctx->errcode == EXT2_ET_NO_CURRENT_NODE) {
1863 blk64_t lblk = extent.e_lblk;
1865 blk = extent.e_pblk;
1866 pctx->errcode = ext2fs_extent_get(ehandle,
1867 EXT2_EXTENT_DOWN, &extent);
1868 if (pctx->errcode) {
1869 pctx->str = "EXT2_EXTENT_DOWN";
1870 problem = PR_1_EXTENT_HEADER_INVALID;
1871 if (pctx->errcode == EXT2_ET_EXTENT_HEADER_BAD)
1872 goto report_problem;
1875 /* The next extent should match this index's logical start */
1876 if (extent.e_lblk != lblk) {
1877 struct ext2_extent_info e_info;
1879 ext2fs_extent_get_info(ehandle, &e_info);
1881 pctx->blk2 = extent.e_lblk;
1882 pctx->num = e_info.curr_level - 1;
1883 problem = PR_1_EXTENT_INDEX_START_INVALID;
1884 if (fix_problem(ctx, problem, pctx)) {
1885 pb->inode_modified = 1;
1887 ext2fs_extent_fix_parents(ehandle);
1888 if (pctx->errcode) {
1889 pctx->str = "ext2fs_extent_fix_parents";
1894 scan_extent_node(ctx, pctx, pb, extent.e_lblk,
1895 last_lblk, eof_block, ehandle);
1898 pctx->errcode = ext2fs_extent_get(ehandle,
1899 EXT2_EXTENT_UP, &extent);
1900 if (pctx->errcode) {
1901 pctx->str = "EXT2_EXTENT_UP";
1904 mark_block_used(ctx, blk);
1909 if ((pb->previous_block != 0) &&
1910 (pb->previous_block+1 != extent.e_pblk)) {
1911 if (ctx->options & E2F_OPT_FRAGCHECK) {
1916 else if (pb->is_reg)
1919 printf(("%6lu(%c): expecting %6lu "
1921 "phys %6lu log %lu len %lu\n"),
1922 (unsigned long) pctx->ino, type,
1923 (unsigned long) pb->previous_block+1,
1924 (unsigned long) extent.e_pblk,
1925 (unsigned long) extent.e_lblk,
1926 (unsigned long) extent.e_len);
1931 * If we notice a gap in the logical block mappings of an
1932 * extent-mapped directory, offer to close the hole by
1933 * moving the logical block down, otherwise we'll go mad in
1934 * pass 3 allocating empty directory blocks to fill the hole.
1937 pb->last_block + 1 < (e2_blkcnt_t)extent.e_lblk) {
1940 new_lblk = pb->last_block + 1;
1941 if (EXT2FS_CLUSTER_RATIO(ctx->fs) > 1)
1942 new_lblk = ((new_lblk +
1943 EXT2FS_CLUSTER_RATIO(ctx->fs)) &
1944 EXT2FS_CLUSTER_MASK(ctx->fs)) |
1946 EXT2FS_CLUSTER_MASK(ctx->fs));
1947 pctx->blk = extent.e_lblk;
1948 pctx->blk2 = new_lblk;
1949 if (fix_problem(ctx, PR_1_COLLAPSE_DBLOCK, pctx)) {
1950 extent.e_lblk = new_lblk;
1951 pb->inode_modified = 1;
1952 pctx->errcode = ext2fs_extent_replace(ehandle,
1954 if (pctx->errcode) {
1958 pctx->errcode = ext2fs_extent_fix_parents(ehandle);
1960 goto failed_add_dir_block;
1961 pctx->errcode = ext2fs_extent_goto(ehandle,
1964 goto failed_add_dir_block;
1965 last_lblk = extent.e_lblk + extent.e_len - 1;
1969 while (is_dir && (++pb->last_db_block <
1970 (e2_blkcnt_t) extent.e_lblk)) {
1971 pctx->errcode = ext2fs_add_dir_block2(ctx->fs->dblist,
1974 if (pctx->errcode) {
1976 pctx->num = pb->last_db_block;
1977 goto failed_add_dir_block;
1980 if (!ctx->fs->cluster_ratio_bits) {
1981 mark_blocks_used(ctx, extent.e_pblk, extent.e_len);
1982 pb->num_blocks += extent.e_len;
1984 for (blk = extent.e_pblk, blockcnt = extent.e_lblk, i = 0;
1986 blk++, blockcnt++, i++) {
1987 if (ctx->fs->cluster_ratio_bits &&
1988 !(pb->previous_block &&
1989 (EXT2FS_B2C(ctx->fs, blk) ==
1990 EXT2FS_B2C(ctx->fs, pb->previous_block)) &&
1991 (blk & EXT2FS_CLUSTER_MASK(ctx->fs)) ==
1992 ((unsigned) blockcnt & EXT2FS_CLUSTER_MASK(ctx->fs)))) {
1993 mark_block_used(ctx, blk);
1997 pb->previous_block = blk;
2000 pctx->errcode = ext2fs_add_dir_block2(ctx->fs->dblist, pctx->ino, blk, blockcnt);
2001 if (pctx->errcode) {
2003 pctx->num = blockcnt;
2004 failed_add_dir_block:
2005 fix_problem(ctx, PR_1_ADD_DBLOCK, pctx);
2006 /* Should never get here */
2007 ctx->flags |= E2F_FLAG_ABORT;
2012 if (is_dir && extent.e_len > 0)
2013 pb->last_db_block = blockcnt - 1;
2014 pb->previous_block = extent.e_pblk + extent.e_len - 1;
2015 start_block = pb->last_block = last_lblk;
2016 if (is_leaf && !is_dir &&
2017 !(extent.e_flags & EXT2_EXTENT_FLAGS_UNINIT))
2018 pb->last_init_lblock = last_lblk;
2020 pctx->errcode = ext2fs_extent_get(ehandle,
2021 EXT2_EXTENT_NEXT_SIB,
2024 if (pctx->errcode == EXT2_ET_EXTENT_NO_NEXT)
2028 static void check_blocks_extents(e2fsck_t ctx, struct problem_context *pctx,
2029 struct process_block_struct *pb)
2031 struct ext2_extent_info info;
2032 struct ext2_inode *inode = pctx->inode;
2033 ext2_extent_handle_t ehandle;
2034 ext2_filsys fs = ctx->fs;
2035 ext2_ino_t ino = pctx->ino;
2039 pctx->errcode = ext2fs_extent_open2(fs, ino, inode, &ehandle);
2040 if (pctx->errcode) {
2041 if (fix_problem(ctx, PR_1_READ_EXTENT, pctx))
2042 e2fsck_clear_inode(ctx, ino, inode, 0,
2043 "check_blocks_extents");
2048 retval = ext2fs_extent_get_info(ehandle, &info);
2050 if (info.max_depth >= MAX_EXTENT_DEPTH_COUNT)
2051 info.max_depth = MAX_EXTENT_DEPTH_COUNT-1;
2052 ctx->extent_depth_count[info.max_depth]++;
2055 eof_lblk = ((EXT2_I_SIZE(inode) + fs->blocksize - 1) >>
2056 EXT2_BLOCK_SIZE_BITS(fs->super)) - 1;
2057 scan_extent_node(ctx, pctx, pb, 0, 0, eof_lblk, ehandle);
2058 if (pctx->errcode &&
2059 fix_problem(ctx, PR_1_EXTENT_ITERATE_FAILURE, pctx)) {
2061 inode->i_blocks = 0;
2062 e2fsck_clear_inode(ctx, ino, inode, E2F_FLAG_RESTART,
2063 "check_blocks_extents");
2066 ext2fs_extent_free(ehandle);
2070 * This subroutine is called on each inode to account for all of the
2071 * blocks used by that inode.
2073 static void check_blocks(e2fsck_t ctx, struct problem_context *pctx,
2076 ext2_filsys fs = ctx->fs;
2077 struct process_block_struct pb;
2078 ext2_ino_t ino = pctx->ino;
2079 struct ext2_inode *inode = pctx->inode;
2080 unsigned bad_size = 0;
2081 int dirty_inode = 0;
2088 pb.last_init_lblock = -1;
2089 pb.last_db_block = -1;
2090 pb.num_illegal_blocks = 0;
2091 pb.suppress = 0; pb.clear = 0;
2094 pb.previous_block = 0;
2095 pb.is_dir = LINUX_S_ISDIR(inode->i_mode);
2096 pb.is_reg = LINUX_S_ISREG(inode->i_mode);
2097 pb.max_blocks = 1 << (31 - fs->super->s_log_block_size);
2101 pb.inode_modified = 0;
2105 extent_fs = (ctx->fs->super->s_feature_incompat &
2106 EXT3_FEATURE_INCOMPAT_EXTENTS);
2108 if (inode->i_flags & EXT2_COMPRBLK_FL) {
2109 if (fs->super->s_feature_incompat &
2110 EXT2_FEATURE_INCOMPAT_COMPRESSION)
2113 if (fix_problem(ctx, PR_1_COMPR_SET, pctx)) {
2114 inode->i_flags &= ~EXT2_COMPRBLK_FL;
2120 if (ext2fs_file_acl_block(fs, inode) &&
2121 check_ext_attr(ctx, pctx, block_buf)) {
2122 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
2127 if (ext2fs_inode_has_valid_blocks2(fs, inode)) {
2128 if (extent_fs && (inode->i_flags & EXT4_EXTENTS_FL))
2129 check_blocks_extents(ctx, pctx, &pb);
2132 * If we've modified the inode, write it out before
2133 * iterate() tries to use it.
2136 e2fsck_write_inode(ctx, ino, inode,
2140 pctx->errcode = ext2fs_block_iterate3(fs, ino,
2141 pb.is_dir ? BLOCK_FLAG_HOLE : 0,
2142 block_buf, process_block, &pb);
2144 * We do not have uninitialized extents in non extent
2147 pb.last_init_lblock = pb.last_block;
2149 * If iterate() changed a block mapping, we have to
2150 * re-read the inode. If we decide to clear the
2151 * inode after clearing some stuff, we'll re-write the
2152 * bad mappings into the inode!
2154 if (pb.inode_modified)
2155 e2fsck_read_inode(ctx, ino, inode,
2159 end_problem_latch(ctx, PR_LATCH_BLOCK);
2160 end_problem_latch(ctx, PR_LATCH_TOOBIG);
2161 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
2164 fix_problem(ctx, PR_1_BLOCK_ITERATE, pctx);
2166 if (pb.fragmented && pb.num_blocks < fs->super->s_blocks_per_group) {
2167 if (LINUX_S_ISDIR(inode->i_mode))
2168 ctx->fs_fragmented_dir++;
2170 ctx->fs_fragmented++;
2174 e2fsck_clear_inode(ctx, ino, inode, E2F_FLAG_RESTART,
2179 if (inode->i_flags & EXT2_INDEX_FL) {
2180 if (handle_htree(ctx, pctx, ino, inode, block_buf)) {
2181 inode->i_flags &= ~EXT2_INDEX_FL;
2185 e2fsck_add_dx_dir(ctx, ino, pb.last_block+1);
2190 if (!pb.num_blocks && pb.is_dir) {
2191 if (fix_problem(ctx, PR_1_ZERO_LENGTH_DIR, pctx)) {
2192 e2fsck_clear_inode(ctx, ino, inode, 0, "check_blocks");
2193 ctx->fs_directory_count--;
2198 if (ino == EXT2_ROOT_INO || ino >= EXT2_FIRST_INODE(ctx->fs->super)) {
2199 quota_data_add(ctx->qctx, inode, ino,
2200 pb.num_blocks * fs->blocksize);
2201 quota_data_inodes(ctx->qctx, inode, ino, +1);
2204 if (!(fs->super->s_feature_ro_compat &
2205 EXT4_FEATURE_RO_COMPAT_HUGE_FILE) ||
2206 !(inode->i_flags & EXT4_HUGE_FILE_FL))
2207 pb.num_blocks *= (fs->blocksize / 512);
2208 pb.num_blocks *= EXT2FS_CLUSTER_RATIO(fs);
2210 printf("inode %u, i_size = %u, last_block = %lld, i_blocks=%llu, num_blocks = %llu\n",
2211 ino, inode->i_size, pb.last_block, ext2fs_inode_i_blocks(fs, inode),
2215 int nblock = inode->i_size >> EXT2_BLOCK_SIZE_BITS(fs->super);
2216 if (inode->i_size & (fs->blocksize - 1))
2218 else if (nblock > (pb.last_block + 1))
2220 else if (nblock < (pb.last_block + 1)) {
2221 if (((pb.last_block + 1) - nblock) >
2222 fs->super->s_prealloc_dir_blocks)
2226 e2_blkcnt_t blkpg = ctx->blocks_per_page;
2228 size = EXT2_I_SIZE(inode);
2229 if ((pb.last_init_lblock >= 0) &&
2230 /* allow allocated blocks to end of PAGE_SIZE */
2231 (size < (__u64)pb.last_init_lblock * fs->blocksize) &&
2232 (pb.last_init_lblock / blkpg * blkpg != pb.last_init_lblock ||
2233 size < (__u64)(pb.last_init_lblock & ~(blkpg-1)) *
2236 else if (!(extent_fs && (inode->i_flags & EXT4_EXTENTS_FL)) &&
2237 size > ext2_max_sizes[fs->super->s_log_block_size])
2238 /* too big for a direct/indirect-mapped file */
2240 else if ((extent_fs && (inode->i_flags & EXT4_EXTENTS_FL)) &&
2242 ((1ULL << (32 + EXT2_BLOCK_SIZE_BITS(fs->super))) - 1))
2243 /* too big for an extent-based file - 32bit ee_block */
2246 /* i_size for symlinks is checked elsewhere */
2247 if (bad_size && !LINUX_S_ISLNK(inode->i_mode)) {
2248 pctx->num = (pb.last_block+1) * fs->blocksize;
2249 pctx->group = bad_size;
2250 if (fix_problem(ctx, PR_1_BAD_I_SIZE, pctx)) {
2251 inode->i_size = pctx->num;
2252 if (!LINUX_S_ISDIR(inode->i_mode))
2253 inode->i_size_high = pctx->num >> 32;
2258 if (LINUX_S_ISREG(inode->i_mode) &&
2259 ext2fs_needs_large_file_feature(EXT2_I_SIZE(inode)))
2261 if ((pb.num_blocks != ext2fs_inode_i_blocks(fs, inode)) ||
2262 ((fs->super->s_feature_ro_compat &
2263 EXT4_FEATURE_RO_COMPAT_HUGE_FILE) &&
2264 (inode->i_flags & EXT4_HUGE_FILE_FL) &&
2265 (inode->osd2.linux2.l_i_blocks_hi != 0))) {
2266 pctx->num = pb.num_blocks;
2267 if (fix_problem(ctx, PR_1_BAD_I_BLOCKS, pctx)) {
2268 inode->i_blocks = pb.num_blocks;
2269 inode->osd2.linux2.l_i_blocks_hi = pb.num_blocks >> 32;
2275 if (ctx->dirs_to_hash && pb.is_dir &&
2276 !(inode->i_flags & EXT2_INDEX_FL) &&
2277 ((inode->i_size / fs->blocksize) >= 3))
2278 ext2fs_u32_list_add(ctx->dirs_to_hash, ino);
2282 e2fsck_write_inode(ctx, ino, inode, "check_blocks");
2287 * Helper function called by process block when an illegal block is
2288 * found. It returns a description about why the block is illegal
2290 static char *describe_illegal_block(ext2_filsys fs, blk64_t block)
2294 static char problem[80];
2296 super = fs->super->s_first_data_block;
2297 strcpy(problem, "PROGRAMMING ERROR: Unknown reason for illegal block");
2298 if (block < super) {
2299 sprintf(problem, "< FIRSTBLOCK (%u)", super);
2301 } else if (block >= ext2fs_blocks_count(fs->super)) {
2302 sprintf(problem, "> BLOCKS (%u)", ext2fs_blocks_count(fs->super));
2305 for (i = 0; i < fs->group_desc_count; i++) {
2306 if (block == super) {
2307 sprintf(problem, "is the superblock in group %d", i);
2310 if (block > super &&
2311 block <= (super + fs->desc_blocks)) {
2312 sprintf(problem, "is in the group descriptors "
2316 if (block == ext2fs_block_bitmap_loc(fs, i)) {
2317 sprintf(problem, "is the block bitmap of group %d", i);
2320 if (block == ext2fs_inode_bitmap_loc(fs, i)) {
2321 sprintf(problem, "is the inode bitmap of group %d", i);
2324 if (block >= ext2fs_inode_table_loc(fs, i) &&
2325 (block < ext2fs_inode_table_loc(fs, i)
2326 + fs->inode_blocks_per_group)) {
2327 sprintf(problem, "is in the inode table of group %d",
2331 super += fs->super->s_blocks_per_group;
2338 * This is a helper function for check_blocks().
2340 static int process_block(ext2_filsys fs,
2342 e2_blkcnt_t blockcnt,
2343 blk64_t ref_block EXT2FS_ATTR((unused)),
2344 int ref_offset EXT2FS_ATTR((unused)),
2347 struct process_block_struct *p;
2348 struct problem_context *pctx;
2349 blk64_t blk = *block_nr;
2351 problem_t problem = 0;
2354 p = (struct process_block_struct *) priv_data;
2358 if (p->compressed && (blk == EXT2FS_COMPRESSED_BLKADDR)) {
2359 /* todo: Check that the comprblk_fl is high, that the
2360 blkaddr pattern looks right (all non-holes up to
2361 first EXT2FS_COMPRESSED_BLKADDR, then all
2362 EXT2FS_COMPRESSED_BLKADDR up to end of cluster),
2363 that the feature_incompat bit is high, and that the
2364 inode is a regular file. If we're doing a "full
2365 check" (a concept introduced to e2fsck by e2compr,
2366 meaning that we look at data blocks as well as
2367 metadata) then call some library routine that
2368 checks the compressed data. I'll have to think
2369 about this, because one particularly important
2370 problem to be able to fix is to recalculate the
2371 cluster size if necessary. I think that perhaps
2372 we'd better do most/all e2compr-specific checks
2373 separately, after the non-e2compr checks. If not
2374 doing a full check, it may be useful to test that
2375 the personality is linux; e.g. if it isn't then
2376 perhaps this really is just an illegal block. */
2381 * For a directory, add logical block zero for processing even if it's
2382 * not mapped or we'll be perennially stuck with broken "." and ".."
2385 if (p->is_dir && blockcnt == 0 && blk == 0) {
2386 pctx->errcode = ext2fs_add_dir_block2(fs->dblist, p->ino, 0, 0);
2387 if (pctx->errcode) {
2389 pctx->num = blockcnt;
2390 goto failed_add_dir_block;
2399 printf("Process_block, inode %lu, block %u, #%d\n", p->ino, blk,
2404 * Simplistic fragmentation check. We merely require that the
2405 * file be contiguous. (Which can never be true for really
2406 * big files that are greater than a block group.)
2408 if (!HOLE_BLKADDR(p->previous_block) && p->ino != EXT2_RESIZE_INO) {
2409 if (p->previous_block+1 != blk) {
2410 if (ctx->options & E2F_OPT_FRAGCHECK) {
2418 printf(_("%6lu(%c): expecting %6lu "
2419 "got phys %6lu (blkcnt %lld)\n"),
2420 (unsigned long) pctx->ino, type,
2421 (unsigned long) p->previous_block+1,
2422 (unsigned long) blk,
2429 if (p->is_dir && blockcnt > (1 << (21 - fs->super->s_log_block_size)))
2430 problem = PR_1_TOOBIG_DIR;
2431 if (p->is_reg && p->num_blocks+1 >= p->max_blocks)
2432 problem = PR_1_TOOBIG_REG;
2433 if (!p->is_dir && !p->is_reg && blockcnt > 0)
2434 problem = PR_1_TOOBIG_SYMLINK;
2436 if (blk < fs->super->s_first_data_block ||
2437 blk >= ext2fs_blocks_count(fs->super))
2438 problem = PR_1_ILLEGAL_BLOCK_NUM;
2441 p->num_illegal_blocks++;
2442 if (!p->suppress && (p->num_illegal_blocks % 12) == 0) {
2443 if (fix_problem(ctx, PR_1_TOO_MANY_BAD_BLOCKS, pctx)) {
2447 if (fix_problem(ctx, PR_1_SUPPRESS_MESSAGES, pctx)) {
2449 set_latch_flags(PR_LATCH_BLOCK,
2454 pctx->blkcount = blockcnt;
2455 if (fix_problem(ctx, problem, pctx)) {
2456 blk = *block_nr = 0;
2457 ret_code = BLOCK_CHANGED;
2458 p->inode_modified = 1;
2460 * If the directory block is too big and is beyond the
2461 * end of the FS, don't bother trying to add it for
2462 * processing -- the kernel would never have created a
2463 * directory this large, and we risk an ENOMEM abort.
2464 * In any case, the toobig handler for extent-based
2465 * directories also doesn't feed toobig blocks to
2468 if (problem == PR_1_TOOBIG_DIR)
2475 if (p->ino == EXT2_RESIZE_INO) {
2477 * The resize inode has already be sanity checked
2478 * during pass #0 (the superblock checks). All we
2479 * have to do is mark the double indirect block as
2480 * being in use; all of the other blocks are handled
2481 * by mark_table_blocks()).
2483 if (blockcnt == BLOCK_COUNT_DIND)
2484 mark_block_used(ctx, blk);
2486 } else if (!(ctx->fs->cluster_ratio_bits &&
2487 p->previous_block &&
2488 (EXT2FS_B2C(ctx->fs, blk) ==
2489 EXT2FS_B2C(ctx->fs, p->previous_block)) &&
2490 (blk & EXT2FS_CLUSTER_MASK(ctx->fs)) ==
2491 ((unsigned) blockcnt & EXT2FS_CLUSTER_MASK(ctx->fs)))) {
2492 mark_block_used(ctx, blk);
2496 p->last_block = blockcnt;
2497 p->previous_block = blk;
2499 if (p->is_dir && (blockcnt >= 0)) {
2500 while (++p->last_db_block < blockcnt) {
2501 pctx->errcode = ext2fs_add_dir_block2(fs->dblist,
2504 if (pctx->errcode) {
2506 pctx->num = p->last_db_block;
2507 goto failed_add_dir_block;
2510 pctx->errcode = ext2fs_add_dir_block2(fs->dblist, p->ino,
2512 if (pctx->errcode) {
2514 pctx->num = blockcnt;
2515 failed_add_dir_block:
2516 fix_problem(ctx, PR_1_ADD_DBLOCK, pctx);
2517 /* Should never get here */
2518 ctx->flags |= E2F_FLAG_ABORT;
2525 static int process_bad_block(ext2_filsys fs,
2527 e2_blkcnt_t blockcnt,
2528 blk64_t ref_block EXT2FS_ATTR((unused)),
2529 int ref_offset EXT2FS_ATTR((unused)),
2532 struct process_block_struct *p;
2533 blk64_t blk = *block_nr;
2534 blk64_t first_block;
2536 struct problem_context *pctx;
2540 * Note: This function processes blocks for the bad blocks
2541 * inode, which is never compressed. So we don't use HOLE_BLKADDR().
2547 p = (struct process_block_struct *) priv_data;
2551 pctx->ino = EXT2_BAD_INO;
2553 pctx->blkcount = blockcnt;
2555 if ((blk < fs->super->s_first_data_block) ||
2556 (blk >= ext2fs_blocks_count(fs->super))) {
2557 if (fix_problem(ctx, PR_1_BB_ILLEGAL_BLOCK_NUM, pctx)) {
2559 return BLOCK_CHANGED;
2565 if (ext2fs_test_block_bitmap2(p->fs_meta_blocks, blk)) {
2567 if (fix_problem(ctx, PR_1_BB_FS_BLOCK, pctx)) {
2569 return BLOCK_CHANGED;
2571 } else if (ext2fs_test_block_bitmap2(ctx->block_found_map,
2574 if (fix_problem(ctx, PR_1_BBINODE_BAD_METABLOCK,
2577 return BLOCK_CHANGED;
2579 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
2582 mark_block_used(ctx, blk);
2586 printf ("DEBUG: Marking %u as bad.\n", blk);
2588 ctx->fs_badblocks_count++;
2590 * If the block is not used, then mark it as used and return.
2591 * If it is already marked as found, this must mean that
2592 * there's an overlap between the filesystem table blocks
2593 * (bitmaps and inode table) and the bad block list.
2595 if (!ext2fs_test_block_bitmap2(ctx->block_found_map, blk)) {
2596 ext2fs_mark_block_bitmap2(ctx->block_found_map, blk);
2600 * Try to find the where the filesystem block was used...
2602 first_block = fs->super->s_first_data_block;
2604 for (i = 0; i < fs->group_desc_count; i++ ) {
2607 if (!ext2fs_bg_has_super(fs, i))
2609 if (blk == first_block) {
2611 if (fix_problem(ctx,
2612 PR_1_BAD_PRIMARY_SUPERBLOCK,
2615 return BLOCK_CHANGED;
2619 fix_problem(ctx, PR_1_BAD_SUPERBLOCK, pctx);
2622 if ((blk > first_block) &&
2623 (blk <= first_block + fs->desc_blocks)) {
2625 pctx->blk = *block_nr;
2626 if (fix_problem(ctx,
2627 PR_1_BAD_PRIMARY_GROUP_DESCRIPTOR, pctx)) {
2629 return BLOCK_CHANGED;
2633 fix_problem(ctx, PR_1_BAD_GROUP_DESCRIPTORS, pctx);
2637 if (blk == ext2fs_block_bitmap_loc(fs, i)) {
2638 if (fix_problem(ctx, PR_1_BB_BAD_BLOCK, pctx)) {
2639 ctx->invalid_block_bitmap_flag[i]++;
2640 ctx->invalid_bitmaps++;
2644 if (blk == ext2fs_inode_bitmap_loc(fs, i)) {
2645 if (fix_problem(ctx, PR_1_IB_BAD_BLOCK, pctx)) {
2646 ctx->invalid_inode_bitmap_flag[i]++;
2647 ctx->invalid_bitmaps++;
2651 if ((blk >= ext2fs_inode_table_loc(fs, i)) &&
2652 (blk < (ext2fs_inode_table_loc(fs, i) +
2653 fs->inode_blocks_per_group))) {
2655 * If there are bad blocks in the inode table,
2656 * the inode scan code will try to do
2657 * something reasonable automatically.
2661 first_block += fs->super->s_blocks_per_group;
2664 * If we've gotten to this point, then the only
2665 * possibility is that the bad block inode meta data
2666 * is using a bad block.
2668 if ((blk == p->inode->i_block[EXT2_IND_BLOCK]) ||
2669 (blk == p->inode->i_block[EXT2_DIND_BLOCK]) ||
2670 (blk == p->inode->i_block[EXT2_TIND_BLOCK])) {
2672 if (fix_problem(ctx, PR_1_BBINODE_BAD_METABLOCK, pctx)) {
2674 return BLOCK_CHANGED;
2676 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
2683 /* Warn user that the block wasn't claimed */
2684 fix_problem(ctx, PR_1_PROGERR_CLAIMED_BLOCK, pctx);
2689 static void new_table_block(e2fsck_t ctx, blk64_t first_block, dgrp_t group,
2690 const char *name, int num, blk64_t *new_block)
2692 ext2_filsys fs = ctx->fs;
2694 blk64_t old_block = *new_block;
2697 unsigned flexbg_size;
2700 struct problem_context pctx;
2702 clear_problem_context(&pctx);
2705 pctx.blk = old_block;
2709 * For flex_bg filesystems, first try to allocate the metadata
2710 * within the flex_bg, and if that fails then try finding the
2711 * space anywhere in the filesystem.
2713 is_flexbg = EXT2_HAS_INCOMPAT_FEATURE(fs->super,
2714 EXT4_FEATURE_INCOMPAT_FLEX_BG);
2716 flexbg_size = 1 << fs->super->s_log_groups_per_flex;
2717 flexbg = group / flexbg_size;
2718 first_block = ext2fs_group_first_block2(fs,
2719 flexbg_size * flexbg);
2720 last_grp = group | (flexbg_size - 1);
2721 if (last_grp >= fs->group_desc_count)
2722 last_grp = fs->group_desc_count - 1;
2723 last_block = ext2fs_group_last_block2(fs, last_grp);
2725 last_block = ext2fs_group_last_block2(fs, group);
2726 pctx.errcode = ext2fs_get_free_blocks2(fs, first_block, last_block,
2727 num, ctx->block_found_map,
2729 if (is_flexbg && (pctx.errcode == EXT2_ET_BLOCK_ALLOC_FAIL))
2730 pctx.errcode = ext2fs_get_free_blocks2(fs,
2731 fs->super->s_first_data_block,
2732 ext2fs_blocks_count(fs->super),
2733 num, ctx->block_found_map, new_block);
2736 fix_problem(ctx, PR_1_RELOC_BLOCK_ALLOCATE, &pctx);
2737 ext2fs_unmark_valid(fs);
2738 ctx->flags |= E2F_FLAG_ABORT;
2741 pctx.errcode = ext2fs_get_mem(fs->blocksize, &buf);
2743 fix_problem(ctx, PR_1_RELOC_MEMORY_ALLOCATE, &pctx);
2744 ext2fs_unmark_valid(fs);
2745 ctx->flags |= E2F_FLAG_ABORT;
2748 ext2fs_mark_super_dirty(fs);
2749 fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY;
2750 pctx.blk2 = *new_block;
2751 fix_problem(ctx, (old_block ? PR_1_RELOC_FROM_TO :
2752 PR_1_RELOC_TO), &pctx);
2754 for (i = 0; i < num; i++) {
2756 ext2fs_mark_block_bitmap2(ctx->block_found_map, (*new_block)+i);
2758 pctx.errcode = io_channel_read_blk64(fs->io,
2759 old_block + i, 1, buf);
2761 fix_problem(ctx, PR_1_RELOC_READ_ERR, &pctx);
2763 memset(buf, 0, fs->blocksize);
2765 pctx.blk = (*new_block) + i;
2766 pctx.errcode = io_channel_write_blk64(fs->io, pctx.blk,
2769 fix_problem(ctx, PR_1_RELOC_WRITE_ERR, &pctx);
2771 ext2fs_free_mem(&buf);
2775 * This routine gets called at the end of pass 1 if bad blocks are
2776 * detected in the superblock, group descriptors, inode_bitmaps, or
2777 * block bitmaps. At this point, all of the blocks have been mapped
2778 * out, so we can try to allocate new block(s) to replace the bad
2781 static void handle_fs_bad_blocks(e2fsck_t ctx)
2783 ext2_filsys fs = ctx->fs;
2785 blk64_t first_block;
2788 for (i = 0; i < fs->group_desc_count; i++) {
2789 first_block = ext2fs_group_first_block2(fs, i);
2791 if (ctx->invalid_block_bitmap_flag[i]) {
2792 new_blk = ext2fs_block_bitmap_loc(fs, i);
2793 new_table_block(ctx, first_block, i, _("block bitmap"),
2795 ext2fs_block_bitmap_loc_set(fs, i, new_blk);
2797 if (ctx->invalid_inode_bitmap_flag[i]) {
2798 new_blk = ext2fs_inode_bitmap_loc(fs, i);
2799 new_table_block(ctx, first_block, i, _("inode bitmap"),
2801 ext2fs_inode_bitmap_loc_set(fs, i, new_blk);
2803 if (ctx->invalid_inode_table_flag[i]) {
2804 new_blk = ext2fs_inode_table_loc(fs, i);
2805 new_table_block(ctx, first_block, i, _("inode table"),
2806 fs->inode_blocks_per_group,
2808 ext2fs_inode_table_loc_set(fs, i, new_blk);
2809 ctx->flags |= E2F_FLAG_RESTART;
2812 ctx->invalid_bitmaps = 0;
2816 * This routine marks all blocks which are used by the superblock,
2817 * group descriptors, inode bitmaps, and block bitmaps.
2819 static void mark_table_blocks(e2fsck_t ctx)
2821 ext2_filsys fs = ctx->fs;
2825 struct problem_context pctx;
2827 clear_problem_context(&pctx);
2829 for (i = 0; i < fs->group_desc_count; i++) {
2832 ext2fs_reserve_super_and_bgd(fs, i, ctx->block_found_map);
2835 * Mark the blocks used for the inode table
2837 if (ext2fs_inode_table_loc(fs, i)) {
2838 for (j = 0, b = ext2fs_inode_table_loc(fs, i);
2839 j < fs->inode_blocks_per_group;
2841 if (ext2fs_test_block_bitmap2(ctx->block_found_map,
2844 if (!ctx->invalid_inode_table_flag[i] &&
2846 PR_1_ITABLE_CONFLICT, &pctx)) {
2847 ctx->invalid_inode_table_flag[i]++;
2848 ctx->invalid_bitmaps++;
2851 ext2fs_mark_block_bitmap2(ctx->block_found_map,
2858 * Mark block used for the block bitmap
2860 if (ext2fs_block_bitmap_loc(fs, i)) {
2861 if (ext2fs_test_block_bitmap2(ctx->block_found_map,
2862 ext2fs_block_bitmap_loc(fs, i))) {
2863 pctx.blk = ext2fs_block_bitmap_loc(fs, i);
2864 if (fix_problem(ctx, PR_1_BB_CONFLICT, &pctx)) {
2865 ctx->invalid_block_bitmap_flag[i]++;
2866 ctx->invalid_bitmaps++;
2869 ext2fs_mark_block_bitmap2(ctx->block_found_map,
2870 ext2fs_block_bitmap_loc(fs, i));
2875 * Mark block used for the inode bitmap
2877 if (ext2fs_inode_bitmap_loc(fs, i)) {
2878 if (ext2fs_test_block_bitmap2(ctx->block_found_map,
2879 ext2fs_inode_bitmap_loc(fs, i))) {
2880 pctx.blk = ext2fs_inode_bitmap_loc(fs, i);
2881 if (fix_problem(ctx, PR_1_IB_CONFLICT, &pctx)) {
2882 ctx->invalid_inode_bitmap_flag[i]++;
2883 ctx->invalid_bitmaps++;
2886 ext2fs_mark_block_bitmap2(ctx->block_found_map,
2887 ext2fs_inode_bitmap_loc(fs, i));
2894 * Thes subroutines short circuits ext2fs_get_blocks and
2895 * ext2fs_check_directory; we use them since we already have the inode
2896 * structure, so there's no point in letting the ext2fs library read
2899 static errcode_t pass1_get_blocks(ext2_filsys fs, ext2_ino_t ino,
2902 e2fsck_t ctx = (e2fsck_t) fs->priv_data;
2905 if ((ino != ctx->stashed_ino) || !ctx->stashed_inode)
2906 return EXT2_ET_CALLBACK_NOTHANDLED;
2908 for (i=0; i < EXT2_N_BLOCKS; i++)
2909 blocks[i] = ctx->stashed_inode->i_block[i];
2913 static errcode_t pass1_read_inode(ext2_filsys fs, ext2_ino_t ino,
2914 struct ext2_inode *inode)
2916 e2fsck_t ctx = (e2fsck_t) fs->priv_data;
2918 if ((ino != ctx->stashed_ino) || !ctx->stashed_inode)
2919 return EXT2_ET_CALLBACK_NOTHANDLED;
2920 *inode = *ctx->stashed_inode;
2924 static errcode_t pass1_write_inode(ext2_filsys fs, ext2_ino_t ino,
2925 struct ext2_inode *inode)
2927 e2fsck_t ctx = (e2fsck_t) fs->priv_data;
2929 if ((ino == ctx->stashed_ino) && ctx->stashed_inode &&
2930 (inode != ctx->stashed_inode))
2931 *ctx->stashed_inode = *inode;
2932 return EXT2_ET_CALLBACK_NOTHANDLED;
2935 static errcode_t pass1_check_directory(ext2_filsys fs, ext2_ino_t ino)
2937 e2fsck_t ctx = (e2fsck_t) fs->priv_data;
2939 if ((ino != ctx->stashed_ino) || !ctx->stashed_inode)
2940 return EXT2_ET_CALLBACK_NOTHANDLED;
2942 if (!LINUX_S_ISDIR(ctx->stashed_inode->i_mode))
2943 return EXT2_ET_NO_DIRECTORY;
2947 static errcode_t e2fsck_get_alloc_block(ext2_filsys fs, blk64_t goal,
2950 e2fsck_t ctx = (e2fsck_t) fs->priv_data;
2954 if (ctx->block_found_map) {
2955 retval = ext2fs_new_block2(fs, goal, ctx->block_found_map,
2959 if (fs->block_map) {
2960 ext2fs_mark_block_bitmap2(fs->block_map, new_block);
2961 ext2fs_mark_bb_dirty(fs);
2964 if (!fs->block_map) {
2965 retval = ext2fs_read_block_bitmap(fs);
2970 retval = ext2fs_new_block2(fs, goal, 0, &new_block);
2979 static void e2fsck_block_alloc_stats(ext2_filsys fs, blk64_t blk, int inuse)
2981 e2fsck_t ctx = (e2fsck_t) fs->priv_data;
2983 if (ctx->block_found_map) {
2985 ext2fs_mark_block_bitmap2(ctx->block_found_map, blk);
2987 ext2fs_unmark_block_bitmap2(ctx->block_found_map, blk);
2991 void e2fsck_use_inode_shortcuts(e2fsck_t ctx, int use_shortcuts)
2993 ext2_filsys fs = ctx->fs;
2995 if (use_shortcuts) {
2996 fs->get_blocks = pass1_get_blocks;
2997 fs->check_directory = pass1_check_directory;
2998 fs->read_inode = pass1_read_inode;
2999 fs->write_inode = pass1_write_inode;
3000 ctx->stashed_ino = 0;
3003 fs->check_directory = 0;
3005 fs->write_inode = 0;
3009 void e2fsck_intercept_block_allocations(e2fsck_t ctx)
3011 ext2fs_set_alloc_block_callback(ctx->fs, e2fsck_get_alloc_block, 0);
3012 ext2fs_set_block_alloc_stats_callback(ctx->fs,
3013 e2fsck_block_alloc_stats, 0);