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
)) {
2386 if (ctx
->invalid_bitmaps
) {
2388 * If fsck knows the bitmaps are bad,
2389 * skip to the next extent and
2390 * try to clear this extent again
2391 * after fixing the bitmaps, by
2394 pctx
->errcode
= ext2fs_extent_get(
2396 EXT2_EXTENT_NEXT_SIB
,
2398 ctx
->flags
|= E2F_FLAG_RESTART_LATER
;
2399 if (pctx
->errcode
==
2400 EXT2_ET_NO_CURRENT_NODE
) {
2406 e2fsck_read_bitmaps(ctx
);
2407 pb
->inode_modified
= 1;
2409 ext2fs_extent_delete(ehandle
, 0);
2410 if (pctx
->errcode
) {
2411 pctx
->str
= "ext2fs_extent_delete";
2414 pctx
->errcode
= ext2fs_extent_fix_parents(ehandle
);
2415 if (pctx
->errcode
&&
2416 pctx
->errcode
!= EXT2_ET_NO_CURRENT_NODE
) {
2417 pctx
->str
= "ext2fs_extent_fix_parents";
2420 pctx
->errcode
= ext2fs_extent_get(ehandle
,
2421 EXT2_EXTENT_CURRENT
,
2423 if (pctx
->errcode
== EXT2_ET_NO_CURRENT_NODE
) {
2434 blk64_t lblk
= extent
.e_lblk
;
2435 int next_try_repairs
= 1;
2437 blk
= extent
.e_pblk
;
2440 * If this lower extent block collides with critical
2441 * metadata, don't try to repair the damage. Pass 1b
2442 * will reallocate the block; then we can try again.
2444 if (pb
->ino
!= EXT2_RESIZE_INO
&&
2445 ext2fs_test_block_bitmap2(ctx
->block_metadata_map
,
2447 next_try_repairs
= 0;
2450 PR_1_CRITICAL_METADATA_COLLISION
,
2452 ctx
->flags
|= E2F_FLAG_RESTART_LATER
;
2454 pctx
->errcode
= ext2fs_extent_get(ehandle
,
2455 EXT2_EXTENT_DOWN
, &extent
);
2456 if (pctx
->errcode
&&
2457 pctx
->errcode
!= EXT2_ET_EXTENT_CSUM_INVALID
) {
2458 pctx
->str
= "EXT2_EXTENT_DOWN";
2459 problem
= PR_1_EXTENT_HEADER_INVALID
;
2460 if (!next_try_repairs
)
2462 if (pctx
->errcode
== EXT2_ET_EXTENT_HEADER_BAD
)
2463 goto report_problem
;
2466 /* The next extent should match this index's logical start */
2467 if (extent
.e_lblk
!= lblk
) {
2468 struct ext2_extent_info e_info
;
2470 ext2fs_extent_get_info(ehandle
, &e_info
);
2472 pctx
->blk2
= extent
.e_lblk
;
2473 pctx
->num
= e_info
.curr_level
- 1;
2474 problem
= PR_1_EXTENT_INDEX_START_INVALID
;
2475 if (fix_problem(ctx
, problem
, pctx
)) {
2476 pb
->inode_modified
= 1;
2478 ext2fs_extent_fix_parents(ehandle
);
2479 if (pctx
->errcode
) {
2480 pctx
->str
= "ext2fs_extent_fix_parents";
2485 scan_extent_node(ctx
, pctx
, pb
, extent
.e_lblk
,
2486 last_lblk
, eof_block
, ehandle
,
2490 pctx
->errcode
= ext2fs_extent_get(ehandle
,
2491 EXT2_EXTENT_UP
, &extent
);
2492 if (pctx
->errcode
) {
2493 pctx
->str
= "EXT2_EXTENT_UP";
2496 mark_block_used(ctx
, blk
);
2501 if ((pb
->previous_block
!= 0) &&
2502 (pb
->previous_block
+1 != extent
.e_pblk
)) {
2503 if (ctx
->options
& E2F_OPT_FRAGCHECK
) {
2508 else if (pb
->is_reg
)
2511 printf(("%6lu(%c): expecting %6lu "
2513 "phys %6lu log %lu len %lu\n"),
2514 (unsigned long) pctx
->ino
, type
,
2515 (unsigned long) pb
->previous_block
+1,
2516 (unsigned long) extent
.e_pblk
,
2517 (unsigned long) extent
.e_lblk
,
2518 (unsigned long) extent
.e_len
);
2523 * If we notice a gap in the logical block mappings of an
2524 * extent-mapped directory, offer to close the hole by
2525 * moving the logical block down, otherwise we'll go mad in
2526 * pass 3 allocating empty directory blocks to fill the hole.
2528 if (try_repairs
&& is_dir
&&
2529 pb
->last_block
+ 1 < (e2_blkcnt_t
)extent
.e_lblk
) {
2532 new_lblk
= pb
->last_block
+ 1;
2533 if (EXT2FS_CLUSTER_RATIO(ctx
->fs
) > 1)
2534 new_lblk
= ((new_lblk
+
2535 EXT2FS_CLUSTER_RATIO(ctx
->fs
)) &
2536 EXT2FS_CLUSTER_MASK(ctx
->fs
)) |
2538 EXT2FS_CLUSTER_MASK(ctx
->fs
));
2539 pctx
->blk
= extent
.e_lblk
;
2540 pctx
->blk2
= new_lblk
;
2541 if (fix_problem(ctx
, PR_1_COLLAPSE_DBLOCK
, pctx
)) {
2542 extent
.e_lblk
= new_lblk
;
2543 pb
->inode_modified
= 1;
2544 pctx
->errcode
= ext2fs_extent_replace(ehandle
,
2546 if (pctx
->errcode
) {
2550 pctx
->errcode
= ext2fs_extent_fix_parents(ehandle
);
2552 goto failed_add_dir_block
;
2553 pctx
->errcode
= ext2fs_extent_goto(ehandle
,
2556 goto failed_add_dir_block
;
2557 last_lblk
= extent
.e_lblk
+ extent
.e_len
- 1;
2562 while (is_dir
&& (++pb
->last_db_block
<
2563 (e2_blkcnt_t
) extent
.e_lblk
)) {
2564 pctx
->errcode
= ext2fs_add_dir_block2(ctx
->fs
->dblist
,
2567 if (pctx
->errcode
) {
2569 pctx
->num
= pb
->last_db_block
;
2570 goto failed_add_dir_block
;
2573 if (!ctx
->fs
->cluster_ratio_bits
) {
2574 mark_blocks_used(ctx
, extent
.e_pblk
, extent
.e_len
);
2575 pb
->num_blocks
+= extent
.e_len
;
2577 for (blk
= extent
.e_pblk
, blockcnt
= extent
.e_lblk
, i
= 0;
2579 blk
++, blockcnt
++, i
++) {
2580 if (ctx
->fs
->cluster_ratio_bits
&&
2581 !(pb
->previous_block
&&
2582 (EXT2FS_B2C(ctx
->fs
, blk
) ==
2583 EXT2FS_B2C(ctx
->fs
, pb
->previous_block
)) &&
2584 (blk
& EXT2FS_CLUSTER_MASK(ctx
->fs
)) ==
2585 ((unsigned) blockcnt
& EXT2FS_CLUSTER_MASK(ctx
->fs
)))) {
2586 mark_block_used(ctx
, blk
);
2589 if (has_unaligned_cluster_map(ctx
, pb
->previous_block
,
2590 pb
->last_block
, blk
,
2592 pctx
->blk
= blockcnt
;
2594 fix_problem(ctx
, PR_1_MISALIGNED_CLUSTER
, pctx
);
2595 mark_block_used(ctx
, blk
);
2596 mark_block_used(ctx
, blk
);
2598 pb
->last_block
= blockcnt
;
2599 pb
->previous_block
= blk
;
2602 pctx
->errcode
= ext2fs_add_dir_block2(ctx
->fs
->dblist
, pctx
->ino
, blk
, blockcnt
);
2603 if (pctx
->errcode
) {
2605 pctx
->num
= blockcnt
;
2606 failed_add_dir_block
:
2607 fix_problem(ctx
, PR_1_ADD_DBLOCK
, pctx
);
2608 /* Should never get here */
2609 ctx
->flags
|= E2F_FLAG_ABORT
;
2614 if (is_dir
&& extent
.e_len
> 0)
2615 pb
->last_db_block
= blockcnt
- 1;
2616 pb
->previous_block
= extent
.e_pblk
+ extent
.e_len
- 1;
2617 start_block
= pb
->last_block
= last_lblk
;
2618 if (is_leaf
&& !is_dir
&&
2619 !(extent
.e_flags
& EXT2_EXTENT_FLAGS_UNINIT
))
2620 pb
->last_init_lblock
= last_lblk
;
2622 pctx
->errcode
= ext2fs_extent_get(ehandle
,
2623 EXT2_EXTENT_NEXT_SIB
,
2627 /* Failed csum but passes checks? Ask to fix checksum. */
2629 fix_problem(ctx
, PR_1_EXTENT_ONLY_CSUM_INVALID
, pctx
)) {
2630 pb
->inode_modified
= 1;
2631 pctx
->errcode
= ext2fs_extent_replace(ehandle
, 0, &extent
);
2636 if (pctx
->errcode
== EXT2_ET_EXTENT_NO_NEXT
)
2640 static void check_blocks_extents(e2fsck_t ctx
, struct problem_context
*pctx
,
2641 struct process_block_struct
*pb
)
2643 struct ext2_extent_info info
;
2644 struct ext2_inode
*inode
= pctx
->inode
;
2645 ext2_extent_handle_t ehandle
;
2646 ext2_filsys fs
= ctx
->fs
;
2647 ext2_ino_t ino
= pctx
->ino
;
2651 pctx
->errcode
= ext2fs_extent_open2(fs
, ino
, inode
, &ehandle
);
2652 if (pctx
->errcode
) {
2653 if (fix_problem(ctx
, PR_1_READ_EXTENT
, pctx
))
2654 e2fsck_clear_inode(ctx
, ino
, inode
, 0,
2655 "check_blocks_extents");
2660 retval
= ext2fs_extent_get_info(ehandle
, &info
);
2662 if (info
.max_depth
>= MAX_EXTENT_DEPTH_COUNT
)
2663 info
.max_depth
= MAX_EXTENT_DEPTH_COUNT
-1;
2664 ctx
->extent_depth_count
[info
.max_depth
]++;
2667 eof_lblk
= ((EXT2_I_SIZE(inode
) + fs
->blocksize
- 1) >>
2668 EXT2_BLOCK_SIZE_BITS(fs
->super
)) - 1;
2669 scan_extent_node(ctx
, pctx
, pb
, 0, 0, eof_lblk
, ehandle
, 1);
2670 if (pctx
->errcode
&&
2671 fix_problem(ctx
, PR_1_EXTENT_ITERATE_FAILURE
, pctx
)) {
2673 inode
->i_blocks
= 0;
2674 e2fsck_clear_inode(ctx
, ino
, inode
, E2F_FLAG_RESTART
,
2675 "check_blocks_extents");
2678 ext2fs_extent_free(ehandle
);
2682 * In fact we don't need to check blocks for an inode with inline data
2683 * because this inode doesn't have any blocks. In this function all
2684 * we need to do is add this inode into dblist when it is a directory.
2686 static void check_blocks_inline_data(e2fsck_t ctx
, struct problem_context
*pctx
,
2687 struct process_block_struct
*pb
)
2694 pctx
->errcode
= ext2fs_add_dir_block2(ctx
->fs
->dblist
, pb
->ino
, 0, 0);
2695 if (pctx
->errcode
) {
2698 fix_problem(ctx
, PR_1_ADD_DBLOCK
, pctx
);
2699 ctx
->flags
|= E2F_FLAG_ABORT
;
2704 * This subroutine is called on each inode to account for all of the
2705 * blocks used by that inode.
2707 static void check_blocks(e2fsck_t ctx
, struct problem_context
*pctx
,
2710 ext2_filsys fs
= ctx
->fs
;
2711 struct process_block_struct pb
;
2712 ext2_ino_t ino
= pctx
->ino
;
2713 struct ext2_inode
*inode
= pctx
->inode
;
2714 unsigned bad_size
= 0;
2715 int dirty_inode
= 0;
2723 pb
.last_init_lblock
= -1;
2724 pb
.last_db_block
= -1;
2725 pb
.num_illegal_blocks
= 0;
2726 pb
.suppress
= 0; pb
.clear
= 0;
2729 pb
.previous_block
= 0;
2730 pb
.is_dir
= LINUX_S_ISDIR(inode
->i_mode
);
2731 pb
.is_reg
= LINUX_S_ISREG(inode
->i_mode
);
2732 pb
.max_blocks
= 1 << (31 - fs
->super
->s_log_block_size
);
2736 pb
.inode_modified
= 0;
2741 extent_fs
= (ctx
->fs
->super
->s_feature_incompat
&
2742 EXT3_FEATURE_INCOMPAT_EXTENTS
);
2743 inlinedata_fs
= (ctx
->fs
->super
->s_feature_incompat
&
2744 EXT4_FEATURE_INCOMPAT_INLINE_DATA
);
2746 if (inode
->i_flags
& EXT2_COMPRBLK_FL
) {
2747 if (fs
->super
->s_feature_incompat
&
2748 EXT2_FEATURE_INCOMPAT_COMPRESSION
)
2751 if (fix_problem(ctx
, PR_1_COMPR_SET
, pctx
)) {
2752 inode
->i_flags
&= ~EXT2_COMPRBLK_FL
;
2758 if (check_ext_attr(ctx
, pctx
, block_buf
)) {
2759 if (ctx
->flags
& E2F_FLAG_SIGNAL_MASK
)
2764 if (inlinedata_fs
&& (inode
->i_flags
& EXT4_INLINE_DATA_FL
))
2765 check_blocks_inline_data(ctx
, pctx
, &pb
);
2766 else if (ext2fs_inode_has_valid_blocks2(fs
, inode
)) {
2767 if (extent_fs
&& (inode
->i_flags
& EXT4_EXTENTS_FL
))
2768 check_blocks_extents(ctx
, pctx
, &pb
);
2772 * If we've modified the inode, write it out before
2773 * iterate() tries to use it.
2776 e2fsck_write_inode(ctx
, ino
, inode
,
2781 fs
->flags
|= EXT2_FLAG_IGNORE_CSUM_ERRORS
;
2782 pctx
->errcode
= ext2fs_block_iterate3(fs
, ino
,
2783 pb
.is_dir
? BLOCK_FLAG_HOLE
: 0,
2784 block_buf
, process_block
, &pb
);
2786 * We do not have uninitialized extents in non extent
2789 pb
.last_init_lblock
= pb
.last_block
;
2791 * If iterate() changed a block mapping, we have to
2792 * re-read the inode. If we decide to clear the
2793 * inode after clearing some stuff, we'll re-write the
2794 * bad mappings into the inode!
2796 if (pb
.inode_modified
)
2797 e2fsck_read_inode(ctx
, ino
, inode
,
2799 fs
->flags
= (flags
& EXT2_FLAG_IGNORE_CSUM_ERRORS
) |
2800 (fs
->flags
& ~EXT2_FLAG_IGNORE_CSUM_ERRORS
);
2803 end_problem_latch(ctx
, PR_LATCH_BLOCK
);
2804 end_problem_latch(ctx
, PR_LATCH_TOOBIG
);
2805 if (ctx
->flags
& E2F_FLAG_SIGNAL_MASK
)
2808 fix_problem(ctx
, PR_1_BLOCK_ITERATE
, pctx
);
2810 if (pb
.fragmented
&& pb
.num_blocks
< fs
->super
->s_blocks_per_group
) {
2811 if (LINUX_S_ISDIR(inode
->i_mode
))
2812 ctx
->fs_fragmented_dir
++;
2814 ctx
->fs_fragmented
++;
2818 e2fsck_clear_inode(ctx
, ino
, inode
, E2F_FLAG_RESTART
,
2823 if (inode
->i_flags
& EXT2_INDEX_FL
) {
2824 if (handle_htree(ctx
, pctx
, ino
, inode
, block_buf
)) {
2825 inode
->i_flags
&= ~EXT2_INDEX_FL
;
2829 e2fsck_add_dx_dir(ctx
, ino
, pb
.last_block
+1);
2834 if (!pb
.num_blocks
&& pb
.is_dir
&&
2835 !(inode
->i_flags
& EXT4_INLINE_DATA_FL
)) {
2836 if (fix_problem(ctx
, PR_1_ZERO_LENGTH_DIR
, pctx
)) {
2837 e2fsck_clear_inode(ctx
, ino
, inode
, 0, "check_blocks");
2838 ctx
->fs_directory_count
--;
2843 if (ino
== EXT2_ROOT_INO
|| ino
>= EXT2_FIRST_INODE(ctx
->fs
->super
)) {
2844 quota_data_add(ctx
->qctx
, inode
, ino
,
2845 pb
.num_blocks
* fs
->blocksize
);
2846 quota_data_inodes(ctx
->qctx
, inode
, ino
, +1);
2849 if (!(fs
->super
->s_feature_ro_compat
&
2850 EXT4_FEATURE_RO_COMPAT_HUGE_FILE
) ||
2851 !(inode
->i_flags
& EXT4_HUGE_FILE_FL
))
2852 pb
.num_blocks
*= (fs
->blocksize
/ 512);
2853 pb
.num_blocks
*= EXT2FS_CLUSTER_RATIO(fs
);
2855 printf("inode %u, i_size = %u, last_block = %lld, i_blocks=%llu, num_blocks = %llu\n",
2856 ino
, inode
->i_size
, pb
.last_block
, ext2fs_inode_i_blocks(fs
, inode
),
2860 int nblock
= inode
->i_size
>> EXT2_BLOCK_SIZE_BITS(fs
->super
);
2861 if (inode
->i_flags
& EXT4_INLINE_DATA_FL
) {
2867 flags
= ctx
->fs
->flags
;
2868 ctx
->fs
->flags
|= EXT2_FLAG_IGNORE_CSUM_ERRORS
;
2869 err
= ext2fs_inline_data_size(ctx
->fs
, pctx
->ino
,
2871 ctx
->fs
->flags
= (flags
&
2872 EXT2_FLAG_IGNORE_CSUM_ERRORS
) |
2874 ~EXT2_FLAG_IGNORE_CSUM_ERRORS
);
2875 if (err
|| size
!= inode
->i_size
) {
2879 } else if (inode
->i_size
& (fs
->blocksize
- 1))
2881 else if (nblock
> (pb
.last_block
+ 1))
2883 else if (nblock
< (pb
.last_block
+ 1)) {
2884 if (((pb
.last_block
+ 1) - nblock
) >
2885 fs
->super
->s_prealloc_dir_blocks
)
2889 e2_blkcnt_t blkpg
= ctx
->blocks_per_page
;
2891 size
= EXT2_I_SIZE(inode
);
2892 if ((pb
.last_init_lblock
>= 0) &&
2893 /* allow allocated blocks to end of PAGE_SIZE */
2894 (size
< (__u64
)pb
.last_init_lblock
* fs
->blocksize
) &&
2895 (pb
.last_init_lblock
/ blkpg
* blkpg
!= pb
.last_init_lblock
||
2896 size
< (__u64
)(pb
.last_init_lblock
& ~(blkpg
-1)) *
2899 else if (!(extent_fs
&& (inode
->i_flags
& EXT4_EXTENTS_FL
)) &&
2900 size
> ext2_max_sizes
[fs
->super
->s_log_block_size
])
2901 /* too big for a direct/indirect-mapped file */
2903 else if ((extent_fs
&& (inode
->i_flags
& EXT4_EXTENTS_FL
)) &&
2905 ((1ULL << (32 + EXT2_BLOCK_SIZE_BITS(fs
->super
))) - 1))
2906 /* too big for an extent-based file - 32bit ee_block */
2909 /* i_size for symlinks is checked elsewhere */
2910 if (bad_size
&& !LINUX_S_ISLNK(inode
->i_mode
)) {
2911 /* Did inline_data set pctx->num earlier? */
2913 pctx
->num
= (pb
.last_block
+ 1) * fs
->blocksize
;
2914 pctx
->group
= bad_size
;
2915 if (fix_problem(ctx
, PR_1_BAD_I_SIZE
, pctx
)) {
2916 if (LINUX_S_ISDIR(inode
->i_mode
))
2917 pctx
->num
&= 0xFFFFFFFFULL
;
2918 ext2fs_inode_size_set(fs
, inode
, pctx
->num
);
2919 if (EXT2_I_SIZE(inode
) == 0 &&
2920 (inode
->i_flags
& EXT4_INLINE_DATA_FL
)) {
2921 memset(inode
->i_block
, 0,
2922 sizeof(inode
->i_block
));
2923 inode
->i_flags
&= ~EXT4_INLINE_DATA_FL
;
2929 if (LINUX_S_ISREG(inode
->i_mode
) &&
2930 ext2fs_needs_large_file_feature(EXT2_I_SIZE(inode
)))
2932 if ((pb
.num_blocks
!= ext2fs_inode_i_blocks(fs
, inode
)) ||
2933 ((fs
->super
->s_feature_ro_compat
&
2934 EXT4_FEATURE_RO_COMPAT_HUGE_FILE
) &&
2935 (inode
->i_flags
& EXT4_HUGE_FILE_FL
) &&
2936 (inode
->osd2
.linux2
.l_i_blocks_hi
!= 0))) {
2937 pctx
->num
= pb
.num_blocks
;
2938 if (fix_problem(ctx
, PR_1_BAD_I_BLOCKS
, pctx
)) {
2939 inode
->i_blocks
= pb
.num_blocks
;
2940 inode
->osd2
.linux2
.l_i_blocks_hi
= pb
.num_blocks
>> 32;
2946 if (ctx
->dirs_to_hash
&& pb
.is_dir
&&
2947 !(ctx
->lost_and_found
&& ctx
->lost_and_found
== ino
) &&
2948 !(inode
->i_flags
& EXT2_INDEX_FL
) &&
2949 ((inode
->i_size
/ fs
->blocksize
) >= 3))
2950 e2fsck_rehash_dir_later(ctx
, ino
);
2954 e2fsck_write_inode(ctx
, ino
, inode
, "check_blocks");
2959 * Helper function called by process block when an illegal block is
2960 * found. It returns a description about why the block is illegal
2962 static char *describe_illegal_block(ext2_filsys fs
, blk64_t block
)
2966 static char problem
[80];
2968 super
= fs
->super
->s_first_data_block
;
2969 strcpy(problem
, "PROGRAMMING ERROR: Unknown reason for illegal block");
2970 if (block
< super
) {
2971 sprintf(problem
, "< FIRSTBLOCK (%u)", super
);
2973 } else if (block
>= ext2fs_blocks_count(fs
->super
)) {
2974 sprintf(problem
, "> BLOCKS (%u)", ext2fs_blocks_count(fs
->super
));
2977 for (i
= 0; i
< fs
->group_desc_count
; i
++) {
2978 if (block
== super
) {
2979 sprintf(problem
, "is the superblock in group %d", i
);
2982 if (block
> super
&&
2983 block
<= (super
+ fs
->desc_blocks
)) {
2984 sprintf(problem
, "is in the group descriptors "
2988 if (block
== ext2fs_block_bitmap_loc(fs
, i
)) {
2989 sprintf(problem
, "is the block bitmap of group %d", i
);
2992 if (block
== ext2fs_inode_bitmap_loc(fs
, i
)) {
2993 sprintf(problem
, "is the inode bitmap of group %d", i
);
2996 if (block
>= ext2fs_inode_table_loc(fs
, i
) &&
2997 (block
< ext2fs_inode_table_loc(fs
, i
)
2998 + fs
->inode_blocks_per_group
)) {
2999 sprintf(problem
, "is in the inode table of group %d",
3003 super
+= fs
->super
->s_blocks_per_group
;
3010 * This is a helper function for check_blocks().
3012 static int process_block(ext2_filsys fs
,
3014 e2_blkcnt_t blockcnt
,
3015 blk64_t ref_block
EXT2FS_ATTR((unused
)),
3016 int ref_offset
EXT2FS_ATTR((unused
)),
3019 struct process_block_struct
*p
;
3020 struct problem_context
*pctx
;
3021 blk64_t blk
= *block_nr
;
3023 problem_t problem
= 0;
3026 p
= (struct process_block_struct
*) priv_data
;
3030 if (p
->compressed
&& (blk
== EXT2FS_COMPRESSED_BLKADDR
)) {
3031 /* todo: Check that the comprblk_fl is high, that the
3032 blkaddr pattern looks right (all non-holes up to
3033 first EXT2FS_COMPRESSED_BLKADDR, then all
3034 EXT2FS_COMPRESSED_BLKADDR up to end of cluster),
3035 that the feature_incompat bit is high, and that the
3036 inode is a regular file. If we're doing a "full
3037 check" (a concept introduced to e2fsck by e2compr,
3038 meaning that we look at data blocks as well as
3039 metadata) then call some library routine that
3040 checks the compressed data. I'll have to think
3041 about this, because one particularly important
3042 problem to be able to fix is to recalculate the
3043 cluster size if necessary. I think that perhaps
3044 we'd better do most/all e2compr-specific checks
3045 separately, after the non-e2compr checks. If not
3046 doing a full check, it may be useful to test that
3047 the personality is linux; e.g. if it isn't then
3048 perhaps this really is just an illegal block. */
3053 * For a directory, add logical block zero for processing even if it's
3054 * not mapped or we'll be perennially stuck with broken "." and ".."
3057 if (p
->is_dir
&& blockcnt
== 0 && blk
== 0) {
3058 pctx
->errcode
= ext2fs_add_dir_block2(fs
->dblist
, p
->ino
, 0, 0);
3059 if (pctx
->errcode
) {
3061 pctx
->num
= blockcnt
;
3062 goto failed_add_dir_block
;
3071 printf("Process_block, inode %lu, block %u, #%d\n", p
->ino
, blk
,
3076 * Simplistic fragmentation check. We merely require that the
3077 * file be contiguous. (Which can never be true for really
3078 * big files that are greater than a block group.)
3080 if (!HOLE_BLKADDR(p
->previous_block
) && p
->ino
!= EXT2_RESIZE_INO
) {
3081 if (p
->previous_block
+1 != blk
) {
3082 if (ctx
->options
& E2F_OPT_FRAGCHECK
) {
3090 printf(_("%6lu(%c): expecting %6lu "
3091 "got phys %6lu (blkcnt %lld)\n"),
3092 (unsigned long) pctx
->ino
, type
,
3093 (unsigned long) p
->previous_block
+1,
3094 (unsigned long) blk
,
3101 if (p
->is_dir
&& blockcnt
> (1 << (21 - fs
->super
->s_log_block_size
)))
3102 problem
= PR_1_TOOBIG_DIR
;
3103 if (p
->is_reg
&& p
->num_blocks
+1 >= p
->max_blocks
)
3104 problem
= PR_1_TOOBIG_REG
;
3105 if (!p
->is_dir
&& !p
->is_reg
&& blockcnt
> 0)
3106 problem
= PR_1_TOOBIG_SYMLINK
;
3108 if (blk
< fs
->super
->s_first_data_block
||
3109 blk
>= ext2fs_blocks_count(fs
->super
))
3110 problem
= PR_1_ILLEGAL_BLOCK_NUM
;
3113 * If this IND/DIND/TIND block is squatting atop some critical metadata
3114 * (group descriptors, superblock, bitmap, inode table), any write to
3115 * "fix" mapping problems will destroy the metadata. We'll let pass 1b
3116 * fix that and restart fsck.
3119 p
->ino
!= EXT2_RESIZE_INO
&&
3120 ext2fs_test_block_bitmap2(ctx
->block_metadata_map
, blk
)) {
3123 fix_problem(ctx
, PR_1_CRITICAL_METADATA_COLLISION
, pctx
);
3124 ctx
->flags
|= E2F_FLAG_RESTART_LATER
;
3128 p
->num_illegal_blocks
++;
3130 * A bit of subterfuge here -- we're trying to fix a block
3131 * mapping, but know that the IND/DIND/TIND block has collided
3132 * with some critical metadata. So, fix the in-core mapping so
3133 * iterate won't go insane, but return 0 instead of
3134 * BLOCK_CHANGED so that it won't write the remapping out to
3135 * our multiply linked block.
3137 if (p
->bad_ref
&& ref_block
== p
->bad_ref
) {
3141 if (!p
->suppress
&& (p
->num_illegal_blocks
% 12) == 0) {
3142 if (fix_problem(ctx
, PR_1_TOO_MANY_BAD_BLOCKS
, pctx
)) {
3146 if (fix_problem(ctx
, PR_1_SUPPRESS_MESSAGES
, pctx
)) {
3148 set_latch_flags(PR_LATCH_BLOCK
,
3153 pctx
->blkcount
= blockcnt
;
3154 if (fix_problem(ctx
, problem
, pctx
)) {
3155 blk
= *block_nr
= 0;
3156 ret_code
= BLOCK_CHANGED
;
3157 p
->inode_modified
= 1;
3159 * If the directory block is too big and is beyond the
3160 * end of the FS, don't bother trying to add it for
3161 * processing -- the kernel would never have created a
3162 * directory this large, and we risk an ENOMEM abort.
3163 * In any case, the toobig handler for extent-based
3164 * directories also doesn't feed toobig blocks to
3167 if (problem
== PR_1_TOOBIG_DIR
)
3174 if (p
->ino
== EXT2_RESIZE_INO
) {
3176 * The resize inode has already be sanity checked
3177 * during pass #0 (the superblock checks). All we
3178 * have to do is mark the double indirect block as
3179 * being in use; all of the other blocks are handled
3180 * by mark_table_blocks()).
3182 if (blockcnt
== BLOCK_COUNT_DIND
)
3183 mark_block_used(ctx
, blk
);
3185 } else if (!(ctx
->fs
->cluster_ratio_bits
&&
3186 p
->previous_block
&&
3187 (EXT2FS_B2C(ctx
->fs
, blk
) ==
3188 EXT2FS_B2C(ctx
->fs
, p
->previous_block
)) &&
3189 (blk
& EXT2FS_CLUSTER_MASK(ctx
->fs
)) ==
3190 ((unsigned) blockcnt
& EXT2FS_CLUSTER_MASK(ctx
->fs
)))) {
3191 mark_block_used(ctx
, blk
);
3193 } else if (has_unaligned_cluster_map(ctx
, p
->previous_block
,
3194 p
->last_block
, blk
, blockcnt
)) {
3195 pctx
->blk
= blockcnt
;
3197 fix_problem(ctx
, PR_1_MISALIGNED_CLUSTER
, pctx
);
3198 mark_block_used(ctx
, blk
);
3199 mark_block_used(ctx
, blk
);
3202 p
->last_block
= blockcnt
;
3203 p
->previous_block
= blk
;
3205 if (p
->is_dir
&& (blockcnt
>= 0)) {
3206 while (++p
->last_db_block
< blockcnt
) {
3207 pctx
->errcode
= ext2fs_add_dir_block2(fs
->dblist
,
3210 if (pctx
->errcode
) {
3212 pctx
->num
= p
->last_db_block
;
3213 goto failed_add_dir_block
;
3216 pctx
->errcode
= ext2fs_add_dir_block2(fs
->dblist
, p
->ino
,
3218 if (pctx
->errcode
) {
3220 pctx
->num
= blockcnt
;
3221 failed_add_dir_block
:
3222 fix_problem(ctx
, PR_1_ADD_DBLOCK
, pctx
);
3223 /* Should never get here */
3224 ctx
->flags
|= E2F_FLAG_ABORT
;
3231 static int process_bad_block(ext2_filsys fs
,
3233 e2_blkcnt_t blockcnt
,
3234 blk64_t ref_block
EXT2FS_ATTR((unused
)),
3235 int ref_offset
EXT2FS_ATTR((unused
)),
3238 struct process_block_struct
*p
;
3239 blk64_t blk
= *block_nr
;
3240 blk64_t first_block
;
3242 struct problem_context
*pctx
;
3246 * Note: This function processes blocks for the bad blocks
3247 * inode, which is never compressed. So we don't use HOLE_BLKADDR().
3253 p
= (struct process_block_struct
*) priv_data
;
3257 pctx
->ino
= EXT2_BAD_INO
;
3259 pctx
->blkcount
= blockcnt
;
3261 if ((blk
< fs
->super
->s_first_data_block
) ||
3262 (blk
>= ext2fs_blocks_count(fs
->super
))) {
3263 if (fix_problem(ctx
, PR_1_BB_ILLEGAL_BLOCK_NUM
, pctx
)) {
3265 return BLOCK_CHANGED
;
3271 if (ext2fs_test_block_bitmap2(p
->fs_meta_blocks
, blk
)) {
3273 if (fix_problem(ctx
, PR_1_BB_FS_BLOCK
, pctx
)) {
3275 return BLOCK_CHANGED
;
3277 } else if (ext2fs_test_block_bitmap2(ctx
->block_found_map
,
3280 if (fix_problem(ctx
, PR_1_BBINODE_BAD_METABLOCK
,
3283 return BLOCK_CHANGED
;
3285 if (ctx
->flags
& E2F_FLAG_SIGNAL_MASK
)
3288 mark_block_used(ctx
, blk
);
3292 printf ("DEBUG: Marking %u as bad.\n", blk
);
3294 ctx
->fs_badblocks_count
++;
3296 * If the block is not used, then mark it as used and return.
3297 * If it is already marked as found, this must mean that
3298 * there's an overlap between the filesystem table blocks
3299 * (bitmaps and inode table) and the bad block list.
3301 if (!ext2fs_test_block_bitmap2(ctx
->block_found_map
, blk
)) {
3302 ext2fs_mark_block_bitmap2(ctx
->block_found_map
, blk
);
3306 * Try to find the where the filesystem block was used...
3308 first_block
= fs
->super
->s_first_data_block
;
3310 for (i
= 0; i
< fs
->group_desc_count
; i
++ ) {
3313 if (!ext2fs_bg_has_super(fs
, i
))
3315 if (blk
== first_block
) {
3317 if (fix_problem(ctx
,
3318 PR_1_BAD_PRIMARY_SUPERBLOCK
,
3321 return BLOCK_CHANGED
;
3325 fix_problem(ctx
, PR_1_BAD_SUPERBLOCK
, pctx
);
3328 if ((blk
> first_block
) &&
3329 (blk
<= first_block
+ fs
->desc_blocks
)) {
3331 pctx
->blk
= *block_nr
;
3332 if (fix_problem(ctx
,
3333 PR_1_BAD_PRIMARY_GROUP_DESCRIPTOR
, pctx
)) {
3335 return BLOCK_CHANGED
;
3339 fix_problem(ctx
, PR_1_BAD_GROUP_DESCRIPTORS
, pctx
);
3343 if (blk
== ext2fs_block_bitmap_loc(fs
, i
)) {
3344 if (fix_problem(ctx
, PR_1_BB_BAD_BLOCK
, pctx
)) {
3345 ctx
->invalid_block_bitmap_flag
[i
]++;
3346 ctx
->invalid_bitmaps
++;
3350 if (blk
== ext2fs_inode_bitmap_loc(fs
, i
)) {
3351 if (fix_problem(ctx
, PR_1_IB_BAD_BLOCK
, pctx
)) {
3352 ctx
->invalid_inode_bitmap_flag
[i
]++;
3353 ctx
->invalid_bitmaps
++;
3357 if ((blk
>= ext2fs_inode_table_loc(fs
, i
)) &&
3358 (blk
< (ext2fs_inode_table_loc(fs
, i
) +
3359 fs
->inode_blocks_per_group
))) {
3361 * If there are bad blocks in the inode table,
3362 * the inode scan code will try to do
3363 * something reasonable automatically.
3367 first_block
+= fs
->super
->s_blocks_per_group
;
3370 * If we've gotten to this point, then the only
3371 * possibility is that the bad block inode meta data
3372 * is using a bad block.
3374 if ((blk
== p
->inode
->i_block
[EXT2_IND_BLOCK
]) ||
3375 (blk
== p
->inode
->i_block
[EXT2_DIND_BLOCK
]) ||
3376 (blk
== p
->inode
->i_block
[EXT2_TIND_BLOCK
])) {
3378 if (fix_problem(ctx
, PR_1_BBINODE_BAD_METABLOCK
, pctx
)) {
3380 return BLOCK_CHANGED
;
3382 if (ctx
->flags
& E2F_FLAG_SIGNAL_MASK
)
3389 /* Warn user that the block wasn't claimed */
3390 fix_problem(ctx
, PR_1_PROGERR_CLAIMED_BLOCK
, pctx
);
3395 static void new_table_block(e2fsck_t ctx
, blk64_t first_block
, dgrp_t group
,
3396 const char *name
, int num
, blk64_t
*new_block
)
3398 ext2_filsys fs
= ctx
->fs
;
3400 blk64_t old_block
= *new_block
;
3403 unsigned flexbg_size
;
3406 struct problem_context pctx
;
3408 clear_problem_context(&pctx
);
3411 pctx
.blk
= old_block
;
3415 * For flex_bg filesystems, first try to allocate the metadata
3416 * within the flex_bg, and if that fails then try finding the
3417 * space anywhere in the filesystem.
3419 is_flexbg
= EXT2_HAS_INCOMPAT_FEATURE(fs
->super
,
3420 EXT4_FEATURE_INCOMPAT_FLEX_BG
);
3422 flexbg_size
= 1 << fs
->super
->s_log_groups_per_flex
;
3423 flexbg
= group
/ flexbg_size
;
3424 first_block
= ext2fs_group_first_block2(fs
,
3425 flexbg_size
* flexbg
);
3426 last_grp
= group
| (flexbg_size
- 1);
3427 if (last_grp
>= fs
->group_desc_count
)
3428 last_grp
= fs
->group_desc_count
- 1;
3429 last_block
= ext2fs_group_last_block2(fs
, last_grp
);
3431 last_block
= ext2fs_group_last_block2(fs
, group
);
3432 pctx
.errcode
= ext2fs_get_free_blocks2(fs
, first_block
, last_block
,
3433 num
, ctx
->block_found_map
,
3435 if (is_flexbg
&& (pctx
.errcode
== EXT2_ET_BLOCK_ALLOC_FAIL
))
3436 pctx
.errcode
= ext2fs_get_free_blocks2(fs
,
3437 fs
->super
->s_first_data_block
,
3438 ext2fs_blocks_count(fs
->super
),
3439 num
, ctx
->block_found_map
, new_block
);
3442 fix_problem(ctx
, PR_1_RELOC_BLOCK_ALLOCATE
, &pctx
);
3443 ext2fs_unmark_valid(fs
);
3444 ctx
->flags
|= E2F_FLAG_ABORT
;
3447 pctx
.errcode
= ext2fs_get_mem(fs
->blocksize
, &buf
);
3449 fix_problem(ctx
, PR_1_RELOC_MEMORY_ALLOCATE
, &pctx
);
3450 ext2fs_unmark_valid(fs
);
3451 ctx
->flags
|= E2F_FLAG_ABORT
;
3454 ext2fs_mark_super_dirty(fs
);
3455 fs
->flags
&= ~EXT2_FLAG_MASTER_SB_ONLY
;
3456 pctx
.blk2
= *new_block
;
3457 fix_problem(ctx
, (old_block
? PR_1_RELOC_FROM_TO
:
3458 PR_1_RELOC_TO
), &pctx
);
3460 for (i
= 0; i
< num
; i
++) {
3462 ext2fs_mark_block_bitmap2(ctx
->block_found_map
, (*new_block
)+i
);
3464 pctx
.errcode
= io_channel_read_blk64(fs
->io
,
3465 old_block
+ i
, 1, buf
);
3467 fix_problem(ctx
, PR_1_RELOC_READ_ERR
, &pctx
);
3469 memset(buf
, 0, fs
->blocksize
);
3471 pctx
.blk
= (*new_block
) + i
;
3472 pctx
.errcode
= io_channel_write_blk64(fs
->io
, pctx
.blk
,
3475 fix_problem(ctx
, PR_1_RELOC_WRITE_ERR
, &pctx
);
3477 ext2fs_free_mem(&buf
);
3481 * This routine gets called at the end of pass 1 if bad blocks are
3482 * detected in the superblock, group descriptors, inode_bitmaps, or
3483 * block bitmaps. At this point, all of the blocks have been mapped
3484 * out, so we can try to allocate new block(s) to replace the bad
3487 static void handle_fs_bad_blocks(e2fsck_t ctx
)
3489 ext2_filsys fs
= ctx
->fs
;
3491 blk64_t first_block
;
3494 for (i
= 0; i
< fs
->group_desc_count
; i
++) {
3495 first_block
= ext2fs_group_first_block2(fs
, i
);
3497 if (ctx
->invalid_block_bitmap_flag
[i
]) {
3498 new_blk
= ext2fs_block_bitmap_loc(fs
, i
);
3499 new_table_block(ctx
, first_block
, i
, _("block bitmap"),
3501 ext2fs_block_bitmap_loc_set(fs
, i
, new_blk
);
3503 if (ctx
->invalid_inode_bitmap_flag
[i
]) {
3504 new_blk
= ext2fs_inode_bitmap_loc(fs
, i
);
3505 new_table_block(ctx
, first_block
, i
, _("inode bitmap"),
3507 ext2fs_inode_bitmap_loc_set(fs
, i
, new_blk
);
3509 if (ctx
->invalid_inode_table_flag
[i
]) {
3510 new_blk
= ext2fs_inode_table_loc(fs
, i
);
3511 new_table_block(ctx
, first_block
, i
, _("inode table"),
3512 fs
->inode_blocks_per_group
,
3514 ext2fs_inode_table_loc_set(fs
, i
, new_blk
);
3515 ctx
->flags
|= E2F_FLAG_RESTART
;
3518 ctx
->invalid_bitmaps
= 0;
3522 * This routine marks all blocks which are used by the superblock,
3523 * group descriptors, inode bitmaps, and block bitmaps.
3525 static void mark_table_blocks(e2fsck_t ctx
)
3527 ext2_filsys fs
= ctx
->fs
;
3531 struct problem_context pctx
;
3533 clear_problem_context(&pctx
);
3535 for (i
= 0; i
< fs
->group_desc_count
; i
++) {
3538 ext2fs_reserve_super_and_bgd(fs
, i
, ctx
->block_found_map
);
3539 ext2fs_reserve_super_and_bgd(fs
, i
, ctx
->block_metadata_map
);
3542 * Mark the blocks used for the inode table
3544 if (ext2fs_inode_table_loc(fs
, i
)) {
3545 for (j
= 0, b
= ext2fs_inode_table_loc(fs
, i
);
3546 j
< fs
->inode_blocks_per_group
;
3548 if (ext2fs_test_block_bitmap2(ctx
->block_found_map
,
3551 if (!ctx
->invalid_inode_table_flag
[i
] &&
3553 PR_1_ITABLE_CONFLICT
, &pctx
)) {
3554 ctx
->invalid_inode_table_flag
[i
]++;
3555 ctx
->invalid_bitmaps
++;
3558 ext2fs_mark_block_bitmap2(
3559 ctx
->block_found_map
, b
);
3560 ext2fs_mark_block_bitmap2(
3561 ctx
->block_metadata_map
, b
);
3567 * Mark block used for the block bitmap
3569 if (ext2fs_block_bitmap_loc(fs
, i
)) {
3570 if (ext2fs_test_block_bitmap2(ctx
->block_found_map
,
3571 ext2fs_block_bitmap_loc(fs
, i
))) {
3572 pctx
.blk
= ext2fs_block_bitmap_loc(fs
, i
);
3573 if (fix_problem(ctx
, PR_1_BB_CONFLICT
, &pctx
)) {
3574 ctx
->invalid_block_bitmap_flag
[i
]++;
3575 ctx
->invalid_bitmaps
++;
3578 ext2fs_mark_block_bitmap2(ctx
->block_found_map
,
3579 ext2fs_block_bitmap_loc(fs
, i
));
3580 ext2fs_mark_block_bitmap2(ctx
->block_metadata_map
,
3581 ext2fs_block_bitmap_loc(fs
, i
));
3585 * Mark block used for the inode bitmap
3587 if (ext2fs_inode_bitmap_loc(fs
, i
)) {
3588 if (ext2fs_test_block_bitmap2(ctx
->block_found_map
,
3589 ext2fs_inode_bitmap_loc(fs
, i
))) {
3590 pctx
.blk
= ext2fs_inode_bitmap_loc(fs
, i
);
3591 if (fix_problem(ctx
, PR_1_IB_CONFLICT
, &pctx
)) {
3592 ctx
->invalid_inode_bitmap_flag
[i
]++;
3593 ctx
->invalid_bitmaps
++;
3596 ext2fs_mark_block_bitmap2(ctx
->block_metadata_map
,
3597 ext2fs_inode_bitmap_loc(fs
, i
));
3598 ext2fs_mark_block_bitmap2(ctx
->block_found_map
,
3599 ext2fs_inode_bitmap_loc(fs
, i
));
3606 * Thes subroutines short circuits ext2fs_get_blocks and
3607 * ext2fs_check_directory; we use them since we already have the inode
3608 * structure, so there's no point in letting the ext2fs library read
3611 static errcode_t
pass1_get_blocks(ext2_filsys fs
, ext2_ino_t ino
,
3614 e2fsck_t ctx
= (e2fsck_t
) fs
->priv_data
;
3617 if ((ino
!= ctx
->stashed_ino
) || !ctx
->stashed_inode
)
3618 return EXT2_ET_CALLBACK_NOTHANDLED
;
3620 for (i
=0; i
< EXT2_N_BLOCKS
; i
++)
3621 blocks
[i
] = ctx
->stashed_inode
->i_block
[i
];
3625 static errcode_t
pass1_read_inode(ext2_filsys fs
, ext2_ino_t ino
,
3626 struct ext2_inode
*inode
)
3628 e2fsck_t ctx
= (e2fsck_t
) fs
->priv_data
;
3630 if ((ino
!= ctx
->stashed_ino
) || !ctx
->stashed_inode
)
3631 return EXT2_ET_CALLBACK_NOTHANDLED
;
3632 *inode
= *ctx
->stashed_inode
;
3636 static errcode_t
pass1_write_inode(ext2_filsys fs
, ext2_ino_t ino
,
3637 struct ext2_inode
*inode
)
3639 e2fsck_t ctx
= (e2fsck_t
) fs
->priv_data
;
3641 if ((ino
== ctx
->stashed_ino
) && ctx
->stashed_inode
&&
3642 (inode
!= ctx
->stashed_inode
))
3643 *ctx
->stashed_inode
= *inode
;
3644 return EXT2_ET_CALLBACK_NOTHANDLED
;
3647 static errcode_t
pass1_check_directory(ext2_filsys fs
, ext2_ino_t ino
)
3649 e2fsck_t ctx
= (e2fsck_t
) fs
->priv_data
;
3651 if ((ino
!= ctx
->stashed_ino
) || !ctx
->stashed_inode
)
3652 return EXT2_ET_CALLBACK_NOTHANDLED
;
3654 if (!LINUX_S_ISDIR(ctx
->stashed_inode
->i_mode
))
3655 return EXT2_ET_NO_DIRECTORY
;
3659 static errcode_t
e2fsck_get_alloc_block(ext2_filsys fs
, blk64_t goal
,
3662 e2fsck_t ctx
= (e2fsck_t
) fs
->priv_data
;
3666 if (ctx
->block_found_map
) {
3667 retval
= ext2fs_new_block2(fs
, goal
, ctx
->block_found_map
,
3671 if (fs
->block_map
) {
3672 ext2fs_mark_block_bitmap2(fs
->block_map
, new_block
);
3673 ext2fs_mark_bb_dirty(fs
);
3676 if (!fs
->block_map
) {
3677 retval
= ext2fs_read_block_bitmap(fs
);
3682 retval
= ext2fs_new_block2(fs
, goal
, 0, &new_block
);
3691 static void e2fsck_block_alloc_stats(ext2_filsys fs
, blk64_t blk
, int inuse
)
3693 e2fsck_t ctx
= (e2fsck_t
) fs
->priv_data
;
3695 /* Never free a critical metadata block */
3696 if (ctx
->block_found_map
&&
3697 ctx
->block_metadata_map
&&
3699 ext2fs_test_block_bitmap2(ctx
->block_metadata_map
, blk
))
3702 if (ctx
->block_found_map
) {
3704 ext2fs_mark_block_bitmap2(ctx
->block_found_map
, blk
);
3706 ext2fs_unmark_block_bitmap2(ctx
->block_found_map
, blk
);
3710 void e2fsck_use_inode_shortcuts(e2fsck_t ctx
, int use_shortcuts
)
3712 ext2_filsys fs
= ctx
->fs
;
3714 if (use_shortcuts
) {
3715 fs
->get_blocks
= pass1_get_blocks
;
3716 fs
->check_directory
= pass1_check_directory
;
3717 fs
->read_inode
= pass1_read_inode
;
3718 fs
->write_inode
= pass1_write_inode
;
3719 ctx
->stashed_ino
= 0;
3722 fs
->check_directory
= 0;
3724 fs
->write_inode
= 0;
3728 void e2fsck_intercept_block_allocations(e2fsck_t ctx
)
3730 ext2fs_set_alloc_block_callback(ctx
->fs
, e2fsck_get_alloc_block
, 0);
3731 ext2fs_set_block_alloc_stats_callback(ctx
->fs
,
3732 e2fsck_block_alloc_stats
, 0);