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 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); */
81 struct process_block_struct {
83 unsigned is_dir:1, is_reg:1, clear:1, suppress:1,
84 fragmented:1, compressed:1, bbcheck:1,
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;
100 struct process_inode_block {
102 struct ext2_inode inode;
105 struct scan_callback_struct {
111 * For the inodes to process list.
113 static struct process_inode_block *inodes_to_process;
114 static int process_inode_count;
116 static __u64 ext2_max_sizes[EXT2_MAX_BLOCK_LOG_SIZE -
117 EXT2_MIN_BLOCK_LOG_SIZE + 1];
120 * Free all memory allocated by pass1 in preparation for restarting
123 static void unwind_pass1(ext2_filsys fs EXT2FS_ATTR((unused)))
125 ext2fs_free_mem(&inodes_to_process);
126 inodes_to_process = 0;
130 * Check to make sure a device inode is real. Returns 1 if the device
131 * checks out, 0 if not.
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
137 int e2fsck_pass1_check_device_inode(ext2_filsys fs EXT2FS_ATTR((unused)),
138 struct ext2_inode *inode)
143 * If the index flag is set, then this is a bogus
146 if (inode->i_flags & EXT2_INDEX_FL)
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...
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])
169 * Check to make sure a symlink inode is real. Returns 1 if the symlink
170 * checks out, 0 if not.
172 int e2fsck_pass1_check_symlink(ext2_filsys fs, ext2_ino_t ino,
173 struct ext2_inode *inode, char *buf)
178 ext2_extent_handle_t handle;
179 struct ext2_extent_info info;
180 struct ext2fs_extent extent;
183 if ((inode->i_size_high || inode->i_size == 0) ||
184 (inode->i_flags & EXT2_INDEX_FL))
187 if (inode->i_flags & EXT4_EXTENTS_FL) {
188 if (inode->i_flags & EXT4_INLINE_DATA_FL)
190 if (inode->i_size > fs->blocksize)
192 if (ext2fs_extent_open2(fs, ino, inode, &handle))
195 if (ext2fs_extent_get_info(handle, &info) ||
196 (info.num_entries != 1) ||
197 (info.max_depth != 0))
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)))
207 ext2fs_extent_free(handle);
211 if (inode->i_flags & EXT4_INLINE_DATA_FL) {
214 if (ext2fs_inline_data_size(fs, ino, &inline_size))
216 if (inode->i_size != inline_size)
222 blocks = ext2fs_inode_data_blocks2(fs, inode);
224 if (inode->i_flags & EXT4_INLINE_DATA_FL)
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)))
232 for (i = 1; i < EXT2_N_BLOCKS; i++)
233 if (inode->i_block[i])
236 if (io_channel_read_blk64(fs->io, inode->i_block[0], 1, buf))
239 if (inode->i_flags & EXT4_ENCRYPT_FL) {
240 len = ext2fs_le32_to_cpu(*((__u32 *)buf)) + 4;
242 len = strnlen(buf, fs->blocksize);
244 if (len == fs->blocksize)
246 } else if (inode->i_flags & EXT4_INLINE_DATA_FL) {
247 char *inline_buf = NULL;
248 size_t inline_sz = 0;
250 if (ext2fs_inline_data_size(fs, ino, &inline_sz))
252 if (inode->i_size != inline_sz)
254 if (ext2fs_get_mem(inline_sz + 1, &inline_buf))
257 if (ext2fs_inline_data_get(fs, ino, inode, inline_buf, NULL))
259 inline_buf[inline_sz] = 0;
260 len = strnlen(inline_buf, inline_sz);
261 if (len != inline_sz)
265 ext2fs_free_mem(&inline_buf);
268 if (inode->i_size >= sizeof(inode->i_block))
271 len = strnlen((char *)inode->i_block, sizeof(inode->i_block));
272 if (len == sizeof(inode->i_block))
275 if (len != inode->i_size)
276 if ((inode->i_flags & EXT4_ENCRYPT_FL) == 0)
282 * If the extents or inlinedata flags are set on the inode, offer to clear 'em.
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)
288 if (!(pctx->inode->i_flags & BAD_SPECIAL_FLAGS))
291 if (!fix_problem(ctx, PR_1_SPECIAL_EXTENTS_IDATA, pctx))
294 pctx->inode->i_flags &= ~BAD_SPECIAL_FLAGS;
295 e2fsck_write_inode(ctx, pctx->ino, pctx->inode, "pass1");
297 #undef BAD_SPECIAL_FLAGS
300 * If the immutable (or append-only) flag is set on the inode, offer
303 #define BAD_SPECIAL_FLAGS (EXT2_IMMUTABLE_FL | EXT2_APPEND_FL)
304 static void check_immutable(e2fsck_t ctx, struct problem_context *pctx)
306 if (!(pctx->inode->i_flags & BAD_SPECIAL_FLAGS))
309 if (!fix_problem(ctx, PR_1_SET_IMMUTABLE, pctx))
312 pctx->inode->i_flags &= ~BAD_SPECIAL_FLAGS;
313 e2fsck_write_inode(ctx, pctx->ino, pctx->inode, "pass1");
317 * If device, fifo or socket, check size is zero -- if not offer to
320 static void check_size(e2fsck_t ctx, struct problem_context *pctx)
322 struct ext2_inode *inode = pctx->inode;
324 if (EXT2_I_SIZE(inode) == 0)
327 if (!fix_problem(ctx, PR_1_SET_NONZSIZE, pctx))
330 ext2fs_inode_size_set(ctx->fs, inode, 0);
331 e2fsck_write_inode(ctx, pctx->ino, pctx->inode, "pass1");
334 static void check_ea_in_inode(e2fsck_t ctx, struct problem_context *pctx)
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;
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;
352 /* scan all entry's headers first */
354 /* take finish entry 0UL into account */
355 remain = storage_size - sizeof(__u32);
357 region = region_create(0, storage_size);
359 fix_problem(ctx, PR_1_EA_ALLOC_REGION_ABORT, pctx);
361 ctx->flags |= E2F_FLAG_ABORT;
364 if (region_allocate(region, 0, sizeof(__u32))) {
365 problem = PR_1_INODE_EA_ALLOC_COLLISION;
369 while (remain >= sizeof(struct ext2_ext_attr_entry) &&
370 !EXT2_EXT_IS_LAST_ENTRY(entry)) {
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;
379 /* header eats this space */
380 remain -= sizeof(struct ext2_ext_attr_entry);
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;
389 /* attribute len eats this space */
390 remain -= EXT2_EXT_ATTR_SIZE(entry->e_name_len);
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;
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;
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;
413 hash = ext2fs_ext_attr_hash_entry(entry,
414 start + entry->e_value_offs);
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;
423 remain -= entry->e_value_size;
425 entry = EXT2_EXT_ATTR_NEXT(entry);
428 if (region_allocate(region, (char *)entry - (char *)header,
430 problem = PR_1_INODE_EA_ALLOC_COLLISION;
437 * it seems like a corruption. it's very unlikely we could repair
438 * EA(s) in automatic fashion -bzzz
440 if (problem == 0 || !fix_problem(ctx, problem, pctx))
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");
449 static void check_inode_extra_space(e2fsck_t ctx, struct problem_context *pctx)
451 struct ext2_super_block *sb = ctx->fs->super;
452 struct ext2_inode_large *inode;
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 */
463 printf("inode #%u, i_extra_size %d\n", pctx->ino,
464 inode->i_extra_isize);
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;
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
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))
477 inode->i_extra_isize = min;
478 e2fsck_write_inode_full(ctx, pctx->ino, pctx->inode,
479 EXT2_INODE_SIZE(sb), "pass1");
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);
492 * Check to see if the inode might really be a directory, despite i_mode
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]
499 static void check_is_really_dir(e2fsck_t ctx, struct problem_context *pctx,
502 struct ext2_inode *inode = pctx->inode;
503 struct ext2_dir_entry *dirent;
506 unsigned int i, rec_len, not_device = 0;
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
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)
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
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
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
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.
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)) {
548 unsigned int rec_len;
549 struct ext2_dir_entry de;
551 if (ext2fs_inline_data_size(ctx->fs, pctx->ino, &size))
554 * If the size isn't a multiple of 4, it's probably not a
560 * If the first 10 bytes don't look like a directory entry,
561 * it's probably not a directory.
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) &&
576 rec_len > EXT4_MIN_INLINE_DATA_SIZE -
577 EXT4_INLINE_DATA_DOTDOT_SIZE)
579 /* device files never have a "system.data" entry */
581 } else if (extent_fs && (inode->i_flags & EXT4_EXTENTS_FL)) {
583 if (ext2fs_bmap2(ctx->fs, pctx->ino, inode, 0, 0, 0, 0,
586 /* device files are never extent mapped */
589 for (i=0; i < EXT2_N_BLOCKS; i++) {
590 blk = inode->i_block[i];
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,
600 return; /* Invalid block, can't be dir */
602 blk = inode->i_block[0];
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.
610 if ((LINUX_S_ISCHR(inode->i_mode) || LINUX_S_ISBLK(inode->i_mode)) &&
611 (inode->i_links_count == 1) && !not_device)
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);
621 dirent = (struct ext2_dir_entry *) buf;
622 retval = ext2fs_get_rec_len(ctx->fs, dirent, &rec_len);
625 if ((ext2fs_dirent_name_len(dirent) != 1) ||
626 (dirent->name[0] != '.') ||
627 (dirent->inode != pctx->ino) ||
630 (rec_len >= ctx->fs->blocksize - 12))
633 dirent = (struct ext2_dir_entry *) (buf + rec_len);
634 retval = ext2fs_get_rec_len(ctx->fs, dirent, &rec_len);
637 if ((ext2fs_dirent_name_len(dirent) != 2) ||
638 (dirent->name[0] != '.') ||
639 (dirent->name[1] != '.') ||
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");
653 void e2fsck_setup_tdb_icount(e2fsck_t ctx, int flags,
656 unsigned int threshold;
664 profile_get_string(ctx->profile, "scratch_files", "directory", 0, 0,
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);
671 retval = ext2fs_get_num_dirs(ctx->fs, &num_dirs);
673 num_dirs = 1024; /* Guess */
675 if (!enable || !tdb_dir || access(tdb_dir, W_OK) ||
676 (threshold && num_dirs <= threshold))
679 retval = ext2fs_create_icount_tdb(ctx->fs, tdb_dir, flags, ret);
684 static errcode_t recheck_bad_inode_checksum(ext2_filsys fs, ext2_ino_t ino,
686 struct problem_context *pctx)
689 struct ext2_inode_large inode;
692 * Reread inode. If we don't see checksum error, then this inode
693 * has been fixed elsewhere.
695 ctx->stashed_ino = 0;
696 retval = ext2fs_read_inode_full(fs, ino, (struct ext2_inode *)&inode,
698 if (retval && retval != EXT2_ET_INODE_CSUM_INVALID)
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.
708 if (!fix_problem(ctx, PR_1_INODE_ONLY_CSUM_INVALID, pctx))
711 retval = ext2fs_write_inode_full(fs, ino, (struct ext2_inode *)&inode,
716 static void reserve_block_for_root_repair(e2fsck_t ctx)
720 ext2_filsys fs = ctx->fs;
722 ctx->root_repair_block = 0;
723 if (ext2fs_test_inode_bitmap2(ctx->inode_used_map, EXT2_ROOT_INO))
726 err = ext2fs_new_block2(fs, 0, ctx->block_found_map, &blk);
729 ext2fs_mark_block_bitmap2(ctx->block_found_map, blk);
730 ctx->root_repair_block = blk;
733 static void reserve_block_for_lnf_repair(e2fsck_t ctx)
737 ext2_filsys fs = ctx->fs;
738 static const char name[] = "lost+found";
741 ctx->lnf_repair_block = 0;
742 if (!ext2fs_lookup(fs, EXT2_ROOT_INO, name, sizeof(name)-1, 0, &ino))
745 err = ext2fs_new_block2(fs, 0, ctx->block_found_map, &blk);
748 ext2fs_mark_block_bitmap2(ctx->block_found_map, blk);
749 ctx->lnf_repair_block = blk;
752 static errcode_t get_inline_data_ea_size(ext2_filsys fs, ext2_ino_t ino,
756 struct ext2_xattr_handle *handle;
759 retval = ext2fs_xattrs_open(fs, ino, &handle);
763 retval = ext2fs_xattrs_read(handle);
767 retval = ext2fs_xattr_get(handle, "system.data", &p, sz);
772 (void) ext2fs_xattrs_close(&handle);
776 static void finish_processing_inode(e2fsck_t ctx, ext2_ino_t ino,
777 struct problem_context *pctx,
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.
788 pctx->errcode = recheck_bad_inode_checksum(ctx->fs, ino, ctx, pctx);
790 ctx->flags |= E2F_FLAG_ABORT;
792 #define FINISH_INODE_LOOP(ctx, ino, pctx, failed_csum) \
794 finish_processing_inode((ctx), (ino), (pctx), (failed_csum)); \
795 if ((ctx)->flags & E2F_FLAG_ABORT) \
799 static int could_be_block_map(ext2_filsys fs, struct ext2_inode *inode)
804 for (i = 0; i < EXT2_N_BLOCKS; i++) {
805 x = inode->i_block[i];
806 #ifdef WORDS_BIGENDIAN
807 x = ext2fs_swab32(x);
809 if (x >= ext2fs_blocks_count(fs->super))
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.
820 static int fix_inline_data_extents_file(e2fsck_t ctx,
822 struct ext2_inode *inode,
824 struct problem_context *pctx)
826 size_t max_inline_ea_size;
827 ext2_filsys fs = ctx->fs;
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))
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);
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;
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);
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;
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?
874 if (could_be_block_map(fs, inode) &&
875 fix_problem(ctx, PR_1_CLEAR_EXTENT_INLINE_DATA_FLAGS, pctx)) {
876 #ifdef WORDS_BIGENDIAN
879 for (i = 0; i < EXT2_N_BLOCKS; i++)
880 inode->i_block[i] = ext2fs_swab32(inode->i_block[i]);
883 inode->i_flags &= ~(EXT4_EXTENTS_FL | EXT4_INLINE_DATA_FL);
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");
896 e2fsck_write_inode(ctx, ino, inode, "pass1");
901 void e2fsck_pass1(e2fsck_t ctx)
905 ext2_filsys fs = ctx->fs;
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;
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;
918 unsigned int save_type;
919 int imagic_fs, extent_fs, inlinedata_fs;
920 int low_dtime_check = 1;
924 init_resource_track(&rtrack, ctx->fs->io);
925 clear_problem_context(&pctx);
927 if (!(ctx->options & E2F_OPT_PREEN))
928 fix_problem(ctx, PR_1_PASS_HEADER, &pctx);
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;
937 mtrace_print("Pass 1");
940 #define EXT2_BPP(bits) (1ULL << ((bits) - 2))
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;
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);
957 * Allocate bitmaps structures
959 pctx.errcode = e2fsck_allocate_inode_bitmap(fs, _("in-use inode map"),
960 EXT2FS_BMAP64_RBTREE,
962 &ctx->inode_used_map);
965 fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx);
966 ctx->flags |= E2F_FLAG_ABORT;
969 pctx.errcode = e2fsck_allocate_inode_bitmap(fs,
970 _("directory inode map"),
971 EXT2FS_BMAP64_AUTODIR,
972 "inode_dir_map", &ctx->inode_dir_map);
975 fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx);
976 ctx->flags |= E2F_FLAG_ABORT;
979 pctx.errcode = e2fsck_allocate_inode_bitmap(fs,
980 _("regular file inode map"), EXT2FS_BMAP64_RBTREE,
981 "inode_reg_map", &ctx->inode_reg_map);
984 fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx);
985 ctx->flags |= E2F_FLAG_ABORT;
988 pctx.errcode = e2fsck_allocate_subcluster_bitmap(fs,
989 _("in-use block map"), EXT2FS_BMAP64_RBTREE,
990 "block_found_map", &ctx->block_found_map);
993 fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, &pctx);
994 ctx->flags |= E2F_FLAG_ABORT;
997 pctx.errcode = e2fsck_allocate_block_bitmap(fs,
998 _("metadata block map"), EXT2FS_BMAP64_RBTREE,
999 "block_metadata_map", &ctx->block_metadata_map);
1002 fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, &pctx);
1003 ctx->flags |= E2F_FLAG_ABORT;
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;
1016 fix_problem(ctx, PR_1_ALLOCATE_ICOUNT, &pctx);
1017 ctx->flags |= E2F_FLAG_ABORT;
1020 inode_size = EXT2_INODE_SIZE(fs->super);
1021 inode = (struct ext2_inode *)
1022 e2fsck_allocate_memory(ctx, inode_size, "scratch inode");
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;
1031 pctx.errcode = ext2fs_init_dblist(fs, 0);
1033 fix_problem(ctx, PR_1_ALLOCATE_DBCOUNT, &pctx);
1034 ctx->flags |= E2F_FLAG_ABORT;
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.
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);
1052 mark_table_blocks(ctx);
1053 pctx.errcode = ext2fs_convert_subcluster_bitmap(fs,
1054 &ctx->block_found_map);
1056 fix_problem(ctx, PR_1_CONVERT_SUBCLUSTER, &pctx);
1057 ctx->flags |= E2F_FLAG_ABORT;
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,
1068 ehandler_operation(old_op);
1070 fix_problem(ctx, PR_1_ISCAN_ERROR, &pctx);
1071 ctx->flags |= E2F_FLAG_ABORT;
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)))
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;
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);
1095 /* Set up ctx->lost_and_found if possible */
1096 (void) e2fsck_get_lost_and_found(ctx, 0);
1099 if (ino % (fs->super->s_inodes_per_group * 4) == 1) {
1100 if (e2fsck_mmp_update(fs))
1101 fatal_error(ctx, 0);
1103 old_op = ehandler_operation(_("getting next inode from scan"));
1104 pctx.errcode = ext2fs_get_next_inode_full(scan, &ino,
1106 ehandler_operation(old_op);
1107 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
1109 if (pctx.errcode == EXT2_ET_BAD_BLOCK_IN_INODE_TABLE) {
1111 * If badblocks says badblocks is bad, offer to clear
1112 * the list, update the in-core bb list, and restart
1115 if (ino == EXT2_BAD_INO &&
1116 fix_problem(ctx, PR_1_BADBLOCKS_IN_BADBLOCKS,
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);
1126 fix_problem(ctx, PR_1_ISCAN_ERROR,
1128 ctx->flags |= E2F_FLAG_ABORT;
1131 err = ext2fs_inode_scan_goto_blockgroup(scan,
1134 fix_problem(ctx, PR_1_ISCAN_ERROR,
1136 ctx->flags |= E2F_FLAG_ABORT;
1141 if (!ctx->inode_bb_map)
1143 ext2fs_mark_inode_bitmap2(ctx->inode_bb_map, ino);
1144 ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino);
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;
1158 ctx->stashed_ino = ino;
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)) {
1165 e2fsck_clear_inode(ctx, ino, inode, 0, "pass1");
1167 failed_csum = pctx.errcode != 0;
1169 if (inode->i_links_count) {
1170 pctx.errcode = ext2fs_icount_store(ctx->inode_link_info,
1171 ino, inode->i_links_count);
1173 pctx.num = inode->i_links_count;
1174 fix_problem(ctx, PR_1_ICOUNT_STORE, &pctx);
1175 ctx->flags |= E2F_FLAG_ABORT;
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,
1187 /* skip FINISH_INODE_LOOP */
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))) {
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);
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 */
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))) {
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);
1228 /* Everything is awesome... */
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,
1247 err = ext2fs_inode_size_set(fs, inode,
1248 sizeof(inode->i_block));
1251 ctx->flags |= E2F_FLAG_ABORT;
1254 e2fsck_write_inode(ctx, ino, inode,
1260 /* Some other kind of non-xattr error? */
1262 ctx->flags |= E2F_FLAG_ABORT;
1268 * Test for incorrect extent flag settings.
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.
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.
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);
1291 } else if (fix_problem(ctx, PR_1_EXTENTS_SET, &pctx)) {
1293 e2fsck_clear_inode(ctx, ino, inode, 0, "pass1");
1294 if (ino == EXT2_BAD_INO)
1295 ext2fs_mark_inode_bitmap2(ctx->inode_used_map,
1297 /* skip FINISH_INODE_LOOP */
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.
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))) {
1316 #ifdef WORDS_BIGENDIAN
1317 __u32 tmp_block[EXT2_N_BLOCKS];
1319 for (i = 0; i < EXT2_N_BLOCKS; i++)
1320 tmp_block[i] = ext2fs_swab32(inode->i_block[i]);
1323 ehp = inode->i_block;
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));
1333 e2fsck_write_inode(ctx, ino, inode, "pass1");
1338 if (ino == EXT2_BAD_INO) {
1339 struct process_block_struct pb;
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,
1352 pctx.errcode = ext2fs_copy_bitmap(ctx->block_found_map,
1353 &pb.fs_meta_blocks);
1356 fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, &pctx);
1357 ctx->flags |= E2F_FLAG_ABORT;
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;
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);
1373 fix_problem(ctx, PR_1_BLOCK_ITERATE, &pctx);
1374 ctx->flags |= E2F_FLAG_ABORT;
1378 if (!fix_problem(ctx, PR_1_BBINODE_BAD_METABLOCK_PROMPT, &pctx)) {
1379 ctx->flags |= E2F_FLAG_ABORT;
1382 ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino);
1383 clear_problem_context(&pctx);
1384 FINISH_INODE_LOOP(ctx, ino, &pctx, failed_csum);
1386 } else if (ino == EXT2_ROOT_INO) {
1388 * Make sure the root inode is a directory; if
1389 * not, offer to clear it. It will be
1390 * regnerated in pass #3.
1392 if (!LINUX_S_ISDIR(inode->i_mode)) {
1393 if (fix_problem(ctx, PR_1_ROOT_NO_DIR, &pctx))
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.
1405 if (inode->i_dtime && inode->i_links_count) {
1406 if (fix_problem(ctx, PR_1_ROOT_DTIME, &pctx)) {
1408 e2fsck_write_inode(ctx, ino, inode,
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,
1419 inode->i_mode = LINUX_S_IFREG;
1420 e2fsck_write_inode(ctx, ino, inode,
1424 check_blocks(ctx, &pctx, block_buf);
1425 FINISH_INODE_LOOP(ctx, ino, &pctx, failed_csum);
1428 if ((inode->i_links_count ||
1429 inode->i_blocks || inode->i_block[0]) &&
1430 fix_problem(ctx, PR_1_JOURNAL_INODE_NOT_CLEAR,
1432 memset(inode, 0, inode_size);
1433 ext2fs_icount_store(ctx->inode_link_info,
1435 e2fsck_write_inode_full(ctx, ino, inode,
1436 inode_size, "pass1");
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,
1449 inode->i_mode = LINUX_S_IFREG;
1450 e2fsck_write_inode(ctx, ino, inode,
1454 check_blocks(ctx, &pctx, block_buf);
1455 FINISH_INODE_LOOP(ctx, ino, &pctx, failed_csum);
1458 if ((inode->i_links_count ||
1459 inode->i_blocks || inode->i_block[0]) &&
1460 fix_problem(ctx, PR_1_QUOTA_INODE_NOT_CLEAR,
1462 memset(inode, 0, inode_size);
1463 ext2fs_icount_store(ctx->inode_link_info,
1465 e2fsck_write_inode_full(ctx, ino, inode,
1466 inode_size, "pass1");
1469 } else if (ino < EXT2_FIRST_INODE(fs->super)) {
1470 problem_t problem = 0;
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;
1481 if (inode->i_mode != 0)
1482 problem = PR_1_RESERVED_BAD_MODE;
1485 if (fix_problem(ctx, problem, &pctx)) {
1487 e2fsck_write_inode(ctx, ino, inode,
1492 check_blocks(ctx, &pctx, block_buf);
1493 FINISH_INODE_LOOP(ctx, ino, &pctx, failed_csum);
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
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. :-)
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 ?
1519 e2fsck_write_inode(ctx, ino, inode,
1526 * This code assumes that deleted inodes have
1527 * i_links_count set to 0.
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,
1539 FINISH_INODE_LOOP(ctx, ino, &pctx, failed_csum);
1543 * n.b. 0.3c ext2fs code didn't clear i_links_count for
1544 * deleted files. Oops.
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.
1552 if (inode->i_dtime) {
1553 if (fix_problem(ctx, PR_1_SET_DTIME, &pctx)) {
1555 e2fsck_write_inode(ctx, ino, inode, "pass1");
1560 ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino);
1561 switch (fs->super->s_creator_os) {
1563 frag = inode->osd2.hurd2.h_i_frag;
1564 fsize = inode->osd2.hurd2.h_i_fsize;
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) {
1585 if (!ctx->inode_imagic_map)
1586 alloc_imagic_map(ctx);
1587 ext2fs_mark_inode_bitmap2(ctx->inode_imagic_map,
1590 if (fix_problem(ctx, PR_1_SET_IMAGIC, &pctx)) {
1591 inode->i_flags &= ~EXT2_IMAGIC_FL;
1592 e2fsck_write_inode(ctx, ino,
1599 check_inode_extra_space(ctx, &pctx);
1600 check_is_really_dir(ctx, &pctx, block_buf);
1603 * ext2fs_inode_has_valid_blocks2 does not actually look
1604 * at i_block[] values, so not endian-sensitive here.
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");
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,
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);
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);
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++;
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++;
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++;
1684 check_blocks(ctx, &pctx, block_buf);
1686 FINISH_INODE_LOOP(ctx, ino, &pctx, failed_csum);
1688 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
1691 if (process_inode_count >= ctx->process_inode_size) {
1692 process_inodes(ctx, block_buf);
1694 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
1698 process_inodes(ctx, block_buf);
1699 ext2fs_close_inode_scan(scan);
1702 reserve_block_for_root_repair(ctx);
1703 reserve_block_for_lnf_repair(ctx);
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.
1710 if (ctx->refcount) {
1711 adjust_extattr_refcount(ctx, ctx->refcount, block_buf, -1);
1712 ea_refcount_free(ctx->refcount);
1715 if (ctx->refcount_extra) {
1716 adjust_extattr_refcount(ctx, ctx->refcount_extra,
1718 ea_refcount_free(ctx->refcount_extra);
1719 ctx->refcount_extra = 0;
1722 if (ctx->invalid_bitmaps)
1723 handle_fs_bad_blocks(ctx);
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;
1731 if (ctx->flags & E2F_FLAG_RESIZE_INODE) {
1732 clear_problem_context(&pctx);
1733 pctx.errcode = ext2fs_create_resize_inode(fs);
1735 if (!fix_problem(ctx, PR_1_RESIZE_INODE_CREATE,
1737 ctx->flags |= E2F_FLAG_ABORT;
1742 if (!pctx.errcode) {
1743 e2fsck_read_inode(ctx, EXT2_RESIZE_INO, inode,
1745 inode->i_mtime = ctx->now;
1746 e2fsck_write_inode(ctx, EXT2_RESIZE_INO, inode,
1749 ctx->flags &= ~E2F_FLAG_RESIZE_INODE;
1752 if (ctx->flags & E2F_FLAG_RESTART) {
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.
1759 ctx->use_superblock = 0;
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);
1769 e2fsck_pass1_dupblocks(ctx, block_buf);
1771 ext2fs_free_mem(&inodes_to_process);
1773 e2fsck_use_inode_shortcuts(ctx, 0);
1776 ext2fs_close_inode_scan(scan);
1778 ext2fs_free_mem(&block_buf);
1780 ext2fs_free_mem(&inode);
1783 * The l+f inode may have been cleared, so zap it now and
1784 * later passes will recalculate it if necessary
1786 ctx->lost_and_found = 0;
1788 if ((ctx->flags & E2F_FLAG_SIGNAL_MASK) == 0)
1789 print_resource_track(ctx, _("Pass 1"), &rtrack, ctx->fs->io);
1791 #undef FINISH_INODE_LOOP
1794 * When the inode_scan routines call this callback at the end of the
1795 * glock group, call process_inodes.
1797 static errcode_t scan_callback(ext2_filsys fs,
1798 ext2_inode_scan scan EXT2FS_ATTR((unused)),
1799 dgrp_t group, void * priv_data)
1801 struct scan_callback_struct *scan_struct;
1804 scan_struct = (struct scan_callback_struct *) priv_data;
1805 ctx = scan_struct->ctx;
1807 process_inodes((e2fsck_t) fs->priv_data, scan_struct->block_buf);
1810 if ((ctx->progress)(ctx, 1, group+1,
1811 ctx->fs->group_desc_count))
1812 return EXT2_ET_CANCEL_REQUESTED;
1818 * Process the inodes in the "inodes to process" list.
1820 static void process_inodes(e2fsck_t ctx, char *block_buf)
1823 struct ext2_inode *old_stashed_inode;
1824 ext2_ino_t old_stashed_ino;
1825 const char *old_operation;
1827 struct problem_context pctx;
1830 printf("begin process_inodes: ");
1832 if (process_inode_count == 0)
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;
1845 printf("%u ", pctx.ino);
1847 sprintf(buf, _("reading indirect blocks of inode %u"),
1849 ehandler_operation(buf);
1850 check_blocks(ctx, &pctx, block_buf);
1851 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
1854 ctx->stashed_inode = old_stashed_inode;
1855 ctx->stashed_ino = old_stashed_ino;
1856 process_inode_count = 0;
1858 printf("end process inodes\n");
1860 ehandler_operation(old_operation);
1863 static EXT2_QSORT_TYPE process_inode_cmp(const void *a, const void *b)
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;
1871 ret = (ib_a->inode.i_block[EXT2_IND_BLOCK] -
1872 ib_b->inode.i_block[EXT2_IND_BLOCK]);
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.
1879 ret = ext2fs_file_acl_block(0, &(ib_a->inode)) -
1880 ext2fs_file_acl_block(0, &(ib_b->inode));
1882 ret = ib_a->ino - ib_b->ino;
1887 * Mark an inode as being bad in some what
1889 static void mark_inode_bad(e2fsck_t ctx, ino_t ino)
1891 struct problem_context pctx;
1893 if (!ctx->inode_bad_map) {
1894 clear_problem_context(&pctx);
1896 pctx.errcode = e2fsck_allocate_inode_bitmap(ctx->fs,
1897 _("bad inode map"), EXT2FS_BMAP64_RBTREE,
1898 "inode_bad_map", &ctx->inode_bad_map);
1901 fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx);
1902 /* Should never get here */
1903 ctx->flags |= E2F_FLAG_ABORT;
1907 ext2fs_mark_inode_bitmap2(ctx->inode_bad_map, ino);
1910 static void add_encrypted_dir(e2fsck_t ctx, ino_t ino)
1912 struct problem_context pctx;
1914 if (!ctx->encrypted_dirs) {
1915 pctx.errcode = ext2fs_u32_list_create(&ctx->encrypted_dirs, 0);
1919 pctx.errcode = ext2fs_u32_list_add(ctx->encrypted_dirs, ino);
1920 if (pctx.errcode == 0)
1923 fix_problem(ctx, PR_1_ALLOCATE_ENCRYPTED_DIRLIST, &pctx);
1924 /* Should never get here */
1925 ctx->flags |= E2F_FLAG_ABORT;
1929 * This procedure will allocate the inode "bb" (badblock) map table
1931 static void alloc_bb_map(e2fsck_t ctx)
1933 struct problem_context pctx;
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);
1941 fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx);
1942 /* Should never get here */
1943 ctx->flags |= E2F_FLAG_ABORT;
1949 * This procedure will allocate the inode imagic table
1951 static void alloc_imagic_map(e2fsck_t ctx)
1953 struct problem_context pctx;
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);
1961 fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx);
1962 /* Should never get here */
1963 ctx->flags |= E2F_FLAG_ABORT;
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.
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.
1975 static _INLINE_ void mark_block_used(e2fsck_t ctx, blk64_t block)
1977 struct problem_context pctx;
1979 clear_problem_context(&pctx);
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);
1989 fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR,
1991 /* Should never get here */
1992 ctx->flags |= E2F_FLAG_ABORT;
1996 ext2fs_fast_mark_block_bitmap2(ctx->block_dup_map, block);
1998 ext2fs_fast_mark_block_bitmap2(ctx->block_found_map, block);
2002 static _INLINE_ void mark_blocks_used(e2fsck_t ctx, blk64_t block,
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);
2009 mark_block_used(ctx, block++);
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.
2019 static void adjust_extattr_refcount(e2fsck_t ctx, ext2_refcount_t refcount,
2020 char *block_buf, int adjust_sign)
2022 struct ext2_ext_attr_header *header;
2023 struct problem_context pctx;
2024 ext2_filsys fs = ctx->fs;
2029 clear_problem_context(&pctx);
2031 ea_refcount_intr_begin(refcount);
2033 if ((blk = ea_refcount_intr_next(refcount, &count)) == 0)
2036 pctx.errcode = ext2fs_read_ext_attr3(fs, blk, block_buf,
2039 fix_problem(ctx, PR_1_EXTATTR_READ_ABORT, &pctx);
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,
2052 fix_problem(ctx, PR_1_EXTATTR_WRITE_ABORT,
2061 * Handle processing the extended attribute blocks
2063 static int check_ext_attr(e2fsck_t ctx, struct problem_context *pctx,
2066 ext2_filsys fs = ctx->fs;
2067 ext2_ino_t ino = pctx->ino;
2068 struct ext2_inode *inode = pctx->inode;
2071 struct ext2_ext_attr_header *header;
2072 struct ext2_ext_attr_entry *entry;
2074 region_t region = 0;
2075 int failed_csum = 0;
2077 blk = ext2fs_file_acl_block(fs, inode);
2082 * If the Extended attribute flag isn't set, then a non-zero
2083 * file acl means that the inode is corrupted.
2085 * Or if the extended attribute block is an invalid block,
2086 * then the inode is also corrupted.
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);
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) {
2103 fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, pctx);
2104 ctx->flags |= E2F_FLAG_ABORT;
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) {
2114 fix_problem(ctx, PR_1_ALLOCATE_REFCOUNT, pctx);
2115 ctx->flags |= E2F_FLAG_ABORT;
2121 /* Debugging text */
2122 printf("Inode %u has EA block %u\n", ino, blk);
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)
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) {
2135 fix_problem(ctx, PR_1_ALLOCATE_REFCOUNT, pctx);
2136 ctx->flags |= E2F_FLAG_ABORT;
2140 ea_refcount_increment(ctx->refcount_extra, blk, 0);
2145 * OK, we haven't seen this EA block yet. So we need to
2149 pctx->errcode = ext2fs_read_ext_attr3(fs, blk, block_buf, pctx->ino);
2150 if (pctx->errcode == EXT2_ET_EXT_ATTR_CSUM_INVALID) {
2153 } else if (pctx->errcode == EXT2_ET_BAD_EA_HEADER)
2156 if (pctx->errcode &&
2157 fix_problem(ctx, PR_1_READ_EA_BLOCK, pctx)) {
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))
2171 if (header->h_blocks != 1) {
2172 if (fix_problem(ctx, PR_1_EA_MULTI_BLOCK, pctx))
2176 if (pctx->errcode && fix_problem(ctx, PR_1_READ_EA_BLOCK, pctx))
2179 region = region_create(0, fs->blocksize);
2181 fix_problem(ctx, PR_1_EA_ALLOC_REGION_ABORT, pctx);
2182 ctx->flags |= E2F_FLAG_ABORT;
2185 if (region_allocate(region, 0, sizeof(struct ext2_ext_attr_header))) {
2186 if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, pctx))
2190 entry = (struct ext2_ext_attr_entry *)(header+1);
2191 end = block_buf + fs->blocksize;
2192 while ((char *)entry < end && *(__u32 *)entry) {
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))
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))
2209 if (entry->e_value_block != 0) {
2210 if (fix_problem(ctx, PR_1_EA_BAD_VALUE, pctx))
2213 if (entry->e_value_offs + entry->e_value_size > fs->blocksize) {
2214 if (fix_problem(ctx, PR_1_EA_BAD_VALUE, pctx))
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))
2225 hash = ext2fs_ext_attr_hash_entry(entry, block_buf +
2226 entry->e_value_offs);
2228 if (entry->e_hash != hash) {
2229 pctx->num = entry->e_hash;
2230 if (fix_problem(ctx, PR_1_ATTR_HASH, pctx))
2232 entry->e_hash = hash;
2235 entry = EXT2_EXT_ATTR_NEXT(entry);
2237 if (region_allocate(region, (char *)entry - (char *)header, 4)) {
2238 if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, pctx))
2241 region_free(region);
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.
2248 fix_problem(ctx, PR_1_EA_BLOCK_ONLY_CSUM_INVALID, pctx)) {
2249 pctx->errcode = ext2fs_write_ext_attr3(fs, blk, block_buf,
2255 count = header->h_refcount - 1;
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);
2264 region_free(region);
2265 ext2fs_file_acl_block_set(fs, inode, 0);
2266 e2fsck_write_inode(ctx, ino, inode, "check_ext_attr");
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,
2275 struct ext2_dx_root_info *root;
2276 ext2_filsys fs = ctx->fs;
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)))
2286 pctx->errcode = ext2fs_bmap2(fs, ino, inode, 0, 0, 0, 0, &blk);
2288 if ((pctx->errcode) ||
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))
2298 retval = io_channel_read_blk64(fs->io, blk, 1, block_buf);
2299 if (retval && fix_problem(ctx, PR_1_HTREE_BADROOT, pctx))
2302 /* XXX should check that beginning matches a directory */
2303 root = (struct ext2_dx_root_info *) (block_buf + 24);
2305 if ((root->reserved_zero || root->info_length < 8) &&
2306 fix_problem(ctx, PR_1_HTREE_BADROOT, pctx))
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))
2316 if ((root->unused_flags & EXT2_HASH_FLAG_INCOMPAT) &&
2317 fix_problem(ctx, PR_1_HTREE_INCOMPAT, pctx))
2320 pctx->num = root->indirect_levels;
2321 if ((root->indirect_levels > 1) &&
2322 fix_problem(ctx, PR_1_HTREE_DEPTH, pctx))
2328 void e2fsck_clear_inode(e2fsck_t ctx, ext2_ino_t ino,
2329 struct ext2_inode *inode, int restart_flag,
2333 inode->i_links_count = 0;
2334 ext2fs_icount_store(ctx->inode_link_info, ino, 0);
2335 inode->i_dtime = ctx->now;
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
2344 if (ino < EXT2_FIRST_INODE(ctx->fs->super))
2345 memset(inode->i_block, 0, sizeof(inode->i_block));
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);
2355 * If the inode was partially accounted for before processing
2356 * was aborted, we need to restart the pass 1 scan.
2358 ctx->flags |= restart_flag;
2360 if (ino == EXT2_BAD_INO)
2361 memset(inode, 0, sizeof(struct ext2_inode));
2363 e2fsck_write_inode(ctx, ino, inode, source);
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
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)
2376 blk64_t cluster_mask;
2378 if (!ctx->fs->cluster_ratio_bits)
2380 cluster_mask = EXT2FS_CLUSTER_MASK(ctx->fs);
2383 * If the block in the logical cluster doesn't align with the block in
2384 * the physical cluster...
2386 if ((lblk & cluster_mask) != (pblk & cluster_mask))
2390 * If we cross a physical cluster boundary within a logical cluster...
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))
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,
2404 ext2_extent_handle_t ehandle,
2407 struct ext2fs_extent extent;
2408 blk64_t blk, last_lblk;
2409 e2_blkcnt_t blockcnt;
2411 int is_dir, is_leaf;
2413 struct ext2_extent_info info;
2414 int failed_csum = 0;
2416 if (pctx->errcode == EXT2_ET_EXTENT_CSUM_INVALID)
2419 pctx->errcode = ext2fs_extent_get_info(ehandle, &info);
2423 pctx->errcode = ext2fs_extent_get(ehandle, EXT2_EXTENT_FIRST_SIB,
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;
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;
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;
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;
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;
2464 * Uninitialized blocks in a directory? Clear the flag and
2465 * we'll interpret the blocks later.
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,
2479 if (try_repairs && problem) {
2481 if (fix_problem(ctx, problem, pctx)) {
2482 if (ctx->invalid_bitmaps) {
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
2490 pctx->errcode = ext2fs_extent_get(
2492 EXT2_EXTENT_NEXT_SIB,
2494 ctx->flags |= E2F_FLAG_RESTART_LATER;
2495 if (pctx->errcode ==
2496 EXT2_ET_NO_CURRENT_NODE) {
2502 e2fsck_read_bitmaps(ctx);
2503 pb->inode_modified = 1;
2505 ext2fs_extent_delete(ehandle, 0);
2506 if (pctx->errcode) {
2507 pctx->str = "ext2fs_extent_delete";
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";
2516 pctx->errcode = ext2fs_extent_get(ehandle,
2517 EXT2_EXTENT_CURRENT,
2519 if (pctx->errcode == EXT2_ET_NO_CURRENT_NODE) {
2530 blk64_t lblk = extent.e_lblk;
2531 int next_try_repairs = 1;
2533 blk = extent.e_pblk;
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.
2540 if (pb->ino != EXT2_RESIZE_INO &&
2541 ext2fs_test_block_bitmap2(ctx->block_metadata_map,
2543 next_try_repairs = 0;
2546 PR_1_CRITICAL_METADATA_COLLISION,
2548 ctx->flags |= E2F_FLAG_RESTART_LATER;
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)
2558 if (pctx->errcode == EXT2_ET_EXTENT_HEADER_BAD)
2559 goto report_problem;
2562 /* The next extent should match this index's logical start */
2563 if (extent.e_lblk != lblk) {
2564 struct ext2_extent_info e_info;
2566 ext2fs_extent_get_info(ehandle, &e_info);
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;
2574 ext2fs_extent_fix_parents(ehandle);
2575 if (pctx->errcode) {
2576 pctx->str = "ext2fs_extent_fix_parents";
2581 scan_extent_node(ctx, pctx, pb, extent.e_lblk,
2582 last_lblk, eof_block, ehandle,
2586 pctx->errcode = ext2fs_extent_get(ehandle,
2587 EXT2_EXTENT_UP, &extent);
2588 if (pctx->errcode) {
2589 pctx->str = "EXT2_EXTENT_UP";
2592 mark_block_used(ctx, blk);
2597 if ((pb->previous_block != 0) &&
2598 (pb->previous_block+1 != extent.e_pblk)) {
2599 if (ctx->options & E2F_OPT_FRAGCHECK) {
2604 else if (pb->is_reg)
2607 printf(("%6lu(%c): expecting %6lu "
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);
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.
2624 if (try_repairs && is_dir &&
2625 pb->last_block + 1 < (e2_blkcnt_t)extent.e_lblk) {
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)) |
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,
2642 if (pctx->errcode) {
2646 pctx->errcode = ext2fs_extent_fix_parents(ehandle);
2648 goto failed_add_dir_block;
2649 pctx->errcode = ext2fs_extent_goto(ehandle,
2652 goto failed_add_dir_block;
2653 last_lblk = extent.e_lblk + extent.e_len - 1;
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,
2663 if (pctx->errcode) {
2665 pctx->num = pb->last_db_block;
2666 goto failed_add_dir_block;
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;
2673 for (blk = extent.e_pblk, blockcnt = extent.e_lblk, i = 0;
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);
2685 if (has_unaligned_cluster_map(ctx, pb->previous_block,
2686 pb->last_block, blk,
2688 pctx->blk = blockcnt;
2690 fix_problem(ctx, PR_1_MISALIGNED_CLUSTER, pctx);
2691 mark_block_used(ctx, blk);
2692 mark_block_used(ctx, blk);
2694 pb->last_block = blockcnt;
2695 pb->previous_block = blk;
2698 pctx->errcode = ext2fs_add_dir_block2(ctx->fs->dblist, pctx->ino, blk, blockcnt);
2699 if (pctx->errcode) {
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;
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;
2718 pctx->errcode = ext2fs_extent_get(ehandle,
2719 EXT2_EXTENT_NEXT_SIB,
2723 /* Failed csum but passes checks? Ask to fix checksum. */
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);
2732 if (pctx->errcode == EXT2_ET_EXTENT_NO_NEXT)
2736 static void check_blocks_extents(e2fsck_t ctx, struct problem_context *pctx,
2737 struct process_block_struct *pb)
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;
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");
2756 retval = ext2fs_extent_get_info(ehandle, &info);
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]++;
2763 pb->region = region_create(0, info.max_lblk);
2765 ext2fs_extent_free(ehandle);
2766 fix_problem(ctx, PR_1_EXTENT_ALLOC_REGION_ABORT, pctx);
2767 ctx->flags |= E2F_FLAG_ABORT;
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)) {
2777 inode->i_blocks = 0;
2778 e2fsck_clear_inode(ctx, ino, inode, E2F_FLAG_RESTART,
2779 "check_blocks_extents");
2782 region_free(pb->region);
2784 ext2fs_extent_free(ehandle);
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.
2792 static void check_blocks_inline_data(e2fsck_t ctx, struct problem_context *pctx,
2793 struct process_block_struct *pb)
2796 size_t inline_data_size = 0;
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);
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,
2813 ctx->fs->flags = (flags & EXT2_FLAG_IGNORE_CSUM_ERRORS) |
2814 (ctx->fs->flags & ~EXT2_FLAG_IGNORE_CSUM_ERRORS);
2815 if (pctx->errcode) {
2820 if (inline_data_size <= EXT4_MIN_INLINE_DATA_SIZE)
2823 pctx->errcode = ext2fs_add_dir_block2(ctx->fs->dblist, pb->ino, 0, 1);
2831 fix_problem(ctx, PR_1_ADD_DBLOCK, pctx);
2832 ctx->flags |= E2F_FLAG_ABORT;
2836 * This subroutine is called on each inode to account for all of the
2837 * blocks used by that inode.
2839 static void check_blocks(e2fsck_t ctx, struct problem_context *pctx,
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;
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;
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);
2868 pb.inode_modified = 0;
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);
2877 if (inode->i_flags & EXT2_COMPRBLK_FL) {
2878 if (fs->super->s_feature_incompat &
2879 EXT2_FEATURE_INCOMPAT_COMPRESSION)
2882 if (fix_problem(ctx, PR_1_COMPR_SET, pctx)) {
2883 inode->i_flags &= ~EXT2_COMPRBLK_FL;
2889 if (check_ext_attr(ctx, pctx, block_buf)) {
2890 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
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);
2903 * If we've modified the inode, write it out before
2904 * iterate() tries to use it.
2907 e2fsck_write_inode(ctx, ino, inode,
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);
2917 * We do not have uninitialized extents in non extent
2920 pb.last_init_lblock = pb.last_block;
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!
2927 if (pb.inode_modified)
2928 e2fsck_read_inode(ctx, ino, inode,
2930 fs->flags = (flags & EXT2_FLAG_IGNORE_CSUM_ERRORS) |
2931 (fs->flags & ~EXT2_FLAG_IGNORE_CSUM_ERRORS);
2934 end_problem_latch(ctx, PR_LATCH_BLOCK);
2935 end_problem_latch(ctx, PR_LATCH_TOOBIG);
2936 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
2939 fix_problem(ctx, PR_1_BLOCK_ITERATE, pctx);
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++;
2945 ctx->fs_fragmented++;
2949 e2fsck_clear_inode(ctx, ino, inode, E2F_FLAG_RESTART,
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;
2960 e2fsck_add_dx_dir(ctx, ino, pb.last_block+1);
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--;
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);
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);
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),
2991 int nblock = inode->i_size >> EXT2_BLOCK_SIZE_BITS(fs->super);
2992 if (inode->i_flags & EXT4_INLINE_DATA_FL) {
2998 flags = ctx->fs->flags;
2999 ctx->fs->flags |= EXT2_FLAG_IGNORE_CSUM_ERRORS;
3000 err = ext2fs_inline_data_size(ctx->fs, pctx->ino,
3002 ctx->fs->flags = (flags &
3003 EXT2_FLAG_IGNORE_CSUM_ERRORS) |
3005 ~EXT2_FLAG_IGNORE_CSUM_ERRORS);
3006 if (err || size != inode->i_size) {
3010 } else if (inode->i_size & (fs->blocksize - 1))
3012 else if (nblock > (pb.last_block + 1))
3014 else if (nblock < (pb.last_block + 1)) {
3015 if (((pb.last_block + 1) - nblock) >
3016 fs->super->s_prealloc_dir_blocks)
3020 e2_blkcnt_t blkpg = ctx->blocks_per_page;
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)) *
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 */
3034 else if ((extent_fs && (inode->i_flags & EXT4_EXTENTS_FL)) &&
3036 ((1ULL << (32 + EXT2_BLOCK_SIZE_BITS(fs->super))) - 1))
3037 /* too big for an extent-based file - 32bit ee_block */
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? */
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;
3060 if (LINUX_S_ISREG(inode->i_mode) &&
3061 ext2fs_needs_large_file_feature(EXT2_I_SIZE(inode)))
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;
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);
3086 e2fsck_write_inode(ctx, ino, inode, "check_blocks");
3091 * Helper function called by process block when an illegal block is
3092 * found. It returns a description about why the block is illegal
3094 static char *describe_illegal_block(ext2_filsys fs, blk64_t block)
3098 static char problem[80];
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);
3105 } else if (block >= ext2fs_blocks_count(fs->super)) {
3106 sprintf(problem, "> BLOCKS (%u)", ext2fs_blocks_count(fs->super));
3109 for (i = 0; i < fs->group_desc_count; i++) {
3110 if (block == super) {
3111 sprintf(problem, "is the superblock in group %d", i);
3114 if (block > super &&
3115 block <= (super + fs->desc_blocks)) {
3116 sprintf(problem, "is in the group descriptors "
3120 if (block == ext2fs_block_bitmap_loc(fs, i)) {
3121 sprintf(problem, "is the block bitmap of group %d", i);
3124 if (block == ext2fs_inode_bitmap_loc(fs, i)) {
3125 sprintf(problem, "is the inode bitmap of group %d", i);
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",
3135 super += fs->super->s_blocks_per_group;
3142 * This is a helper function for check_blocks().
3144 static int process_block(ext2_filsys fs,
3146 e2_blkcnt_t blockcnt,
3147 blk64_t ref_block EXT2FS_ATTR((unused)),
3148 int ref_offset EXT2FS_ATTR((unused)),
3151 struct process_block_struct *p;
3152 struct problem_context *pctx;
3153 blk64_t blk = *block_nr;
3155 problem_t problem = 0;
3158 p = (struct process_block_struct *) priv_data;
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. */
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 ".."
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) {
3193 pctx->num = blockcnt;
3194 goto failed_add_dir_block;
3203 printf("Process_block, inode %lu, block %u, #%d\n", p->ino, blk,
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.)
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) {
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,
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;
3240 if (blk < fs->super->s_first_data_block ||
3241 blk >= ext2fs_blocks_count(fs->super))
3242 problem = PR_1_ILLEGAL_BLOCK_NUM;
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.
3251 p->ino != EXT2_RESIZE_INO &&
3252 ext2fs_test_block_bitmap2(ctx->block_metadata_map, blk)) {
3254 fix_problem(ctx, PR_1_CRITICAL_METADATA_COLLISION, pctx);
3255 ctx->flags |= E2F_FLAG_RESTART_LATER;
3259 p->num_illegal_blocks++;
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.
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!
3275 if (p->ino != EXT2_RESIZE_INO &&
3277 ext2fs_test_block_bitmap2(ctx->block_metadata_map,
3282 if (!p->suppress && (p->num_illegal_blocks % 12) == 0) {
3283 if (fix_problem(ctx, PR_1_TOO_MANY_BAD_BLOCKS, pctx)) {
3287 if (fix_problem(ctx, PR_1_SUPPRESS_MESSAGES, pctx)) {
3289 set_latch_flags(PR_LATCH_BLOCK,
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;
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
3308 if (problem == PR_1_TOOBIG_DIR)
3315 if (p->ino == EXT2_RESIZE_INO) {
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()).
3323 if (blockcnt == BLOCK_COUNT_DIND)
3324 mark_block_used(ctx, blk);
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);
3334 } else if (has_unaligned_cluster_map(ctx, p->previous_block,
3335 p->last_block, blk, blockcnt)) {
3336 pctx->blk = blockcnt;
3338 fix_problem(ctx, PR_1_MISALIGNED_CLUSTER, pctx);
3339 mark_block_used(ctx, blk);
3340 mark_block_used(ctx, blk);
3343 p->last_block = blockcnt;
3344 p->previous_block = blk;
3346 if (p->is_dir && (blockcnt >= 0)) {
3347 while (++p->last_db_block < blockcnt) {
3348 pctx->errcode = ext2fs_add_dir_block2(fs->dblist,
3351 if (pctx->errcode) {
3353 pctx->num = p->last_db_block;
3354 goto failed_add_dir_block;
3357 pctx->errcode = ext2fs_add_dir_block2(fs->dblist, p->ino,
3359 if (pctx->errcode) {
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;
3372 static int process_bad_block(ext2_filsys fs,
3374 e2_blkcnt_t blockcnt,
3375 blk64_t ref_block EXT2FS_ATTR((unused)),
3376 int ref_offset EXT2FS_ATTR((unused)),
3379 struct process_block_struct *p;
3380 blk64_t blk = *block_nr;
3381 blk64_t first_block;
3383 struct problem_context *pctx;
3387 * Note: This function processes blocks for the bad blocks
3388 * inode, which is never compressed. So we don't use HOLE_BLKADDR().
3394 p = (struct process_block_struct *) priv_data;
3398 pctx->ino = EXT2_BAD_INO;
3400 pctx->blkcount = blockcnt;
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)) {
3406 return BLOCK_CHANGED;
3412 if (ext2fs_test_block_bitmap2(p->fs_meta_blocks, blk)) {
3414 if (fix_problem(ctx, PR_1_BB_FS_BLOCK, pctx)) {
3416 return BLOCK_CHANGED;
3418 } else if (ext2fs_test_block_bitmap2(ctx->block_found_map,
3421 if (fix_problem(ctx, PR_1_BBINODE_BAD_METABLOCK,
3424 return BLOCK_CHANGED;
3426 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
3429 mark_block_used(ctx, blk);
3433 printf ("DEBUG: Marking %u as bad.\n", blk);
3435 ctx->fs_badblocks_count++;
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.
3442 if (!ext2fs_test_block_bitmap2(ctx->block_found_map, blk)) {
3443 ext2fs_mark_block_bitmap2(ctx->block_found_map, blk);
3447 * Try to find the where the filesystem block was used...
3449 first_block = fs->super->s_first_data_block;
3451 for (i = 0; i < fs->group_desc_count; i++ ) {
3454 if (!ext2fs_bg_has_super(fs, i))
3456 if (blk == first_block) {
3458 if (fix_problem(ctx,
3459 PR_1_BAD_PRIMARY_SUPERBLOCK,
3462 return BLOCK_CHANGED;
3466 fix_problem(ctx, PR_1_BAD_SUPERBLOCK, pctx);
3469 if ((blk > first_block) &&
3470 (blk <= first_block + fs->desc_blocks)) {
3472 pctx->blk = *block_nr;
3473 if (fix_problem(ctx,
3474 PR_1_BAD_PRIMARY_GROUP_DESCRIPTOR, pctx)) {
3476 return BLOCK_CHANGED;
3480 fix_problem(ctx, PR_1_BAD_GROUP_DESCRIPTORS, pctx);
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++;
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++;
3498 if ((blk >= ext2fs_inode_table_loc(fs, i)) &&
3499 (blk < (ext2fs_inode_table_loc(fs, i) +
3500 fs->inode_blocks_per_group))) {
3502 * If there are bad blocks in the inode table,
3503 * the inode scan code will try to do
3504 * something reasonable automatically.
3508 first_block += fs->super->s_blocks_per_group;
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.
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])) {
3519 if (fix_problem(ctx, PR_1_BBINODE_BAD_METABLOCK, pctx)) {
3521 return BLOCK_CHANGED;
3523 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
3530 /* Warn user that the block wasn't claimed */
3531 fix_problem(ctx, PR_1_PROGERR_CLAIMED_BLOCK, pctx);
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)
3539 ext2_filsys fs = ctx->fs;
3541 blk64_t old_block = *new_block;
3544 unsigned flexbg_size;
3547 struct problem_context pctx;
3549 clear_problem_context(&pctx);
3552 pctx.blk = old_block;
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.
3560 is_flexbg = EXT2_HAS_INCOMPAT_FEATURE(fs->super,
3561 EXT4_FEATURE_INCOMPAT_FLEX_BG);
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);
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,
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);
3583 fix_problem(ctx, PR_1_RELOC_BLOCK_ALLOCATE, &pctx);
3584 ext2fs_unmark_valid(fs);
3585 ctx->flags |= E2F_FLAG_ABORT;
3588 pctx.errcode = ext2fs_get_mem(fs->blocksize, &buf);
3590 fix_problem(ctx, PR_1_RELOC_MEMORY_ALLOCATE, &pctx);
3591 ext2fs_unmark_valid(fs);
3592 ctx->flags |= E2F_FLAG_ABORT;
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);
3601 for (i = 0; i < num; i++) {
3603 ext2fs_mark_block_bitmap2(ctx->block_found_map, (*new_block)+i);
3605 pctx.errcode = io_channel_read_blk64(fs->io,
3606 old_block + i, 1, buf);
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,
3613 pctx.blk = (*new_block) + i;
3614 pctx.errcode = ext2fs_zero_blocks2(fs, pctx.blk, 1,
3619 fix_problem(ctx, PR_1_RELOC_WRITE_ERR, &pctx);
3621 ext2fs_free_mem(&buf);
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
3631 static void handle_fs_bad_blocks(e2fsck_t ctx)
3633 ext2_filsys fs = ctx->fs;
3635 blk64_t first_block;
3638 for (i = 0; i < fs->group_desc_count; i++) {
3639 first_block = ext2fs_group_first_block2(fs, i);
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"),
3645 ext2fs_block_bitmap_loc_set(fs, i, new_blk);
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"),
3651 ext2fs_inode_bitmap_loc_set(fs, i, new_blk);
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,
3658 ext2fs_inode_table_loc_set(fs, i, new_blk);
3659 ctx->flags |= E2F_FLAG_RESTART;
3662 ctx->invalid_bitmaps = 0;
3666 * This routine marks all blocks which are used by the superblock,
3667 * group descriptors, inode bitmaps, and block bitmaps.
3669 static void mark_table_blocks(e2fsck_t ctx)
3671 ext2_filsys fs = ctx->fs;
3675 struct problem_context pctx;
3677 clear_problem_context(&pctx);
3679 for (i = 0; i < fs->group_desc_count; i++) {
3682 ext2fs_reserve_super_and_bgd(fs, i, ctx->block_found_map);
3683 ext2fs_reserve_super_and_bgd(fs, i, ctx->block_metadata_map);
3686 * Mark the blocks used for the inode table
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;
3692 if (ext2fs_test_block_bitmap2(ctx->block_found_map,
3695 if (!ctx->invalid_inode_table_flag[i] &&
3697 PR_1_ITABLE_CONFLICT, &pctx)) {
3698 ctx->invalid_inode_table_flag[i]++;
3699 ctx->invalid_bitmaps++;
3702 ext2fs_mark_block_bitmap2(
3703 ctx->block_found_map, b);
3704 ext2fs_mark_block_bitmap2(
3705 ctx->block_metadata_map, b);
3711 * Mark block used for the block bitmap
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++;
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));
3729 * Mark block used for the inode bitmap
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++;
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));
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
3755 static errcode_t pass1_get_blocks(ext2_filsys fs, ext2_ino_t ino,
3758 e2fsck_t ctx = (e2fsck_t) fs->priv_data;
3761 if ((ino != ctx->stashed_ino) || !ctx->stashed_inode)
3762 return EXT2_ET_CALLBACK_NOTHANDLED;
3764 for (i=0; i < EXT2_N_BLOCKS; i++)
3765 blocks[i] = ctx->stashed_inode->i_block[i];
3769 static errcode_t pass1_read_inode(ext2_filsys fs, ext2_ino_t ino,
3770 struct ext2_inode *inode)
3772 e2fsck_t ctx = (e2fsck_t) fs->priv_data;
3774 if ((ino != ctx->stashed_ino) || !ctx->stashed_inode)
3775 return EXT2_ET_CALLBACK_NOTHANDLED;
3776 *inode = *ctx->stashed_inode;
3780 static errcode_t pass1_write_inode(ext2_filsys fs, ext2_ino_t ino,
3781 struct ext2_inode *inode)
3783 e2fsck_t ctx = (e2fsck_t) fs->priv_data;
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;
3791 static errcode_t pass1_check_directory(ext2_filsys fs, ext2_ino_t ino)
3793 e2fsck_t ctx = (e2fsck_t) fs->priv_data;
3795 if ((ino != ctx->stashed_ino) || !ctx->stashed_inode)
3796 return EXT2_ET_CALLBACK_NOTHANDLED;
3798 if (!LINUX_S_ISDIR(ctx->stashed_inode->i_mode))
3799 return EXT2_ET_NO_DIRECTORY;
3803 static errcode_t e2fsck_get_alloc_block(ext2_filsys fs, blk64_t goal,
3806 e2fsck_t ctx = (e2fsck_t) fs->priv_data;
3810 if (ctx->block_found_map) {
3811 retval = ext2fs_new_block2(fs, goal, ctx->block_found_map,
3815 if (fs->block_map) {
3816 ext2fs_mark_block_bitmap2(fs->block_map, new_block);
3817 ext2fs_mark_bb_dirty(fs);
3820 if (!fs->block_map) {
3821 retval = ext2fs_read_block_bitmap(fs);
3826 retval = ext2fs_new_block2(fs, goal, fs->block_map, &new_block);
3835 static void e2fsck_block_alloc_stats(ext2_filsys fs, blk64_t blk, int inuse)
3837 e2fsck_t ctx = (e2fsck_t) fs->priv_data;
3839 /* Never free a critical metadata block */
3840 if (ctx->block_found_map &&
3841 ctx->block_metadata_map &&
3843 ext2fs_test_block_bitmap2(ctx->block_metadata_map, blk))
3846 if (ctx->block_found_map) {
3848 ext2fs_mark_block_bitmap2(ctx->block_found_map, blk);
3850 ext2fs_unmark_block_bitmap2(ctx->block_found_map, blk);
3854 void e2fsck_use_inode_shortcuts(e2fsck_t ctx, int use_shortcuts)
3856 ext2_filsys fs = ctx->fs;
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;
3866 fs->check_directory = 0;
3868 fs->write_inode = 0;
3872 void e2fsck_intercept_block_allocations(e2fsck_t ctx)
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);