2 * pass1.c -- pass #1 of e2fsck: sequential scan of the inode table
4 * Copyright (C) 1993, 1994, 1995, 1996, 1997 Theodore Ts'o.
7 * This file may be redistributed under the terms of the GNU Public
11 * Pass 1 of e2fsck iterates over all the inodes in the filesystems,
12 * and applies the following tests to each inode:
14 * - The mode field of the inode must be legal.
15 * - The size and block count fields of the inode are correct.
16 * - A data block must not be used by another inode
18 * Pass 1 also gathers the collects the following information:
20 * - A bitmap of which inodes are in use. (inode_used_map)
21 * - A bitmap of which inodes are directories. (inode_dir_map)
22 * - A bitmap of which inodes are regular files. (inode_reg_map)
23 * - A bitmap of which inodes have bad fields. (inode_bad_map)
24 * - A bitmap of which inodes are in bad blocks. (inode_bb_map)
25 * - A bitmap of which inodes are imagic inodes. (inode_imagic_map)
26 * - A bitmap of which blocks are in use. (block_found_map)
27 * - A bitmap of which blocks are in use by two inodes (block_dup_map)
28 * - The data blocks of the directory inodes. (dir_map)
30 * Pass 1 is designed to stash away enough information so that the
31 * other passes should not need to read in the inode information
32 * during the normal course of a filesystem check. (Althogh if an
33 * inconsistency is detected, other passes may need to read in an
36 * Note that pass 1B will be invoked if there are any duplicate blocks
40 #define _GNU_SOURCE 1 /* get strnlen() */
49 #include <ext2fs/ext2_ext_attr.h>
53 #ifdef NO_INLINE_FUNCS
56 #define _INLINE_ inline
59 static int process_block(ext2_filsys fs
, blk64_t
*blocknr
,
60 e2_blkcnt_t blockcnt
, blk64_t ref_blk
,
61 int ref_offset
, void *priv_data
);
62 static int process_bad_block(ext2_filsys fs
, blk64_t
*block_nr
,
63 e2_blkcnt_t blockcnt
, blk64_t ref_blk
,
64 int ref_offset
, void *priv_data
);
65 static void check_blocks(e2fsck_t ctx
, struct problem_context
*pctx
,
67 static void mark_table_blocks(e2fsck_t ctx
);
68 static void alloc_bb_map(e2fsck_t ctx
);
69 static void alloc_imagic_map(e2fsck_t ctx
);
70 static void mark_inode_bad(e2fsck_t ctx
, ino_t ino
);
71 static void handle_fs_bad_blocks(e2fsck_t ctx
);
72 static void process_inodes(e2fsck_t ctx
, char *block_buf
);
73 static EXT2_QSORT_TYPE
process_inode_cmp(const void *a
, const void *b
);
74 static errcode_t
scan_callback(ext2_filsys fs
, ext2_inode_scan scan
,
75 dgrp_t group
, void * priv_data
);
76 static void adjust_extattr_refcount(e2fsck_t ctx
, ext2_refcount_t refcount
,
77 char *block_buf
, int adjust_sign
);
78 /* static char *describe_illegal_block(ext2_filsys fs, blk64_t block); */
80 struct process_block_struct
{
82 unsigned is_dir
:1, is_reg
:1, clear
:1, suppress
:1,
83 fragmented
:1, compressed
:1, bbcheck
:1,
87 e2_blkcnt_t last_block
;
88 e2_blkcnt_t last_init_lblock
;
89 e2_blkcnt_t last_db_block
;
90 int num_illegal_blocks
;
91 blk64_t previous_block
;
92 struct ext2_inode
*inode
;
93 struct problem_context
*pctx
;
94 ext2fs_block_bitmap fs_meta_blocks
;
99 struct process_inode_block
{
101 struct ext2_inode inode
;
104 struct scan_callback_struct
{
110 * For the inodes to process list.
112 static struct process_inode_block
*inodes_to_process
;
113 static int process_inode_count
;
115 static __u64 ext2_max_sizes
[EXT2_MAX_BLOCK_LOG_SIZE
-
116 EXT2_MIN_BLOCK_LOG_SIZE
+ 1];
119 * Free all memory allocated by pass1 in preparation for restarting
122 static void unwind_pass1(ext2_filsys fs
EXT2FS_ATTR((unused
)))
124 ext2fs_free_mem(&inodes_to_process
);
125 inodes_to_process
= 0;
129 * Check to make sure a device inode is real. Returns 1 if the device
130 * checks out, 0 if not.
132 * Note: this routine is now also used to check FIFO's and Sockets,
133 * since they have the same requirement; the i_block fields should be
136 int e2fsck_pass1_check_device_inode(ext2_filsys fs
EXT2FS_ATTR((unused
)),
137 struct ext2_inode
*inode
)
142 * If the index flag is set, then this is a bogus
145 if (inode
->i_flags
& EXT2_INDEX_FL
)
149 * We should be able to do the test below all the time, but
150 * because the kernel doesn't forcibly clear the device
151 * inode's additional i_block fields, there are some rare
152 * occasions when a legitimate device inode will have non-zero
153 * additional i_block fields. So for now, we only complain
154 * when the immutable flag is set, which should never happen
155 * for devices. (And that's when the problem is caused, since
156 * you can't set or clear immutable flags for devices.) Once
157 * the kernel has been fixed we can change this...
159 if (inode
->i_flags
& (EXT2_IMMUTABLE_FL
| EXT2_APPEND_FL
)) {
160 for (i
=4; i
< EXT2_N_BLOCKS
; i
++)
161 if (inode
->i_block
[i
])
168 * Check to make sure a symlink inode is real. Returns 1 if the symlink
169 * checks out, 0 if not.
171 int e2fsck_pass1_check_symlink(ext2_filsys fs
, ext2_ino_t ino
,
172 struct ext2_inode
*inode
, char *buf
)
177 ext2_extent_handle_t handle
;
178 struct ext2_extent_info info
;
179 struct ext2fs_extent extent
;
181 if ((inode
->i_size_high
|| inode
->i_size
== 0) ||
182 (inode
->i_flags
& EXT2_INDEX_FL
))
185 if (inode
->i_flags
& EXT4_EXTENTS_FL
) {
186 if (inode
->i_flags
& EXT4_INLINE_DATA_FL
)
188 if (inode
->i_size
> fs
->blocksize
)
190 if (ext2fs_extent_open2(fs
, ino
, inode
, &handle
))
193 if (ext2fs_extent_get_info(handle
, &info
) ||
194 (info
.num_entries
!= 1) ||
195 (info
.max_depth
!= 0))
197 if (ext2fs_extent_get(handle
, EXT2_EXTENT_ROOT
, &extent
) ||
198 (extent
.e_lblk
!= 0) ||
199 (extent
.e_len
!= 1) ||
200 (extent
.e_pblk
< fs
->super
->s_first_data_block
) ||
201 (extent
.e_pblk
>= ext2fs_blocks_count(fs
->super
)))
205 ext2fs_extent_free(handle
);
209 if (inode
->i_flags
& EXT4_INLINE_DATA_FL
) {
212 if (ext2fs_inline_data_size(fs
, ino
, &inline_size
))
214 if (inode
->i_size
!= inline_size
)
220 blocks
= ext2fs_inode_data_blocks2(fs
, inode
);
222 if (inode
->i_flags
& EXT4_INLINE_DATA_FL
)
224 if ((inode
->i_size
>= fs
->blocksize
) ||
225 (blocks
!= fs
->blocksize
>> 9) ||
226 (inode
->i_block
[0] < fs
->super
->s_first_data_block
) ||
227 (inode
->i_block
[0] >= ext2fs_blocks_count(fs
->super
)))
230 for (i
= 1; i
< EXT2_N_BLOCKS
; i
++)
231 if (inode
->i_block
[i
])
234 if (io_channel_read_blk64(fs
->io
, inode
->i_block
[0], 1, buf
))
237 len
= strnlen(buf
, fs
->blocksize
);
238 if (len
== fs
->blocksize
)
240 } else if (inode
->i_flags
& EXT4_INLINE_DATA_FL
) {
241 char *inline_buf
= NULL
;
242 size_t inline_sz
= 0;
244 if (ext2fs_inline_data_size(fs
, ino
, &inline_sz
))
246 if (inode
->i_size
!= inline_sz
)
248 if (ext2fs_get_mem(inline_sz
+ 1, &inline_buf
))
251 if (ext2fs_inline_data_get(fs
, ino
, inode
, inline_buf
, NULL
))
253 inline_buf
[inline_sz
] = 0;
254 len
= strnlen(inline_buf
, inline_sz
);
255 if (len
!= inline_sz
)
259 ext2fs_free_mem(&inline_buf
);
262 if (inode
->i_size
>= sizeof(inode
->i_block
))
265 len
= strnlen((char *)inode
->i_block
, sizeof(inode
->i_block
));
266 if (len
== sizeof(inode
->i_block
))
269 if (len
!= inode
->i_size
)
275 * If the extents or inlinedata flags are set on the inode, offer to clear 'em.
277 #define BAD_SPECIAL_FLAGS (EXT4_EXTENTS_FL | EXT4_INLINE_DATA_FL)
278 static void check_extents_inlinedata(e2fsck_t ctx
,
279 struct problem_context
*pctx
)
281 if (!(pctx
->inode
->i_flags
& BAD_SPECIAL_FLAGS
))
284 if (!fix_problem(ctx
, PR_1_SPECIAL_EXTENTS_IDATA
, pctx
))
287 pctx
->inode
->i_flags
&= ~BAD_SPECIAL_FLAGS
;
288 e2fsck_write_inode(ctx
, pctx
->ino
, pctx
->inode
, "pass1");
290 #undef BAD_SPECIAL_FLAGS
293 * If the immutable (or append-only) flag is set on the inode, offer
296 #define BAD_SPECIAL_FLAGS (EXT2_IMMUTABLE_FL | EXT2_APPEND_FL)
297 static void check_immutable(e2fsck_t ctx
, struct problem_context
*pctx
)
299 if (!(pctx
->inode
->i_flags
& BAD_SPECIAL_FLAGS
))
302 if (!fix_problem(ctx
, PR_1_SET_IMMUTABLE
, pctx
))
305 pctx
->inode
->i_flags
&= ~BAD_SPECIAL_FLAGS
;
306 e2fsck_write_inode(ctx
, pctx
->ino
, pctx
->inode
, "pass1");
310 * If device, fifo or socket, check size is zero -- if not offer to
313 static void check_size(e2fsck_t ctx
, struct problem_context
*pctx
)
315 struct ext2_inode
*inode
= pctx
->inode
;
317 if (EXT2_I_SIZE(inode
) == 0)
320 if (!fix_problem(ctx
, PR_1_SET_NONZSIZE
, pctx
))
323 ext2fs_inode_size_set(ctx
->fs
, inode
, 0);
324 e2fsck_write_inode(ctx
, pctx
->ino
, pctx
->inode
, "pass1");
327 static void check_ea_in_inode(e2fsck_t ctx
, struct problem_context
*pctx
)
329 struct ext2_super_block
*sb
= ctx
->fs
->super
;
330 struct ext2_inode_large
*inode
;
331 struct ext2_ext_attr_entry
*entry
;
332 char *start
, *header
;
333 unsigned int storage_size
, remain
;
334 problem_t problem
= 0;
337 inode
= (struct ext2_inode_large
*) pctx
->inode
;
338 storage_size
= EXT2_INODE_SIZE(ctx
->fs
->super
) - EXT2_GOOD_OLD_INODE_SIZE
-
339 inode
->i_extra_isize
;
340 header
= ((char *) inode
) + EXT2_GOOD_OLD_INODE_SIZE
+
341 inode
->i_extra_isize
;
342 start
= header
+ sizeof(__u32
);
343 entry
= (struct ext2_ext_attr_entry
*) start
;
345 /* scan all entry's headers first */
347 /* take finish entry 0UL into account */
348 remain
= storage_size
- sizeof(__u32
);
350 region
= region_create(0, storage_size
);
352 fix_problem(ctx
, PR_1_EA_ALLOC_REGION_ABORT
, pctx
);
354 ctx
->flags
|= E2F_FLAG_ABORT
;
357 if (region_allocate(region
, 0, sizeof(__u32
))) {
358 problem
= PR_1_INODE_EA_ALLOC_COLLISION
;
362 while (remain
>= sizeof(struct ext2_ext_attr_entry
) &&
363 !EXT2_EXT_IS_LAST_ENTRY(entry
)) {
366 if (region_allocate(region
, (char *)entry
- (char *)header
,
367 EXT2_EXT_ATTR_LEN(entry
->e_name_len
))) {
368 problem
= PR_1_INODE_EA_ALLOC_COLLISION
;
372 /* header eats this space */
373 remain
-= sizeof(struct ext2_ext_attr_entry
);
375 /* is attribute name valid? */
376 if (EXT2_EXT_ATTR_SIZE(entry
->e_name_len
) > remain
) {
377 pctx
->num
= entry
->e_name_len
;
378 problem
= PR_1_ATTR_NAME_LEN
;
382 /* attribute len eats this space */
383 remain
-= EXT2_EXT_ATTR_SIZE(entry
->e_name_len
);
385 /* check value size */
386 if (entry
->e_value_size
> remain
) {
387 pctx
->num
= entry
->e_value_size
;
388 problem
= PR_1_ATTR_VALUE_SIZE
;
392 /* e_value_block must be 0 in inode's ea */
393 if (entry
->e_value_block
!= 0) {
394 pctx
->num
= entry
->e_value_block
;
395 problem
= PR_1_ATTR_VALUE_BLOCK
;
399 if (entry
->e_value_size
&&
400 region_allocate(region
, sizeof(__u32
) + entry
->e_value_offs
,
401 EXT2_EXT_ATTR_SIZE(entry
->e_value_size
))) {
402 problem
= PR_1_INODE_EA_ALLOC_COLLISION
;
406 hash
= ext2fs_ext_attr_hash_entry(entry
,
407 start
+ entry
->e_value_offs
);
409 /* e_hash may be 0 in older inode's ea */
410 if (entry
->e_hash
!= 0 && entry
->e_hash
!= hash
) {
411 pctx
->num
= entry
->e_hash
;
412 problem
= PR_1_ATTR_HASH
;
416 remain
-= entry
->e_value_size
;
418 entry
= EXT2_EXT_ATTR_NEXT(entry
);
421 if (region_allocate(region
, (char *)entry
- (char *)header
,
423 problem
= PR_1_INODE_EA_ALLOC_COLLISION
;
430 * it seems like a corruption. it's very unlikely we could repair
431 * EA(s) in automatic fashion -bzzz
433 if (problem
== 0 || !fix_problem(ctx
, problem
, pctx
))
436 /* simply remove all possible EA(s) */
437 *((__u32
*)header
) = 0UL;
438 e2fsck_write_inode_full(ctx
, pctx
->ino
, pctx
->inode
,
439 EXT2_INODE_SIZE(sb
), "pass1");
442 static void check_inode_extra_space(e2fsck_t ctx
, struct problem_context
*pctx
)
444 struct ext2_super_block
*sb
= ctx
->fs
->super
;
445 struct ext2_inode_large
*inode
;
449 inode
= (struct ext2_inode_large
*) pctx
->inode
;
450 if (EXT2_INODE_SIZE(sb
) == EXT2_GOOD_OLD_INODE_SIZE
) {
451 /* this isn't large inode. so, nothing to check */
456 printf("inode #%u, i_extra_size %d\n", pctx
->ino
,
457 inode
->i_extra_isize
);
459 /* i_extra_isize must cover i_extra_isize + i_checksum_hi at least */
460 min
= sizeof(inode
->i_extra_isize
) + sizeof(inode
->i_checksum_hi
);
461 max
= EXT2_INODE_SIZE(sb
) - EXT2_GOOD_OLD_INODE_SIZE
;
463 * For now we will allow i_extra_isize to be 0, but really
464 * implementations should never allow i_extra_isize to be 0
466 if (inode
->i_extra_isize
&&
467 (inode
->i_extra_isize
< min
|| inode
->i_extra_isize
> max
)) {
468 if (!fix_problem(ctx
, PR_1_EXTRA_ISIZE
, pctx
))
470 inode
->i_extra_isize
= min
;
471 e2fsck_write_inode_full(ctx
, pctx
->ino
, pctx
->inode
,
472 EXT2_INODE_SIZE(sb
), "pass1");
476 eamagic
= (__u32
*) (((char *) inode
) + EXT2_GOOD_OLD_INODE_SIZE
+
477 inode
->i_extra_isize
);
478 if (*eamagic
== EXT2_EXT_ATTR_MAGIC
) {
479 /* it seems inode has an extended attribute(s) in body */
480 check_ea_in_inode(ctx
, pctx
);
485 * Check to see if the inode might really be a directory, despite i_mode
487 * This is a lot of complexity for something for which I'm not really
488 * convinced happens frequently in the wild. If for any reason this
489 * causes any problems, take this code out.
490 * [tytso:20070331.0827EDT]
492 static void check_is_really_dir(e2fsck_t ctx
, struct problem_context
*pctx
,
495 struct ext2_inode
*inode
= pctx
->inode
;
496 struct ext2_dir_entry
*dirent
;
499 unsigned int i
, rec_len
, not_device
= 0;
504 * If the mode looks OK, we believe it. If the first block in
505 * the i_block array is 0, this cannot be a directory. If the
506 * inode is extent-mapped, it is still the case that the latter
507 * cannot be 0 - the magic number in the extent header would make
510 if (LINUX_S_ISDIR(inode
->i_mode
) || LINUX_S_ISREG(inode
->i_mode
) ||
511 LINUX_S_ISLNK(inode
->i_mode
) || inode
->i_block
[0] == 0)
515 * Check the block numbers in the i_block array for validity:
516 * zero blocks are skipped (but the first one cannot be zero -
517 * see above), other blocks are checked against the first and
518 * max data blocks (from the the superblock) and against the
519 * block bitmap. Any invalid block found means this cannot be
522 * If there are non-zero blocks past the fourth entry, then
523 * this cannot be a device file: we remember that for the next
526 * For extent mapped files, we don't do any sanity checking:
527 * just try to get the phys block of logical block 0 and run
530 * For inline data files, we just try to get the size of inline
531 * data. If it's true, we will treat it as a directory.
534 extent_fs
= (ctx
->fs
->super
->s_feature_incompat
&
535 EXT3_FEATURE_INCOMPAT_EXTENTS
);
536 inlinedata_fs
= (ctx
->fs
->super
->s_feature_incompat
&
537 EXT4_FEATURE_INCOMPAT_INLINE_DATA
);
538 if (inlinedata_fs
&& (inode
->i_flags
& EXT4_INLINE_DATA_FL
)) {
541 if (ext2fs_inline_data_size(ctx
->fs
, pctx
->ino
, &size
))
544 * If the size isn't a multiple of 4, it's probably not a
549 /* device files never have a "system.data" entry */
551 } else if (extent_fs
&& (inode
->i_flags
& EXT4_EXTENTS_FL
)) {
553 if (ext2fs_bmap2(ctx
->fs
, pctx
->ino
, inode
, 0, 0, 0, 0,
556 /* device files are never extent mapped */
559 for (i
=0; i
< EXT2_N_BLOCKS
; i
++) {
560 blk
= inode
->i_block
[i
];
566 if (blk
< ctx
->fs
->super
->s_first_data_block
||
567 blk
>= ext2fs_blocks_count(ctx
->fs
->super
) ||
568 ext2fs_fast_test_block_bitmap2(ctx
->block_found_map
,
570 return; /* Invalid block, can't be dir */
572 blk
= inode
->i_block
[0];
576 * If the mode says this is a device file and the i_links_count field
577 * is sane and we have not ruled it out as a device file previously,
578 * we declare it a device file, not a directory.
580 if ((LINUX_S_ISCHR(inode
->i_mode
) || LINUX_S_ISBLK(inode
->i_mode
)) &&
581 (inode
->i_links_count
== 1) && !not_device
)
584 /* read the first block */
585 ehandler_operation(_("reading directory block"));
586 retval
= ext2fs_read_dir_block4(ctx
->fs
, blk
, buf
, 0, pctx
->ino
);
587 ehandler_operation(0);
591 dirent
= (struct ext2_dir_entry
*) buf
;
592 retval
= ext2fs_get_rec_len(ctx
->fs
, dirent
, &rec_len
);
595 if ((ext2fs_dirent_name_len(dirent
) != 1) ||
596 (dirent
->name
[0] != '.') ||
597 (dirent
->inode
!= pctx
->ino
) ||
600 (rec_len
>= ctx
->fs
->blocksize
- 12))
603 dirent
= (struct ext2_dir_entry
*) (buf
+ rec_len
);
604 retval
= ext2fs_get_rec_len(ctx
->fs
, dirent
, &rec_len
);
607 if ((ext2fs_dirent_name_len(dirent
) != 2) ||
608 (dirent
->name
[0] != '.') ||
609 (dirent
->name
[1] != '.') ||
615 if (fix_problem(ctx
, PR_1_TREAT_AS_DIRECTORY
, pctx
)) {
616 inode
->i_mode
= (inode
->i_mode
& 07777) | LINUX_S_IFDIR
;
617 e2fsck_write_inode_full(ctx
, pctx
->ino
, inode
,
618 EXT2_INODE_SIZE(ctx
->fs
->super
),
619 "check_is_really_dir");
623 void e2fsck_setup_tdb_icount(e2fsck_t ctx
, int flags
,
626 unsigned int threshold
;
634 profile_get_string(ctx
->profile
, "scratch_files", "directory", 0, 0,
636 profile_get_uint(ctx
->profile
, "scratch_files",
637 "numdirs_threshold", 0, 0, &threshold
);
638 profile_get_boolean(ctx
->profile
, "scratch_files",
639 "icount", 0, 1, &enable
);
641 retval
= ext2fs_get_num_dirs(ctx
->fs
, &num_dirs
);
643 num_dirs
= 1024; /* Guess */
645 if (!enable
|| !tdb_dir
|| access(tdb_dir
, W_OK
) ||
646 (threshold
&& num_dirs
<= threshold
))
649 retval
= ext2fs_create_icount_tdb(ctx
->fs
, tdb_dir
, flags
, ret
);
654 static errcode_t
recheck_bad_inode_checksum(ext2_filsys fs
, ext2_ino_t ino
,
656 struct problem_context
*pctx
)
659 struct ext2_inode_large inode
;
662 * Reread inode. If we don't see checksum error, then this inode
663 * has been fixed elsewhere.
665 retval
= ext2fs_read_inode_full(fs
, ino
, (struct ext2_inode
*)&inode
,
667 if (retval
&& retval
!= EXT2_ET_INODE_CSUM_INVALID
)
673 * Checksum still doesn't match. That implies that the inode passes
674 * all the sanity checks, so maybe the checksum is simply corrupt.
675 * See if the user will go for fixing that.
677 if (!fix_problem(ctx
, PR_1_INODE_ONLY_CSUM_INVALID
, pctx
))
680 retval
= ext2fs_write_inode_full(fs
, ino
, (struct ext2_inode
*)&inode
,
685 static void reserve_block_for_root_repair(e2fsck_t ctx
)
689 ext2_filsys fs
= ctx
->fs
;
691 ctx
->root_repair_block
= 0;
692 if (ext2fs_test_inode_bitmap2(ctx
->inode_used_map
, EXT2_ROOT_INO
))
695 err
= ext2fs_new_block2(fs
, 0, ctx
->block_found_map
, &blk
);
698 ext2fs_mark_block_bitmap2(ctx
->block_found_map
, blk
);
699 ctx
->root_repair_block
= blk
;
702 static void reserve_block_for_lnf_repair(e2fsck_t ctx
)
706 ext2_filsys fs
= ctx
->fs
;
707 static const char name
[] = "lost+found";
710 ctx
->lnf_repair_block
= 0;
711 if (!ext2fs_lookup(fs
, EXT2_ROOT_INO
, name
, sizeof(name
)-1, 0, &ino
))
714 err
= ext2fs_new_block2(fs
, 0, ctx
->block_found_map
, &blk
);
717 ext2fs_mark_block_bitmap2(ctx
->block_found_map
, blk
);
718 ctx
->lnf_repair_block
= blk
;
721 static errcode_t
get_inline_data_ea_size(ext2_filsys fs
, ext2_ino_t ino
,
725 struct ext2_xattr_handle
*handle
;
728 retval
= ext2fs_xattrs_open(fs
, ino
, &handle
);
732 retval
= ext2fs_xattrs_read(handle
);
736 retval
= ext2fs_xattr_get(handle
, "system.data", &p
, sz
);
741 (void) ext2fs_xattrs_close(&handle
);
745 static void finish_processing_inode(e2fsck_t ctx
, ext2_ino_t ino
,
746 struct problem_context
*pctx
,
753 * If the inode failed the checksum and the user didn't
754 * clear the inode, test the checksum again -- if it still
755 * fails, ask the user if the checksum should be corrected.
757 pctx
->errcode
= recheck_bad_inode_checksum(ctx
->fs
, ino
, ctx
, pctx
);
759 ctx
->flags
|= E2F_FLAG_ABORT
;
761 #define FINISH_INODE_LOOP(ctx, ino, pctx, failed_csum) \
763 finish_processing_inode((ctx), (ino), (pctx), (failed_csum)); \
764 if ((ctx)->flags & E2F_FLAG_ABORT) \
768 static int could_be_block_map(ext2_filsys fs
, struct ext2_inode
*inode
)
773 for (i
= 0; i
< EXT2_N_BLOCKS
; i
++) {
774 x
= inode
->i_block
[i
];
775 #ifdef WORDS_BIGENDIAN
776 x
= ext2fs_swab32(x
);
778 if (x
>= ext2fs_blocks_count(fs
->super
))
786 * Figure out what to do with an inode that has both extents and inline data
787 * inode flags set. Returns -1 if we decide to erase the inode, 0 otherwise.
789 static int fix_inline_data_extents_file(e2fsck_t ctx
,
791 struct ext2_inode
*inode
,
793 struct problem_context
*pctx
)
795 size_t max_inline_ea_size
;
796 ext2_filsys fs
= ctx
->fs
;
799 /* Both feature flags not set? Just run the regular checks */
800 if (!EXT2_HAS_INCOMPAT_FEATURE(fs
->super
,
801 EXT3_FEATURE_INCOMPAT_EXTENTS
) &&
802 !EXT2_HAS_INCOMPAT_FEATURE(fs
->super
,
803 EXT4_FEATURE_INCOMPAT_INLINE_DATA
))
806 /* Clear both flags if it's a special file */
807 if (LINUX_S_ISCHR(inode
->i_mode
) ||
808 LINUX_S_ISBLK(inode
->i_mode
) ||
809 LINUX_S_ISFIFO(inode
->i_mode
) ||
810 LINUX_S_ISSOCK(inode
->i_mode
)) {
811 check_extents_inlinedata(ctx
, pctx
);
815 /* If it looks like an extent tree, try to clear inlinedata */
816 if (ext2fs_extent_header_verify(inode
->i_block
,
817 sizeof(inode
->i_block
)) == 0 &&
818 fix_problem(ctx
, PR_1_CLEAR_INLINE_DATA_FOR_EXTENT
, pctx
)) {
819 inode
->i_flags
&= ~EXT4_INLINE_DATA_FL
;
824 /* If it looks short enough to be inline data, try to clear extents */
825 if (EXT2_INODE_SIZE(fs
->super
) > EXT2_GOOD_OLD_INODE_SIZE
)
826 max_inline_ea_size
= EXT2_INODE_SIZE(fs
->super
) -
827 (EXT2_GOOD_OLD_INODE_SIZE
+
828 ((struct ext2_inode_large
*)inode
)->i_extra_isize
);
830 max_inline_ea_size
= 0;
831 if (EXT2_I_SIZE(inode
) <
832 EXT4_MIN_INLINE_DATA_SIZE
+ max_inline_ea_size
&&
833 fix_problem(ctx
, PR_1_CLEAR_EXTENT_FOR_INLINE_DATA
, pctx
)) {
834 inode
->i_flags
&= ~EXT4_EXTENTS_FL
;
840 * Too big for inline data, but no evidence of extent tree -
841 * maybe it's a block map file? If the mappings all look valid?
843 if (could_be_block_map(fs
, inode
) &&
844 fix_problem(ctx
, PR_1_CLEAR_EXTENT_INLINE_DATA_FLAGS
, pctx
)) {
845 #ifdef WORDS_BIGENDIAN
848 for (i
= 0; i
< EXT2_N_BLOCKS
; i
++)
849 inode
->i_block
[i
] = ext2fs_swab32(inode
->i_block
[i
]);
852 inode
->i_flags
&= ~(EXT4_EXTENTS_FL
| EXT4_INLINE_DATA_FL
);
857 /* Oh well, just clear the busted inode. */
858 if (fix_problem(ctx
, PR_1_CLEAR_EXTENT_INLINE_DATA_INODE
, pctx
)) {
859 e2fsck_clear_inode(ctx
, ino
, inode
, 0, "pass1");
865 e2fsck_write_inode(ctx
, ino
, inode
, "pass1");
870 void e2fsck_pass1(e2fsck_t ctx
)
874 ext2_filsys fs
= ctx
->fs
;
876 struct ext2_inode
*inode
= NULL
;
877 ext2_inode_scan scan
= NULL
;
878 char *block_buf
= NULL
;
879 #ifdef RESOURCE_TRACK
880 struct resource_track rtrack
;
882 unsigned char frag
, fsize
;
883 struct problem_context pctx
;
884 struct scan_callback_struct scan_struct
;
885 struct ext2_super_block
*sb
= ctx
->fs
->super
;
887 unsigned int save_type
;
888 int imagic_fs
, extent_fs
, inlinedata_fs
;
889 int low_dtime_check
= 1;
893 init_resource_track(&rtrack
, ctx
->fs
->io
);
894 clear_problem_context(&pctx
);
896 if (!(ctx
->options
& E2F_OPT_PREEN
))
897 fix_problem(ctx
, PR_1_PASS_HEADER
, &pctx
);
899 if ((fs
->super
->s_feature_compat
& EXT2_FEATURE_COMPAT_DIR_INDEX
) &&
900 !(ctx
->options
& E2F_OPT_NO
)) {
901 if (ext2fs_u32_list_create(&ctx
->dirs_to_hash
, 50))
902 ctx
->dirs_to_hash
= 0;
906 mtrace_print("Pass 1");
909 #define EXT2_BPP(bits) (1ULL << ((bits) - 2))
911 for (i
= EXT2_MIN_BLOCK_LOG_SIZE
; i
<= EXT2_MAX_BLOCK_LOG_SIZE
; i
++) {
912 max_sizes
= EXT2_NDIR_BLOCKS
+ EXT2_BPP(i
);
913 max_sizes
= max_sizes
+ EXT2_BPP(i
) * EXT2_BPP(i
);
914 max_sizes
= max_sizes
+ EXT2_BPP(i
) * EXT2_BPP(i
) * EXT2_BPP(i
);
915 max_sizes
= (max_sizes
* (1UL << i
));
916 ext2_max_sizes
[i
- EXT2_MIN_BLOCK_LOG_SIZE
] = max_sizes
;
920 imagic_fs
= (sb
->s_feature_compat
& EXT2_FEATURE_COMPAT_IMAGIC_INODES
);
921 extent_fs
= (sb
->s_feature_incompat
& EXT3_FEATURE_INCOMPAT_EXTENTS
);
922 inlinedata_fs
= (sb
->s_feature_incompat
&
923 EXT4_FEATURE_INCOMPAT_INLINE_DATA
);
926 * Allocate bitmaps structures
928 pctx
.errcode
= e2fsck_allocate_inode_bitmap(fs
, _("in-use inode map"),
929 EXT2FS_BMAP64_RBTREE
,
931 &ctx
->inode_used_map
);
934 fix_problem(ctx
, PR_1_ALLOCATE_IBITMAP_ERROR
, &pctx
);
935 ctx
->flags
|= E2F_FLAG_ABORT
;
938 pctx
.errcode
= e2fsck_allocate_inode_bitmap(fs
,
939 _("directory inode map"),
940 EXT2FS_BMAP64_AUTODIR
,
941 "inode_dir_map", &ctx
->inode_dir_map
);
944 fix_problem(ctx
, PR_1_ALLOCATE_IBITMAP_ERROR
, &pctx
);
945 ctx
->flags
|= E2F_FLAG_ABORT
;
948 pctx
.errcode
= e2fsck_allocate_inode_bitmap(fs
,
949 _("regular file inode map"), EXT2FS_BMAP64_RBTREE
,
950 "inode_reg_map", &ctx
->inode_reg_map
);
953 fix_problem(ctx
, PR_1_ALLOCATE_IBITMAP_ERROR
, &pctx
);
954 ctx
->flags
|= E2F_FLAG_ABORT
;
957 pctx
.errcode
= e2fsck_allocate_subcluster_bitmap(fs
,
958 _("in-use block map"), EXT2FS_BMAP64_RBTREE
,
959 "block_found_map", &ctx
->block_found_map
);
962 fix_problem(ctx
, PR_1_ALLOCATE_BBITMAP_ERROR
, &pctx
);
963 ctx
->flags
|= E2F_FLAG_ABORT
;
966 pctx
.errcode
= e2fsck_allocate_block_bitmap(fs
,
967 _("metadata block map"), EXT2FS_BMAP64_RBTREE
,
968 "block_metadata_map", &ctx
->block_metadata_map
);
971 fix_problem(ctx
, PR_1_ALLOCATE_BBITMAP_ERROR
, &pctx
);
972 ctx
->flags
|= E2F_FLAG_ABORT
;
975 e2fsck_setup_tdb_icount(ctx
, 0, &ctx
->inode_link_info
);
976 if (!ctx
->inode_link_info
) {
977 e2fsck_set_bitmap_type(fs
, EXT2FS_BMAP64_RBTREE
,
978 "inode_link_info", &save_type
);
979 pctx
.errcode
= ext2fs_create_icount2(fs
, 0, 0, 0,
980 &ctx
->inode_link_info
);
981 fs
->default_bitmap_type
= save_type
;
985 fix_problem(ctx
, PR_1_ALLOCATE_ICOUNT
, &pctx
);
986 ctx
->flags
|= E2F_FLAG_ABORT
;
989 inode_size
= EXT2_INODE_SIZE(fs
->super
);
990 inode
= (struct ext2_inode
*)
991 e2fsck_allocate_memory(ctx
, inode_size
, "scratch inode");
993 inodes_to_process
= (struct process_inode_block
*)
994 e2fsck_allocate_memory(ctx
,
995 (ctx
->process_inode_size
*
996 sizeof(struct process_inode_block
)),
997 "array of inodes to process");
998 process_inode_count
= 0;
1000 pctx
.errcode
= ext2fs_init_dblist(fs
, 0);
1002 fix_problem(ctx
, PR_1_ALLOCATE_DBCOUNT
, &pctx
);
1003 ctx
->flags
|= E2F_FLAG_ABORT
;
1008 * If the last orphan field is set, clear it, since the pass1
1009 * processing will automatically find and clear the orphans.
1010 * In the future, we may want to try using the last_orphan
1011 * linked list ourselves, but for now, we clear it so that the
1012 * ext3 mount code won't get confused.
1014 if (!(ctx
->options
& E2F_OPT_READONLY
)) {
1015 if (fs
->super
->s_last_orphan
) {
1016 fs
->super
->s_last_orphan
= 0;
1017 ext2fs_mark_super_dirty(fs
);
1021 mark_table_blocks(ctx
);
1022 pctx
.errcode
= ext2fs_convert_subcluster_bitmap(fs
,
1023 &ctx
->block_found_map
);
1025 fix_problem(ctx
, PR_1_CONVERT_SUBCLUSTER
, &pctx
);
1026 ctx
->flags
|= E2F_FLAG_ABORT
;
1029 block_buf
= (char *) e2fsck_allocate_memory(ctx
, fs
->blocksize
* 3,
1030 "block interate buffer");
1031 if (EXT2_INODE_SIZE(fs
->super
) == EXT2_GOOD_OLD_INODE_SIZE
)
1032 e2fsck_use_inode_shortcuts(ctx
, 1);
1033 e2fsck_intercept_block_allocations(ctx
);
1034 old_op
= ehandler_operation(_("opening inode scan"));
1035 pctx
.errcode
= ext2fs_open_inode_scan(fs
, ctx
->inode_buffer_blocks
,
1037 ehandler_operation(old_op
);
1039 fix_problem(ctx
, PR_1_ISCAN_ERROR
, &pctx
);
1040 ctx
->flags
|= E2F_FLAG_ABORT
;
1043 ext2fs_inode_scan_flags(scan
, EXT2_SF_SKIP_MISSING_ITABLE
|
1044 EXT2_SF_WARN_GARBAGE_INODES
, 0);
1045 ctx
->stashed_inode
= inode
;
1046 scan_struct
.ctx
= ctx
;
1047 scan_struct
.block_buf
= block_buf
;
1048 ext2fs_set_inode_callback(scan
, scan_callback
, &scan_struct
);
1049 if (ctx
->progress
&& ((ctx
->progress
)(ctx
, 1, 0,
1050 ctx
->fs
->group_desc_count
)))
1052 if ((fs
->super
->s_wtime
< fs
->super
->s_inodes_count
) ||
1053 (fs
->super
->s_mtime
< fs
->super
->s_inodes_count
) ||
1054 (fs
->super
->s_mkfs_time
&&
1055 fs
->super
->s_mkfs_time
< fs
->super
->s_inodes_count
))
1056 low_dtime_check
= 0;
1058 if ((fs
->super
->s_feature_incompat
& EXT4_FEATURE_INCOMPAT_MMP
) &&
1059 fs
->super
->s_mmp_block
> fs
->super
->s_first_data_block
&&
1060 fs
->super
->s_mmp_block
< ext2fs_blocks_count(fs
->super
))
1061 ext2fs_mark_block_bitmap2(ctx
->block_found_map
,
1062 fs
->super
->s_mmp_block
);
1064 /* Set up ctx->lost_and_found if possible */
1065 (void) e2fsck_get_lost_and_found(ctx
, 0);
1068 if (ino
% (fs
->super
->s_inodes_per_group
* 4) == 1) {
1069 if (e2fsck_mmp_update(fs
))
1070 fatal_error(ctx
, 0);
1072 old_op
= ehandler_operation(_("getting next inode from scan"));
1073 pctx
.errcode
= ext2fs_get_next_inode_full(scan
, &ino
,
1075 ehandler_operation(old_op
);
1076 if (ctx
->flags
& E2F_FLAG_SIGNAL_MASK
)
1078 if (pctx
.errcode
== EXT2_ET_BAD_BLOCK_IN_INODE_TABLE
) {
1079 if (!ctx
->inode_bb_map
)
1081 ext2fs_mark_inode_bitmap2(ctx
->inode_bb_map
, ino
);
1082 ext2fs_mark_inode_bitmap2(ctx
->inode_used_map
, ino
);
1086 pctx
.errcode
!= EXT2_ET_INODE_CSUM_INVALID
&&
1087 pctx
.errcode
!= EXT2_ET_INODE_IS_GARBAGE
) {
1088 fix_problem(ctx
, PR_1_ISCAN_ERROR
, &pctx
);
1089 ctx
->flags
|= E2F_FLAG_ABORT
;
1096 ctx
->stashed_ino
= ino
;
1098 /* Clear trashed inode? */
1099 if (pctx
.errcode
== EXT2_ET_INODE_IS_GARBAGE
&&
1100 inode
->i_links_count
> 0 &&
1101 fix_problem(ctx
, PR_1_INODE_IS_GARBAGE
, &pctx
)) {
1103 e2fsck_clear_inode(ctx
, ino
, inode
, 0, "pass1");
1105 failed_csum
= pctx
.errcode
!= 0;
1107 if (inode
->i_links_count
) {
1108 pctx
.errcode
= ext2fs_icount_store(ctx
->inode_link_info
,
1109 ino
, inode
->i_links_count
);
1111 pctx
.num
= inode
->i_links_count
;
1112 fix_problem(ctx
, PR_1_ICOUNT_STORE
, &pctx
);
1113 ctx
->flags
|= E2F_FLAG_ABORT
;
1118 /* Conflicting inlinedata/extents inode flags? */
1119 if ((inode
->i_flags
& EXT4_INLINE_DATA_FL
) &&
1120 (inode
->i_flags
& EXT4_EXTENTS_FL
)) {
1121 int res
= fix_inline_data_extents_file(ctx
, ino
, inode
,
1125 /* skip FINISH_INODE_LOOP */
1130 /* Test for incorrect inline_data flags settings. */
1131 if ((inode
->i_flags
& EXT4_INLINE_DATA_FL
) && !inlinedata_fs
&&
1132 (ino
>= EXT2_FIRST_INODE(fs
->super
))) {
1135 pctx
.errcode
= ext2fs_inline_data_size(fs
, ino
, &size
);
1136 if (!pctx
.errcode
&& size
&&
1137 !fix_problem(ctx
, PR_1_INLINE_DATA_FEATURE
, &pctx
)) {
1138 sb
->s_feature_incompat
|=
1139 EXT4_FEATURE_INCOMPAT_INLINE_DATA
;
1140 ext2fs_mark_super_dirty(fs
);
1142 } else if (!fix_problem(ctx
, PR_1_INLINE_DATA_SET
, &pctx
)) {
1143 e2fsck_clear_inode(ctx
, ino
, inode
, 0, "pass1");
1144 /* skip FINISH_INODE_LOOP */
1149 /* Test for inline data flag but no attr */
1150 if ((inode
->i_flags
& EXT4_INLINE_DATA_FL
) && inlinedata_fs
&&
1151 EXT2_I_SIZE(inode
) > EXT4_MIN_INLINE_DATA_SIZE
&&
1152 (ino
>= EXT2_FIRST_INODE(fs
->super
))) {
1159 fs
->flags
|= EXT2_FLAG_IGNORE_CSUM_ERRORS
;
1160 err
= get_inline_data_ea_size(fs
, ino
, &size
);
1161 fs
->flags
= (flags
& EXT2_FLAG_IGNORE_CSUM_ERRORS
) |
1162 (fs
->flags
& ~EXT2_FLAG_IGNORE_CSUM_ERRORS
);
1166 /* Everything is awesome... */
1168 case EXT2_ET_BAD_EA_BLOCK_NUM
:
1169 case EXT2_ET_BAD_EA_HASH
:
1170 case EXT2_ET_BAD_EA_HEADER
:
1171 case EXT2_ET_EA_BAD_NAME_LEN
:
1172 case EXT2_ET_EA_BAD_VALUE_SIZE
:
1173 case EXT2_ET_EA_KEY_NOT_FOUND
:
1174 case EXT2_ET_EA_NO_SPACE
:
1175 case EXT2_ET_MISSING_EA_FEATURE
:
1176 case EXT2_ET_INLINE_DATA_CANT_ITERATE
:
1177 case EXT2_ET_INLINE_DATA_NO_BLOCK
:
1178 case EXT2_ET_INLINE_DATA_NO_SPACE
:
1179 case EXT2_ET_NO_INLINE_DATA
:
1180 case EXT2_ET_EXT_ATTR_CSUM_INVALID
:
1181 case EXT2_ET_EA_BAD_VALUE_OFFSET
:
1182 /* broken EA or no system.data EA; truncate */
1183 if (fix_problem(ctx
, PR_1_INLINE_DATA_NO_ATTR
,
1185 err
= ext2fs_inode_size_set(fs
, inode
,
1186 sizeof(inode
->i_block
));
1189 ctx
->flags
|= E2F_FLAG_ABORT
;
1192 e2fsck_write_inode(ctx
, ino
, inode
,
1198 /* Some other kind of non-xattr error? */
1200 ctx
->flags
|= E2F_FLAG_ABORT
;
1206 * Test for incorrect extent flag settings.
1208 * On big-endian machines we must be careful:
1209 * When the inode is read, the i_block array is not swapped
1210 * if the extent flag is set. Therefore if we are testing
1211 * for or fixing a wrongly-set flag, we must potentially
1212 * (un)swap before testing, or after fixing.
1216 * In this case the extents flag was set when read, so
1217 * extent_header_verify is ok. If the inode is cleared,
1218 * no need to swap... so no extra swapping here.
1220 if ((inode
->i_flags
& EXT4_EXTENTS_FL
) && !extent_fs
&&
1221 (inode
->i_links_count
|| (ino
== EXT2_BAD_INO
) ||
1222 (ino
== EXT2_ROOT_INO
) || (ino
== EXT2_JOURNAL_INO
))) {
1223 if ((ext2fs_extent_header_verify(inode
->i_block
,
1224 sizeof(inode
->i_block
)) == 0) &&
1225 fix_problem(ctx
, PR_1_EXTENT_FEATURE
, &pctx
)) {
1226 sb
->s_feature_incompat
|= EXT3_FEATURE_INCOMPAT_EXTENTS
;
1227 ext2fs_mark_super_dirty(fs
);
1229 } else if (fix_problem(ctx
, PR_1_EXTENTS_SET
, &pctx
)) {
1231 e2fsck_clear_inode(ctx
, ino
, inode
, 0, "pass1");
1232 if (ino
== EXT2_BAD_INO
)
1233 ext2fs_mark_inode_bitmap2(ctx
->inode_used_map
,
1235 /* skip FINISH_INODE_LOOP */
1241 * For big-endian machines:
1242 * If the inode didn't have the extents flag set when it
1243 * was read, then the i_blocks array was swapped. To test
1244 * as an extents header, we must swap it back first.
1245 * IF we then set the extents flag, the entire i_block
1246 * array must be un/re-swapped to make it proper extents data.
1248 if (extent_fs
&& !(inode
->i_flags
& EXT4_EXTENTS_FL
) &&
1249 (inode
->i_links_count
|| (ino
== EXT2_BAD_INO
) ||
1250 (ino
== EXT2_ROOT_INO
) || (ino
== EXT2_JOURNAL_INO
)) &&
1251 (LINUX_S_ISREG(inode
->i_mode
) ||
1252 LINUX_S_ISDIR(inode
->i_mode
))) {
1254 #ifdef WORDS_BIGENDIAN
1255 __u32 tmp_block
[EXT2_N_BLOCKS
];
1257 for (i
= 0; i
< EXT2_N_BLOCKS
; i
++)
1258 tmp_block
[i
] = ext2fs_swab32(inode
->i_block
[i
]);
1261 ehp
= inode
->i_block
;
1263 if ((ext2fs_extent_header_verify(ehp
,
1264 sizeof(inode
->i_block
)) == 0) &&
1265 (fix_problem(ctx
, PR_1_UNSET_EXTENT_FL
, &pctx
))) {
1266 inode
->i_flags
|= EXT4_EXTENTS_FL
;
1267 #ifdef WORDS_BIGENDIAN
1268 memcpy(inode
->i_block
, tmp_block
,
1269 sizeof(inode
->i_block
));
1271 e2fsck_write_inode(ctx
, ino
, inode
, "pass1");
1276 if (ino
== EXT2_BAD_INO
) {
1277 struct process_block_struct pb
;
1279 if ((failed_csum
|| inode
->i_mode
|| inode
->i_uid
||
1280 inode
->i_gid
|| inode
->i_links_count
||
1281 (inode
->i_flags
& EXT4_INLINE_DATA_FL
) ||
1282 inode
->i_file_acl
) &&
1283 fix_problem(ctx
, PR_1_INVALID_BAD_INODE
, &pctx
)) {
1284 memset(inode
, 0, sizeof(struct ext2_inode
));
1285 e2fsck_write_inode(ctx
, ino
, inode
,
1290 pctx
.errcode
= ext2fs_copy_bitmap(ctx
->block_found_map
,
1291 &pb
.fs_meta_blocks
);
1294 fix_problem(ctx
, PR_1_ALLOCATE_BBITMAP_ERROR
, &pctx
);
1295 ctx
->flags
|= E2F_FLAG_ABORT
;
1298 pb
.ino
= EXT2_BAD_INO
;
1299 pb
.num_blocks
= pb
.last_block
= 0;
1300 pb
.last_db_block
= -1;
1301 pb
.num_illegal_blocks
= 0;
1302 pb
.suppress
= 0; pb
.clear
= 0; pb
.is_dir
= 0;
1303 pb
.is_reg
= 0; pb
.fragmented
= 0; pb
.bbcheck
= 0;
1307 pctx
.errcode
= ext2fs_block_iterate3(fs
, ino
, 0,
1308 block_buf
, process_bad_block
, &pb
);
1309 ext2fs_free_block_bitmap(pb
.fs_meta_blocks
);
1311 fix_problem(ctx
, PR_1_BLOCK_ITERATE
, &pctx
);
1312 ctx
->flags
|= E2F_FLAG_ABORT
;
1316 if (!fix_problem(ctx
, PR_1_BBINODE_BAD_METABLOCK_PROMPT
, &pctx
)) {
1317 ctx
->flags
|= E2F_FLAG_ABORT
;
1320 ext2fs_mark_inode_bitmap2(ctx
->inode_used_map
, ino
);
1321 clear_problem_context(&pctx
);
1322 FINISH_INODE_LOOP(ctx
, ino
, &pctx
, failed_csum
);
1324 } else if (ino
== EXT2_ROOT_INO
) {
1326 * Make sure the root inode is a directory; if
1327 * not, offer to clear it. It will be
1328 * regnerated in pass #3.
1330 if (!LINUX_S_ISDIR(inode
->i_mode
)) {
1331 if (fix_problem(ctx
, PR_1_ROOT_NO_DIR
, &pctx
))
1335 * If dtime is set, offer to clear it. mke2fs
1336 * version 0.2b created filesystems with the
1337 * dtime field set for the root and lost+found
1338 * directories. We won't worry about
1339 * /lost+found, since that can be regenerated
1340 * easily. But we will fix the root directory
1341 * as a special case.
1343 if (inode
->i_dtime
&& inode
->i_links_count
) {
1344 if (fix_problem(ctx
, PR_1_ROOT_DTIME
, &pctx
)) {
1346 e2fsck_write_inode(ctx
, ino
, inode
,
1351 } else if (ino
== EXT2_JOURNAL_INO
) {
1352 ext2fs_mark_inode_bitmap2(ctx
->inode_used_map
, ino
);
1353 if (fs
->super
->s_journal_inum
== EXT2_JOURNAL_INO
) {
1354 if (!LINUX_S_ISREG(inode
->i_mode
) &&
1355 fix_problem(ctx
, PR_1_JOURNAL_BAD_MODE
,
1357 inode
->i_mode
= LINUX_S_IFREG
;
1358 e2fsck_write_inode(ctx
, ino
, inode
,
1362 check_blocks(ctx
, &pctx
, block_buf
);
1363 FINISH_INODE_LOOP(ctx
, ino
, &pctx
, failed_csum
);
1366 if ((inode
->i_links_count
||
1367 inode
->i_blocks
|| inode
->i_block
[0]) &&
1368 fix_problem(ctx
, PR_1_JOURNAL_INODE_NOT_CLEAR
,
1370 memset(inode
, 0, inode_size
);
1371 ext2fs_icount_store(ctx
->inode_link_info
,
1373 e2fsck_write_inode_full(ctx
, ino
, inode
,
1374 inode_size
, "pass1");
1377 } else if ((ino
== EXT4_USR_QUOTA_INO
) ||
1378 (ino
== EXT4_GRP_QUOTA_INO
)) {
1379 ext2fs_mark_inode_bitmap2(ctx
->inode_used_map
, ino
);
1380 if ((fs
->super
->s_feature_ro_compat
&
1381 EXT4_FEATURE_RO_COMPAT_QUOTA
) &&
1382 ((fs
->super
->s_usr_quota_inum
== ino
) ||
1383 (fs
->super
->s_grp_quota_inum
== ino
))) {
1384 if (!LINUX_S_ISREG(inode
->i_mode
) &&
1385 fix_problem(ctx
, PR_1_QUOTA_BAD_MODE
,
1387 inode
->i_mode
= LINUX_S_IFREG
;
1388 e2fsck_write_inode(ctx
, ino
, inode
,
1392 check_blocks(ctx
, &pctx
, block_buf
);
1393 FINISH_INODE_LOOP(ctx
, ino
, &pctx
, failed_csum
);
1396 if ((inode
->i_links_count
||
1397 inode
->i_blocks
|| inode
->i_block
[0]) &&
1398 fix_problem(ctx
, PR_1_QUOTA_INODE_NOT_CLEAR
,
1400 memset(inode
, 0, inode_size
);
1401 ext2fs_icount_store(ctx
->inode_link_info
,
1403 e2fsck_write_inode_full(ctx
, ino
, inode
,
1404 inode_size
, "pass1");
1407 } else if (ino
< EXT2_FIRST_INODE(fs
->super
)) {
1408 problem_t problem
= 0;
1410 ext2fs_mark_inode_bitmap2(ctx
->inode_used_map
, ino
);
1411 if (ino
== EXT2_BOOT_LOADER_INO
) {
1412 if (LINUX_S_ISDIR(inode
->i_mode
))
1413 problem
= PR_1_RESERVED_BAD_MODE
;
1414 } else if (ino
== EXT2_RESIZE_INO
) {
1415 if (inode
->i_mode
&&
1416 !LINUX_S_ISREG(inode
->i_mode
))
1417 problem
= PR_1_RESERVED_BAD_MODE
;
1419 if (inode
->i_mode
!= 0)
1420 problem
= PR_1_RESERVED_BAD_MODE
;
1423 if (fix_problem(ctx
, problem
, &pctx
)) {
1425 e2fsck_write_inode(ctx
, ino
, inode
,
1430 check_blocks(ctx
, &pctx
, block_buf
);
1431 FINISH_INODE_LOOP(ctx
, ino
, &pctx
, failed_csum
);
1436 * Check for inodes who might have been part of the
1437 * orphaned list linked list. They should have gotten
1438 * dealt with by now, unless the list had somehow been
1441 * FIXME: In the future, inodes which are still in use
1442 * (and which are therefore) pending truncation should
1443 * be handled specially. Right now we just clear the
1444 * dtime field, and the normal e2fsck handling of
1445 * inodes where i_size and the inode blocks are
1446 * inconsistent is to fix i_size, instead of releasing
1447 * the extra blocks. This won't catch the inodes that
1448 * was at the end of the orphan list, but it's better
1449 * than nothing. The right answer is that there
1450 * shouldn't be any bugs in the orphan list handling. :-)
1452 if (inode
->i_dtime
&& low_dtime_check
&&
1453 inode
->i_dtime
< ctx
->fs
->super
->s_inodes_count
) {
1454 if (fix_problem(ctx
, PR_1_LOW_DTIME
, &pctx
)) {
1455 inode
->i_dtime
= inode
->i_links_count
?
1457 e2fsck_write_inode(ctx
, ino
, inode
,
1464 * This code assumes that deleted inodes have
1465 * i_links_count set to 0.
1467 if (!inode
->i_links_count
) {
1468 if (!inode
->i_dtime
&& inode
->i_mode
) {
1469 if (fix_problem(ctx
,
1470 PR_1_ZERO_DTIME
, &pctx
)) {
1471 inode
->i_dtime
= ctx
->now
;
1472 e2fsck_write_inode(ctx
, ino
, inode
,
1477 FINISH_INODE_LOOP(ctx
, ino
, &pctx
, failed_csum
);
1481 * n.b. 0.3c ext2fs code didn't clear i_links_count for
1482 * deleted files. Oops.
1484 * Since all new ext2 implementations get this right,
1485 * we now assume that the case of non-zero
1486 * i_links_count and non-zero dtime means that we
1487 * should keep the file, not delete it.
1490 if (inode
->i_dtime
) {
1491 if (fix_problem(ctx
, PR_1_SET_DTIME
, &pctx
)) {
1493 e2fsck_write_inode(ctx
, ino
, inode
, "pass1");
1498 ext2fs_mark_inode_bitmap2(ctx
->inode_used_map
, ino
);
1499 switch (fs
->super
->s_creator_os
) {
1501 frag
= inode
->osd2
.hurd2
.h_i_frag
;
1502 fsize
= inode
->osd2
.hurd2
.h_i_fsize
;
1508 if (inode
->i_faddr
|| frag
|| fsize
||
1509 (LINUX_S_ISDIR(inode
->i_mode
) && inode
->i_dir_acl
))
1510 mark_inode_bad(ctx
, ino
);
1511 if (!(fs
->super
->s_feature_incompat
&
1512 EXT4_FEATURE_INCOMPAT_64BIT
) &&
1513 inode
->osd2
.linux2
.l_i_file_acl_high
!= 0)
1514 mark_inode_bad(ctx
, ino
);
1515 if ((fs
->super
->s_creator_os
== EXT2_OS_LINUX
) &&
1516 !(fs
->super
->s_feature_ro_compat
&
1517 EXT4_FEATURE_RO_COMPAT_HUGE_FILE
) &&
1518 (inode
->osd2
.linux2
.l_i_blocks_hi
!= 0))
1519 mark_inode_bad(ctx
, ino
);
1520 if (inode
->i_flags
& EXT2_IMAGIC_FL
) {
1522 if (!ctx
->inode_imagic_map
)
1523 alloc_imagic_map(ctx
);
1524 ext2fs_mark_inode_bitmap2(ctx
->inode_imagic_map
,
1527 if (fix_problem(ctx
, PR_1_SET_IMAGIC
, &pctx
)) {
1528 inode
->i_flags
&= ~EXT2_IMAGIC_FL
;
1529 e2fsck_write_inode(ctx
, ino
,
1536 check_inode_extra_space(ctx
, &pctx
);
1537 check_is_really_dir(ctx
, &pctx
, block_buf
);
1540 * ext2fs_inode_has_valid_blocks2 does not actually look
1541 * at i_block[] values, so not endian-sensitive here.
1543 if (extent_fs
&& (inode
->i_flags
& EXT4_EXTENTS_FL
) &&
1544 LINUX_S_ISLNK(inode
->i_mode
) &&
1545 !ext2fs_inode_has_valid_blocks2(fs
, inode
) &&
1546 fix_problem(ctx
, PR_1_FAST_SYMLINK_EXTENT_FL
, &pctx
)) {
1547 inode
->i_flags
&= ~EXT4_EXTENTS_FL
;
1548 e2fsck_write_inode(ctx
, ino
, inode
, "pass1");
1552 if (LINUX_S_ISDIR(inode
->i_mode
)) {
1553 ext2fs_mark_inode_bitmap2(ctx
->inode_dir_map
, ino
);
1554 e2fsck_add_dir_info(ctx
, ino
, 0);
1555 ctx
->fs_directory_count
++;
1556 } else if (LINUX_S_ISREG (inode
->i_mode
)) {
1557 ext2fs_mark_inode_bitmap2(ctx
->inode_reg_map
, ino
);
1558 ctx
->fs_regular_count
++;
1559 } else if (LINUX_S_ISCHR (inode
->i_mode
) &&
1560 e2fsck_pass1_check_device_inode(fs
, inode
)) {
1561 check_extents_inlinedata(ctx
, &pctx
);
1562 check_immutable(ctx
, &pctx
);
1563 check_size(ctx
, &pctx
);
1564 ctx
->fs_chardev_count
++;
1565 } else if (LINUX_S_ISBLK (inode
->i_mode
) &&
1566 e2fsck_pass1_check_device_inode(fs
, inode
)) {
1567 check_extents_inlinedata(ctx
, &pctx
);
1568 check_immutable(ctx
, &pctx
);
1569 check_size(ctx
, &pctx
);
1570 ctx
->fs_blockdev_count
++;
1571 } else if (LINUX_S_ISLNK (inode
->i_mode
) &&
1572 e2fsck_pass1_check_symlink(fs
, ino
, inode
,
1574 check_immutable(ctx
, &pctx
);
1575 ctx
->fs_symlinks_count
++;
1576 if (inode
->i_flags
& EXT4_INLINE_DATA_FL
) {
1577 FINISH_INODE_LOOP(ctx
, ino
, &pctx
, failed_csum
);
1579 } else if (ext2fs_inode_data_blocks(fs
, inode
) == 0) {
1580 ctx
->fs_fast_symlinks_count
++;
1581 check_blocks(ctx
, &pctx
, block_buf
);
1582 FINISH_INODE_LOOP(ctx
, ino
, &pctx
, failed_csum
);
1586 else if (LINUX_S_ISFIFO (inode
->i_mode
) &&
1587 e2fsck_pass1_check_device_inode(fs
, inode
)) {
1588 check_extents_inlinedata(ctx
, &pctx
);
1589 check_immutable(ctx
, &pctx
);
1590 check_size(ctx
, &pctx
);
1591 ctx
->fs_fifo_count
++;
1592 } else if ((LINUX_S_ISSOCK (inode
->i_mode
)) &&
1593 e2fsck_pass1_check_device_inode(fs
, inode
)) {
1594 check_extents_inlinedata(ctx
, &pctx
);
1595 check_immutable(ctx
, &pctx
);
1596 check_size(ctx
, &pctx
);
1597 ctx
->fs_sockets_count
++;
1599 mark_inode_bad(ctx
, ino
);
1600 if (!(inode
->i_flags
& EXT4_EXTENTS_FL
) &&
1601 !(inode
->i_flags
& EXT4_INLINE_DATA_FL
)) {
1602 if (inode
->i_block
[EXT2_IND_BLOCK
])
1603 ctx
->fs_ind_count
++;
1604 if (inode
->i_block
[EXT2_DIND_BLOCK
])
1605 ctx
->fs_dind_count
++;
1606 if (inode
->i_block
[EXT2_TIND_BLOCK
])
1607 ctx
->fs_tind_count
++;
1609 if (!(inode
->i_flags
& EXT4_EXTENTS_FL
) &&
1610 !(inode
->i_flags
& EXT4_INLINE_DATA_FL
) &&
1611 (inode
->i_block
[EXT2_IND_BLOCK
] ||
1612 inode
->i_block
[EXT2_DIND_BLOCK
] ||
1613 inode
->i_block
[EXT2_TIND_BLOCK
] ||
1614 ext2fs_file_acl_block(fs
, inode
))) {
1615 inodes_to_process
[process_inode_count
].ino
= ino
;
1616 inodes_to_process
[process_inode_count
].inode
= *inode
;
1617 process_inode_count
++;
1619 check_blocks(ctx
, &pctx
, block_buf
);
1621 FINISH_INODE_LOOP(ctx
, ino
, &pctx
, failed_csum
);
1623 if (ctx
->flags
& E2F_FLAG_SIGNAL_MASK
)
1626 if (process_inode_count
>= ctx
->process_inode_size
) {
1627 process_inodes(ctx
, block_buf
);
1629 if (ctx
->flags
& E2F_FLAG_SIGNAL_MASK
)
1633 process_inodes(ctx
, block_buf
);
1634 ext2fs_close_inode_scan(scan
);
1637 reserve_block_for_root_repair(ctx
);
1638 reserve_block_for_lnf_repair(ctx
);
1641 * If any extended attribute blocks' reference counts need to
1642 * be adjusted, either up (ctx->refcount_extra), or down
1643 * (ctx->refcount), then fix them.
1645 if (ctx
->refcount
) {
1646 adjust_extattr_refcount(ctx
, ctx
->refcount
, block_buf
, -1);
1647 ea_refcount_free(ctx
->refcount
);
1650 if (ctx
->refcount_extra
) {
1651 adjust_extattr_refcount(ctx
, ctx
->refcount_extra
,
1653 ea_refcount_free(ctx
->refcount_extra
);
1654 ctx
->refcount_extra
= 0;
1657 if (ctx
->invalid_bitmaps
)
1658 handle_fs_bad_blocks(ctx
);
1660 /* We don't need the block_ea_map any more */
1661 if (ctx
->block_ea_map
) {
1662 ext2fs_free_block_bitmap(ctx
->block_ea_map
);
1663 ctx
->block_ea_map
= 0;
1666 if (ctx
->flags
& E2F_FLAG_RESIZE_INODE
) {
1667 clear_problem_context(&pctx
);
1668 pctx
.errcode
= ext2fs_create_resize_inode(fs
);
1670 if (!fix_problem(ctx
, PR_1_RESIZE_INODE_CREATE
,
1672 ctx
->flags
|= E2F_FLAG_ABORT
;
1677 if (!pctx
.errcode
) {
1678 e2fsck_read_inode(ctx
, EXT2_RESIZE_INO
, inode
,
1680 inode
->i_mtime
= ctx
->now
;
1681 e2fsck_write_inode(ctx
, EXT2_RESIZE_INO
, inode
,
1684 ctx
->flags
&= ~E2F_FLAG_RESIZE_INODE
;
1687 if (ctx
->flags
& E2F_FLAG_RESTART
) {
1689 * Only the master copy of the superblock and block
1690 * group descriptors are going to be written during a
1691 * restart, so set the superblock to be used to be the
1692 * master superblock.
1694 ctx
->use_superblock
= 0;
1699 if (ctx
->block_dup_map
) {
1700 if (ctx
->options
& E2F_OPT_PREEN
) {
1701 clear_problem_context(&pctx
);
1702 fix_problem(ctx
, PR_1_DUP_BLOCKS_PREENSTOP
, &pctx
);
1704 e2fsck_pass1_dupblocks(ctx
, block_buf
);
1706 ext2fs_free_mem(&inodes_to_process
);
1708 e2fsck_use_inode_shortcuts(ctx
, 0);
1711 ext2fs_close_inode_scan(scan
);
1713 ext2fs_free_mem(&block_buf
);
1715 ext2fs_free_mem(&inode
);
1718 * The l+f inode may have been cleared, so zap it now and
1719 * later passes will recalculate it if necessary
1721 ctx
->lost_and_found
= 0;
1723 if ((ctx
->flags
& E2F_FLAG_SIGNAL_MASK
) == 0)
1724 print_resource_track(ctx
, _("Pass 1"), &rtrack
, ctx
->fs
->io
);
1726 #undef FINISH_INODE_LOOP
1729 * When the inode_scan routines call this callback at the end of the
1730 * glock group, call process_inodes.
1732 static errcode_t
scan_callback(ext2_filsys fs
,
1733 ext2_inode_scan scan
EXT2FS_ATTR((unused
)),
1734 dgrp_t group
, void * priv_data
)
1736 struct scan_callback_struct
*scan_struct
;
1739 scan_struct
= (struct scan_callback_struct
*) priv_data
;
1740 ctx
= scan_struct
->ctx
;
1742 process_inodes((e2fsck_t
) fs
->priv_data
, scan_struct
->block_buf
);
1745 if ((ctx
->progress
)(ctx
, 1, group
+1,
1746 ctx
->fs
->group_desc_count
))
1747 return EXT2_ET_CANCEL_REQUESTED
;
1753 * Process the inodes in the "inodes to process" list.
1755 static void process_inodes(e2fsck_t ctx
, char *block_buf
)
1758 struct ext2_inode
*old_stashed_inode
;
1759 ext2_ino_t old_stashed_ino
;
1760 const char *old_operation
;
1762 struct problem_context pctx
;
1765 printf("begin process_inodes: ");
1767 if (process_inode_count
== 0)
1769 old_operation
= ehandler_operation(0);
1770 old_stashed_inode
= ctx
->stashed_inode
;
1771 old_stashed_ino
= ctx
->stashed_ino
;
1772 qsort(inodes_to_process
, process_inode_count
,
1773 sizeof(struct process_inode_block
), process_inode_cmp
);
1774 clear_problem_context(&pctx
);
1775 for (i
=0; i
< process_inode_count
; i
++) {
1776 pctx
.inode
= ctx
->stashed_inode
= &inodes_to_process
[i
].inode
;
1777 pctx
.ino
= ctx
->stashed_ino
= inodes_to_process
[i
].ino
;
1780 printf("%u ", pctx
.ino
);
1782 sprintf(buf
, _("reading indirect blocks of inode %u"),
1784 ehandler_operation(buf
);
1785 check_blocks(ctx
, &pctx
, block_buf
);
1786 if (ctx
->flags
& E2F_FLAG_SIGNAL_MASK
)
1789 ctx
->stashed_inode
= old_stashed_inode
;
1790 ctx
->stashed_ino
= old_stashed_ino
;
1791 process_inode_count
= 0;
1793 printf("end process inodes\n");
1795 ehandler_operation(old_operation
);
1798 static EXT2_QSORT_TYPE
process_inode_cmp(const void *a
, const void *b
)
1800 const struct process_inode_block
*ib_a
=
1801 (const struct process_inode_block
*) a
;
1802 const struct process_inode_block
*ib_b
=
1803 (const struct process_inode_block
*) b
;
1806 ret
= (ib_a
->inode
.i_block
[EXT2_IND_BLOCK
] -
1807 ib_b
->inode
.i_block
[EXT2_IND_BLOCK
]);
1810 * We only call process_inodes() for non-extent
1811 * inodes, so it's OK to pass NULL to
1812 * ext2fs_file_acl_block() here.
1814 ret
= ext2fs_file_acl_block(0, &(ib_a
->inode
)) -
1815 ext2fs_file_acl_block(0, &(ib_b
->inode
));
1817 ret
= ib_a
->ino
- ib_b
->ino
;
1822 * Mark an inode as being bad in some what
1824 static void mark_inode_bad(e2fsck_t ctx
, ino_t ino
)
1826 struct problem_context pctx
;
1828 if (!ctx
->inode_bad_map
) {
1829 clear_problem_context(&pctx
);
1831 pctx
.errcode
= e2fsck_allocate_inode_bitmap(ctx
->fs
,
1832 _("bad inode map"), EXT2FS_BMAP64_RBTREE
,
1833 "inode_bad_map", &ctx
->inode_bad_map
);
1836 fix_problem(ctx
, PR_1_ALLOCATE_IBITMAP_ERROR
, &pctx
);
1837 /* Should never get here */
1838 ctx
->flags
|= E2F_FLAG_ABORT
;
1842 ext2fs_mark_inode_bitmap2(ctx
->inode_bad_map
, ino
);
1847 * This procedure will allocate the inode "bb" (badblock) map table
1849 static void alloc_bb_map(e2fsck_t ctx
)
1851 struct problem_context pctx
;
1853 clear_problem_context(&pctx
);
1854 pctx
.errcode
= e2fsck_allocate_inode_bitmap(ctx
->fs
,
1855 _("inode in bad block map"), EXT2FS_BMAP64_RBTREE
,
1856 "inode_bb_map", &ctx
->inode_bb_map
);
1859 fix_problem(ctx
, PR_1_ALLOCATE_IBITMAP_ERROR
, &pctx
);
1860 /* Should never get here */
1861 ctx
->flags
|= E2F_FLAG_ABORT
;
1867 * This procedure will allocate the inode imagic table
1869 static void alloc_imagic_map(e2fsck_t ctx
)
1871 struct problem_context pctx
;
1873 clear_problem_context(&pctx
);
1874 pctx
.errcode
= e2fsck_allocate_inode_bitmap(ctx
->fs
,
1875 _("imagic inode map"), EXT2FS_BMAP64_RBTREE
,
1876 "inode_imagic_map", &ctx
->inode_imagic_map
);
1879 fix_problem(ctx
, PR_1_ALLOCATE_IBITMAP_ERROR
, &pctx
);
1880 /* Should never get here */
1881 ctx
->flags
|= E2F_FLAG_ABORT
;
1887 * Marks a block as in use, setting the dup_map if it's been set
1888 * already. Called by process_block and process_bad_block.
1890 * WARNING: Assumes checks have already been done to make sure block
1891 * is valid. This is true in both process_block and process_bad_block.
1893 static _INLINE_
void mark_block_used(e2fsck_t ctx
, blk64_t block
)
1895 struct problem_context pctx
;
1897 clear_problem_context(&pctx
);
1899 if (ext2fs_fast_test_block_bitmap2(ctx
->block_found_map
, block
)) {
1900 if (!ctx
->block_dup_map
) {
1901 pctx
.errcode
= e2fsck_allocate_block_bitmap(ctx
->fs
,
1902 _("multiply claimed block map"),
1903 EXT2FS_BMAP64_RBTREE
, "block_dup_map",
1904 &ctx
->block_dup_map
);
1907 fix_problem(ctx
, PR_1_ALLOCATE_BBITMAP_ERROR
,
1909 /* Should never get here */
1910 ctx
->flags
|= E2F_FLAG_ABORT
;
1914 ext2fs_fast_mark_block_bitmap2(ctx
->block_dup_map
, block
);
1916 ext2fs_fast_mark_block_bitmap2(ctx
->block_found_map
, block
);
1920 static _INLINE_
void mark_blocks_used(e2fsck_t ctx
, blk64_t block
,
1923 if (ext2fs_test_block_bitmap_range2(ctx
->block_found_map
, block
, num
))
1924 ext2fs_mark_block_bitmap_range2(ctx
->block_found_map
, block
, num
);
1927 mark_block_used(ctx
, block
++);
1931 * Adjust the extended attribute block's reference counts at the end
1932 * of pass 1, either by subtracting out references for EA blocks that
1933 * are still referenced in ctx->refcount, or by adding references for
1934 * EA blocks that had extra references as accounted for in
1935 * ctx->refcount_extra.
1937 static void adjust_extattr_refcount(e2fsck_t ctx
, ext2_refcount_t refcount
,
1938 char *block_buf
, int adjust_sign
)
1940 struct ext2_ext_attr_header
*header
;
1941 struct problem_context pctx
;
1942 ext2_filsys fs
= ctx
->fs
;
1947 clear_problem_context(&pctx
);
1949 ea_refcount_intr_begin(refcount
);
1951 if ((blk
= ea_refcount_intr_next(refcount
, &count
)) == 0)
1954 pctx
.errcode
= ext2fs_read_ext_attr3(fs
, blk
, block_buf
,
1957 fix_problem(ctx
, PR_1_EXTATTR_READ_ABORT
, &pctx
);
1960 header
= (struct ext2_ext_attr_header
*) block_buf
;
1961 pctx
.blkcount
= header
->h_refcount
;
1962 should_be
= header
->h_refcount
+ adjust_sign
* count
;
1963 pctx
.num
= should_be
;
1964 if (fix_problem(ctx
, PR_1_EXTATTR_REFCOUNT
, &pctx
)) {
1965 header
->h_refcount
= should_be
;
1966 pctx
.errcode
= ext2fs_write_ext_attr3(fs
, blk
,
1970 fix_problem(ctx
, PR_1_EXTATTR_WRITE_ABORT
,
1979 * Handle processing the extended attribute blocks
1981 static int check_ext_attr(e2fsck_t ctx
, struct problem_context
*pctx
,
1984 ext2_filsys fs
= ctx
->fs
;
1985 ext2_ino_t ino
= pctx
->ino
;
1986 struct ext2_inode
*inode
= pctx
->inode
;
1989 struct ext2_ext_attr_header
*header
;
1990 struct ext2_ext_attr_entry
*entry
;
1992 region_t region
= 0;
1993 int failed_csum
= 0;
1995 blk
= ext2fs_file_acl_block(fs
, inode
);
2000 * If the Extended attribute flag isn't set, then a non-zero
2001 * file acl means that the inode is corrupted.
2003 * Or if the extended attribute block is an invalid block,
2004 * then the inode is also corrupted.
2006 if (!(fs
->super
->s_feature_compat
& EXT2_FEATURE_COMPAT_EXT_ATTR
) ||
2007 (blk
< fs
->super
->s_first_data_block
) ||
2008 (blk
>= ext2fs_blocks_count(fs
->super
))) {
2009 mark_inode_bad(ctx
, ino
);
2013 /* If ea bitmap hasn't been allocated, create it */
2014 if (!ctx
->block_ea_map
) {
2015 pctx
->errcode
= e2fsck_allocate_block_bitmap(fs
,
2016 _("ext attr block map"),
2017 EXT2FS_BMAP64_RBTREE
, "block_ea_map",
2018 &ctx
->block_ea_map
);
2019 if (pctx
->errcode
) {
2021 fix_problem(ctx
, PR_1_ALLOCATE_BBITMAP_ERROR
, pctx
);
2022 ctx
->flags
|= E2F_FLAG_ABORT
;
2027 /* Create the EA refcount structure if necessary */
2028 if (!ctx
->refcount
) {
2029 pctx
->errcode
= ea_refcount_create(0, &ctx
->refcount
);
2030 if (pctx
->errcode
) {
2032 fix_problem(ctx
, PR_1_ALLOCATE_REFCOUNT
, pctx
);
2033 ctx
->flags
|= E2F_FLAG_ABORT
;
2039 /* Debugging text */
2040 printf("Inode %u has EA block %u\n", ino
, blk
);
2043 /* Have we seen this EA block before? */
2044 if (ext2fs_fast_test_block_bitmap2(ctx
->block_ea_map
, blk
)) {
2045 if (ea_refcount_decrement(ctx
->refcount
, blk
, 0) == 0)
2047 /* Ooops, this EA was referenced more than it stated */
2048 if (!ctx
->refcount_extra
) {
2049 pctx
->errcode
= ea_refcount_create(0,
2050 &ctx
->refcount_extra
);
2051 if (pctx
->errcode
) {
2053 fix_problem(ctx
, PR_1_ALLOCATE_REFCOUNT
, pctx
);
2054 ctx
->flags
|= E2F_FLAG_ABORT
;
2058 ea_refcount_increment(ctx
->refcount_extra
, blk
, 0);
2063 * OK, we haven't seen this EA block yet. So we need to
2067 pctx
->errcode
= ext2fs_read_ext_attr3(fs
, blk
, block_buf
, pctx
->ino
);
2068 if (pctx
->errcode
== EXT2_ET_EXT_ATTR_CSUM_INVALID
) {
2071 } else if (pctx
->errcode
== EXT2_ET_BAD_EA_HEADER
)
2074 if (pctx
->errcode
&&
2075 fix_problem(ctx
, PR_1_READ_EA_BLOCK
, pctx
)) {
2079 header
= (struct ext2_ext_attr_header
*) block_buf
;
2080 pctx
->blk
= ext2fs_file_acl_block(fs
, inode
);
2081 if (((ctx
->ext_attr_ver
== 1) &&
2082 (header
->h_magic
!= EXT2_EXT_ATTR_MAGIC_v1
)) ||
2083 ((ctx
->ext_attr_ver
== 2) &&
2084 (header
->h_magic
!= EXT2_EXT_ATTR_MAGIC
))) {
2085 if (fix_problem(ctx
, PR_1_BAD_EA_BLOCK
, pctx
))
2089 if (header
->h_blocks
!= 1) {
2090 if (fix_problem(ctx
, PR_1_EA_MULTI_BLOCK
, pctx
))
2094 if (pctx
->errcode
&& fix_problem(ctx
, PR_1_READ_EA_BLOCK
, pctx
))
2097 region
= region_create(0, fs
->blocksize
);
2099 fix_problem(ctx
, PR_1_EA_ALLOC_REGION_ABORT
, pctx
);
2100 ctx
->flags
|= E2F_FLAG_ABORT
;
2103 if (region_allocate(region
, 0, sizeof(struct ext2_ext_attr_header
))) {
2104 if (fix_problem(ctx
, PR_1_EA_ALLOC_COLLISION
, pctx
))
2108 entry
= (struct ext2_ext_attr_entry
*)(header
+1);
2109 end
= block_buf
+ fs
->blocksize
;
2110 while ((char *)entry
< end
&& *(__u32
*)entry
) {
2113 if (region_allocate(region
, (char *)entry
- (char *)header
,
2114 EXT2_EXT_ATTR_LEN(entry
->e_name_len
))) {
2115 if (fix_problem(ctx
, PR_1_EA_ALLOC_COLLISION
, pctx
))
2119 if ((ctx
->ext_attr_ver
== 1 &&
2120 (entry
->e_name_len
== 0 || entry
->e_name_index
!= 0)) ||
2121 (ctx
->ext_attr_ver
== 2 &&
2122 entry
->e_name_index
== 0)) {
2123 if (fix_problem(ctx
, PR_1_EA_BAD_NAME
, pctx
))
2127 if (entry
->e_value_block
!= 0) {
2128 if (fix_problem(ctx
, PR_1_EA_BAD_VALUE
, pctx
))
2131 if (entry
->e_value_offs
+ entry
->e_value_size
> fs
->blocksize
) {
2132 if (fix_problem(ctx
, PR_1_EA_BAD_VALUE
, pctx
))
2136 if (entry
->e_value_size
&&
2137 region_allocate(region
, entry
->e_value_offs
,
2138 EXT2_EXT_ATTR_SIZE(entry
->e_value_size
))) {
2139 if (fix_problem(ctx
, PR_1_EA_ALLOC_COLLISION
, pctx
))
2143 hash
= ext2fs_ext_attr_hash_entry(entry
, block_buf
+
2144 entry
->e_value_offs
);
2146 if (entry
->e_hash
!= hash
) {
2147 pctx
->num
= entry
->e_hash
;
2148 if (fix_problem(ctx
, PR_1_ATTR_HASH
, pctx
))
2150 entry
->e_hash
= hash
;
2153 entry
= EXT2_EXT_ATTR_NEXT(entry
);
2155 if (region_allocate(region
, (char *)entry
- (char *)header
, 4)) {
2156 if (fix_problem(ctx
, PR_1_EA_ALLOC_COLLISION
, pctx
))
2159 region_free(region
);
2162 * We only get here if there was no other errors that were fixed.
2163 * If there was a checksum fail, ask to correct it.
2166 fix_problem(ctx
, PR_1_EA_BLOCK_ONLY_CSUM_INVALID
, pctx
)) {
2167 pctx
->errcode
= ext2fs_write_ext_attr3(fs
, blk
, block_buf
,
2173 count
= header
->h_refcount
- 1;
2175 ea_refcount_store(ctx
->refcount
, blk
, count
);
2176 mark_block_used(ctx
, blk
);
2177 ext2fs_fast_mark_block_bitmap2(ctx
->block_ea_map
, blk
);
2182 region_free(region
);
2183 ext2fs_file_acl_block_set(fs
, inode
, 0);
2184 e2fsck_write_inode(ctx
, ino
, inode
, "check_ext_attr");
2188 /* Returns 1 if bad htree, 0 if OK */
2189 static int handle_htree(e2fsck_t ctx
, struct problem_context
*pctx
,
2190 ext2_ino_t ino
, struct ext2_inode
*inode
,
2193 struct ext2_dx_root_info
*root
;
2194 ext2_filsys fs
= ctx
->fs
;
2198 if ((!LINUX_S_ISDIR(inode
->i_mode
) &&
2199 fix_problem(ctx
, PR_1_HTREE_NODIR
, pctx
)) ||
2200 (!(fs
->super
->s_feature_compat
& EXT2_FEATURE_COMPAT_DIR_INDEX
) &&
2201 fix_problem(ctx
, PR_1_HTREE_SET
, pctx
)))
2204 pctx
->errcode
= ext2fs_bmap2(fs
, ino
, inode
, 0, 0, 0, 0, &blk
);
2206 if ((pctx
->errcode
) ||
2208 (blk
< fs
->super
->s_first_data_block
) ||
2209 (blk
>= ext2fs_blocks_count(fs
->super
))) {
2210 if (fix_problem(ctx
, PR_1_HTREE_BADROOT
, pctx
))
2216 retval
= io_channel_read_blk64(fs
->io
, blk
, 1, block_buf
);
2217 if (retval
&& fix_problem(ctx
, PR_1_HTREE_BADROOT
, pctx
))
2220 /* XXX should check that beginning matches a directory */
2221 root
= (struct ext2_dx_root_info
*) (block_buf
+ 24);
2223 if ((root
->reserved_zero
|| root
->info_length
< 8) &&
2224 fix_problem(ctx
, PR_1_HTREE_BADROOT
, pctx
))
2227 pctx
->num
= root
->hash_version
;
2228 if ((root
->hash_version
!= EXT2_HASH_LEGACY
) &&
2229 (root
->hash_version
!= EXT2_HASH_HALF_MD4
) &&
2230 (root
->hash_version
!= EXT2_HASH_TEA
) &&
2231 fix_problem(ctx
, PR_1_HTREE_HASHV
, pctx
))
2234 if ((root
->unused_flags
& EXT2_HASH_FLAG_INCOMPAT
) &&
2235 fix_problem(ctx
, PR_1_HTREE_INCOMPAT
, pctx
))
2238 pctx
->num
= root
->indirect_levels
;
2239 if ((root
->indirect_levels
> 1) &&
2240 fix_problem(ctx
, PR_1_HTREE_DEPTH
, pctx
))
2246 void e2fsck_clear_inode(e2fsck_t ctx
, ext2_ino_t ino
,
2247 struct ext2_inode
*inode
, int restart_flag
,
2251 inode
->i_links_count
= 0;
2252 ext2fs_icount_store(ctx
->inode_link_info
, ino
, 0);
2253 inode
->i_dtime
= ctx
->now
;
2255 ext2fs_unmark_inode_bitmap2(ctx
->inode_dir_map
, ino
);
2256 ext2fs_unmark_inode_bitmap2(ctx
->inode_used_map
, ino
);
2257 if (ctx
->inode_reg_map
)
2258 ext2fs_unmark_inode_bitmap2(ctx
->inode_reg_map
, ino
);
2259 if (ctx
->inode_bad_map
)
2260 ext2fs_unmark_inode_bitmap2(ctx
->inode_bad_map
, ino
);
2263 * If the inode was partially accounted for before processing
2264 * was aborted, we need to restart the pass 1 scan.
2266 ctx
->flags
|= restart_flag
;
2268 if (ino
== EXT2_BAD_INO
)
2269 memset(inode
, 0, sizeof(struct ext2_inode
));
2271 e2fsck_write_inode(ctx
, ino
, inode
, source
);
2275 * Use the multiple-blocks reclamation code to fix alignment problems in
2276 * a bigalloc filesystem. We want a logical cluster to map to *only* one
2277 * physical cluster, and we want the block offsets within that cluster to
2280 static int has_unaligned_cluster_map(e2fsck_t ctx
,
2281 blk64_t last_pblk
, e2_blkcnt_t last_lblk
,
2282 blk64_t pblk
, blk64_t lblk
)
2284 blk64_t cluster_mask
;
2286 if (!ctx
->fs
->cluster_ratio_bits
)
2288 cluster_mask
= EXT2FS_CLUSTER_MASK(ctx
->fs
);
2291 * If the block in the logical cluster doesn't align with the block in
2292 * the physical cluster...
2294 if ((lblk
& cluster_mask
) != (pblk
& cluster_mask
))
2298 * If we cross a physical cluster boundary within a logical cluster...
2300 if (last_pblk
&& (lblk
& cluster_mask
) != 0 &&
2301 EXT2FS_B2C(ctx
->fs
, lblk
) == EXT2FS_B2C(ctx
->fs
, last_lblk
) &&
2302 EXT2FS_B2C(ctx
->fs
, pblk
) != EXT2FS_B2C(ctx
->fs
, last_pblk
))
2308 static void scan_extent_node(e2fsck_t ctx
, struct problem_context
*pctx
,
2309 struct process_block_struct
*pb
,
2310 blk64_t start_block
, blk64_t end_block
,
2312 ext2_extent_handle_t ehandle
,
2315 struct ext2fs_extent extent
;
2316 blk64_t blk
, last_lblk
;
2317 e2_blkcnt_t blockcnt
;
2319 int is_dir
, is_leaf
;
2321 struct ext2_extent_info info
;
2322 int failed_csum
= 0;
2324 if (pctx
->errcode
== EXT2_ET_EXTENT_CSUM_INVALID
)
2327 pctx
->errcode
= ext2fs_extent_get_info(ehandle
, &info
);
2331 pctx
->errcode
= ext2fs_extent_get(ehandle
, EXT2_EXTENT_FIRST_SIB
,
2333 while ((pctx
->errcode
== 0 ||
2334 pctx
->errcode
== EXT2_ET_EXTENT_CSUM_INVALID
) &&
2335 info
.num_entries
-- > 0) {
2336 is_leaf
= extent
.e_flags
& EXT2_EXTENT_FLAGS_LEAF
;
2337 is_dir
= LINUX_S_ISDIR(pctx
->inode
->i_mode
);
2338 last_lblk
= extent
.e_lblk
+ extent
.e_len
- 1;
2341 pctx
->blk
= extent
.e_pblk
;
2342 pctx
->blk2
= extent
.e_lblk
;
2343 pctx
->num
= extent
.e_len
;
2344 pctx
->blkcount
= extent
.e_lblk
+ extent
.e_len
;
2346 if (extent
.e_pblk
== 0 ||
2347 extent
.e_pblk
< ctx
->fs
->super
->s_first_data_block
||
2348 extent
.e_pblk
>= ext2fs_blocks_count(ctx
->fs
->super
))
2349 problem
= PR_1_EXTENT_BAD_START_BLK
;
2350 else if (extent
.e_lblk
< start_block
)
2351 problem
= PR_1_OUT_OF_ORDER_EXTENTS
;
2352 else if ((end_block
&& last_lblk
> end_block
) &&
2353 (!(extent
.e_flags
& EXT2_EXTENT_FLAGS_UNINIT
&&
2354 last_lblk
> eof_block
)))
2355 problem
= PR_1_EXTENT_END_OUT_OF_BOUNDS
;
2356 else if (is_leaf
&& extent
.e_len
== 0)
2357 problem
= PR_1_EXTENT_LENGTH_ZERO
;
2359 (extent
.e_pblk
+ extent
.e_len
) >
2360 ext2fs_blocks_count(ctx
->fs
->super
))
2361 problem
= PR_1_EXTENT_ENDS_BEYOND
;
2362 else if (is_leaf
&& is_dir
&&
2363 ((extent
.e_lblk
+ extent
.e_len
) >
2364 (1 << (21 - ctx
->fs
->super
->s_log_block_size
))))
2365 problem
= PR_1_TOOBIG_DIR
;
2368 * Uninitialized blocks in a directory? Clear the flag and
2369 * we'll interpret the blocks later.
2371 if (try_repairs
&& is_dir
&& problem
== 0 &&
2372 (extent
.e_flags
& EXT2_EXTENT_FLAGS_UNINIT
) &&
2373 fix_problem(ctx
, PR_1_UNINIT_DBLOCK
, pctx
)) {
2374 extent
.e_flags
&= ~EXT2_EXTENT_FLAGS_UNINIT
;
2375 pb
->inode_modified
= 1;
2376 pctx
->errcode
= ext2fs_extent_replace(ehandle
, 0,
2383 if (try_repairs
&& problem
) {
2385 if (fix_problem(ctx
, problem
, pctx
)) {
2387 if (ctx
->invalid_bitmaps
) {
2389 * If fsck knows the bitmaps are bad,
2390 * skip to the next extent and
2391 * try to clear this extent again
2392 * after fixing the bitmaps, by
2395 pctx
->errcode
= ext2fs_extent_get(
2397 EXT2_EXTENT_NEXT_SIB
,
2399 ctx
->flags
|= E2F_FLAG_RESTART_LATER
;
2400 if (pctx
->errcode
==
2401 EXT2_ET_NO_CURRENT_NODE
) {
2407 e2fsck_read_bitmaps(ctx
);
2408 pb
->inode_modified
= 1;
2410 ext2fs_extent_delete(ehandle
, 0);
2411 if (pctx
->errcode
) {
2412 pctx
->str
= "ext2fs_extent_delete";
2415 pctx
->errcode
= ext2fs_extent_fix_parents(ehandle
);
2416 if (pctx
->errcode
&&
2417 pctx
->errcode
!= EXT2_ET_NO_CURRENT_NODE
) {
2418 pctx
->str
= "ext2fs_extent_fix_parents";
2421 pctx
->errcode
= ext2fs_extent_get(ehandle
,
2422 EXT2_EXTENT_CURRENT
,
2424 if (pctx
->errcode
== EXT2_ET_NO_CURRENT_NODE
) {
2435 blk64_t lblk
= extent
.e_lblk
;
2436 int next_try_repairs
= 1;
2438 blk
= extent
.e_pblk
;
2441 * If this lower extent block collides with critical
2442 * metadata, don't try to repair the damage. Pass 1b
2443 * will reallocate the block; then we can try again.
2445 if (pb
->ino
!= EXT2_RESIZE_INO
&&
2446 ext2fs_test_block_bitmap2(ctx
->block_metadata_map
,
2448 next_try_repairs
= 0;
2451 PR_1_CRITICAL_METADATA_COLLISION
,
2453 ctx
->flags
|= E2F_FLAG_RESTART_LATER
;
2455 pctx
->errcode
= ext2fs_extent_get(ehandle
,
2456 EXT2_EXTENT_DOWN
, &extent
);
2457 if (pctx
->errcode
&&
2458 pctx
->errcode
!= EXT2_ET_EXTENT_CSUM_INVALID
) {
2459 pctx
->str
= "EXT2_EXTENT_DOWN";
2460 problem
= PR_1_EXTENT_HEADER_INVALID
;
2461 if (!next_try_repairs
)
2463 if (pctx
->errcode
== EXT2_ET_EXTENT_HEADER_BAD
)
2464 goto report_problem
;
2467 /* The next extent should match this index's logical start */
2468 if (extent
.e_lblk
!= lblk
) {
2469 struct ext2_extent_info e_info
;
2471 ext2fs_extent_get_info(ehandle
, &e_info
);
2473 pctx
->blk2
= extent
.e_lblk
;
2474 pctx
->num
= e_info
.curr_level
- 1;
2475 problem
= PR_1_EXTENT_INDEX_START_INVALID
;
2476 if (fix_problem(ctx
, problem
, pctx
)) {
2477 pb
->inode_modified
= 1;
2479 ext2fs_extent_fix_parents(ehandle
);
2480 if (pctx
->errcode
) {
2481 pctx
->str
= "ext2fs_extent_fix_parents";
2486 scan_extent_node(ctx
, pctx
, pb
, extent
.e_lblk
,
2487 last_lblk
, eof_block
, ehandle
,
2491 pctx
->errcode
= ext2fs_extent_get(ehandle
,
2492 EXT2_EXTENT_UP
, &extent
);
2493 if (pctx
->errcode
) {
2494 pctx
->str
= "EXT2_EXTENT_UP";
2497 mark_block_used(ctx
, blk
);
2502 if ((pb
->previous_block
!= 0) &&
2503 (pb
->previous_block
+1 != extent
.e_pblk
)) {
2504 if (ctx
->options
& E2F_OPT_FRAGCHECK
) {
2509 else if (pb
->is_reg
)
2512 printf(("%6lu(%c): expecting %6lu "
2514 "phys %6lu log %lu len %lu\n"),
2515 (unsigned long) pctx
->ino
, type
,
2516 (unsigned long) pb
->previous_block
+1,
2517 (unsigned long) extent
.e_pblk
,
2518 (unsigned long) extent
.e_lblk
,
2519 (unsigned long) extent
.e_len
);
2524 * If we notice a gap in the logical block mappings of an
2525 * extent-mapped directory, offer to close the hole by
2526 * moving the logical block down, otherwise we'll go mad in
2527 * pass 3 allocating empty directory blocks to fill the hole.
2529 if (try_repairs
&& is_dir
&&
2530 pb
->last_block
+ 1 < (e2_blkcnt_t
)extent
.e_lblk
) {
2533 new_lblk
= pb
->last_block
+ 1;
2534 if (EXT2FS_CLUSTER_RATIO(ctx
->fs
) > 1)
2535 new_lblk
= ((new_lblk
+
2536 EXT2FS_CLUSTER_RATIO(ctx
->fs
)) &
2537 EXT2FS_CLUSTER_MASK(ctx
->fs
)) |
2539 EXT2FS_CLUSTER_MASK(ctx
->fs
));
2540 pctx
->blk
= extent
.e_lblk
;
2541 pctx
->blk2
= new_lblk
;
2542 if (fix_problem(ctx
, PR_1_COLLAPSE_DBLOCK
, pctx
)) {
2543 extent
.e_lblk
= new_lblk
;
2544 pb
->inode_modified
= 1;
2545 pctx
->errcode
= ext2fs_extent_replace(ehandle
,
2547 if (pctx
->errcode
) {
2551 pctx
->errcode
= ext2fs_extent_fix_parents(ehandle
);
2553 goto failed_add_dir_block
;
2554 pctx
->errcode
= ext2fs_extent_goto(ehandle
,
2557 goto failed_add_dir_block
;
2558 last_lblk
= extent
.e_lblk
+ extent
.e_len
- 1;
2563 while (is_dir
&& (++pb
->last_db_block
<
2564 (e2_blkcnt_t
) extent
.e_lblk
)) {
2565 pctx
->errcode
= ext2fs_add_dir_block2(ctx
->fs
->dblist
,
2568 if (pctx
->errcode
) {
2570 pctx
->num
= pb
->last_db_block
;
2571 goto failed_add_dir_block
;
2574 if (!ctx
->fs
->cluster_ratio_bits
) {
2575 mark_blocks_used(ctx
, extent
.e_pblk
, extent
.e_len
);
2576 pb
->num_blocks
+= extent
.e_len
;
2578 for (blk
= extent
.e_pblk
, blockcnt
= extent
.e_lblk
, i
= 0;
2580 blk
++, blockcnt
++, i
++) {
2581 if (ctx
->fs
->cluster_ratio_bits
&&
2582 !(pb
->previous_block
&&
2583 (EXT2FS_B2C(ctx
->fs
, blk
) ==
2584 EXT2FS_B2C(ctx
->fs
, pb
->previous_block
)) &&
2585 (blk
& EXT2FS_CLUSTER_MASK(ctx
->fs
)) ==
2586 ((unsigned) blockcnt
& EXT2FS_CLUSTER_MASK(ctx
->fs
)))) {
2587 mark_block_used(ctx
, blk
);
2590 if (has_unaligned_cluster_map(ctx
, pb
->previous_block
,
2591 pb
->last_block
, blk
,
2593 pctx
->blk
= blockcnt
;
2595 fix_problem(ctx
, PR_1_MISALIGNED_CLUSTER
, pctx
);
2596 mark_block_used(ctx
, blk
);
2597 mark_block_used(ctx
, blk
);
2599 pb
->last_block
= blockcnt
;
2600 pb
->previous_block
= blk
;
2603 pctx
->errcode
= ext2fs_add_dir_block2(ctx
->fs
->dblist
, pctx
->ino
, blk
, blockcnt
);
2604 if (pctx
->errcode
) {
2606 pctx
->num
= blockcnt
;
2607 failed_add_dir_block
:
2608 fix_problem(ctx
, PR_1_ADD_DBLOCK
, pctx
);
2609 /* Should never get here */
2610 ctx
->flags
|= E2F_FLAG_ABORT
;
2615 if (is_dir
&& extent
.e_len
> 0)
2616 pb
->last_db_block
= blockcnt
- 1;
2617 pb
->previous_block
= extent
.e_pblk
+ extent
.e_len
- 1;
2618 start_block
= pb
->last_block
= last_lblk
;
2619 if (is_leaf
&& !is_dir
&&
2620 !(extent
.e_flags
& EXT2_EXTENT_FLAGS_UNINIT
))
2621 pb
->last_init_lblock
= last_lblk
;
2623 pctx
->errcode
= ext2fs_extent_get(ehandle
,
2624 EXT2_EXTENT_NEXT_SIB
,
2628 /* Failed csum but passes checks? Ask to fix checksum. */
2630 fix_problem(ctx
, PR_1_EXTENT_ONLY_CSUM_INVALID
, pctx
)) {
2631 pb
->inode_modified
= 1;
2632 pctx
->errcode
= ext2fs_extent_replace(ehandle
, 0, &extent
);
2637 if (pctx
->errcode
== EXT2_ET_EXTENT_NO_NEXT
)
2641 static void check_blocks_extents(e2fsck_t ctx
, struct problem_context
*pctx
,
2642 struct process_block_struct
*pb
)
2644 struct ext2_extent_info info
;
2645 struct ext2_inode
*inode
= pctx
->inode
;
2646 ext2_extent_handle_t ehandle
;
2647 ext2_filsys fs
= ctx
->fs
;
2648 ext2_ino_t ino
= pctx
->ino
;
2652 pctx
->errcode
= ext2fs_extent_open2(fs
, ino
, inode
, &ehandle
);
2653 if (pctx
->errcode
) {
2654 if (fix_problem(ctx
, PR_1_READ_EXTENT
, pctx
))
2655 e2fsck_clear_inode(ctx
, ino
, inode
, 0,
2656 "check_blocks_extents");
2661 retval
= ext2fs_extent_get_info(ehandle
, &info
);
2663 if (info
.max_depth
>= MAX_EXTENT_DEPTH_COUNT
)
2664 info
.max_depth
= MAX_EXTENT_DEPTH_COUNT
-1;
2665 ctx
->extent_depth_count
[info
.max_depth
]++;
2668 eof_lblk
= ((EXT2_I_SIZE(inode
) + fs
->blocksize
- 1) >>
2669 EXT2_BLOCK_SIZE_BITS(fs
->super
)) - 1;
2670 scan_extent_node(ctx
, pctx
, pb
, 0, 0, eof_lblk
, ehandle
, 1);
2671 if (pctx
->errcode
&&
2672 fix_problem(ctx
, PR_1_EXTENT_ITERATE_FAILURE
, pctx
)) {
2674 inode
->i_blocks
= 0;
2675 e2fsck_clear_inode(ctx
, ino
, inode
, E2F_FLAG_RESTART
,
2676 "check_blocks_extents");
2679 ext2fs_extent_free(ehandle
);
2683 * In fact we don't need to check blocks for an inode with inline data
2684 * because this inode doesn't have any blocks. In this function all
2685 * we need to do is add this inode into dblist when it is a directory.
2687 static void check_blocks_inline_data(e2fsck_t ctx
, struct problem_context
*pctx
,
2688 struct process_block_struct
*pb
)
2695 pctx
->errcode
= ext2fs_add_dir_block2(ctx
->fs
->dblist
, pb
->ino
, 0, 0);
2696 if (pctx
->errcode
) {
2699 fix_problem(ctx
, PR_1_ADD_DBLOCK
, pctx
);
2700 ctx
->flags
|= E2F_FLAG_ABORT
;
2705 * This subroutine is called on each inode to account for all of the
2706 * blocks used by that inode.
2708 static void check_blocks(e2fsck_t ctx
, struct problem_context
*pctx
,
2711 ext2_filsys fs
= ctx
->fs
;
2712 struct process_block_struct pb
;
2713 ext2_ino_t ino
= pctx
->ino
;
2714 struct ext2_inode
*inode
= pctx
->inode
;
2715 unsigned bad_size
= 0;
2716 int dirty_inode
= 0;
2724 pb
.last_init_lblock
= -1;
2725 pb
.last_db_block
= -1;
2726 pb
.num_illegal_blocks
= 0;
2727 pb
.suppress
= 0; pb
.clear
= 0;
2730 pb
.previous_block
= 0;
2731 pb
.is_dir
= LINUX_S_ISDIR(inode
->i_mode
);
2732 pb
.is_reg
= LINUX_S_ISREG(inode
->i_mode
);
2733 pb
.max_blocks
= 1 << (31 - fs
->super
->s_log_block_size
);
2737 pb
.inode_modified
= 0;
2742 extent_fs
= (ctx
->fs
->super
->s_feature_incompat
&
2743 EXT3_FEATURE_INCOMPAT_EXTENTS
);
2744 inlinedata_fs
= (ctx
->fs
->super
->s_feature_incompat
&
2745 EXT4_FEATURE_INCOMPAT_INLINE_DATA
);
2747 if (inode
->i_flags
& EXT2_COMPRBLK_FL
) {
2748 if (fs
->super
->s_feature_incompat
&
2749 EXT2_FEATURE_INCOMPAT_COMPRESSION
)
2752 if (fix_problem(ctx
, PR_1_COMPR_SET
, pctx
)) {
2753 inode
->i_flags
&= ~EXT2_COMPRBLK_FL
;
2759 if (check_ext_attr(ctx
, pctx
, block_buf
)) {
2760 if (ctx
->flags
& E2F_FLAG_SIGNAL_MASK
)
2765 if (inlinedata_fs
&& (inode
->i_flags
& EXT4_INLINE_DATA_FL
))
2766 check_blocks_inline_data(ctx
, pctx
, &pb
);
2767 else if (ext2fs_inode_has_valid_blocks2(fs
, inode
)) {
2768 if (extent_fs
&& (inode
->i_flags
& EXT4_EXTENTS_FL
))
2769 check_blocks_extents(ctx
, pctx
, &pb
);
2773 * If we've modified the inode, write it out before
2774 * iterate() tries to use it.
2777 e2fsck_write_inode(ctx
, ino
, inode
,
2782 fs
->flags
|= EXT2_FLAG_IGNORE_CSUM_ERRORS
;
2783 pctx
->errcode
= ext2fs_block_iterate3(fs
, ino
,
2784 pb
.is_dir
? BLOCK_FLAG_HOLE
: 0,
2785 block_buf
, process_block
, &pb
);
2787 * We do not have uninitialized extents in non extent
2790 pb
.last_init_lblock
= pb
.last_block
;
2792 * If iterate() changed a block mapping, we have to
2793 * re-read the inode. If we decide to clear the
2794 * inode after clearing some stuff, we'll re-write the
2795 * bad mappings into the inode!
2797 if (pb
.inode_modified
)
2798 e2fsck_read_inode(ctx
, ino
, inode
,
2800 fs
->flags
= (flags
& EXT2_FLAG_IGNORE_CSUM_ERRORS
) |
2801 (fs
->flags
& ~EXT2_FLAG_IGNORE_CSUM_ERRORS
);
2804 end_problem_latch(ctx
, PR_LATCH_BLOCK
);
2805 end_problem_latch(ctx
, PR_LATCH_TOOBIG
);
2806 if (ctx
->flags
& E2F_FLAG_SIGNAL_MASK
)
2809 fix_problem(ctx
, PR_1_BLOCK_ITERATE
, pctx
);
2811 if (pb
.fragmented
&& pb
.num_blocks
< fs
->super
->s_blocks_per_group
) {
2812 if (LINUX_S_ISDIR(inode
->i_mode
))
2813 ctx
->fs_fragmented_dir
++;
2815 ctx
->fs_fragmented
++;
2819 e2fsck_clear_inode(ctx
, ino
, inode
, E2F_FLAG_RESTART
,
2824 if (inode
->i_flags
& EXT2_INDEX_FL
) {
2825 if (handle_htree(ctx
, pctx
, ino
, inode
, block_buf
)) {
2826 inode
->i_flags
&= ~EXT2_INDEX_FL
;
2830 e2fsck_add_dx_dir(ctx
, ino
, pb
.last_block
+1);
2835 if (!pb
.num_blocks
&& pb
.is_dir
&&
2836 !(inode
->i_flags
& EXT4_INLINE_DATA_FL
)) {
2837 if (fix_problem(ctx
, PR_1_ZERO_LENGTH_DIR
, pctx
)) {
2838 e2fsck_clear_inode(ctx
, ino
, inode
, 0, "check_blocks");
2839 ctx
->fs_directory_count
--;
2844 if (ino
== EXT2_ROOT_INO
|| ino
>= EXT2_FIRST_INODE(ctx
->fs
->super
)) {
2845 quota_data_add(ctx
->qctx
, inode
, ino
,
2846 pb
.num_blocks
* fs
->blocksize
);
2847 quota_data_inodes(ctx
->qctx
, inode
, ino
, +1);
2850 if (!(fs
->super
->s_feature_ro_compat
&
2851 EXT4_FEATURE_RO_COMPAT_HUGE_FILE
) ||
2852 !(inode
->i_flags
& EXT4_HUGE_FILE_FL
))
2853 pb
.num_blocks
*= (fs
->blocksize
/ 512);
2854 pb
.num_blocks
*= EXT2FS_CLUSTER_RATIO(fs
);
2856 printf("inode %u, i_size = %u, last_block = %lld, i_blocks=%llu, num_blocks = %llu\n",
2857 ino
, inode
->i_size
, pb
.last_block
, ext2fs_inode_i_blocks(fs
, inode
),
2861 int nblock
= inode
->i_size
>> EXT2_BLOCK_SIZE_BITS(fs
->super
);
2862 if (inode
->i_flags
& EXT4_INLINE_DATA_FL
) {
2868 flags
= ctx
->fs
->flags
;
2869 ctx
->fs
->flags
|= EXT2_FLAG_IGNORE_CSUM_ERRORS
;
2870 err
= ext2fs_inline_data_size(ctx
->fs
, pctx
->ino
,
2872 ctx
->fs
->flags
= (flags
&
2873 EXT2_FLAG_IGNORE_CSUM_ERRORS
) |
2875 ~EXT2_FLAG_IGNORE_CSUM_ERRORS
);
2876 if (err
|| size
!= inode
->i_size
) {
2880 } else if (inode
->i_size
& (fs
->blocksize
- 1))
2882 else if (nblock
> (pb
.last_block
+ 1))
2884 else if (nblock
< (pb
.last_block
+ 1)) {
2885 if (((pb
.last_block
+ 1) - nblock
) >
2886 fs
->super
->s_prealloc_dir_blocks
)
2890 e2_blkcnt_t blkpg
= ctx
->blocks_per_page
;
2892 size
= EXT2_I_SIZE(inode
);
2893 if ((pb
.last_init_lblock
>= 0) &&
2894 /* allow allocated blocks to end of PAGE_SIZE */
2895 (size
< (__u64
)pb
.last_init_lblock
* fs
->blocksize
) &&
2896 (pb
.last_init_lblock
/ blkpg
* blkpg
!= pb
.last_init_lblock
||
2897 size
< (__u64
)(pb
.last_init_lblock
& ~(blkpg
-1)) *
2900 else if (!(extent_fs
&& (inode
->i_flags
& EXT4_EXTENTS_FL
)) &&
2901 size
> ext2_max_sizes
[fs
->super
->s_log_block_size
])
2902 /* too big for a direct/indirect-mapped file */
2904 else if ((extent_fs
&& (inode
->i_flags
& EXT4_EXTENTS_FL
)) &&
2906 ((1ULL << (32 + EXT2_BLOCK_SIZE_BITS(fs
->super
))) - 1))
2907 /* too big for an extent-based file - 32bit ee_block */
2910 /* i_size for symlinks is checked elsewhere */
2911 if (bad_size
&& !LINUX_S_ISLNK(inode
->i_mode
)) {
2912 /* Did inline_data set pctx->num earlier? */
2914 pctx
->num
= (pb
.last_block
+ 1) * fs
->blocksize
;
2915 pctx
->group
= bad_size
;
2916 if (fix_problem(ctx
, PR_1_BAD_I_SIZE
, pctx
)) {
2917 if (LINUX_S_ISDIR(inode
->i_mode
))
2918 pctx
->num
&= 0xFFFFFFFFULL
;
2919 ext2fs_inode_size_set(fs
, inode
, pctx
->num
);
2920 if (EXT2_I_SIZE(inode
) == 0 &&
2921 (inode
->i_flags
& EXT4_INLINE_DATA_FL
)) {
2922 memset(inode
->i_block
, 0,
2923 sizeof(inode
->i_block
));
2924 inode
->i_flags
&= ~EXT4_INLINE_DATA_FL
;
2930 if (LINUX_S_ISREG(inode
->i_mode
) &&
2931 ext2fs_needs_large_file_feature(EXT2_I_SIZE(inode
)))
2933 if ((pb
.num_blocks
!= ext2fs_inode_i_blocks(fs
, inode
)) ||
2934 ((fs
->super
->s_feature_ro_compat
&
2935 EXT4_FEATURE_RO_COMPAT_HUGE_FILE
) &&
2936 (inode
->i_flags
& EXT4_HUGE_FILE_FL
) &&
2937 (inode
->osd2
.linux2
.l_i_blocks_hi
!= 0))) {
2938 pctx
->num
= pb
.num_blocks
;
2939 if (fix_problem(ctx
, PR_1_BAD_I_BLOCKS
, pctx
)) {
2940 inode
->i_blocks
= pb
.num_blocks
;
2941 inode
->osd2
.linux2
.l_i_blocks_hi
= pb
.num_blocks
>> 32;
2947 if (ctx
->dirs_to_hash
&& pb
.is_dir
&&
2948 !(ctx
->lost_and_found
&& ctx
->lost_and_found
== ino
) &&
2949 !(inode
->i_flags
& EXT2_INDEX_FL
) &&
2950 ((inode
->i_size
/ fs
->blocksize
) >= 3))
2951 e2fsck_rehash_dir_later(ctx
, ino
);
2955 e2fsck_write_inode(ctx
, ino
, inode
, "check_blocks");
2960 * Helper function called by process block when an illegal block is
2961 * found. It returns a description about why the block is illegal
2963 static char *describe_illegal_block(ext2_filsys fs
, blk64_t block
)
2967 static char problem
[80];
2969 super
= fs
->super
->s_first_data_block
;
2970 strcpy(problem
, "PROGRAMMING ERROR: Unknown reason for illegal block");
2971 if (block
< super
) {
2972 sprintf(problem
, "< FIRSTBLOCK (%u)", super
);
2974 } else if (block
>= ext2fs_blocks_count(fs
->super
)) {
2975 sprintf(problem
, "> BLOCKS (%u)", ext2fs_blocks_count(fs
->super
));
2978 for (i
= 0; i
< fs
->group_desc_count
; i
++) {
2979 if (block
== super
) {
2980 sprintf(problem
, "is the superblock in group %d", i
);
2983 if (block
> super
&&
2984 block
<= (super
+ fs
->desc_blocks
)) {
2985 sprintf(problem
, "is in the group descriptors "
2989 if (block
== ext2fs_block_bitmap_loc(fs
, i
)) {
2990 sprintf(problem
, "is the block bitmap of group %d", i
);
2993 if (block
== ext2fs_inode_bitmap_loc(fs
, i
)) {
2994 sprintf(problem
, "is the inode bitmap of group %d", i
);
2997 if (block
>= ext2fs_inode_table_loc(fs
, i
) &&
2998 (block
< ext2fs_inode_table_loc(fs
, i
)
2999 + fs
->inode_blocks_per_group
)) {
3000 sprintf(problem
, "is in the inode table of group %d",
3004 super
+= fs
->super
->s_blocks_per_group
;
3011 * This is a helper function for check_blocks().
3013 static int process_block(ext2_filsys fs
,
3015 e2_blkcnt_t blockcnt
,
3016 blk64_t ref_block
EXT2FS_ATTR((unused
)),
3017 int ref_offset
EXT2FS_ATTR((unused
)),
3020 struct process_block_struct
*p
;
3021 struct problem_context
*pctx
;
3022 blk64_t blk
= *block_nr
;
3024 problem_t problem
= 0;
3027 p
= (struct process_block_struct
*) priv_data
;
3031 if (p
->compressed
&& (blk
== EXT2FS_COMPRESSED_BLKADDR
)) {
3032 /* todo: Check that the comprblk_fl is high, that the
3033 blkaddr pattern looks right (all non-holes up to
3034 first EXT2FS_COMPRESSED_BLKADDR, then all
3035 EXT2FS_COMPRESSED_BLKADDR up to end of cluster),
3036 that the feature_incompat bit is high, and that the
3037 inode is a regular file. If we're doing a "full
3038 check" (a concept introduced to e2fsck by e2compr,
3039 meaning that we look at data blocks as well as
3040 metadata) then call some library routine that
3041 checks the compressed data. I'll have to think
3042 about this, because one particularly important
3043 problem to be able to fix is to recalculate the
3044 cluster size if necessary. I think that perhaps
3045 we'd better do most/all e2compr-specific checks
3046 separately, after the non-e2compr checks. If not
3047 doing a full check, it may be useful to test that
3048 the personality is linux; e.g. if it isn't then
3049 perhaps this really is just an illegal block. */
3054 * For a directory, add logical block zero for processing even if it's
3055 * not mapped or we'll be perennially stuck with broken "." and ".."
3058 if (p
->is_dir
&& blockcnt
== 0 && blk
== 0) {
3059 pctx
->errcode
= ext2fs_add_dir_block2(fs
->dblist
, p
->ino
, 0, 0);
3060 if (pctx
->errcode
) {
3062 pctx
->num
= blockcnt
;
3063 goto failed_add_dir_block
;
3072 printf("Process_block, inode %lu, block %u, #%d\n", p
->ino
, blk
,
3077 * Simplistic fragmentation check. We merely require that the
3078 * file be contiguous. (Which can never be true for really
3079 * big files that are greater than a block group.)
3081 if (!HOLE_BLKADDR(p
->previous_block
) && p
->ino
!= EXT2_RESIZE_INO
) {
3082 if (p
->previous_block
+1 != blk
) {
3083 if (ctx
->options
& E2F_OPT_FRAGCHECK
) {
3091 printf(_("%6lu(%c): expecting %6lu "
3092 "got phys %6lu (blkcnt %lld)\n"),
3093 (unsigned long) pctx
->ino
, type
,
3094 (unsigned long) p
->previous_block
+1,
3095 (unsigned long) blk
,
3102 if (p
->is_dir
&& blockcnt
> (1 << (21 - fs
->super
->s_log_block_size
)))
3103 problem
= PR_1_TOOBIG_DIR
;
3104 if (p
->is_reg
&& p
->num_blocks
+1 >= p
->max_blocks
)
3105 problem
= PR_1_TOOBIG_REG
;
3106 if (!p
->is_dir
&& !p
->is_reg
&& blockcnt
> 0)
3107 problem
= PR_1_TOOBIG_SYMLINK
;
3109 if (blk
< fs
->super
->s_first_data_block
||
3110 blk
>= ext2fs_blocks_count(fs
->super
))
3111 problem
= PR_1_ILLEGAL_BLOCK_NUM
;
3114 * If this IND/DIND/TIND block is squatting atop some critical metadata
3115 * (group descriptors, superblock, bitmap, inode table), any write to
3116 * "fix" mapping problems will destroy the metadata. We'll let pass 1b
3117 * fix that and restart fsck.
3120 p
->ino
!= EXT2_RESIZE_INO
&&
3121 ext2fs_test_block_bitmap2(ctx
->block_metadata_map
, blk
)) {
3124 fix_problem(ctx
, PR_1_CRITICAL_METADATA_COLLISION
, pctx
);
3125 ctx
->flags
|= E2F_FLAG_RESTART_LATER
;
3129 p
->num_illegal_blocks
++;
3131 * A bit of subterfuge here -- we're trying to fix a block
3132 * mapping, but know that the IND/DIND/TIND block has collided
3133 * with some critical metadata. So, fix the in-core mapping so
3134 * iterate won't go insane, but return 0 instead of
3135 * BLOCK_CHANGED so that it won't write the remapping out to
3136 * our multiply linked block.
3138 if (p
->bad_ref
&& ref_block
== p
->bad_ref
) {
3142 if (!p
->suppress
&& (p
->num_illegal_blocks
% 12) == 0) {
3143 if (fix_problem(ctx
, PR_1_TOO_MANY_BAD_BLOCKS
, pctx
)) {
3147 if (fix_problem(ctx
, PR_1_SUPPRESS_MESSAGES
, pctx
)) {
3149 set_latch_flags(PR_LATCH_BLOCK
,
3154 pctx
->blkcount
= blockcnt
;
3155 if (fix_problem(ctx
, problem
, pctx
)) {
3156 blk
= *block_nr
= 0;
3157 ret_code
= BLOCK_CHANGED
;
3158 p
->inode_modified
= 1;
3160 * If the directory block is too big and is beyond the
3161 * end of the FS, don't bother trying to add it for
3162 * processing -- the kernel would never have created a
3163 * directory this large, and we risk an ENOMEM abort.
3164 * In any case, the toobig handler for extent-based
3165 * directories also doesn't feed toobig blocks to
3168 if (problem
== PR_1_TOOBIG_DIR
)
3175 if (p
->ino
== EXT2_RESIZE_INO
) {
3177 * The resize inode has already be sanity checked
3178 * during pass #0 (the superblock checks). All we
3179 * have to do is mark the double indirect block as
3180 * being in use; all of the other blocks are handled
3181 * by mark_table_blocks()).
3183 if (blockcnt
== BLOCK_COUNT_DIND
)
3184 mark_block_used(ctx
, blk
);
3186 } else if (!(ctx
->fs
->cluster_ratio_bits
&&
3187 p
->previous_block
&&
3188 (EXT2FS_B2C(ctx
->fs
, blk
) ==
3189 EXT2FS_B2C(ctx
->fs
, p
->previous_block
)) &&
3190 (blk
& EXT2FS_CLUSTER_MASK(ctx
->fs
)) ==
3191 ((unsigned) blockcnt
& EXT2FS_CLUSTER_MASK(ctx
->fs
)))) {
3192 mark_block_used(ctx
, blk
);
3194 } else if (has_unaligned_cluster_map(ctx
, p
->previous_block
,
3195 p
->last_block
, blk
, blockcnt
)) {
3196 pctx
->blk
= blockcnt
;
3198 fix_problem(ctx
, PR_1_MISALIGNED_CLUSTER
, pctx
);
3199 mark_block_used(ctx
, blk
);
3200 mark_block_used(ctx
, blk
);
3203 p
->last_block
= blockcnt
;
3204 p
->previous_block
= blk
;
3206 if (p
->is_dir
&& (blockcnt
>= 0)) {
3207 while (++p
->last_db_block
< blockcnt
) {
3208 pctx
->errcode
= ext2fs_add_dir_block2(fs
->dblist
,
3211 if (pctx
->errcode
) {
3213 pctx
->num
= p
->last_db_block
;
3214 goto failed_add_dir_block
;
3217 pctx
->errcode
= ext2fs_add_dir_block2(fs
->dblist
, p
->ino
,
3219 if (pctx
->errcode
) {
3221 pctx
->num
= blockcnt
;
3222 failed_add_dir_block
:
3223 fix_problem(ctx
, PR_1_ADD_DBLOCK
, pctx
);
3224 /* Should never get here */
3225 ctx
->flags
|= E2F_FLAG_ABORT
;
3232 static int process_bad_block(ext2_filsys fs
,
3234 e2_blkcnt_t blockcnt
,
3235 blk64_t ref_block
EXT2FS_ATTR((unused
)),
3236 int ref_offset
EXT2FS_ATTR((unused
)),
3239 struct process_block_struct
*p
;
3240 blk64_t blk
= *block_nr
;
3241 blk64_t first_block
;
3243 struct problem_context
*pctx
;
3247 * Note: This function processes blocks for the bad blocks
3248 * inode, which is never compressed. So we don't use HOLE_BLKADDR().
3254 p
= (struct process_block_struct
*) priv_data
;
3258 pctx
->ino
= EXT2_BAD_INO
;
3260 pctx
->blkcount
= blockcnt
;
3262 if ((blk
< fs
->super
->s_first_data_block
) ||
3263 (blk
>= ext2fs_blocks_count(fs
->super
))) {
3264 if (fix_problem(ctx
, PR_1_BB_ILLEGAL_BLOCK_NUM
, pctx
)) {
3266 return BLOCK_CHANGED
;
3272 if (ext2fs_test_block_bitmap2(p
->fs_meta_blocks
, blk
)) {
3274 if (fix_problem(ctx
, PR_1_BB_FS_BLOCK
, pctx
)) {
3276 return BLOCK_CHANGED
;
3278 } else if (ext2fs_test_block_bitmap2(ctx
->block_found_map
,
3281 if (fix_problem(ctx
, PR_1_BBINODE_BAD_METABLOCK
,
3284 return BLOCK_CHANGED
;
3286 if (ctx
->flags
& E2F_FLAG_SIGNAL_MASK
)
3289 mark_block_used(ctx
, blk
);
3293 printf ("DEBUG: Marking %u as bad.\n", blk
);
3295 ctx
->fs_badblocks_count
++;
3297 * If the block is not used, then mark it as used and return.
3298 * If it is already marked as found, this must mean that
3299 * there's an overlap between the filesystem table blocks
3300 * (bitmaps and inode table) and the bad block list.
3302 if (!ext2fs_test_block_bitmap2(ctx
->block_found_map
, blk
)) {
3303 ext2fs_mark_block_bitmap2(ctx
->block_found_map
, blk
);
3307 * Try to find the where the filesystem block was used...
3309 first_block
= fs
->super
->s_first_data_block
;
3311 for (i
= 0; i
< fs
->group_desc_count
; i
++ ) {
3314 if (!ext2fs_bg_has_super(fs
, i
))
3316 if (blk
== first_block
) {
3318 if (fix_problem(ctx
,
3319 PR_1_BAD_PRIMARY_SUPERBLOCK
,
3322 return BLOCK_CHANGED
;
3326 fix_problem(ctx
, PR_1_BAD_SUPERBLOCK
, pctx
);
3329 if ((blk
> first_block
) &&
3330 (blk
<= first_block
+ fs
->desc_blocks
)) {
3332 pctx
->blk
= *block_nr
;
3333 if (fix_problem(ctx
,
3334 PR_1_BAD_PRIMARY_GROUP_DESCRIPTOR
, pctx
)) {
3336 return BLOCK_CHANGED
;
3340 fix_problem(ctx
, PR_1_BAD_GROUP_DESCRIPTORS
, pctx
);
3344 if (blk
== ext2fs_block_bitmap_loc(fs
, i
)) {
3345 if (fix_problem(ctx
, PR_1_BB_BAD_BLOCK
, pctx
)) {
3346 ctx
->invalid_block_bitmap_flag
[i
]++;
3347 ctx
->invalid_bitmaps
++;
3351 if (blk
== ext2fs_inode_bitmap_loc(fs
, i
)) {
3352 if (fix_problem(ctx
, PR_1_IB_BAD_BLOCK
, pctx
)) {
3353 ctx
->invalid_inode_bitmap_flag
[i
]++;
3354 ctx
->invalid_bitmaps
++;
3358 if ((blk
>= ext2fs_inode_table_loc(fs
, i
)) &&
3359 (blk
< (ext2fs_inode_table_loc(fs
, i
) +
3360 fs
->inode_blocks_per_group
))) {
3362 * If there are bad blocks in the inode table,
3363 * the inode scan code will try to do
3364 * something reasonable automatically.
3368 first_block
+= fs
->super
->s_blocks_per_group
;
3371 * If we've gotten to this point, then the only
3372 * possibility is that the bad block inode meta data
3373 * is using a bad block.
3375 if ((blk
== p
->inode
->i_block
[EXT2_IND_BLOCK
]) ||
3376 (blk
== p
->inode
->i_block
[EXT2_DIND_BLOCK
]) ||
3377 (blk
== p
->inode
->i_block
[EXT2_TIND_BLOCK
])) {
3379 if (fix_problem(ctx
, PR_1_BBINODE_BAD_METABLOCK
, pctx
)) {
3381 return BLOCK_CHANGED
;
3383 if (ctx
->flags
& E2F_FLAG_SIGNAL_MASK
)
3390 /* Warn user that the block wasn't claimed */
3391 fix_problem(ctx
, PR_1_PROGERR_CLAIMED_BLOCK
, pctx
);
3396 static void new_table_block(e2fsck_t ctx
, blk64_t first_block
, dgrp_t group
,
3397 const char *name
, int num
, blk64_t
*new_block
)
3399 ext2_filsys fs
= ctx
->fs
;
3401 blk64_t old_block
= *new_block
;
3404 unsigned flexbg_size
;
3407 struct problem_context pctx
;
3409 clear_problem_context(&pctx
);
3412 pctx
.blk
= old_block
;
3416 * For flex_bg filesystems, first try to allocate the metadata
3417 * within the flex_bg, and if that fails then try finding the
3418 * space anywhere in the filesystem.
3420 is_flexbg
= EXT2_HAS_INCOMPAT_FEATURE(fs
->super
,
3421 EXT4_FEATURE_INCOMPAT_FLEX_BG
);
3423 flexbg_size
= 1 << fs
->super
->s_log_groups_per_flex
;
3424 flexbg
= group
/ flexbg_size
;
3425 first_block
= ext2fs_group_first_block2(fs
,
3426 flexbg_size
* flexbg
);
3427 last_grp
= group
| (flexbg_size
- 1);
3428 if (last_grp
>= fs
->group_desc_count
)
3429 last_grp
= fs
->group_desc_count
- 1;
3430 last_block
= ext2fs_group_last_block2(fs
, last_grp
);
3432 last_block
= ext2fs_group_last_block2(fs
, group
);
3433 pctx
.errcode
= ext2fs_get_free_blocks2(fs
, first_block
, last_block
,
3434 num
, ctx
->block_found_map
,
3436 if (is_flexbg
&& (pctx
.errcode
== EXT2_ET_BLOCK_ALLOC_FAIL
))
3437 pctx
.errcode
= ext2fs_get_free_blocks2(fs
,
3438 fs
->super
->s_first_data_block
,
3439 ext2fs_blocks_count(fs
->super
),
3440 num
, ctx
->block_found_map
, new_block
);
3443 fix_problem(ctx
, PR_1_RELOC_BLOCK_ALLOCATE
, &pctx
);
3444 ext2fs_unmark_valid(fs
);
3445 ctx
->flags
|= E2F_FLAG_ABORT
;
3448 pctx
.errcode
= ext2fs_get_mem(fs
->blocksize
, &buf
);
3450 fix_problem(ctx
, PR_1_RELOC_MEMORY_ALLOCATE
, &pctx
);
3451 ext2fs_unmark_valid(fs
);
3452 ctx
->flags
|= E2F_FLAG_ABORT
;
3455 ext2fs_mark_super_dirty(fs
);
3456 fs
->flags
&= ~EXT2_FLAG_MASTER_SB_ONLY
;
3457 pctx
.blk2
= *new_block
;
3458 fix_problem(ctx
, (old_block
? PR_1_RELOC_FROM_TO
:
3459 PR_1_RELOC_TO
), &pctx
);
3461 for (i
= 0; i
< num
; i
++) {
3463 ext2fs_mark_block_bitmap2(ctx
->block_found_map
, (*new_block
)+i
);
3465 pctx
.errcode
= io_channel_read_blk64(fs
->io
,
3466 old_block
+ i
, 1, buf
);
3468 fix_problem(ctx
, PR_1_RELOC_READ_ERR
, &pctx
);
3470 memset(buf
, 0, fs
->blocksize
);
3472 pctx
.blk
= (*new_block
) + i
;
3473 pctx
.errcode
= io_channel_write_blk64(fs
->io
, pctx
.blk
,
3476 fix_problem(ctx
, PR_1_RELOC_WRITE_ERR
, &pctx
);
3478 ext2fs_free_mem(&buf
);
3482 * This routine gets called at the end of pass 1 if bad blocks are
3483 * detected in the superblock, group descriptors, inode_bitmaps, or
3484 * block bitmaps. At this point, all of the blocks have been mapped
3485 * out, so we can try to allocate new block(s) to replace the bad
3488 static void handle_fs_bad_blocks(e2fsck_t ctx
)
3490 ext2_filsys fs
= ctx
->fs
;
3492 blk64_t first_block
;
3495 for (i
= 0; i
< fs
->group_desc_count
; i
++) {
3496 first_block
= ext2fs_group_first_block2(fs
, i
);
3498 if (ctx
->invalid_block_bitmap_flag
[i
]) {
3499 new_blk
= ext2fs_block_bitmap_loc(fs
, i
);
3500 new_table_block(ctx
, first_block
, i
, _("block bitmap"),
3502 ext2fs_block_bitmap_loc_set(fs
, i
, new_blk
);
3504 if (ctx
->invalid_inode_bitmap_flag
[i
]) {
3505 new_blk
= ext2fs_inode_bitmap_loc(fs
, i
);
3506 new_table_block(ctx
, first_block
, i
, _("inode bitmap"),
3508 ext2fs_inode_bitmap_loc_set(fs
, i
, new_blk
);
3510 if (ctx
->invalid_inode_table_flag
[i
]) {
3511 new_blk
= ext2fs_inode_table_loc(fs
, i
);
3512 new_table_block(ctx
, first_block
, i
, _("inode table"),
3513 fs
->inode_blocks_per_group
,
3515 ext2fs_inode_table_loc_set(fs
, i
, new_blk
);
3516 ctx
->flags
|= E2F_FLAG_RESTART
;
3519 ctx
->invalid_bitmaps
= 0;
3523 * This routine marks all blocks which are used by the superblock,
3524 * group descriptors, inode bitmaps, and block bitmaps.
3526 static void mark_table_blocks(e2fsck_t ctx
)
3528 ext2_filsys fs
= ctx
->fs
;
3532 struct problem_context pctx
;
3534 clear_problem_context(&pctx
);
3536 for (i
= 0; i
< fs
->group_desc_count
; i
++) {
3539 ext2fs_reserve_super_and_bgd(fs
, i
, ctx
->block_found_map
);
3540 ext2fs_reserve_super_and_bgd(fs
, i
, ctx
->block_metadata_map
);
3543 * Mark the blocks used for the inode table
3545 if (ext2fs_inode_table_loc(fs
, i
)) {
3546 for (j
= 0, b
= ext2fs_inode_table_loc(fs
, i
);
3547 j
< fs
->inode_blocks_per_group
;
3549 if (ext2fs_test_block_bitmap2(ctx
->block_found_map
,
3552 if (!ctx
->invalid_inode_table_flag
[i
] &&
3554 PR_1_ITABLE_CONFLICT
, &pctx
)) {
3555 ctx
->invalid_inode_table_flag
[i
]++;
3556 ctx
->invalid_bitmaps
++;
3559 ext2fs_mark_block_bitmap2(
3560 ctx
->block_found_map
, b
);
3561 ext2fs_mark_block_bitmap2(
3562 ctx
->block_metadata_map
, b
);
3568 * Mark block used for the block bitmap
3570 if (ext2fs_block_bitmap_loc(fs
, i
)) {
3571 if (ext2fs_test_block_bitmap2(ctx
->block_found_map
,
3572 ext2fs_block_bitmap_loc(fs
, i
))) {
3573 pctx
.blk
= ext2fs_block_bitmap_loc(fs
, i
);
3574 if (fix_problem(ctx
, PR_1_BB_CONFLICT
, &pctx
)) {
3575 ctx
->invalid_block_bitmap_flag
[i
]++;
3576 ctx
->invalid_bitmaps
++;
3579 ext2fs_mark_block_bitmap2(ctx
->block_found_map
,
3580 ext2fs_block_bitmap_loc(fs
, i
));
3581 ext2fs_mark_block_bitmap2(ctx
->block_metadata_map
,
3582 ext2fs_block_bitmap_loc(fs
, i
));
3586 * Mark block used for the inode bitmap
3588 if (ext2fs_inode_bitmap_loc(fs
, i
)) {
3589 if (ext2fs_test_block_bitmap2(ctx
->block_found_map
,
3590 ext2fs_inode_bitmap_loc(fs
, i
))) {
3591 pctx
.blk
= ext2fs_inode_bitmap_loc(fs
, i
);
3592 if (fix_problem(ctx
, PR_1_IB_CONFLICT
, &pctx
)) {
3593 ctx
->invalid_inode_bitmap_flag
[i
]++;
3594 ctx
->invalid_bitmaps
++;
3597 ext2fs_mark_block_bitmap2(ctx
->block_metadata_map
,
3598 ext2fs_inode_bitmap_loc(fs
, i
));
3599 ext2fs_mark_block_bitmap2(ctx
->block_found_map
,
3600 ext2fs_inode_bitmap_loc(fs
, i
));
3607 * Thes subroutines short circuits ext2fs_get_blocks and
3608 * ext2fs_check_directory; we use them since we already have the inode
3609 * structure, so there's no point in letting the ext2fs library read
3612 static errcode_t
pass1_get_blocks(ext2_filsys fs
, ext2_ino_t ino
,
3615 e2fsck_t ctx
= (e2fsck_t
) fs
->priv_data
;
3618 if ((ino
!= ctx
->stashed_ino
) || !ctx
->stashed_inode
)
3619 return EXT2_ET_CALLBACK_NOTHANDLED
;
3621 for (i
=0; i
< EXT2_N_BLOCKS
; i
++)
3622 blocks
[i
] = ctx
->stashed_inode
->i_block
[i
];
3626 static errcode_t
pass1_read_inode(ext2_filsys fs
, ext2_ino_t ino
,
3627 struct ext2_inode
*inode
)
3629 e2fsck_t ctx
= (e2fsck_t
) fs
->priv_data
;
3631 if ((ino
!= ctx
->stashed_ino
) || !ctx
->stashed_inode
)
3632 return EXT2_ET_CALLBACK_NOTHANDLED
;
3633 *inode
= *ctx
->stashed_inode
;
3637 static errcode_t
pass1_write_inode(ext2_filsys fs
, ext2_ino_t ino
,
3638 struct ext2_inode
*inode
)
3640 e2fsck_t ctx
= (e2fsck_t
) fs
->priv_data
;
3642 if ((ino
== ctx
->stashed_ino
) && ctx
->stashed_inode
&&
3643 (inode
!= ctx
->stashed_inode
))
3644 *ctx
->stashed_inode
= *inode
;
3645 return EXT2_ET_CALLBACK_NOTHANDLED
;
3648 static errcode_t
pass1_check_directory(ext2_filsys fs
, ext2_ino_t ino
)
3650 e2fsck_t ctx
= (e2fsck_t
) fs
->priv_data
;
3652 if ((ino
!= ctx
->stashed_ino
) || !ctx
->stashed_inode
)
3653 return EXT2_ET_CALLBACK_NOTHANDLED
;
3655 if (!LINUX_S_ISDIR(ctx
->stashed_inode
->i_mode
))
3656 return EXT2_ET_NO_DIRECTORY
;
3660 static errcode_t
e2fsck_get_alloc_block(ext2_filsys fs
, blk64_t goal
,
3663 e2fsck_t ctx
= (e2fsck_t
) fs
->priv_data
;
3667 if (ctx
->block_found_map
) {
3668 retval
= ext2fs_new_block2(fs
, goal
, ctx
->block_found_map
,
3672 if (fs
->block_map
) {
3673 ext2fs_mark_block_bitmap2(fs
->block_map
, new_block
);
3674 ext2fs_mark_bb_dirty(fs
);
3677 if (!fs
->block_map
) {
3678 retval
= ext2fs_read_block_bitmap(fs
);
3683 retval
= ext2fs_new_block2(fs
, goal
, 0, &new_block
);
3692 static void e2fsck_block_alloc_stats(ext2_filsys fs
, blk64_t blk
, int inuse
)
3694 e2fsck_t ctx
= (e2fsck_t
) fs
->priv_data
;
3696 /* Never free a critical metadata block */
3697 if (ctx
->block_found_map
&&
3698 ctx
->block_metadata_map
&&
3700 ext2fs_test_block_bitmap2(ctx
->block_metadata_map
, blk
))
3703 if (ctx
->block_found_map
) {
3705 ext2fs_mark_block_bitmap2(ctx
->block_found_map
, blk
);
3707 ext2fs_unmark_block_bitmap2(ctx
->block_found_map
, blk
);
3711 void e2fsck_use_inode_shortcuts(e2fsck_t ctx
, int use_shortcuts
)
3713 ext2_filsys fs
= ctx
->fs
;
3715 if (use_shortcuts
) {
3716 fs
->get_blocks
= pass1_get_blocks
;
3717 fs
->check_directory
= pass1_check_directory
;
3718 fs
->read_inode
= pass1_read_inode
;
3719 fs
->write_inode
= pass1_write_inode
;
3720 ctx
->stashed_ino
= 0;
3723 fs
->check_directory
= 0;
3725 fs
->write_inode
= 0;
3729 void e2fsck_intercept_block_allocations(e2fsck_t ctx
)
3731 ext2fs_set_alloc_block_callback(ctx
->fs
, e2fsck_get_alloc_block
, 0);
3732 ext2fs_set_block_alloc_stats_callback(ctx
->fs
,
3733 e2fsck_block_alloc_stats
, 0);