2 * pass2.c --- check directory structure
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 2 of e2fsck iterates through all active directory inodes, and
12 * applies to following tests to each directory entry in the directory
13 * blocks in the inodes:
15 * - The length of the directory entry (rec_len) should be at
16 * least 8 bytes, and no more than the remaining space
17 * left in the directory block.
18 * - The length of the name in the directory entry (name_len)
19 * should be less than (rec_len - 8).
20 * - The inode number in the directory entry should be within
22 * - The inode number should refer to a in-use inode.
23 * - The first entry should be '.', and its inode should be
24 * the inode of the directory.
25 * - The second entry should be '..'.
27 * To minimize disk seek time, the directory blocks are processed in
28 * sorted order of block numbers.
30 * Pass 2 also collects the following information:
31 * - The inode numbers of the subdirectories for each directory.
33 * Pass 2 relies on the following information from previous passes:
34 * - The directory information collected in pass 1.
35 * - The inode_used_map bitmap
36 * - The inode_bad_map bitmap
37 * - The inode_dir_map bitmap
39 * Pass 2 frees the following data structures
40 * - The inode_bad_map bitmap
41 * - The inode_reg_map bitmap
44 #define _GNU_SOURCE 1 /* get strnlen() */
50 #include "support/dict.h"
52 #ifdef NO_INLINE_FUNCS
55 #define _INLINE_ inline
58 /* #define DX_DEBUG */
61 * Keeps track of how many times an inode is referenced.
63 static void deallocate_inode(e2fsck_t ctx
, ext2_ino_t ino
, char* block_buf
);
64 static int check_dir_block2(ext2_filsys fs
,
65 struct ext2_db_entry2
*dir_blocks_info
,
67 static int check_dir_block(ext2_filsys fs
,
68 struct ext2_db_entry2
*dir_blocks_info
,
70 static int allocate_dir_block(e2fsck_t ctx
,
71 struct ext2_db_entry2
*dir_blocks_info
,
72 char *buf
, struct problem_context
*pctx
);
73 static void clear_htree(e2fsck_t ctx
, ext2_ino_t ino
);
74 static int htree_depth(struct dx_dir_info
*dx_dir
,
75 struct dx_dirblock_info
*dx_db
);
76 static EXT2_QSORT_TYPE
special_dir_block_cmp(const void *a
, const void *b
);
78 struct check_dir_struct
{
80 struct problem_context pctx
;
83 unsigned long long list_offset
;
84 unsigned long long ra_entries
;
85 unsigned long long next_ra_off
;
88 static void update_parents(struct dx_dir_info
*dx_dir
, int type
)
90 struct dx_dirblock_info
*dx_db
, *dx_parent
, *dx_previous
;
93 for (b
= 0, dx_db
= dx_dir
->dx_block
;
94 b
< dx_dir
->numblocks
;
96 dx_parent
= &dx_dir
->dx_block
[dx_db
->parent
];
97 if (dx_db
->type
!= type
)
101 * XXX Make sure dx_parent->min_hash > dx_db->min_hash
103 if (dx_db
->flags
& DX_FLAG_FIRST
) {
104 dx_parent
->min_hash
= dx_db
->min_hash
;
105 if (dx_parent
->previous
) {
107 &dx_dir
->dx_block
[dx_parent
->previous
];
108 dx_previous
->node_max_hash
=
113 * XXX Make sure dx_parent->max_hash < dx_db->max_hash
115 if (dx_db
->flags
& DX_FLAG_LAST
) {
116 dx_parent
->max_hash
= dx_db
->max_hash
;
121 void e2fsck_pass2(e2fsck_t ctx
)
123 struct ext2_super_block
*sb
= ctx
->fs
->super
;
124 struct problem_context pctx
;
125 ext2_filsys fs
= ctx
->fs
;
127 #ifdef RESOURCE_TRACK
128 struct resource_track rtrack
;
130 struct check_dir_struct cd
;
131 struct dx_dir_info
*dx_dir
;
132 struct dx_dirblock_info
*dx_db
;
137 int (*check_dir_func
)(ext2_filsys fs
,
138 struct ext2_db_entry2
*dir_blocks_info
,
141 init_resource_track(&rtrack
, ctx
->fs
->io
);
142 clear_problem_context(&cd
.pctx
);
145 mtrace_print("Pass 2");
148 if (!(ctx
->options
& E2F_OPT_PREEN
))
149 fix_problem(ctx
, PR_2_PASS_HEADER
, &cd
.pctx
);
151 cd
.pctx
.errcode
= e2fsck_setup_icount(ctx
, "inode_count",
152 EXT2_ICOUNT_OPT_INCREMENT
,
153 ctx
->inode_link_info
, &ctx
->inode_count
);
154 if (cd
.pctx
.errcode
) {
155 fix_problem(ctx
, PR_2_ALLOCATE_ICOUNT
, &cd
.pctx
);
156 ctx
->flags
|= E2F_FLAG_ABORT
;
159 buf
= (char *) e2fsck_allocate_memory(ctx
, 2*fs
->blocksize
,
160 "directory scan buffer");
163 * Set up the parent pointer for the root directory, if
164 * present. (If the root directory is not present, we will
165 * create it in pass 3.)
167 (void) e2fsck_dir_info_set_parent(ctx
, EXT2_ROOT_INO
, EXT2_ROOT_INO
);
172 cd
.max
= ext2fs_dblist_count2(fs
->dblist
);
174 cd
.ra_entries
= ctx
->readahead_kb
* 1024 / ctx
->fs
->blocksize
;
178 (void) (ctx
->progress
)(ctx
, 2, 0, cd
.max
);
180 if (ext2fs_has_feature_dir_index(fs
->super
))
181 ext2fs_dblist_sort2(fs
->dblist
, special_dir_block_cmp
);
183 check_dir_func
= cd
.ra_entries
? check_dir_block2
: check_dir_block
;
184 cd
.pctx
.errcode
= ext2fs_dblist_iterate2(fs
->dblist
, check_dir_func
,
186 if (ctx
->flags
& E2F_FLAG_RESTART_LATER
) {
187 ctx
->flags
|= E2F_FLAG_RESTART
;
188 ctx
->flags
&= ~E2F_FLAG_RESTART_LATER
;
191 if (ctx
->flags
& E2F_FLAG_RUN_RETURN
)
194 if (cd
.pctx
.errcode
) {
195 fix_problem(ctx
, PR_2_DBLIST_ITERATE
, &cd
.pctx
);
196 ctx
->flags
|= E2F_FLAG_ABORT
;
200 for (i
=0; (dx_dir
= e2fsck_dx_dir_info_iter(ctx
, &i
)) != 0;) {
201 if (ctx
->flags
& E2F_FLAG_SIGNAL_MASK
)
203 if (e2fsck_dir_will_be_rehashed(ctx
, dx_dir
->ino
) ||
204 dx_dir
->numblocks
== 0)
206 clear_problem_context(&pctx
);
208 pctx
.dir
= dx_dir
->ino
;
209 dx_db
= dx_dir
->dx_block
;
210 if (dx_db
->flags
& DX_FLAG_REFERENCED
)
211 dx_db
->flags
|= DX_FLAG_DUP_REF
;
213 dx_db
->flags
|= DX_FLAG_REFERENCED
;
215 * Find all of the first and last leaf blocks, and
216 * update their parent's min and max hash values
218 update_parents(dx_dir
, DX_DIRBLOCK_LEAF
);
220 /* for 3 level htree: update 2 level parent's min
221 * and max hash values */
222 update_parents(dx_dir
, DX_DIRBLOCK_NODE
);
224 for (b
=0, dx_db
= dx_dir
->dx_block
;
225 b
< dx_dir
->numblocks
;
228 pctx
.group
= dx_db
->parent
;
230 if (!(dx_db
->flags
& DX_FLAG_FIRST
) &&
231 (dx_db
->min_hash
< dx_db
->node_min_hash
)) {
232 pctx
.blk
= dx_db
->min_hash
;
233 pctx
.blk2
= dx_db
->node_min_hash
;
234 code
= PR_2_HTREE_MIN_HASH
;
235 fix_problem(ctx
, code
, &pctx
);
238 if (dx_db
->type
== DX_DIRBLOCK_LEAF
) {
239 depth
= htree_depth(dx_dir
, dx_db
);
240 if (depth
!= dx_dir
->depth
) {
241 pctx
.num
= dx_dir
->depth
;
242 code
= PR_2_HTREE_BAD_DEPTH
;
243 fix_problem(ctx
, code
, &pctx
);
248 * This test doesn't apply for the root block
252 (dx_db
->max_hash
> dx_db
->node_max_hash
)) {
253 pctx
.blk
= dx_db
->max_hash
;
254 pctx
.blk2
= dx_db
->node_max_hash
;
255 code
= PR_2_HTREE_MAX_HASH
;
256 fix_problem(ctx
, code
, &pctx
);
259 if (!(dx_db
->flags
& DX_FLAG_REFERENCED
)) {
260 code
= PR_2_HTREE_NOTREF
;
261 fix_problem(ctx
, code
, &pctx
);
263 } else if (dx_db
->flags
& DX_FLAG_DUP_REF
) {
264 code
= PR_2_HTREE_DUPREF
;
265 fix_problem(ctx
, code
, &pctx
);
269 if (bad_dir
&& fix_problem(ctx
, PR_2_HTREE_CLEAR
, &pctx
)) {
270 clear_htree(ctx
, dx_dir
->ino
);
271 dx_dir
->numblocks
= 0;
274 e2fsck_free_dx_dir_info(ctx
);
276 ext2fs_free_mem(&buf
);
277 ext2fs_free_dblist(fs
->dblist
);
279 if (ctx
->inode_bad_map
) {
280 ext2fs_free_inode_bitmap(ctx
->inode_bad_map
);
281 ctx
->inode_bad_map
= 0;
283 if (ctx
->inode_reg_map
) {
284 ext2fs_free_inode_bitmap(ctx
->inode_reg_map
);
285 ctx
->inode_reg_map
= 0;
287 if (ctx
->encrypted_dirs
) {
288 ext2fs_u32_list_free(ctx
->encrypted_dirs
);
289 ctx
->encrypted_dirs
= 0;
292 clear_problem_context(&pctx
);
293 if (ctx
->large_files
) {
294 if (!ext2fs_has_feature_large_file(sb
) &&
295 fix_problem(ctx
, PR_2_FEATURE_LARGE_FILES
, &pctx
)) {
296 ext2fs_set_feature_large_file(sb
);
297 fs
->flags
&= ~EXT2_FLAG_MASTER_SB_ONLY
;
298 ext2fs_mark_super_dirty(fs
);
300 if (sb
->s_rev_level
== EXT2_GOOD_OLD_REV
&&
301 fix_problem(ctx
, PR_1_FS_REV_LEVEL
, &pctx
)) {
302 ext2fs_update_dynamic_rev(fs
);
303 ext2fs_mark_super_dirty(fs
);
307 print_resource_track(ctx
, _("Pass 2"), &rtrack
, fs
->io
);
309 ext2fs_free_mem(&buf
);
312 #define MAX_DEPTH 32000
313 static int htree_depth(struct dx_dir_info
*dx_dir
,
314 struct dx_dirblock_info
*dx_db
)
318 while (dx_db
->type
!= DX_DIRBLOCK_ROOT
&& depth
< MAX_DEPTH
) {
319 dx_db
= &dx_dir
->dx_block
[dx_db
->parent
];
325 static int dict_de_cmp(const void *a
, const void *b
)
327 const struct ext2_dir_entry
*de_a
, *de_b
;
330 de_a
= (const struct ext2_dir_entry
*) a
;
331 a_len
= ext2fs_dirent_name_len(de_a
);
332 de_b
= (const struct ext2_dir_entry
*) b
;
333 b_len
= ext2fs_dirent_name_len(de_b
);
336 return (a_len
- b_len
);
338 return memcmp(de_a
->name
, de_b
->name
, a_len
);
342 * This is special sort function that makes sure that directory blocks
343 * with a dirblock of zero are sorted to the beginning of the list.
344 * This guarantees that the root node of the htree directories are
345 * processed first, so we know what hash version to use.
347 static EXT2_QSORT_TYPE
special_dir_block_cmp(const void *a
, const void *b
)
349 const struct ext2_db_entry2
*db_a
=
350 (const struct ext2_db_entry2
*) a
;
351 const struct ext2_db_entry2
*db_b
=
352 (const struct ext2_db_entry2
*) b
;
354 if (db_a
->blockcnt
&& !db_b
->blockcnt
)
357 if (!db_a
->blockcnt
&& db_b
->blockcnt
)
360 if (db_a
->blk
!= db_b
->blk
)
361 return (int) (db_a
->blk
- db_b
->blk
);
363 if (db_a
->ino
!= db_b
->ino
)
364 return (int) (db_a
->ino
- db_b
->ino
);
366 return (int) (db_a
->blockcnt
- db_b
->blockcnt
);
371 * Make sure the first entry in the directory is '.', and that the
372 * directory entry is sane.
374 static int check_dot(e2fsck_t ctx
,
375 struct ext2_dir_entry
*dirent
,
376 ext2_ino_t ino
, struct problem_context
*pctx
)
378 struct ext2_dir_entry
*nextdir
;
379 unsigned int rec_len
, new_len
;
382 problem_t problem
= 0;
385 problem
= PR_2_MISSING_DOT
;
386 else if ((ext2fs_dirent_name_len(dirent
) != 1) ||
387 (dirent
->name
[0] != '.'))
388 problem
= PR_2_1ST_NOT_DOT
;
389 else if (dirent
->name
[1] != '\0')
390 problem
= PR_2_DOT_NULL_TERM
;
392 (void) ext2fs_get_rec_len(ctx
->fs
, dirent
, &rec_len
);
394 if (fix_problem(ctx
, problem
, pctx
)) {
396 rec_len
= dirent
->rec_len
= 12;
398 ext2fs_dirent_set_name_len(dirent
, 1);
399 ext2fs_dirent_set_file_type(dirent
, EXT2_FT_UNKNOWN
);
400 dirent
->name
[0] = '.';
401 dirent
->name
[1] = '\0';
406 if (dirent
->inode
!= ino
) {
407 if (fix_problem(ctx
, PR_2_BAD_INODE_DOT
, pctx
)) {
413 new_len
= rec_len
- 12;
416 fix_problem(ctx
, PR_2_SPLIT_DOT
, pctx
)) {
417 nextdir
= (struct ext2_dir_entry
*)
418 ((char *) dirent
+ 12);
419 dirent
->rec_len
= 12;
420 (void) ext2fs_set_rec_len(ctx
->fs
, new_len
,
423 ext2fs_dirent_set_name_len(nextdir
, 0);
424 ext2fs_dirent_set_file_type(nextdir
,
434 * Make sure the second entry in the directory is '..', and that the
435 * directory entry is sane. We do not check the inode number of '..'
436 * here; this gets done in pass 3.
438 static int check_dotdot(e2fsck_t ctx
,
439 struct ext2_dir_entry
*dirent
,
440 ext2_ino_t ino
, struct problem_context
*pctx
)
442 problem_t problem
= 0;
443 unsigned int rec_len
;
446 problem
= PR_2_MISSING_DOT_DOT
;
447 else if ((ext2fs_dirent_name_len(dirent
) != 2) ||
448 (dirent
->name
[0] != '.') ||
449 (dirent
->name
[1] != '.'))
450 problem
= PR_2_2ND_NOT_DOT_DOT
;
451 else if (dirent
->name
[2] != '\0')
452 problem
= PR_2_DOT_DOT_NULL_TERM
;
454 (void) ext2fs_get_rec_len(ctx
->fs
, dirent
, &rec_len
);
456 if (fix_problem(ctx
, problem
, pctx
)) {
458 dirent
->rec_len
= 12;
460 * Note: we don't have the parent inode just
461 * yet, so we will fill it in with the root
462 * inode. This will get fixed in pass 3.
464 dirent
->inode
= EXT2_ROOT_INO
;
465 ext2fs_dirent_set_name_len(dirent
, 2);
466 ext2fs_dirent_set_file_type(dirent
, EXT2_FT_UNKNOWN
);
467 dirent
->name
[0] = '.';
468 dirent
->name
[1] = '.';
469 dirent
->name
[2] = '\0';
474 if (e2fsck_dir_info_set_dotdot(ctx
, ino
, dirent
->inode
)) {
475 fix_problem(ctx
, PR_2_NO_DIRINFO
, pctx
);
482 * Check to make sure a directory entry doesn't contain any illegal
485 static int check_name(e2fsck_t ctx
,
486 struct ext2_dir_entry
*dirent
,
487 struct problem_context
*pctx
)
493 for ( i
= 0; i
< ext2fs_dirent_name_len(dirent
); i
++) {
494 if (dirent
->name
[i
] != '/' && dirent
->name
[i
] != '\0')
497 fixup
= fix_problem(ctx
, PR_2_BAD_NAME
, pctx
);
500 dirent
->name
[i
] = '.';
506 static int encrypted_check_name(e2fsck_t ctx
,
507 struct ext2_dir_entry
*dirent
,
508 struct problem_context
*pctx
)
510 if (ext2fs_dirent_name_len(dirent
) < EXT4_CRYPTO_BLOCK_SIZE
) {
511 if (fix_problem(ctx
, PR_2_BAD_ENCRYPTED_NAME
, pctx
)) {
515 ext2fs_unmark_valid(ctx
->fs
);
521 * Check the directory filetype (if present)
523 static _INLINE_
int check_filetype(e2fsck_t ctx
,
524 struct ext2_dir_entry
*dirent
,
525 ext2_ino_t dir_ino
EXT2FS_ATTR((unused
)),
526 struct problem_context
*pctx
)
528 int filetype
= ext2fs_dirent_file_type(dirent
);
529 int should_be
= EXT2_FT_UNKNOWN
;
530 struct ext2_inode inode
;
532 if (!ext2fs_has_feature_filetype(ctx
->fs
->super
)) {
534 !fix_problem(ctx
, PR_2_CLEAR_FILETYPE
, pctx
))
536 ext2fs_dirent_set_file_type(dirent
, EXT2_FT_UNKNOWN
);
540 if (ext2fs_test_inode_bitmap2(ctx
->inode_dir_map
, dirent
->inode
)) {
541 should_be
= EXT2_FT_DIR
;
542 } else if (ext2fs_test_inode_bitmap2(ctx
->inode_reg_map
,
544 should_be
= EXT2_FT_REG_FILE
;
545 } else if (ctx
->inode_bad_map
&&
546 ext2fs_test_inode_bitmap2(ctx
->inode_bad_map
,
550 e2fsck_read_inode(ctx
, dirent
->inode
, &inode
,
552 should_be
= ext2_file_type(inode
.i_mode
);
554 if (filetype
== should_be
)
556 pctx
->num
= should_be
;
558 if (fix_problem(ctx
, filetype
? PR_2_BAD_FILETYPE
: PR_2_SET_FILETYPE
,
562 ext2fs_dirent_set_file_type(dirent
, should_be
);
566 static void parse_int_node(ext2_filsys fs
,
567 struct ext2_db_entry2
*db
,
568 struct check_dir_struct
*cd
,
569 struct dx_dir_info
*dx_dir
,
570 char *block_buf
, int failed_csum
)
572 struct ext2_dx_root_info
*root
;
573 struct ext2_dx_entry
*ent
;
574 struct ext2_dx_countlimit
*limit
;
575 struct dx_dirblock_info
*dx_db
;
576 int i
, expect_limit
, count
;
578 ext2_dirhash_t min_hash
= 0xffffffff;
579 ext2_dirhash_t max_hash
= 0;
580 ext2_dirhash_t hash
= 0, prev_hash
;
583 if (db
->blockcnt
== 0) {
584 root
= (struct ext2_dx_root_info
*) (block_buf
+ 24);
587 printf("Root node dump:\n");
588 printf("\t Reserved zero: %u\n", root
->reserved_zero
);
589 printf("\t Hash Version: %d\n", root
->hash_version
);
590 printf("\t Info length: %d\n", root
->info_length
);
591 printf("\t Indirect levels: %d\n", root
->indirect_levels
);
592 printf("\t Flags: %d\n", root
->unused_flags
);
595 ent
= (struct ext2_dx_entry
*) (block_buf
+ 24 + root
->info_length
);
598 (e2fsck_dir_will_be_rehashed(cd
->ctx
, cd
->pctx
.ino
) ||
599 fix_problem(cd
->ctx
, PR_2_HTREE_ROOT_CSUM_INVALID
,
603 ent
= (struct ext2_dx_entry
*) (block_buf
+8);
606 (e2fsck_dir_will_be_rehashed(cd
->ctx
, cd
->pctx
.ino
) ||
607 fix_problem(cd
->ctx
, PR_2_HTREE_NODE_CSUM_INVALID
,
612 limit
= (struct ext2_dx_countlimit
*) ent
;
615 printf("Number of entries (count): %d\n",
616 ext2fs_le16_to_cpu(limit
->count
));
617 printf("Number of entries (limit): %d\n",
618 ext2fs_le16_to_cpu(limit
->limit
));
621 count
= ext2fs_le16_to_cpu(limit
->count
);
622 if (ext2fs_has_feature_metadata_csum(fs
->super
))
623 csum_size
= sizeof(struct ext2_dx_tail
);
624 expect_limit
= (fs
->blocksize
-
625 (csum_size
+ ((char *) ent
- block_buf
))) /
626 sizeof(struct ext2_dx_entry
);
627 if (ext2fs_le16_to_cpu(limit
->limit
) != expect_limit
) {
628 cd
->pctx
.num
= ext2fs_le16_to_cpu(limit
->limit
);
629 if (fix_problem(cd
->ctx
, PR_2_HTREE_BAD_LIMIT
, &cd
->pctx
))
632 if (count
> expect_limit
) {
633 cd
->pctx
.num
= count
;
634 if (fix_problem(cd
->ctx
, PR_2_HTREE_BAD_COUNT
, &cd
->pctx
))
636 count
= expect_limit
;
639 for (i
=0; i
< count
; i
++) {
641 hash
= i
? (ext2fs_le32_to_cpu(ent
[i
].hash
) & ~1) : 0;
643 printf("Entry #%d: Hash 0x%08x, block %u\n", i
,
644 hash
, ext2fs_le32_to_cpu(ent
[i
].block
));
646 blk
= ext2fs_le32_to_cpu(ent
[i
].block
) & EXT4_DX_BLOCK_MASK
;
647 /* Check to make sure the block is valid */
648 if (blk
>= (blk_t
) dx_dir
->numblocks
) {
650 if (fix_problem(cd
->ctx
, PR_2_HTREE_BADBLK
,
655 if (hash
< prev_hash
&&
656 fix_problem(cd
->ctx
, PR_2_HTREE_HASH_ORDER
, &cd
->pctx
))
658 dx_db
= &dx_dir
->dx_block
[blk
];
659 if (dx_db
->flags
& DX_FLAG_REFERENCED
) {
660 dx_db
->flags
|= DX_FLAG_DUP_REF
;
662 dx_db
->flags
|= DX_FLAG_REFERENCED
;
663 dx_db
->parent
= db
->blockcnt
;
667 i
? (ext2fs_le32_to_cpu(ent
[i
-1].block
) &
668 EXT4_DX_BLOCK_MASK
) : 0;
674 dx_db
->node_min_hash
= hash
;
676 dx_db
->node_max_hash
=
677 ext2fs_le32_to_cpu(ent
[i
+1].hash
) & ~1;
679 dx_db
->node_max_hash
= 0xfffffffe;
680 dx_db
->flags
|= DX_FLAG_LAST
;
683 dx_db
->flags
|= DX_FLAG_FIRST
;
686 printf("Blockcnt = %d, min hash 0x%08x, max hash 0x%08x\n",
687 db
->blockcnt
, min_hash
, max_hash
);
689 dx_db
= &dx_dir
->dx_block
[db
->blockcnt
];
690 dx_db
->min_hash
= min_hash
;
691 dx_db
->max_hash
= max_hash
;
695 clear_htree(cd
->ctx
, cd
->pctx
.ino
);
696 dx_dir
->numblocks
= 0;
697 e2fsck_rehash_dir_later(cd
->ctx
, cd
->pctx
.ino
);
701 * Given a busted directory, try to salvage it somehow.
704 static void salvage_directory(ext2_filsys fs
,
705 struct ext2_dir_entry
*dirent
,
706 struct ext2_dir_entry
*prev
,
707 unsigned int *offset
,
708 unsigned int block_len
)
710 char *cp
= (char *) dirent
;
712 unsigned int rec_len
, prev_rec_len
;
713 unsigned int name_len
;
716 * If the space left for the entry is too small to be an entry,
717 * we can't access dirent's fields, so plumb in the values needed
718 * so that the previous entry absorbs this one.
720 if (block_len
- *offset
< EXT2_DIR_ENTRY_HEADER_LEN
) {
722 rec_len
= block_len
- *offset
;
724 name_len
= ext2fs_dirent_name_len(dirent
);
725 (void) ext2fs_get_rec_len(fs
, dirent
, &rec_len
);
727 left
= block_len
- *offset
- rec_len
;
730 * Special case of directory entry of size 8: copy what's left
731 * of the directory block up to cover up the invalid hole.
733 if ((left
>= 12) && (rec_len
== EXT2_DIR_ENTRY_HEADER_LEN
)) {
734 memmove(cp
, cp
+EXT2_DIR_ENTRY_HEADER_LEN
, left
);
735 memset(cp
+ left
, 0, EXT2_DIR_ENTRY_HEADER_LEN
);
739 * If the directory entry overruns the end of the directory
740 * block, and the name is small enough to fit, then adjust the
744 ((int) rec_len
+ left
> EXT2_DIR_ENTRY_HEADER_LEN
) &&
745 ((int) name_len
+ EXT2_DIR_ENTRY_HEADER_LEN
<= (int) rec_len
+ left
) &&
746 dirent
->inode
<= fs
->super
->s_inodes_count
&&
747 strnlen(dirent
->name
, name_len
) == name_len
) {
748 (void) ext2fs_set_rec_len(fs
, (int) rec_len
+ left
, dirent
);
752 * If the record length of the directory entry is a multiple
753 * of four, and not too big, such that it is valid, let the
754 * previous directory entry absorb the invalid one.
756 if (prev
&& rec_len
&& (rec_len
% 4) == 0 &&
757 (*offset
+ rec_len
<= block_len
)) {
758 (void) ext2fs_get_rec_len(fs
, prev
, &prev_rec_len
);
759 prev_rec_len
+= rec_len
;
760 (void) ext2fs_set_rec_len(fs
, prev_rec_len
, prev
);
765 * Default salvage method --- kill all of the directory
766 * entries for the rest of the block. We will either try to
767 * absorb it into the previous directory entry, or create a
768 * new empty directory entry the rest of the directory block.
771 (void) ext2fs_get_rec_len(fs
, prev
, &prev_rec_len
);
772 prev_rec_len
+= block_len
- *offset
;
773 (void) ext2fs_set_rec_len(fs
, prev_rec_len
, prev
);
774 *offset
= fs
->blocksize
;
776 rec_len
= block_len
- *offset
;
777 (void) ext2fs_set_rec_len(fs
, rec_len
, dirent
);
778 ext2fs_dirent_set_name_len(dirent
, 0);
779 ext2fs_dirent_set_file_type(dirent
, EXT2_FT_UNKNOWN
);
784 #define NEXT_DIRENT(d) ((void *)((char *)(d) + (d)->rec_len))
785 static errcode_t
insert_dirent_tail(ext2_filsys fs
, void *dirbuf
)
787 struct ext2_dir_entry
*d
;
789 struct ext2_dir_entry_tail
*t
;
792 top
= EXT2_DIRENT_TAIL(dirbuf
, fs
->blocksize
);
794 while (d
->rec_len
&& !(d
->rec_len
& 0x3) && NEXT_DIRENT(d
) <= top
)
798 unsigned int min_size
= EXT2_DIR_REC_LEN(
799 ext2fs_dirent_name_len(dirbuf
));
800 if (min_size
> (char *)top
- (char *)d
)
801 return EXT2_ET_DIR_NO_SPACE_FOR_CSUM
;
802 d
->rec_len
= (char *)top
- (char *)d
;
805 t
= (struct ext2_dir_entry_tail
*)top
;
806 if (t
->det_reserved_zero1
||
807 t
->det_rec_len
!= sizeof(struct ext2_dir_entry_tail
) ||
808 t
->det_reserved_name_len
!= EXT2_DIR_NAME_LEN_CSUM
)
809 ext2fs_initialize_dirent_tail(fs
, t
);
815 static errcode_t
fix_inline_dir_size(e2fsck_t ctx
, ext2_ino_t ino
,
816 size_t *inline_data_size
,
817 struct problem_context
*pctx
,
820 ext2_filsys fs
= ctx
->fs
;
821 struct ext2_inode inode
;
822 size_t new_size
, old_size
;
825 old_size
= *inline_data_size
;
827 * If there's not enough bytes to start the "second" dir block
828 * (in the EA space) then truncate everything to the first block.
830 if (old_size
> EXT4_MIN_INLINE_DATA_SIZE
&&
831 old_size
< EXT4_MIN_INLINE_DATA_SIZE
+
832 EXT2_DIR_REC_LEN(1)) {
833 old_size
= EXT4_MIN_INLINE_DATA_SIZE
;
836 /* Increase to the next four-byte boundary for salvaging */
837 new_size
= old_size
+ (4 - (old_size
& 3));
838 memset(buf
+ old_size
, 0, new_size
- old_size
);
839 retval
= ext2fs_inline_data_set(fs
, ino
, 0, buf
, new_size
);
840 if (retval
== EXT2_ET_INLINE_DATA_NO_SPACE
) {
841 /* Or we can't, so truncate. */
843 retval
= ext2fs_inline_data_set(fs
, ino
, 0, buf
, new_size
);
845 if (fix_problem(ctx
, PR_2_FIX_INLINE_DIR_FAILED
,
853 if (fix_problem(ctx
, PR_2_FIX_INLINE_DIR_FAILED
,
862 retval
= ext2fs_read_inode(fs
, ino
, &inode
);
866 retval
= ext2fs_inode_size_set(fs
, &inode
, new_size
);
870 inode
.i_flags
&= ~EXT4_INLINE_DATA_FL
;
871 retval
= ext2fs_write_inode(fs
, ino
, &inode
);
874 *inline_data_size
= new_size
;
880 static int check_dir_block2(ext2_filsys fs
,
881 struct ext2_db_entry2
*db
,
885 struct check_dir_struct
*cd
= priv_data
;
887 if (cd
->ra_entries
&& cd
->list_offset
>= cd
->next_ra_off
) {
888 err
= e2fsck_readahead_dblist(fs
,
889 E2FSCK_RA_DBLIST_IGNORE_BLOCKCNT
,
891 cd
->list_offset
+ cd
->ra_entries
/ 8,
895 cd
->next_ra_off
= cd
->list_offset
+ (cd
->ra_entries
* 7 / 8);
898 err
= check_dir_block(fs
, db
, priv_data
);
903 static int check_dir_block(ext2_filsys fs
,
904 struct ext2_db_entry2
*db
,
907 struct dx_dir_info
*dx_dir
;
908 struct dx_dirblock_info
*dx_db
= 0;
909 struct ext2_dir_entry
*dirent
, *prev
, dot
, dotdot
;
911 unsigned int offset
= 0;
912 int dir_modified
= 0;
914 unsigned int rec_len
;
915 blk64_t block_nr
= db
->blk
;
916 ext2_ino_t ino
= db
->ino
;
917 ext2_ino_t subdir_parent
;
919 struct check_dir_struct
*cd
;
923 struct ext2_dx_root_info
*root
;
924 struct ext2_dx_countlimit
*limit
;
925 static dict_t de_dict
;
926 struct problem_context pctx
;
929 int dx_csum_size
= 0, de_csum_size
= 0;
932 size_t inline_data_size
= 0;
935 size_t max_block_size
;
937 static char *eop_read_dirblock
= NULL
;
939 cd
= (struct check_dir_struct
*) priv_data
;
940 ibuf
= buf
= cd
->buf
;
943 if (ctx
->flags
& E2F_FLAG_RUN_RETURN
)
946 if (ctx
->progress
&& (ctx
->progress
)(ctx
, 2, cd
->count
++, cd
->max
))
949 if (ext2fs_has_feature_metadata_csum(fs
->super
)) {
950 dx_csum_size
= sizeof(struct ext2_dx_tail
);
951 de_csum_size
= sizeof(struct ext2_dir_entry_tail
);
954 if (ext2fs_has_feature_filetype(fs
->super
))
955 filetype
= EXT2_FT_DIR
<< 8;
958 * Make sure the inode is still in use (could have been
959 * deleted in the duplicate/bad blocks pass.
961 if (!(ext2fs_test_inode_bitmap2(ctx
->inode_used_map
, ino
)))
965 cd
->pctx
.blk
= block_nr
;
966 cd
->pctx
.blkcount
= db
->blockcnt
;
971 if (ext2fs_has_feature_inline_data(fs
->super
)) {
974 ec
= ext2fs_inline_data_size(fs
, ino
, &inline_data_size
);
975 if (ec
&& ec
!= EXT2_ET_NO_INLINE_DATA
)
979 /* This will allow (at some point in the future) to punch out empty
980 * directory blocks and reduce the space used by a directory that grows
981 * very large and then the files are deleted. For now, all that is
982 * needed is to avoid e2fsck filling in these holes as part of
984 if (db
->blk
== 0 && ext2fs_has_feature_largedir(fs
->super
) &&
985 !ext2fs_has_feature_inline_data(fs
->super
))
988 if (db
->blk
== 0 && !inline_data_size
) {
989 if (allocate_dir_block(ctx
, db
, buf
, &cd
->pctx
))
999 if (ctx
->dirs_to_hash
&&
1000 ext2fs_u32_list_test(ctx
->dirs_to_hash
, ino
))
1004 printf("In process_dir_block block %lu, #%d, inode %lu\n", block_nr
,
1008 if (!eop_read_dirblock
)
1009 eop_read_dirblock
= (char *) _("reading directory block");
1010 ehandler_operation(eop_read_dirblock
);
1011 if (inline_data_size
) {
1012 memset(buf
, 0, fs
->blocksize
- inline_data_size
);
1013 cd
->pctx
.errcode
= ext2fs_inline_data_get(fs
, ino
, 0, buf
, 0);
1014 if (cd
->pctx
.errcode
)
1015 goto inline_read_fail
;
1016 #ifdef WORDS_BIGENDIAN
1018 goto skip_first_read_swab
;
1019 *((__u32
*)buf
) = ext2fs_le32_to_cpu(*((__u32
*)buf
));
1020 cd
->pctx
.errcode
= ext2fs_dirent_swab_in2(fs
,
1021 buf
+ EXT4_INLINE_DATA_DOTDOT_SIZE
,
1022 EXT4_MIN_INLINE_DATA_SIZE
- EXT4_INLINE_DATA_DOTDOT_SIZE
,
1024 if (cd
->pctx
.errcode
)
1025 goto inline_read_fail
;
1026 skip_first_read_swab
:
1027 if (inline_data_size
<= EXT4_MIN_INLINE_DATA_SIZE
||
1029 goto inline_read_fail
;
1030 cd
->pctx
.errcode
= ext2fs_dirent_swab_in2(fs
,
1031 buf
+ EXT4_MIN_INLINE_DATA_SIZE
,
1032 inline_data_size
- EXT4_MIN_INLINE_DATA_SIZE
,
1036 cd
->pctx
.errcode
= ext2fs_read_dir_block4(fs
, block_nr
,
1040 pctx
.num
= inline_data_size
;
1041 if (((inline_data_size
& 3) ||
1042 (inline_data_size
> EXT4_MIN_INLINE_DATA_SIZE
&&
1043 inline_data_size
< EXT4_MIN_INLINE_DATA_SIZE
+
1044 EXT2_DIR_REC_LEN(1))) &&
1045 fix_problem(ctx
, PR_2_BAD_INLINE_DIR_SIZE
, &pctx
)) {
1046 errcode_t err
= fix_inline_dir_size(ctx
, ino
,
1047 &inline_data_size
, &pctx
,
1050 return DIRENT_ABORT
;
1053 ehandler_operation(0);
1054 if (cd
->pctx
.errcode
== EXT2_ET_DIR_CORRUPTED
)
1055 cd
->pctx
.errcode
= 0; /* We'll handle this ourselves */
1056 else if (cd
->pctx
.errcode
== EXT2_ET_DIR_CSUM_INVALID
) {
1057 cd
->pctx
.errcode
= 0; /* We'll handle this ourselves */
1060 if (cd
->pctx
.errcode
) {
1062 if (!fix_problem(ctx
, PR_2_READ_DIRBLOCK
, &cd
->pctx
)) {
1063 ctx
->flags
|= E2F_FLAG_ABORT
;
1064 return DIRENT_ABORT
;
1066 ext2fs_new_dir_block(fs
, db
->blockcnt
== 0 ? ino
: 0,
1067 EXT2_ROOT_INO
, &buf2
);
1068 memcpy(buf
, buf2
, fs
->blocksize
);
1069 ext2fs_free_mem(&buf2
);
1071 dx_dir
= e2fsck_get_dx_dir_info(ctx
, ino
);
1072 if (dx_dir
&& dx_dir
->numblocks
) {
1073 if (db
->blockcnt
>= dx_dir
->numblocks
) {
1075 if (fix_problem(ctx
, PR_2_UNEXPECTED_HTREE_BLOCK
,
1077 clear_htree(ctx
, ino
);
1078 dx_dir
->numblocks
= 0;
1082 fatal_error(ctx
, _("Can not continue."));
1084 dx_db
= &dx_dir
->dx_block
[db
->blockcnt
];
1085 dx_db
->type
= DX_DIRBLOCK_LEAF
;
1086 dx_db
->phys
= block_nr
;
1087 dx_db
->min_hash
= ~0;
1088 dx_db
->max_hash
= 0;
1090 dirent
= (struct ext2_dir_entry
*) buf
;
1091 (void) ext2fs_get_rec_len(fs
, dirent
, &rec_len
);
1092 limit
= (struct ext2_dx_countlimit
*) (buf
+8);
1093 if (db
->blockcnt
== 0) {
1094 root
= (struct ext2_dx_root_info
*) (buf
+ 24);
1095 dx_db
->type
= DX_DIRBLOCK_ROOT
;
1096 dx_db
->flags
|= DX_FLAG_FIRST
| DX_FLAG_LAST
;
1097 if ((root
->reserved_zero
||
1098 root
->info_length
< 8 ||
1099 root
->indirect_levels
>=
1100 ext2_dir_htree_level(fs
)) &&
1101 fix_problem(ctx
, PR_2_HTREE_BAD_ROOT
, &cd
->pctx
)) {
1102 clear_htree(ctx
, ino
);
1103 dx_dir
->numblocks
= 0;
1106 dx_dir
->hashversion
= root
->hash_version
;
1107 if ((dx_dir
->hashversion
<= EXT2_HASH_TEA
) &&
1108 (fs
->super
->s_flags
& EXT2_FLAGS_UNSIGNED_HASH
))
1109 dx_dir
->hashversion
+= 3;
1110 dx_dir
->depth
= root
->indirect_levels
+ 1;
1111 } else if ((dirent
->inode
== 0) &&
1112 (rec_len
== fs
->blocksize
) &&
1113 (ext2fs_dirent_name_len(dirent
) == 0) &&
1114 (ext2fs_le16_to_cpu(limit
->limit
) ==
1115 ((fs
->blocksize
- (8 + dx_csum_size
)) /
1116 sizeof(struct ext2_dx_entry
)))) {
1117 dx_db
->type
= DX_DIRBLOCK_NODE
;
1119 is_leaf
= dx_db
? (dx_db
->type
== DX_DIRBLOCK_LEAF
) : 0;
1123 /* Leaf node with no space for csum? Rebuild dirs in pass 3A. */
1124 if (is_leaf
&& !inline_data_size
&& failed_csum
&&
1125 !ext2fs_dirent_has_tail(fs
, (struct ext2_dir_entry
*)buf
)) {
1127 if (e2fsck_dir_will_be_rehashed(ctx
, ino
)) {
1131 if (!fix_problem(cd
->ctx
, PR_2_LEAF_NODE_MISSING_CSUM
,
1134 e2fsck_rehash_dir_later(ctx
, ino
);
1138 /* htree nodes don't use fake dirents to store checksums */
1143 if (inline_data_size
) {
1145 buf
+= EXT4_MIN_INLINE_DATA_SIZE
;
1146 max_block_size
= inline_data_size
- EXT4_MIN_INLINE_DATA_SIZE
;
1147 /* Zero-length second block, just exit */
1148 if (max_block_size
== 0)
1151 max_block_size
= EXT4_MIN_INLINE_DATA_SIZE
;
1154 max_block_size
= fs
->blocksize
- de_csum_size
;
1156 if (ctx
->encrypted_dirs
)
1157 encrypted
= ext2fs_u32_list_test(ctx
->encrypted_dirs
, ino
);
1159 dict_init(&de_dict
, DICTCOUNT_T_MAX
, dict_de_cmp
);
1163 ext2_ino_t first_unused_inode
;
1164 unsigned int name_len
;
1167 if (!inline_data_size
|| dot_state
> 1) {
1168 dirent
= (struct ext2_dir_entry
*) (buf
+ offset
);
1170 * If there's not even space for the entry header,
1171 * force salvaging this dir.
1173 if (max_block_size
- offset
< EXT2_DIR_ENTRY_HEADER_LEN
)
1174 rec_len
= EXT2_DIR_REC_LEN(1);
1176 (void) ext2fs_get_rec_len(fs
, dirent
, &rec_len
);
1177 cd
->pctx
.dirent
= dirent
;
1178 cd
->pctx
.num
= offset
;
1179 if ((offset
+ rec_len
> max_block_size
) ||
1181 ((rec_len
% 4) != 0) ||
1182 (((unsigned) ext2fs_dirent_name_len(dirent
) + EXT2_DIR_ENTRY_HEADER_LEN
) > rec_len
)) {
1183 if (fix_problem(ctx
, PR_2_DIR_CORRUPTED
,
1185 #ifdef WORDS_BIGENDIAN
1187 * On big-endian systems, if the dirent
1188 * swap routine finds a rec_len that it
1189 * doesn't like, it continues
1190 * processing the block as if rec_len
1191 * == EXT2_DIR_ENTRY_HEADER_LEN. This means that the name
1192 * field gets byte swapped, which means
1193 * that salvage will not detect the
1194 * correct name length (unless the name
1195 * has a length that's an exact
1196 * multiple of four bytes), and it'll
1197 * discard the entry (unnecessarily)
1198 * and the rest of the dirent block.
1199 * Therefore, swap the rest of the
1200 * block back to disk order, run
1201 * salvage, and re-swap anything after
1202 * the salvaged dirent.
1204 int need_reswab
= 0;
1205 if (rec_len
< EXT2_DIR_ENTRY_HEADER_LEN
|| rec_len
% 4) {
1207 ext2fs_dirent_swab_in2(fs
,
1208 ((char *)dirent
) + EXT2_DIR_ENTRY_HEADER_LEN
,
1209 max_block_size
- offset
- EXT2_DIR_ENTRY_HEADER_LEN
,
1213 salvage_directory(fs
, dirent
, prev
,
1216 #ifdef WORDS_BIGENDIAN
1218 (void) ext2fs_get_rec_len(fs
,
1220 ext2fs_dirent_swab_in2(fs
,
1221 ((char *)dirent
) + offset
+ rec_len
,
1222 max_block_size
- offset
- rec_len
,
1229 goto abort_free_dict
;
1232 if (dot_state
== 0) {
1233 memset(&dot
, 0, sizeof(dot
));
1235 dirent
->inode
= ino
;
1236 dirent
->rec_len
= EXT2_DIR_REC_LEN(1);
1237 dirent
->name_len
= 1 | filetype
;
1238 dirent
->name
[0] = '.';
1239 } else if (dot_state
== 1) {
1240 memset(&dotdot
, 0, sizeof(dotdot
));
1243 ((struct ext2_dir_entry
*)buf
)->inode
;
1244 dirent
->rec_len
= EXT2_DIR_REC_LEN(2);
1245 dirent
->name_len
= 2 | filetype
;
1246 dirent
->name
[0] = '.';
1247 dirent
->name
[1] = '.';
1249 fatal_error(ctx
, _("Can not continue."));
1251 cd
->pctx
.dirent
= dirent
;
1252 cd
->pctx
.num
= offset
;
1255 if (dot_state
== 0) {
1256 if (check_dot(ctx
, dirent
, ino
, &cd
->pctx
))
1258 } else if (dot_state
== 1) {
1259 ret
= check_dotdot(ctx
, dirent
, ino
, &cd
->pctx
);
1261 goto abort_free_dict
;
1264 } else if (dirent
->inode
== ino
) {
1265 problem
= PR_2_LINK_DOT
;
1266 if (fix_problem(ctx
, PR_2_LINK_DOT
, &cd
->pctx
)) {
1276 * Make sure the inode listed is a legal one.
1278 name_len
= ext2fs_dirent_name_len(dirent
);
1279 if (((dirent
->inode
!= EXT2_ROOT_INO
) &&
1280 (dirent
->inode
< EXT2_FIRST_INODE(fs
->super
))) ||
1281 (dirent
->inode
> fs
->super
->s_inodes_count
)) {
1282 problem
= PR_2_BAD_INO
;
1283 } else if (ctx
->inode_bb_map
&&
1284 (ext2fs_test_inode_bitmap2(ctx
->inode_bb_map
,
1287 * If the inode is in a bad block, offer to
1290 problem
= PR_2_BB_INODE
;
1291 } else if ((dot_state
> 1) && (name_len
== 1) &&
1292 (dirent
->name
[0] == '.')) {
1294 * If there's a '.' entry in anything other
1295 * than the first directory entry, it's a
1296 * duplicate entry that should be removed.
1298 problem
= PR_2_DUP_DOT
;
1299 } else if ((dot_state
> 1) && (name_len
== 2) &&
1300 (dirent
->name
[0] == '.') &&
1301 (dirent
->name
[1] == '.')) {
1303 * If there's a '..' entry in anything other
1304 * than the second directory entry, it's a
1305 * duplicate entry that should be removed.
1307 problem
= PR_2_DUP_DOT_DOT
;
1308 } else if ((dot_state
> 1) &&
1309 (dirent
->inode
== EXT2_ROOT_INO
)) {
1311 * Don't allow links to the root directory.
1312 * We check this specially to make sure we
1313 * catch this error case even if the root
1314 * directory hasn't been created yet.
1316 problem
= PR_2_LINK_ROOT
;
1317 } else if ((dot_state
> 1) && (name_len
== 0)) {
1319 * Don't allow zero-length directory names.
1321 problem
= PR_2_NULL_NAME
;
1325 if (fix_problem(ctx
, problem
, &cd
->pctx
)) {
1330 ext2fs_unmark_valid(fs
);
1331 if (problem
== PR_2_BAD_INO
)
1337 * If the inode was marked as having bad fields in
1338 * pass1, process it and offer to fix/clear it.
1339 * (We wait until now so that we can display the
1340 * pathname to the user.)
1342 if (ctx
->inode_bad_map
&&
1343 ext2fs_test_inode_bitmap2(ctx
->inode_bad_map
,
1345 if (e2fsck_process_bad_inode(ctx
, ino
,
1347 buf
+ fs
->blocksize
)) {
1352 if (ctx
->flags
& E2F_FLAG_SIGNAL_MASK
)
1353 return DIRENT_ABORT
;
1356 group
= ext2fs_group_of_ino(fs
, dirent
->inode
);
1357 first_unused_inode
= group
* fs
->super
->s_inodes_per_group
+
1358 1 + fs
->super
->s_inodes_per_group
-
1359 ext2fs_bg_itable_unused(fs
, group
);
1360 cd
->pctx
.group
= group
;
1363 * Check if the inode was missed out because
1364 * _INODE_UNINIT flag was set or bg_itable_unused was
1365 * incorrect. If so, clear the _INODE_UNINIT flag and
1366 * restart e2fsck. In the future it would be nice if
1367 * we could call a function in pass1.c that checks the
1368 * newly visible inodes.
1370 if (ext2fs_bg_flags_test(fs
, group
, EXT2_BG_INODE_UNINIT
)) {
1371 pctx
.num
= dirent
->inode
;
1372 if (fix_problem(ctx
, PR_2_INOREF_BG_INO_UNINIT
,
1374 ext2fs_bg_flags_clear(fs
, group
,
1375 EXT2_BG_INODE_UNINIT
);
1376 ext2fs_mark_super_dirty(fs
);
1377 ctx
->flags
|= E2F_FLAG_RESTART_LATER
;
1379 ext2fs_unmark_valid(fs
);
1380 if (problem
== PR_2_BAD_INO
)
1383 } else if (dirent
->inode
>= first_unused_inode
) {
1384 pctx
.num
= dirent
->inode
;
1385 if (fix_problem(ctx
, PR_2_INOREF_IN_UNUSED
, &cd
->pctx
)){
1386 ext2fs_bg_itable_unused_set(fs
, group
, 0);
1387 ext2fs_mark_super_dirty(fs
);
1388 ctx
->flags
|= E2F_FLAG_RESTART_LATER
;
1390 ext2fs_unmark_valid(fs
);
1391 if (problem
== PR_2_BAD_INO
)
1397 * Offer to clear unused inodes; if we are going to be
1398 * restarting the scan due to bg_itable_unused being
1399 * wrong, then don't clear any inodes to avoid zapping
1400 * inodes that were skipped during pass1 due to an
1401 * incorrect bg_itable_unused; we'll get any real
1402 * problems after we restart.
1404 if (!(ctx
->flags
& E2F_FLAG_RESTART_LATER
) &&
1405 !(ext2fs_test_inode_bitmap2(ctx
->inode_used_map
,
1407 problem
= PR_2_UNUSED_INODE
;
1410 if (fix_problem(ctx
, problem
, &cd
->pctx
)) {
1415 ext2fs_unmark_valid(fs
);
1416 if (problem
== PR_2_BAD_INO
)
1421 if (!encrypted
&& check_name(ctx
, dirent
, &cd
->pctx
))
1424 if (encrypted
&& (dot_state
) > 1 &&
1425 encrypted_check_name(ctx
, dirent
, &cd
->pctx
)) {
1430 if (check_filetype(ctx
, dirent
, ino
, &cd
->pctx
))
1434 if (dx_dir
->casefolded_hash
)
1435 hash_flags
= EXT4_CASEFOLD_FL
;
1437 ext2fs_dirhash2(dx_dir
->hashversion
, dirent
->name
,
1438 ext2fs_dirent_name_len(dirent
),
1439 fs
->encoding
, hash_flags
,
1440 fs
->super
->s_hash_seed
, &hash
, 0);
1441 if (hash
< dx_db
->min_hash
)
1442 dx_db
->min_hash
= hash
;
1443 if (hash
> dx_db
->max_hash
)
1444 dx_db
->max_hash
= hash
;
1448 * If this is a directory, then mark its parent in its
1449 * dir_info structure. If the parent field is already
1450 * filled in, then this directory has more than one
1451 * hard link. We assume the first link is correct,
1452 * and ask the user if he/she wants to clear this one.
1454 if ((dot_state
> 1) &&
1455 (ext2fs_test_inode_bitmap2(ctx
->inode_dir_map
,
1457 if (e2fsck_dir_info_get_parent(ctx
, dirent
->inode
,
1459 cd
->pctx
.ino
= dirent
->inode
;
1460 fix_problem(ctx
, PR_2_NO_DIRINFO
, &cd
->pctx
);
1461 goto abort_free_dict
;
1463 if (subdir_parent
) {
1464 cd
->pctx
.ino2
= subdir_parent
;
1465 if (fix_problem(ctx
, PR_2_LINK_DIR
,
1473 (void) e2fsck_dir_info_set_parent(ctx
,
1474 dirent
->inode
, ino
);
1480 } else if (dict_lookup(&de_dict
, dirent
)) {
1481 clear_problem_context(&pctx
);
1483 pctx
.dirent
= dirent
;
1484 fix_problem(ctx
, PR_2_REPORT_DUP_DIRENT
, &pctx
);
1485 e2fsck_rehash_dir_later(ctx
, ino
);
1488 dict_alloc_insert(&de_dict
, dirent
, dirent
);
1490 ext2fs_icount_increment(ctx
->inode_count
, dirent
->inode
,
1493 ctx
->fs_links_count
++;
1494 ctx
->fs_total_count
++;
1498 (void) ext2fs_get_rec_len(fs
, dirent
, &rec_len
);
1499 if (!inline_data_size
|| dot_state
> 1) {
1502 if (dot_state
== 1) {
1505 * If we get here, we're checking an inline
1506 * directory and we've just checked a (fake)
1507 * dotdot entry that we created on the stack.
1508 * Therefore set 'prev' to NULL so that if we
1509 * call salvage_directory on the next entry,
1510 * it won't try to absorb the next entry into
1511 * the on-stack dotdot entry.
1517 } while (offset
< max_block_size
);
1523 printf("db_block %d, type %d, min_hash 0x%0x, max_hash 0x%0x\n",
1524 db
->blockcnt
, dx_db
->type
,
1525 dx_db
->min_hash
, dx_db
->max_hash
);
1527 cd
->pctx
.dir
= cd
->pctx
.ino
;
1528 if ((dx_db
->type
== DX_DIRBLOCK_ROOT
) ||
1529 (dx_db
->type
== DX_DIRBLOCK_NODE
))
1530 parse_int_node(fs
, db
, cd
, dx_dir
, buf
, failed_csum
);
1533 if (offset
!= max_block_size
) {
1534 cd
->pctx
.num
= rec_len
+ offset
- max_block_size
;
1535 if (fix_problem(ctx
, PR_2_FINAL_RECLEN
, &cd
->pctx
)) {
1536 dirent
->rec_len
= cd
->pctx
.num
;
1541 int flags
, will_rehash
;
1542 /* leaf block with no tail? Rehash dirs later. */
1543 if (ext2fs_has_feature_metadata_csum(fs
->super
) &&
1545 !inline_data_size
&&
1546 !ext2fs_dirent_has_tail(fs
, (struct ext2_dir_entry
*)buf
)) {
1547 if (insert_dirent_tail(fs
, buf
) == 0)
1549 e2fsck_rehash_dir_later(ctx
, ino
);
1553 will_rehash
= e2fsck_dir_will_be_rehashed(ctx
, ino
);
1555 flags
= ctx
->fs
->flags
;
1556 ctx
->fs
->flags
|= EXT2_FLAG_IGNORE_CSUM_ERRORS
;
1558 if (inline_data_size
) {
1560 #ifdef WORDS_BIGENDIAN
1562 goto skip_first_write_swab
;
1563 *((__u32
*)buf
) = ext2fs_le32_to_cpu(*((__u32
*)buf
));
1564 cd
->pctx
.errcode
= ext2fs_dirent_swab_out2(fs
,
1565 buf
+ EXT4_INLINE_DATA_DOTDOT_SIZE
,
1566 EXT4_MIN_INLINE_DATA_SIZE
-
1567 EXT4_INLINE_DATA_DOTDOT_SIZE
,
1569 if (cd
->pctx
.errcode
)
1570 goto skip_second_write_swab
;
1571 skip_first_write_swab
:
1572 if (inline_data_size
<= EXT4_MIN_INLINE_DATA_SIZE
||
1574 goto skip_second_write_swab
;
1575 cd
->pctx
.errcode
= ext2fs_dirent_swab_out2(fs
,
1576 buf
+ EXT4_MIN_INLINE_DATA_SIZE
,
1578 EXT4_MIN_INLINE_DATA_SIZE
,
1580 skip_second_write_swab
:
1581 if (cd
->pctx
.errcode
&&
1582 !fix_problem(ctx
, PR_2_WRITE_DIRBLOCK
, &cd
->pctx
))
1583 goto abort_free_dict
;
1586 ext2fs_inline_data_set(fs
, ino
, 0, buf
,
1589 cd
->pctx
.errcode
= ext2fs_write_dir_block4(fs
, block_nr
,
1592 ctx
->fs
->flags
= (flags
&
1593 EXT2_FLAG_IGNORE_CSUM_ERRORS
) |
1595 ~EXT2_FLAG_IGNORE_CSUM_ERRORS
);
1596 if (cd
->pctx
.errcode
) {
1597 if (!fix_problem(ctx
, PR_2_WRITE_DIRBLOCK
,
1599 goto abort_free_dict
;
1601 ext2fs_mark_changed(fs
);
1602 } else if (is_leaf
&& failed_csum
&& !dir_modified
) {
1604 * If a leaf node that fails csum makes it this far without
1605 * alteration, ask the user if the checksum should be fixed.
1607 if (fix_problem(ctx
, PR_2_LEAF_NODE_ONLY_CSUM_INVALID
,
1611 dict_free_nodes(&de_dict
);
1614 ctx
->flags
|= E2F_FLAG_ABORT
;
1615 dict_free_nodes(&de_dict
);
1616 return DIRENT_ABORT
;
1622 blk64_t last_cluster
;
1626 * This function is called to deallocate a block, and is an interator
1627 * functioned called by deallocate inode via ext2fs_iterate_block().
1629 static int deallocate_inode_block(ext2_filsys fs
,
1631 e2_blkcnt_t blockcnt
EXT2FS_ATTR((unused
)),
1632 blk64_t ref_block
EXT2FS_ATTR((unused
)),
1633 int ref_offset
EXT2FS_ATTR((unused
)),
1636 struct del_block
*p
= priv_data
;
1637 blk64_t cluster
= EXT2FS_B2C(fs
, *block_nr
);
1642 if (cluster
== p
->last_cluster
)
1645 p
->last_cluster
= cluster
;
1646 if ((*block_nr
< fs
->super
->s_first_data_block
) ||
1647 (*block_nr
>= ext2fs_blocks_count(fs
->super
)))
1650 ext2fs_block_alloc_stats2(fs
, *block_nr
, -1);
1656 * This function deallocates an inode
1658 static void deallocate_inode(e2fsck_t ctx
, ext2_ino_t ino
, char* block_buf
)
1660 ext2_filsys fs
= ctx
->fs
;
1661 struct ext2_inode inode
;
1662 struct problem_context pctx
;
1664 struct del_block del_block
;
1666 e2fsck_read_inode(ctx
, ino
, &inode
, "deallocate_inode");
1667 clear_problem_context(&pctx
);
1671 * Fix up the bitmaps...
1673 e2fsck_read_bitmaps(ctx
);
1674 ext2fs_inode_alloc_stats2(fs
, ino
, -1, LINUX_S_ISDIR(inode
.i_mode
));
1676 if (ext2fs_file_acl_block(fs
, &inode
) &&
1677 ext2fs_has_feature_xattr(fs
->super
)) {
1678 pctx
.errcode
= ext2fs_adjust_ea_refcount3(fs
,
1679 ext2fs_file_acl_block(fs
, &inode
),
1680 block_buf
, -1, &count
, ino
);
1681 if (pctx
.errcode
== EXT2_ET_BAD_EA_BLOCK_NUM
) {
1686 pctx
.blk
= ext2fs_file_acl_block(fs
, &inode
);
1687 fix_problem(ctx
, PR_2_ADJ_EA_REFCOUNT
, &pctx
);
1688 ctx
->flags
|= E2F_FLAG_ABORT
;
1692 ext2fs_block_alloc_stats2(fs
,
1693 ext2fs_file_acl_block(fs
, &inode
), -1);
1695 ext2fs_file_acl_block_set(fs
, &inode
, 0);
1698 if (!ext2fs_inode_has_valid_blocks2(fs
, &inode
))
1701 /* Inline data inodes don't have blocks to iterate */
1702 if (inode
.i_flags
& EXT4_INLINE_DATA_FL
)
1705 if (LINUX_S_ISREG(inode
.i_mode
) &&
1706 ext2fs_needs_large_file_feature(EXT2_I_SIZE(&inode
)))
1709 del_block
.ctx
= ctx
;
1711 del_block
.last_cluster
= 0;
1712 pctx
.errcode
= ext2fs_block_iterate3(fs
, ino
, 0, block_buf
,
1713 deallocate_inode_block
,
1716 fix_problem(ctx
, PR_2_DEALLOC_INODE
, &pctx
);
1717 ctx
->flags
|= E2F_FLAG_ABORT
;
1721 /* Inode may have changed by block_iterate, so reread it */
1722 e2fsck_read_inode(ctx
, ino
, &inode
, "deallocate_inode");
1723 e2fsck_clear_inode(ctx
, ino
, &inode
, 0, "deallocate_inode");
1727 * This function clears the htree flag on an inode
1729 static void clear_htree(e2fsck_t ctx
, ext2_ino_t ino
)
1731 struct ext2_inode inode
;
1733 e2fsck_read_inode(ctx
, ino
, &inode
, "clear_htree");
1734 inode
.i_flags
= inode
.i_flags
& ~EXT2_INDEX_FL
;
1735 e2fsck_write_inode(ctx
, ino
, &inode
, "clear_htree");
1736 if (ctx
->dirs_to_hash
)
1737 ext2fs_u32_list_add(ctx
->dirs_to_hash
, ino
);
1741 int e2fsck_process_bad_inode(e2fsck_t ctx
, ext2_ino_t dir
,
1742 ext2_ino_t ino
, char *buf
)
1744 ext2_filsys fs
= ctx
->fs
;
1745 struct ext2_inode inode
;
1746 int inode_modified
= 0;
1748 unsigned char *frag
, *fsize
;
1749 struct problem_context pctx
;
1750 problem_t problem
= 0;
1752 e2fsck_read_inode(ctx
, ino
, &inode
, "process_bad_inode");
1754 clear_problem_context(&pctx
);
1757 pctx
.inode
= &inode
;
1759 if (ext2fs_file_acl_block(fs
, &inode
) &&
1760 !ext2fs_has_feature_xattr(fs
->super
)) {
1761 if (fix_problem(ctx
, PR_2_FILE_ACL_ZERO
, &pctx
)) {
1762 ext2fs_file_acl_block_set(fs
, &inode
, 0);
1768 if (!LINUX_S_ISDIR(inode
.i_mode
) && !LINUX_S_ISREG(inode
.i_mode
) &&
1769 !LINUX_S_ISCHR(inode
.i_mode
) && !LINUX_S_ISBLK(inode
.i_mode
) &&
1770 !LINUX_S_ISLNK(inode
.i_mode
) && !LINUX_S_ISFIFO(inode
.i_mode
) &&
1771 !(LINUX_S_ISSOCK(inode
.i_mode
)))
1772 problem
= PR_2_BAD_MODE
;
1773 else if (LINUX_S_ISCHR(inode
.i_mode
)
1774 && !e2fsck_pass1_check_device_inode(fs
, &inode
))
1775 problem
= PR_2_BAD_CHAR_DEV
;
1776 else if (LINUX_S_ISBLK(inode
.i_mode
)
1777 && !e2fsck_pass1_check_device_inode(fs
, &inode
))
1778 problem
= PR_2_BAD_BLOCK_DEV
;
1779 else if (LINUX_S_ISFIFO(inode
.i_mode
)
1780 && !e2fsck_pass1_check_device_inode(fs
, &inode
))
1781 problem
= PR_2_BAD_FIFO
;
1782 else if (LINUX_S_ISSOCK(inode
.i_mode
)
1783 && !e2fsck_pass1_check_device_inode(fs
, &inode
))
1784 problem
= PR_2_BAD_SOCKET
;
1785 else if (LINUX_S_ISLNK(inode
.i_mode
)
1786 && !e2fsck_pass1_check_symlink(fs
, ino
, &inode
, buf
)) {
1787 problem
= PR_2_INVALID_SYMLINK
;
1791 if (fix_problem(ctx
, problem
, &pctx
)) {
1792 deallocate_inode(ctx
, ino
, 0);
1793 if (ctx
->flags
& E2F_FLAG_SIGNAL_MASK
)
1801 if (inode
.i_faddr
) {
1802 if (fix_problem(ctx
, PR_2_FADDR_ZERO
, &pctx
)) {
1809 switch (fs
->super
->s_creator_os
) {
1811 frag
= &inode
.osd2
.hurd2
.h_i_frag
;
1812 fsize
= &inode
.osd2
.hurd2
.h_i_fsize
;
1817 if (frag
&& *frag
) {
1819 if (fix_problem(ctx
, PR_2_FRAG_ZERO
, &pctx
)) {
1826 if (fsize
&& *fsize
) {
1828 if (fix_problem(ctx
, PR_2_FSIZE_ZERO
, &pctx
)) {
1836 if ((fs
->super
->s_creator_os
== EXT2_OS_LINUX
) &&
1837 !ext2fs_has_feature_huge_file(fs
->super
) &&
1838 (inode
.osd2
.linux2
.l_i_blocks_hi
!= 0)) {
1839 pctx
.num
= inode
.osd2
.linux2
.l_i_blocks_hi
;
1840 if (fix_problem(ctx
, PR_2_BLOCKS_HI_ZERO
, &pctx
)) {
1841 inode
.osd2
.linux2
.l_i_blocks_hi
= 0;
1846 if ((fs
->super
->s_creator_os
== EXT2_OS_LINUX
) &&
1847 !ext2fs_has_feature_64bit(fs
->super
) &&
1848 inode
.osd2
.linux2
.l_i_file_acl_high
!= 0) {
1849 pctx
.num
= inode
.osd2
.linux2
.l_i_file_acl_high
;
1850 if (fix_problem(ctx
, PR_2_I_FILE_ACL_HI_ZERO
, &pctx
)) {
1851 inode
.osd2
.linux2
.l_i_file_acl_high
= 0;
1857 if (ext2fs_file_acl_block(fs
, &inode
) &&
1858 ((ext2fs_file_acl_block(fs
, &inode
) < fs
->super
->s_first_data_block
) ||
1859 (ext2fs_file_acl_block(fs
, &inode
) >= ext2fs_blocks_count(fs
->super
)))) {
1860 if (fix_problem(ctx
, PR_2_FILE_ACL_BAD
, &pctx
)) {
1861 ext2fs_file_acl_block_set(fs
, &inode
, 0);
1866 if (inode
.i_size_high
&& !ext2fs_has_feature_largedir(fs
->super
) &&
1867 LINUX_S_ISDIR(inode
.i_mode
)) {
1868 if (fix_problem(ctx
, PR_2_DIR_SIZE_HIGH_ZERO
, &pctx
)) {
1869 inode
.i_size_high
= 0;
1876 e2fsck_write_inode(ctx
, ino
, &inode
, "process_bad_inode");
1877 if (!not_fixed
&& ctx
->inode_bad_map
)
1878 ext2fs_unmark_inode_bitmap2(ctx
->inode_bad_map
, ino
);
1883 * allocate_dir_block --- this function allocates a new directory
1884 * block for a particular inode; this is done if a directory has
1885 * a "hole" in it, or if a directory has a illegal block number
1886 * that was zeroed out and now needs to be replaced.
1888 static int allocate_dir_block(e2fsck_t ctx
,
1889 struct ext2_db_entry2
*db
,
1890 char *buf
EXT2FS_ATTR((unused
)),
1891 struct problem_context
*pctx
)
1893 ext2_filsys fs
= ctx
->fs
;
1896 struct ext2_inode inode
;
1898 if (fix_problem(ctx
, PR_2_DIRECTORY_HOLE
, pctx
) == 0)
1902 * Read the inode and block bitmaps in; we'll be messing with
1905 e2fsck_read_bitmaps(ctx
);
1908 * First, find a free block
1910 e2fsck_read_inode(ctx
, db
->ino
, &inode
, "allocate_dir_block");
1911 pctx
->errcode
= ext2fs_map_cluster_block(fs
, db
->ino
, &inode
,
1912 db
->blockcnt
, &blk
);
1913 if (pctx
->errcode
|| blk
== 0) {
1914 blk
= ext2fs_find_inode_goal(fs
, db
->ino
, &inode
, db
->blockcnt
);
1915 pctx
->errcode
= ext2fs_new_block2(fs
, blk
,
1916 ctx
->block_found_map
, &blk
);
1917 if (pctx
->errcode
) {
1918 pctx
->str
= "ext2fs_new_block";
1919 fix_problem(ctx
, PR_2_ALLOC_DIRBOCK
, pctx
);
1923 ext2fs_mark_block_bitmap2(ctx
->block_found_map
, blk
);
1924 ext2fs_mark_block_bitmap2(fs
->block_map
, blk
);
1925 ext2fs_mark_bb_dirty(fs
);
1928 * Now let's create the actual data block for the inode
1931 pctx
->errcode
= ext2fs_new_dir_block(fs
, 0, 0, &block
);
1933 pctx
->errcode
= ext2fs_new_dir_block(fs
, db
->ino
,
1934 EXT2_ROOT_INO
, &block
);
1936 if (pctx
->errcode
) {
1937 pctx
->str
= "ext2fs_new_dir_block";
1938 fix_problem(ctx
, PR_2_ALLOC_DIRBOCK
, pctx
);
1942 pctx
->errcode
= ext2fs_write_dir_block4(fs
, blk
, block
, 0, db
->ino
);
1943 ext2fs_free_mem(&block
);
1944 if (pctx
->errcode
) {
1945 pctx
->str
= "ext2fs_write_dir_block";
1946 fix_problem(ctx
, PR_2_ALLOC_DIRBOCK
, pctx
);
1951 * Update the inode block count
1953 ext2fs_iblk_add_blocks(fs
, &inode
, 1);
1954 if (EXT2_I_SIZE(&inode
) < ((__u64
) db
->blockcnt
+1) * fs
->blocksize
) {
1955 pctx
->errcode
= ext2fs_inode_size_set(fs
, &inode
,
1956 (db
->blockcnt
+1) * fs
->blocksize
);
1957 if (pctx
->errcode
) {
1958 pctx
->str
= "ext2fs_inode_size_set";
1959 fix_problem(ctx
, PR_2_ALLOC_DIRBOCK
, pctx
);
1963 e2fsck_write_inode(ctx
, db
->ino
, &inode
, "allocate_dir_block");
1966 * Finally, update the block pointers for the inode
1969 pctx
->errcode
= ext2fs_bmap2(fs
, db
->ino
, &inode
, 0, BMAP_SET
,
1970 db
->blockcnt
, 0, &blk
);
1971 if (pctx
->errcode
) {
1972 pctx
->str
= "ext2fs_block_iterate";
1973 fix_problem(ctx
, PR_2_ALLOC_DIRBOCK
, pctx
);