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 cd
= (struct check_dir_struct
*) priv_data
;
938 ibuf
= buf
= cd
->buf
;
941 if (ctx
->flags
& E2F_FLAG_RUN_RETURN
)
944 if (ctx
->progress
&& (ctx
->progress
)(ctx
, 2, cd
->count
++, cd
->max
))
947 if (ext2fs_has_feature_metadata_csum(fs
->super
)) {
948 dx_csum_size
= sizeof(struct ext2_dx_tail
);
949 de_csum_size
= sizeof(struct ext2_dir_entry_tail
);
952 if (ext2fs_has_feature_filetype(fs
->super
))
953 filetype
= EXT2_FT_DIR
<< 8;
956 * Make sure the inode is still in use (could have been
957 * deleted in the duplicate/bad blocks pass.
959 if (!(ext2fs_test_inode_bitmap2(ctx
->inode_used_map
, ino
)))
963 cd
->pctx
.blk
= block_nr
;
964 cd
->pctx
.blkcount
= db
->blockcnt
;
969 if (ext2fs_has_feature_inline_data(fs
->super
)) {
972 ec
= ext2fs_inline_data_size(fs
, ino
, &inline_data_size
);
973 if (ec
&& ec
!= EXT2_ET_NO_INLINE_DATA
)
977 /* This will allow (at some point in the future) to punch out empty
978 * directory blocks and reduce the space used by a directory that grows
979 * very large and then the files are deleted. For now, all that is
980 * needed is to avoid e2fsck filling in these holes as part of
982 if (db
->blk
== 0 && ext2fs_has_feature_largedir(fs
->super
))
985 if (db
->blk
== 0 && !inline_data_size
) {
986 if (allocate_dir_block(ctx
, db
, buf
, &cd
->pctx
))
996 if (ctx
->dirs_to_hash
&&
997 ext2fs_u32_list_test(ctx
->dirs_to_hash
, ino
))
1001 printf("In process_dir_block block %lu, #%d, inode %lu\n", block_nr
,
1005 ehandler_operation(_("reading directory block"));
1006 if (inline_data_size
) {
1007 memset(buf
, 0, fs
->blocksize
- inline_data_size
);
1008 cd
->pctx
.errcode
= ext2fs_inline_data_get(fs
, ino
, 0, buf
, 0);
1009 if (cd
->pctx
.errcode
)
1010 goto inline_read_fail
;
1011 #ifdef WORDS_BIGENDIAN
1013 goto skip_first_read_swab
;
1014 *((__u32
*)buf
) = ext2fs_le32_to_cpu(*((__u32
*)buf
));
1015 cd
->pctx
.errcode
= ext2fs_dirent_swab_in2(fs
,
1016 buf
+ EXT4_INLINE_DATA_DOTDOT_SIZE
,
1017 EXT4_MIN_INLINE_DATA_SIZE
- EXT4_INLINE_DATA_DOTDOT_SIZE
,
1019 if (cd
->pctx
.errcode
)
1020 goto inline_read_fail
;
1021 skip_first_read_swab
:
1022 if (inline_data_size
<= EXT4_MIN_INLINE_DATA_SIZE
||
1024 goto inline_read_fail
;
1025 cd
->pctx
.errcode
= ext2fs_dirent_swab_in2(fs
,
1026 buf
+ EXT4_MIN_INLINE_DATA_SIZE
,
1027 inline_data_size
- EXT4_MIN_INLINE_DATA_SIZE
,
1031 cd
->pctx
.errcode
= ext2fs_read_dir_block4(fs
, block_nr
,
1035 pctx
.num
= inline_data_size
;
1036 if (((inline_data_size
& 3) ||
1037 (inline_data_size
> EXT4_MIN_INLINE_DATA_SIZE
&&
1038 inline_data_size
< EXT4_MIN_INLINE_DATA_SIZE
+
1039 EXT2_DIR_REC_LEN(1))) &&
1040 fix_problem(ctx
, PR_2_BAD_INLINE_DIR_SIZE
, &pctx
)) {
1041 errcode_t err
= fix_inline_dir_size(ctx
, ino
,
1042 &inline_data_size
, &pctx
,
1045 return DIRENT_ABORT
;
1048 ehandler_operation(0);
1049 if (cd
->pctx
.errcode
== EXT2_ET_DIR_CORRUPTED
)
1050 cd
->pctx
.errcode
= 0; /* We'll handle this ourselves */
1051 else if (cd
->pctx
.errcode
== EXT2_ET_DIR_CSUM_INVALID
) {
1052 cd
->pctx
.errcode
= 0; /* We'll handle this ourselves */
1055 if (cd
->pctx
.errcode
) {
1057 if (!fix_problem(ctx
, PR_2_READ_DIRBLOCK
, &cd
->pctx
)) {
1058 ctx
->flags
|= E2F_FLAG_ABORT
;
1059 return DIRENT_ABORT
;
1061 ext2fs_new_dir_block(fs
, db
->blockcnt
== 0 ? ino
: 0,
1062 EXT2_ROOT_INO
, &buf2
);
1063 memcpy(buf
, buf2
, fs
->blocksize
);
1064 ext2fs_free_mem(&buf2
);
1066 dx_dir
= e2fsck_get_dx_dir_info(ctx
, ino
);
1067 if (dx_dir
&& dx_dir
->numblocks
) {
1068 if (db
->blockcnt
>= dx_dir
->numblocks
) {
1070 if (fix_problem(ctx
, PR_2_UNEXPECTED_HTREE_BLOCK
,
1072 clear_htree(ctx
, ino
);
1073 dx_dir
->numblocks
= 0;
1077 fatal_error(ctx
, _("Can not continue."));
1079 dx_db
= &dx_dir
->dx_block
[db
->blockcnt
];
1080 dx_db
->type
= DX_DIRBLOCK_LEAF
;
1081 dx_db
->phys
= block_nr
;
1082 dx_db
->min_hash
= ~0;
1083 dx_db
->max_hash
= 0;
1085 dirent
= (struct ext2_dir_entry
*) buf
;
1086 (void) ext2fs_get_rec_len(fs
, dirent
, &rec_len
);
1087 limit
= (struct ext2_dx_countlimit
*) (buf
+8);
1088 if (db
->blockcnt
== 0) {
1089 root
= (struct ext2_dx_root_info
*) (buf
+ 24);
1090 dx_db
->type
= DX_DIRBLOCK_ROOT
;
1091 dx_db
->flags
|= DX_FLAG_FIRST
| DX_FLAG_LAST
;
1092 if ((root
->reserved_zero
||
1093 root
->info_length
< 8 ||
1094 root
->indirect_levels
>=
1095 ext2_dir_htree_level(fs
)) &&
1096 fix_problem(ctx
, PR_2_HTREE_BAD_ROOT
, &cd
->pctx
)) {
1097 clear_htree(ctx
, ino
);
1098 dx_dir
->numblocks
= 0;
1101 dx_dir
->hashversion
= root
->hash_version
;
1102 if ((dx_dir
->hashversion
<= EXT2_HASH_TEA
) &&
1103 (fs
->super
->s_flags
& EXT2_FLAGS_UNSIGNED_HASH
))
1104 dx_dir
->hashversion
+= 3;
1105 dx_dir
->depth
= root
->indirect_levels
+ 1;
1106 } else if ((dirent
->inode
== 0) &&
1107 (rec_len
== fs
->blocksize
) &&
1108 (ext2fs_dirent_name_len(dirent
) == 0) &&
1109 (ext2fs_le16_to_cpu(limit
->limit
) ==
1110 ((fs
->blocksize
- (8 + dx_csum_size
)) /
1111 sizeof(struct ext2_dx_entry
)))) {
1112 dx_db
->type
= DX_DIRBLOCK_NODE
;
1114 is_leaf
= dx_db
? (dx_db
->type
== DX_DIRBLOCK_LEAF
) : 0;
1118 /* Leaf node with no space for csum? Rebuild dirs in pass 3A. */
1119 if (is_leaf
&& !inline_data_size
&& failed_csum
&&
1120 !ext2fs_dirent_has_tail(fs
, (struct ext2_dir_entry
*)buf
)) {
1122 if (e2fsck_dir_will_be_rehashed(ctx
, ino
)) {
1126 if (!fix_problem(cd
->ctx
, PR_2_LEAF_NODE_MISSING_CSUM
,
1129 e2fsck_rehash_dir_later(ctx
, ino
);
1133 /* htree nodes don't use fake dirents to store checksums */
1138 if (inline_data_size
) {
1140 buf
+= EXT4_MIN_INLINE_DATA_SIZE
;
1141 max_block_size
= inline_data_size
- EXT4_MIN_INLINE_DATA_SIZE
;
1142 /* Zero-length second block, just exit */
1143 if (max_block_size
== 0)
1146 max_block_size
= EXT4_MIN_INLINE_DATA_SIZE
;
1149 max_block_size
= fs
->blocksize
- de_csum_size
;
1151 if (ctx
->encrypted_dirs
)
1152 encrypted
= ext2fs_u32_list_test(ctx
->encrypted_dirs
, ino
);
1154 dict_init(&de_dict
, DICTCOUNT_T_MAX
, dict_de_cmp
);
1158 ext2_ino_t first_unused_inode
;
1159 unsigned int name_len
;
1162 if (!inline_data_size
|| dot_state
> 1) {
1163 dirent
= (struct ext2_dir_entry
*) (buf
+ offset
);
1165 * If there's not even space for the entry header,
1166 * force salvaging this dir.
1168 if (max_block_size
- offset
< EXT2_DIR_ENTRY_HEADER_LEN
)
1169 rec_len
= EXT2_DIR_REC_LEN(1);
1171 (void) ext2fs_get_rec_len(fs
, dirent
, &rec_len
);
1172 cd
->pctx
.dirent
= dirent
;
1173 cd
->pctx
.num
= offset
;
1174 if ((offset
+ rec_len
> max_block_size
) ||
1176 ((rec_len
% 4) != 0) ||
1177 (((unsigned) ext2fs_dirent_name_len(dirent
) + EXT2_DIR_ENTRY_HEADER_LEN
) > rec_len
)) {
1178 if (fix_problem(ctx
, PR_2_DIR_CORRUPTED
,
1180 #ifdef WORDS_BIGENDIAN
1182 * On big-endian systems, if the dirent
1183 * swap routine finds a rec_len that it
1184 * doesn't like, it continues
1185 * processing the block as if rec_len
1186 * == EXT2_DIR_ENTRY_HEADER_LEN. This means that the name
1187 * field gets byte swapped, which means
1188 * that salvage will not detect the
1189 * correct name length (unless the name
1190 * has a length that's an exact
1191 * multiple of four bytes), and it'll
1192 * discard the entry (unnecessarily)
1193 * and the rest of the dirent block.
1194 * Therefore, swap the rest of the
1195 * block back to disk order, run
1196 * salvage, and re-swap anything after
1197 * the salvaged dirent.
1199 int need_reswab
= 0;
1200 if (rec_len
< EXT2_DIR_ENTRY_HEADER_LEN
|| rec_len
% 4) {
1202 ext2fs_dirent_swab_in2(fs
,
1203 ((char *)dirent
) + EXT2_DIR_ENTRY_HEADER_LEN
,
1204 max_block_size
- offset
- EXT2_DIR_ENTRY_HEADER_LEN
,
1208 salvage_directory(fs
, dirent
, prev
,
1211 #ifdef WORDS_BIGENDIAN
1213 (void) ext2fs_get_rec_len(fs
,
1215 ext2fs_dirent_swab_in2(fs
,
1216 ((char *)dirent
) + offset
+ rec_len
,
1217 max_block_size
- offset
- rec_len
,
1224 goto abort_free_dict
;
1227 if (dot_state
== 0) {
1228 memset(&dot
, 0, sizeof(dot
));
1230 dirent
->inode
= ino
;
1231 dirent
->rec_len
= EXT2_DIR_REC_LEN(1);
1232 dirent
->name_len
= 1 | filetype
;
1233 dirent
->name
[0] = '.';
1234 } else if (dot_state
== 1) {
1235 memset(&dotdot
, 0, sizeof(dotdot
));
1238 ((struct ext2_dir_entry
*)buf
)->inode
;
1239 dirent
->rec_len
= EXT2_DIR_REC_LEN(2);
1240 dirent
->name_len
= 2 | filetype
;
1241 dirent
->name
[0] = '.';
1242 dirent
->name
[1] = '.';
1244 fatal_error(ctx
, _("Can not continue."));
1246 cd
->pctx
.dirent
= dirent
;
1247 cd
->pctx
.num
= offset
;
1250 if (dot_state
== 0) {
1251 if (check_dot(ctx
, dirent
, ino
, &cd
->pctx
))
1253 } else if (dot_state
== 1) {
1254 ret
= check_dotdot(ctx
, dirent
, ino
, &cd
->pctx
);
1256 goto abort_free_dict
;
1259 } else if (dirent
->inode
== ino
) {
1260 problem
= PR_2_LINK_DOT
;
1261 if (fix_problem(ctx
, PR_2_LINK_DOT
, &cd
->pctx
)) {
1271 * Make sure the inode listed is a legal one.
1273 name_len
= ext2fs_dirent_name_len(dirent
);
1274 if (((dirent
->inode
!= EXT2_ROOT_INO
) &&
1275 (dirent
->inode
< EXT2_FIRST_INODE(fs
->super
))) ||
1276 (dirent
->inode
> fs
->super
->s_inodes_count
)) {
1277 problem
= PR_2_BAD_INO
;
1278 } else if (ctx
->inode_bb_map
&&
1279 (ext2fs_test_inode_bitmap2(ctx
->inode_bb_map
,
1282 * If the inode is in a bad block, offer to
1285 problem
= PR_2_BB_INODE
;
1286 } else if ((dot_state
> 1) && (name_len
== 1) &&
1287 (dirent
->name
[0] == '.')) {
1289 * If there's a '.' entry in anything other
1290 * than the first directory entry, it's a
1291 * duplicate entry that should be removed.
1293 problem
= PR_2_DUP_DOT
;
1294 } else if ((dot_state
> 1) && (name_len
== 2) &&
1295 (dirent
->name
[0] == '.') &&
1296 (dirent
->name
[1] == '.')) {
1298 * If there's a '..' entry in anything other
1299 * than the second directory entry, it's a
1300 * duplicate entry that should be removed.
1302 problem
= PR_2_DUP_DOT_DOT
;
1303 } else if ((dot_state
> 1) &&
1304 (dirent
->inode
== EXT2_ROOT_INO
)) {
1306 * Don't allow links to the root directory.
1307 * We check this specially to make sure we
1308 * catch this error case even if the root
1309 * directory hasn't been created yet.
1311 problem
= PR_2_LINK_ROOT
;
1312 } else if ((dot_state
> 1) && (name_len
== 0)) {
1314 * Don't allow zero-length directory names.
1316 problem
= PR_2_NULL_NAME
;
1320 if (fix_problem(ctx
, problem
, &cd
->pctx
)) {
1325 ext2fs_unmark_valid(fs
);
1326 if (problem
== PR_2_BAD_INO
)
1332 * If the inode was marked as having bad fields in
1333 * pass1, process it and offer to fix/clear it.
1334 * (We wait until now so that we can display the
1335 * pathname to the user.)
1337 if (ctx
->inode_bad_map
&&
1338 ext2fs_test_inode_bitmap2(ctx
->inode_bad_map
,
1340 if (e2fsck_process_bad_inode(ctx
, ino
,
1342 buf
+ fs
->blocksize
)) {
1347 if (ctx
->flags
& E2F_FLAG_SIGNAL_MASK
)
1348 return DIRENT_ABORT
;
1351 group
= ext2fs_group_of_ino(fs
, dirent
->inode
);
1352 first_unused_inode
= group
* fs
->super
->s_inodes_per_group
+
1353 1 + fs
->super
->s_inodes_per_group
-
1354 ext2fs_bg_itable_unused(fs
, group
);
1355 cd
->pctx
.group
= group
;
1358 * Check if the inode was missed out because
1359 * _INODE_UNINIT flag was set or bg_itable_unused was
1360 * incorrect. If so, clear the _INODE_UNINIT flag and
1361 * restart e2fsck. In the future it would be nice if
1362 * we could call a function in pass1.c that checks the
1363 * newly visible inodes.
1365 if (ext2fs_bg_flags_test(fs
, group
, EXT2_BG_INODE_UNINIT
)) {
1366 pctx
.num
= dirent
->inode
;
1367 if (fix_problem(ctx
, PR_2_INOREF_BG_INO_UNINIT
,
1369 ext2fs_bg_flags_clear(fs
, group
,
1370 EXT2_BG_INODE_UNINIT
);
1371 ext2fs_mark_super_dirty(fs
);
1372 ctx
->flags
|= E2F_FLAG_RESTART_LATER
;
1374 ext2fs_unmark_valid(fs
);
1375 if (problem
== PR_2_BAD_INO
)
1378 } else if (dirent
->inode
>= first_unused_inode
) {
1379 pctx
.num
= dirent
->inode
;
1380 if (fix_problem(ctx
, PR_2_INOREF_IN_UNUSED
, &cd
->pctx
)){
1381 ext2fs_bg_itable_unused_set(fs
, group
, 0);
1382 ext2fs_mark_super_dirty(fs
);
1383 ctx
->flags
|= E2F_FLAG_RESTART_LATER
;
1385 ext2fs_unmark_valid(fs
);
1386 if (problem
== PR_2_BAD_INO
)
1392 * Offer to clear unused inodes; if we are going to be
1393 * restarting the scan due to bg_itable_unused being
1394 * wrong, then don't clear any inodes to avoid zapping
1395 * inodes that were skipped during pass1 due to an
1396 * incorrect bg_itable_unused; we'll get any real
1397 * problems after we restart.
1399 if (!(ctx
->flags
& E2F_FLAG_RESTART_LATER
) &&
1400 !(ext2fs_test_inode_bitmap2(ctx
->inode_used_map
,
1402 problem
= PR_2_UNUSED_INODE
;
1405 if (fix_problem(ctx
, problem
, &cd
->pctx
)) {
1410 ext2fs_unmark_valid(fs
);
1411 if (problem
== PR_2_BAD_INO
)
1416 if (!encrypted
&& check_name(ctx
, dirent
, &cd
->pctx
))
1419 if (encrypted
&& (dot_state
) > 1 &&
1420 encrypted_check_name(ctx
, dirent
, &cd
->pctx
)) {
1425 if (check_filetype(ctx
, dirent
, ino
, &cd
->pctx
))
1429 ext2fs_dirhash(dx_dir
->hashversion
, dirent
->name
,
1430 ext2fs_dirent_name_len(dirent
),
1431 fs
->super
->s_hash_seed
, &hash
, 0);
1432 if (hash
< dx_db
->min_hash
)
1433 dx_db
->min_hash
= hash
;
1434 if (hash
> dx_db
->max_hash
)
1435 dx_db
->max_hash
= hash
;
1439 * If this is a directory, then mark its parent in its
1440 * dir_info structure. If the parent field is already
1441 * filled in, then this directory has more than one
1442 * hard link. We assume the first link is correct,
1443 * and ask the user if he/she wants to clear this one.
1445 if ((dot_state
> 1) &&
1446 (ext2fs_test_inode_bitmap2(ctx
->inode_dir_map
,
1448 if (e2fsck_dir_info_get_parent(ctx
, dirent
->inode
,
1450 cd
->pctx
.ino
= dirent
->inode
;
1451 fix_problem(ctx
, PR_2_NO_DIRINFO
, &cd
->pctx
);
1452 goto abort_free_dict
;
1454 if (subdir_parent
) {
1455 cd
->pctx
.ino2
= subdir_parent
;
1456 if (fix_problem(ctx
, PR_2_LINK_DIR
,
1464 (void) e2fsck_dir_info_set_parent(ctx
,
1465 dirent
->inode
, ino
);
1471 } else if (dict_lookup(&de_dict
, dirent
)) {
1472 clear_problem_context(&pctx
);
1474 pctx
.dirent
= dirent
;
1475 fix_problem(ctx
, PR_2_REPORT_DUP_DIRENT
, &pctx
);
1476 e2fsck_rehash_dir_later(ctx
, ino
);
1479 dict_alloc_insert(&de_dict
, dirent
, dirent
);
1481 ext2fs_icount_increment(ctx
->inode_count
, dirent
->inode
,
1484 ctx
->fs_links_count
++;
1485 ctx
->fs_total_count
++;
1489 (void) ext2fs_get_rec_len(fs
, dirent
, &rec_len
);
1490 if (!inline_data_size
|| dot_state
> 1) {
1493 if (dot_state
== 1) {
1496 * If we get here, we're checking an inline
1497 * directory and we've just checked a (fake)
1498 * dotdot entry that we created on the stack.
1499 * Therefore set 'prev' to NULL so that if we
1500 * call salvage_directory on the next entry,
1501 * it won't try to absorb the next entry into
1502 * the on-stack dotdot entry.
1508 } while (offset
< max_block_size
);
1514 printf("db_block %d, type %d, min_hash 0x%0x, max_hash 0x%0x\n",
1515 db
->blockcnt
, dx_db
->type
,
1516 dx_db
->min_hash
, dx_db
->max_hash
);
1518 cd
->pctx
.dir
= cd
->pctx
.ino
;
1519 if ((dx_db
->type
== DX_DIRBLOCK_ROOT
) ||
1520 (dx_db
->type
== DX_DIRBLOCK_NODE
))
1521 parse_int_node(fs
, db
, cd
, dx_dir
, buf
, failed_csum
);
1524 if (offset
!= max_block_size
) {
1525 cd
->pctx
.num
= rec_len
+ offset
- max_block_size
;
1526 if (fix_problem(ctx
, PR_2_FINAL_RECLEN
, &cd
->pctx
)) {
1527 dirent
->rec_len
= cd
->pctx
.num
;
1532 int flags
, will_rehash
;
1533 /* leaf block with no tail? Rehash dirs later. */
1534 if (ext2fs_has_feature_metadata_csum(fs
->super
) &&
1536 !inline_data_size
&&
1537 !ext2fs_dirent_has_tail(fs
, (struct ext2_dir_entry
*)buf
)) {
1538 if (insert_dirent_tail(fs
, buf
) == 0)
1540 e2fsck_rehash_dir_later(ctx
, ino
);
1544 will_rehash
= e2fsck_dir_will_be_rehashed(ctx
, ino
);
1546 flags
= ctx
->fs
->flags
;
1547 ctx
->fs
->flags
|= EXT2_FLAG_IGNORE_CSUM_ERRORS
;
1549 if (inline_data_size
) {
1551 #ifdef WORDS_BIGENDIAN
1553 goto skip_first_write_swab
;
1554 *((__u32
*)buf
) = ext2fs_le32_to_cpu(*((__u32
*)buf
));
1555 cd
->pctx
.errcode
= ext2fs_dirent_swab_out2(fs
,
1556 buf
+ EXT4_INLINE_DATA_DOTDOT_SIZE
,
1557 EXT4_MIN_INLINE_DATA_SIZE
-
1558 EXT4_INLINE_DATA_DOTDOT_SIZE
,
1560 if (cd
->pctx
.errcode
)
1561 goto skip_second_write_swab
;
1562 skip_first_write_swab
:
1563 if (inline_data_size
<= EXT4_MIN_INLINE_DATA_SIZE
||
1565 goto skip_second_write_swab
;
1566 cd
->pctx
.errcode
= ext2fs_dirent_swab_out2(fs
,
1567 buf
+ EXT4_MIN_INLINE_DATA_SIZE
,
1569 EXT4_MIN_INLINE_DATA_SIZE
,
1571 skip_second_write_swab
:
1572 if (cd
->pctx
.errcode
&&
1573 !fix_problem(ctx
, PR_2_WRITE_DIRBLOCK
, &cd
->pctx
))
1574 goto abort_free_dict
;
1577 ext2fs_inline_data_set(fs
, ino
, 0, buf
,
1580 cd
->pctx
.errcode
= ext2fs_write_dir_block4(fs
, block_nr
,
1583 ctx
->fs
->flags
= (flags
&
1584 EXT2_FLAG_IGNORE_CSUM_ERRORS
) |
1586 ~EXT2_FLAG_IGNORE_CSUM_ERRORS
);
1587 if (cd
->pctx
.errcode
) {
1588 if (!fix_problem(ctx
, PR_2_WRITE_DIRBLOCK
,
1590 goto abort_free_dict
;
1592 ext2fs_mark_changed(fs
);
1593 } else if (is_leaf
&& failed_csum
&& !dir_modified
) {
1595 * If a leaf node that fails csum makes it this far without
1596 * alteration, ask the user if the checksum should be fixed.
1598 if (fix_problem(ctx
, PR_2_LEAF_NODE_ONLY_CSUM_INVALID
,
1602 dict_free_nodes(&de_dict
);
1605 ctx
->flags
|= E2F_FLAG_ABORT
;
1606 dict_free_nodes(&de_dict
);
1607 return DIRENT_ABORT
;
1613 blk64_t last_cluster
;
1617 * This function is called to deallocate a block, and is an interator
1618 * functioned called by deallocate inode via ext2fs_iterate_block().
1620 static int deallocate_inode_block(ext2_filsys fs
,
1622 e2_blkcnt_t blockcnt
EXT2FS_ATTR((unused
)),
1623 blk64_t ref_block
EXT2FS_ATTR((unused
)),
1624 int ref_offset
EXT2FS_ATTR((unused
)),
1627 struct del_block
*p
= priv_data
;
1628 blk64_t cluster
= EXT2FS_B2C(fs
, *block_nr
);
1633 if (cluster
== p
->last_cluster
)
1636 p
->last_cluster
= cluster
;
1637 if ((*block_nr
< fs
->super
->s_first_data_block
) ||
1638 (*block_nr
>= ext2fs_blocks_count(fs
->super
)))
1641 ext2fs_block_alloc_stats2(fs
, *block_nr
, -1);
1647 * This function deallocates an inode
1649 static void deallocate_inode(e2fsck_t ctx
, ext2_ino_t ino
, char* block_buf
)
1651 ext2_filsys fs
= ctx
->fs
;
1652 struct ext2_inode inode
;
1653 struct problem_context pctx
;
1655 struct del_block del_block
;
1657 e2fsck_read_inode(ctx
, ino
, &inode
, "deallocate_inode");
1658 clear_problem_context(&pctx
);
1662 * Fix up the bitmaps...
1664 e2fsck_read_bitmaps(ctx
);
1665 ext2fs_inode_alloc_stats2(fs
, ino
, -1, LINUX_S_ISDIR(inode
.i_mode
));
1667 if (ext2fs_file_acl_block(fs
, &inode
) &&
1668 ext2fs_has_feature_xattr(fs
->super
)) {
1669 pctx
.errcode
= ext2fs_adjust_ea_refcount3(fs
,
1670 ext2fs_file_acl_block(fs
, &inode
),
1671 block_buf
, -1, &count
, ino
);
1672 if (pctx
.errcode
== EXT2_ET_BAD_EA_BLOCK_NUM
) {
1677 pctx
.blk
= ext2fs_file_acl_block(fs
, &inode
);
1678 fix_problem(ctx
, PR_2_ADJ_EA_REFCOUNT
, &pctx
);
1679 ctx
->flags
|= E2F_FLAG_ABORT
;
1683 ext2fs_block_alloc_stats2(fs
,
1684 ext2fs_file_acl_block(fs
, &inode
), -1);
1686 ext2fs_file_acl_block_set(fs
, &inode
, 0);
1689 if (!ext2fs_inode_has_valid_blocks2(fs
, &inode
))
1692 /* Inline data inodes don't have blocks to iterate */
1693 if (inode
.i_flags
& EXT4_INLINE_DATA_FL
)
1696 if (LINUX_S_ISREG(inode
.i_mode
) &&
1697 ext2fs_needs_large_file_feature(EXT2_I_SIZE(&inode
)))
1700 del_block
.ctx
= ctx
;
1702 del_block
.last_cluster
= 0;
1703 pctx
.errcode
= ext2fs_block_iterate3(fs
, ino
, 0, block_buf
,
1704 deallocate_inode_block
,
1707 fix_problem(ctx
, PR_2_DEALLOC_INODE
, &pctx
);
1708 ctx
->flags
|= E2F_FLAG_ABORT
;
1712 /* Inode may have changed by block_iterate, so reread it */
1713 e2fsck_read_inode(ctx
, ino
, &inode
, "deallocate_inode");
1714 e2fsck_clear_inode(ctx
, ino
, &inode
, 0, "deallocate_inode");
1718 * This function clears the htree flag on an inode
1720 static void clear_htree(e2fsck_t ctx
, ext2_ino_t ino
)
1722 struct ext2_inode inode
;
1724 e2fsck_read_inode(ctx
, ino
, &inode
, "clear_htree");
1725 inode
.i_flags
= inode
.i_flags
& ~EXT2_INDEX_FL
;
1726 e2fsck_write_inode(ctx
, ino
, &inode
, "clear_htree");
1727 if (ctx
->dirs_to_hash
)
1728 ext2fs_u32_list_add(ctx
->dirs_to_hash
, ino
);
1732 int e2fsck_process_bad_inode(e2fsck_t ctx
, ext2_ino_t dir
,
1733 ext2_ino_t ino
, char *buf
)
1735 ext2_filsys fs
= ctx
->fs
;
1736 struct ext2_inode inode
;
1737 int inode_modified
= 0;
1739 unsigned char *frag
, *fsize
;
1740 struct problem_context pctx
;
1741 problem_t problem
= 0;
1743 e2fsck_read_inode(ctx
, ino
, &inode
, "process_bad_inode");
1745 clear_problem_context(&pctx
);
1748 pctx
.inode
= &inode
;
1750 if (ext2fs_file_acl_block(fs
, &inode
) &&
1751 !ext2fs_has_feature_xattr(fs
->super
)) {
1752 if (fix_problem(ctx
, PR_2_FILE_ACL_ZERO
, &pctx
)) {
1753 ext2fs_file_acl_block_set(fs
, &inode
, 0);
1759 if (!LINUX_S_ISDIR(inode
.i_mode
) && !LINUX_S_ISREG(inode
.i_mode
) &&
1760 !LINUX_S_ISCHR(inode
.i_mode
) && !LINUX_S_ISBLK(inode
.i_mode
) &&
1761 !LINUX_S_ISLNK(inode
.i_mode
) && !LINUX_S_ISFIFO(inode
.i_mode
) &&
1762 !(LINUX_S_ISSOCK(inode
.i_mode
)))
1763 problem
= PR_2_BAD_MODE
;
1764 else if (LINUX_S_ISCHR(inode
.i_mode
)
1765 && !e2fsck_pass1_check_device_inode(fs
, &inode
))
1766 problem
= PR_2_BAD_CHAR_DEV
;
1767 else if (LINUX_S_ISBLK(inode
.i_mode
)
1768 && !e2fsck_pass1_check_device_inode(fs
, &inode
))
1769 problem
= PR_2_BAD_BLOCK_DEV
;
1770 else if (LINUX_S_ISFIFO(inode
.i_mode
)
1771 && !e2fsck_pass1_check_device_inode(fs
, &inode
))
1772 problem
= PR_2_BAD_FIFO
;
1773 else if (LINUX_S_ISSOCK(inode
.i_mode
)
1774 && !e2fsck_pass1_check_device_inode(fs
, &inode
))
1775 problem
= PR_2_BAD_SOCKET
;
1776 else if (LINUX_S_ISLNK(inode
.i_mode
)
1777 && !e2fsck_pass1_check_symlink(fs
, ino
, &inode
, buf
)) {
1778 problem
= PR_2_INVALID_SYMLINK
;
1782 if (fix_problem(ctx
, problem
, &pctx
)) {
1783 deallocate_inode(ctx
, ino
, 0);
1784 if (ctx
->flags
& E2F_FLAG_SIGNAL_MASK
)
1792 if (inode
.i_faddr
) {
1793 if (fix_problem(ctx
, PR_2_FADDR_ZERO
, &pctx
)) {
1800 switch (fs
->super
->s_creator_os
) {
1802 frag
= &inode
.osd2
.hurd2
.h_i_frag
;
1803 fsize
= &inode
.osd2
.hurd2
.h_i_fsize
;
1808 if (frag
&& *frag
) {
1810 if (fix_problem(ctx
, PR_2_FRAG_ZERO
, &pctx
)) {
1817 if (fsize
&& *fsize
) {
1819 if (fix_problem(ctx
, PR_2_FSIZE_ZERO
, &pctx
)) {
1827 if ((fs
->super
->s_creator_os
== EXT2_OS_LINUX
) &&
1828 !ext2fs_has_feature_huge_file(fs
->super
) &&
1829 (inode
.osd2
.linux2
.l_i_blocks_hi
!= 0)) {
1830 pctx
.num
= inode
.osd2
.linux2
.l_i_blocks_hi
;
1831 if (fix_problem(ctx
, PR_2_BLOCKS_HI_ZERO
, &pctx
)) {
1832 inode
.osd2
.linux2
.l_i_blocks_hi
= 0;
1837 if ((fs
->super
->s_creator_os
== EXT2_OS_LINUX
) &&
1838 !ext2fs_has_feature_64bit(fs
->super
) &&
1839 inode
.osd2
.linux2
.l_i_file_acl_high
!= 0) {
1840 pctx
.num
= inode
.osd2
.linux2
.l_i_file_acl_high
;
1841 if (fix_problem(ctx
, PR_2_I_FILE_ACL_HI_ZERO
, &pctx
)) {
1842 inode
.osd2
.linux2
.l_i_file_acl_high
= 0;
1848 if (ext2fs_file_acl_block(fs
, &inode
) &&
1849 ((ext2fs_file_acl_block(fs
, &inode
) < fs
->super
->s_first_data_block
) ||
1850 (ext2fs_file_acl_block(fs
, &inode
) >= ext2fs_blocks_count(fs
->super
)))) {
1851 if (fix_problem(ctx
, PR_2_FILE_ACL_BAD
, &pctx
)) {
1852 ext2fs_file_acl_block_set(fs
, &inode
, 0);
1857 if (inode
.i_size_high
&& !ext2fs_has_feature_largedir(fs
->super
) &&
1858 LINUX_S_ISDIR(inode
.i_mode
)) {
1859 if (fix_problem(ctx
, PR_2_DIR_SIZE_HIGH_ZERO
, &pctx
)) {
1860 inode
.i_size_high
= 0;
1867 e2fsck_write_inode(ctx
, ino
, &inode
, "process_bad_inode");
1868 if (!not_fixed
&& ctx
->inode_bad_map
)
1869 ext2fs_unmark_inode_bitmap2(ctx
->inode_bad_map
, ino
);
1874 * allocate_dir_block --- this function allocates a new directory
1875 * block for a particular inode; this is done if a directory has
1876 * a "hole" in it, or if a directory has a illegal block number
1877 * that was zeroed out and now needs to be replaced.
1879 static int allocate_dir_block(e2fsck_t ctx
,
1880 struct ext2_db_entry2
*db
,
1881 char *buf
EXT2FS_ATTR((unused
)),
1882 struct problem_context
*pctx
)
1884 ext2_filsys fs
= ctx
->fs
;
1887 struct ext2_inode inode
;
1889 if (fix_problem(ctx
, PR_2_DIRECTORY_HOLE
, pctx
) == 0)
1893 * Read the inode and block bitmaps in; we'll be messing with
1896 e2fsck_read_bitmaps(ctx
);
1899 * First, find a free block
1901 e2fsck_read_inode(ctx
, db
->ino
, &inode
, "allocate_dir_block");
1902 pctx
->errcode
= ext2fs_map_cluster_block(fs
, db
->ino
, &inode
,
1903 db
->blockcnt
, &blk
);
1904 if (pctx
->errcode
|| blk
== 0) {
1905 blk
= ext2fs_find_inode_goal(fs
, db
->ino
, &inode
, db
->blockcnt
);
1906 pctx
->errcode
= ext2fs_new_block2(fs
, blk
,
1907 ctx
->block_found_map
, &blk
);
1908 if (pctx
->errcode
) {
1909 pctx
->str
= "ext2fs_new_block";
1910 fix_problem(ctx
, PR_2_ALLOC_DIRBOCK
, pctx
);
1914 ext2fs_mark_block_bitmap2(ctx
->block_found_map
, blk
);
1915 ext2fs_mark_block_bitmap2(fs
->block_map
, blk
);
1916 ext2fs_mark_bb_dirty(fs
);
1919 * Now let's create the actual data block for the inode
1922 pctx
->errcode
= ext2fs_new_dir_block(fs
, 0, 0, &block
);
1924 pctx
->errcode
= ext2fs_new_dir_block(fs
, db
->ino
,
1925 EXT2_ROOT_INO
, &block
);
1927 if (pctx
->errcode
) {
1928 pctx
->str
= "ext2fs_new_dir_block";
1929 fix_problem(ctx
, PR_2_ALLOC_DIRBOCK
, pctx
);
1933 pctx
->errcode
= ext2fs_write_dir_block4(fs
, blk
, block
, 0, db
->ino
);
1934 ext2fs_free_mem(&block
);
1935 if (pctx
->errcode
) {
1936 pctx
->str
= "ext2fs_write_dir_block";
1937 fix_problem(ctx
, PR_2_ALLOC_DIRBOCK
, pctx
);
1942 * Update the inode block count
1944 ext2fs_iblk_add_blocks(fs
, &inode
, 1);
1945 if (EXT2_I_SIZE(&inode
) < ((__u64
) db
->blockcnt
+1) * fs
->blocksize
) {
1946 pctx
->errcode
= ext2fs_inode_size_set(fs
, &inode
,
1947 (db
->blockcnt
+1) * fs
->blocksize
);
1948 if (pctx
->errcode
) {
1949 pctx
->str
= "ext2fs_inode_size_set";
1950 fix_problem(ctx
, PR_2_ALLOC_DIRBOCK
, pctx
);
1954 e2fsck_write_inode(ctx
, db
->ino
, &inode
, "allocate_dir_block");
1957 * Finally, update the block pointers for the inode
1960 pctx
->errcode
= ext2fs_bmap2(fs
, db
->ino
, &inode
, 0, BMAP_SET
,
1961 db
->blockcnt
, 0, &blk
);
1962 if (pctx
->errcode
) {
1963 pctx
->str
= "ext2fs_block_iterate";
1964 fix_problem(ctx
, PR_2_ALLOC_DIRBOCK
, pctx
);