2 * pass1.c -- pass #1 of e2fsck: sequential scan of the inode table
4 * Copyright (C) 1993, 1994, 1995, 1996, 1997 Theodore Ts'o.
7 * This file may be redistributed under the terms of the GNU Public
11 * Pass 1 of e2fsck iterates over all the inodes in the filesystems,
12 * and applies the following tests to each inode:
14 * - The mode field of the inode must be legal.
15 * - The size and block count fields of the inode are correct.
16 * - A data block must not be used by another inode
18 * Pass 1 also gathers the collects the following information:
20 * - A bitmap of which inodes are in use. (inode_used_map)
21 * - A bitmap of which inodes are directories. (inode_dir_map)
22 * - A bitmap of which inodes are regular files. (inode_reg_map)
23 * - A bitmap of which inodes have bad fields. (inode_bad_map)
24 * - A bitmap of which inodes are in bad blocks. (inode_bb_map)
25 * - A bitmap of which inodes are imagic inodes. (inode_imagic_map)
26 * - A bitmap of which blocks are in use. (block_found_map)
27 * - A bitmap of which blocks are in use by two inodes (block_dup_map)
28 * - The data blocks of the directory inodes. (dir_map)
30 * Pass 1 is designed to stash away enough information so that the
31 * other passes should not need to read in the inode information
32 * during the normal course of a filesystem check. (Althogh if an
33 * inconsistency is detected, other passes may need to read in an
36 * Note that pass 1B will be invoked if there are any duplicate blocks
40 #define _GNU_SOURCE 1 /* get strnlen() */
48 #include <ext2fs/ext2_ext_attr.h>
52 #ifdef NO_INLINE_FUNCS
55 #define _INLINE_ inline
58 static int process_block(ext2_filsys fs, blk_t *blocknr,
59 e2_blkcnt_t blockcnt, blk_t ref_blk,
60 int ref_offset, void *priv_data);
61 static int process_bad_block(ext2_filsys fs, blk_t *block_nr,
62 e2_blkcnt_t blockcnt, blk_t ref_blk,
63 int ref_offset, void *priv_data);
64 static void check_blocks(e2fsck_t ctx, struct problem_context *pctx,
66 static void mark_table_blocks(e2fsck_t ctx);
67 static void alloc_bb_map(e2fsck_t ctx);
68 static void alloc_imagic_map(e2fsck_t ctx);
69 static void mark_inode_bad(e2fsck_t ctx, ino_t ino);
70 static void handle_fs_bad_blocks(e2fsck_t ctx);
71 static void process_inodes(e2fsck_t ctx, char *block_buf);
72 static EXT2_QSORT_TYPE process_inode_cmp(const void *a, const void *b);
73 static errcode_t scan_callback(ext2_filsys fs, ext2_inode_scan scan,
74 dgrp_t group, void * priv_data);
75 static void adjust_extattr_refcount(e2fsck_t ctx, ext2_refcount_t refcount,
76 char *block_buf, int adjust_sign);
77 /* static char *describe_illegal_block(ext2_filsys fs, blk_t block); */
79 struct process_block_struct {
81 unsigned is_dir:1, is_reg:1, clear:1, suppress:1,
82 fragmented:1, compressed:1, bbcheck:1;
85 e2_blkcnt_t last_block;
86 int num_illegal_blocks;
88 struct ext2_inode *inode;
89 struct problem_context *pctx;
90 ext2fs_block_bitmap fs_meta_blocks;
94 struct process_inode_block {
96 struct ext2_inode inode;
99 struct scan_callback_struct {
105 * For the inodes to process list.
107 static struct process_inode_block *inodes_to_process;
108 static int process_inode_count;
110 static __u64 ext2_max_sizes[EXT2_MAX_BLOCK_LOG_SIZE -
111 EXT2_MIN_BLOCK_LOG_SIZE + 1];
114 * Free all memory allocated by pass1 in preparation for restarting
117 static void unwind_pass1(ext2_filsys fs EXT2FS_ATTR((unused)))
119 ext2fs_free_mem(&inodes_to_process);
120 inodes_to_process = 0;
124 * Check to make sure a device inode is real. Returns 1 if the device
125 * checks out, 0 if not.
127 * Note: this routine is now also used to check FIFO's and Sockets,
128 * since they have the same requirement; the i_block fields should be
131 int e2fsck_pass1_check_device_inode(ext2_filsys fs, struct ext2_inode *inode)
136 * If the index flag is set, then this is a bogus
139 if (inode->i_flags & EXT2_INDEX_FL)
143 * We should be able to do the test below all the time, but
144 * because the kernel doesn't forcibly clear the device
145 * inode's additional i_block fields, there are some rare
146 * occasions when a legitimate device inode will have non-zero
147 * additional i_block fields. So for now, we only complain
148 * when the immutable flag is set, which should never happen
149 * for devices. (And that's when the problem is caused, since
150 * you can't set or clear immutable flags for devices.) Once
151 * the kernel has been fixed we can change this...
153 if (inode->i_flags & (EXT2_IMMUTABLE_FL | EXT2_APPEND_FL)) {
154 for (i=4; i < EXT2_N_BLOCKS; i++)
155 if (inode->i_block[i])
162 * Check to make sure a symlink inode is real. Returns 1 if the symlink
163 * checks out, 0 if not.
165 int e2fsck_pass1_check_symlink(ext2_filsys fs, struct ext2_inode *inode,
172 if ((inode->i_size_high || inode->i_size == 0) ||
173 (inode->i_flags & EXT2_INDEX_FL))
176 blocks = ext2fs_inode_data_blocks(fs, inode);
178 if ((inode->i_size >= fs->blocksize) ||
179 (blocks != fs->blocksize >> 9) ||
180 (inode->i_block[0] < fs->super->s_first_data_block) ||
181 (inode->i_block[0] >= fs->super->s_blocks_count))
184 for (i = 1; i < EXT2_N_BLOCKS; i++)
185 if (inode->i_block[i])
188 if (io_channel_read_blk(fs->io, inode->i_block[0], 1, buf))
191 len = strnlen(buf, fs->blocksize);
192 if (len == fs->blocksize)
195 if (inode->i_size >= sizeof(inode->i_block))
198 len = strnlen((char *)inode->i_block, sizeof(inode->i_block));
199 if (len == sizeof(inode->i_block))
202 if (len != inode->i_size)
208 * If the immutable (or append-only) flag is set on the inode, offer
211 #define BAD_SPECIAL_FLAGS (EXT2_IMMUTABLE_FL | EXT2_APPEND_FL)
212 static void check_immutable(e2fsck_t ctx, struct problem_context *pctx)
214 if (!(pctx->inode->i_flags & BAD_SPECIAL_FLAGS))
217 if (!fix_problem(ctx, PR_1_SET_IMMUTABLE, pctx))
220 pctx->inode->i_flags &= ~BAD_SPECIAL_FLAGS;
221 e2fsck_write_inode(ctx, pctx->ino, pctx->inode, "pass1");
225 * If device, fifo or socket, check size is zero -- if not offer to
228 static void check_size(e2fsck_t ctx, struct problem_context *pctx)
230 struct ext2_inode *inode = pctx->inode;
232 if ((inode->i_size == 0) && (inode->i_size_high == 0))
235 if (!fix_problem(ctx, PR_1_SET_NONZSIZE, pctx))
239 inode->i_size_high = 0;
240 e2fsck_write_inode(ctx, pctx->ino, pctx->inode, "pass1");
243 static void check_ea_in_inode(e2fsck_t ctx, struct problem_context *pctx)
245 struct ext2_super_block *sb = ctx->fs->super;
246 struct ext2_inode_large *inode;
247 struct ext2_ext_attr_entry *entry;
249 unsigned int storage_size, remain, offs;
252 inode = (struct ext2_inode_large *) pctx->inode;
253 storage_size = EXT2_INODE_SIZE(ctx->fs->super) - EXT2_GOOD_OLD_INODE_SIZE -
254 inode->i_extra_isize;
255 start = ((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE +
256 inode->i_extra_isize + sizeof(__u32);
257 end = (char *) inode + EXT2_INODE_SIZE(ctx->fs->super);
258 entry = (struct ext2_ext_attr_entry *) start;
260 /* scan all entry's headers first */
262 /* take finish entry 0UL into account */
263 remain = storage_size - sizeof(__u32);
266 while (!EXT2_EXT_IS_LAST_ENTRY(entry)) {
268 /* header eats this space */
269 remain -= sizeof(struct ext2_ext_attr_entry);
271 /* is attribute name valid? */
272 if (EXT2_EXT_ATTR_SIZE(entry->e_name_len) > remain) {
273 pctx->num = entry->e_name_len;
274 problem = PR_1_ATTR_NAME_LEN;
278 /* attribute len eats this space */
279 remain -= EXT2_EXT_ATTR_SIZE(entry->e_name_len);
281 /* check value size */
282 if (entry->e_value_size == 0 || entry->e_value_size > remain) {
283 pctx->num = entry->e_value_size;
284 problem = PR_1_ATTR_VALUE_SIZE;
288 /* check value placement */
289 if (entry->e_value_offs +
290 EXT2_XATTR_SIZE(entry->e_value_size) != offs) {
291 printf("(entry->e_value_offs + entry->e_value_size: %d, offs: %d)\n", entry->e_value_offs + entry->e_value_size, offs);
292 pctx->num = entry->e_value_offs;
293 problem = PR_1_ATTR_VALUE_OFFSET;
297 /* e_value_block must be 0 in inode's ea */
298 if (entry->e_value_block != 0) {
299 pctx->num = entry->e_value_block;
300 problem = PR_1_ATTR_VALUE_BLOCK;
304 /* e_hash must be 0 in inode's ea */
305 if (entry->e_hash != 0) {
306 pctx->num = entry->e_hash;
307 problem = PR_1_ATTR_HASH;
311 remain -= entry->e_value_size;
312 offs -= EXT2_XATTR_SIZE(entry->e_value_size);
314 entry = EXT2_EXT_ATTR_NEXT(entry);
318 * it seems like a corruption. it's very unlikely we could repair
319 * EA(s) in automatic fashion -bzzz
322 problem = PR_1_ATTR_HASH;
324 if (problem == 0 || !fix_problem(ctx, problem, pctx))
327 /* simple remove all possible EA(s) */
328 *((__u32 *)start) = 0UL;
329 e2fsck_write_inode_full(ctx, pctx->ino, (struct ext2_inode *) inode,
330 EXT2_INODE_SIZE(sb), "pass1");
333 static void check_inode_extra_space(e2fsck_t ctx, struct problem_context *pctx)
335 struct ext2_super_block *sb = ctx->fs->super;
336 struct ext2_inode_large *inode;
340 inode = (struct ext2_inode_large *) pctx->inode;
341 if (EXT2_INODE_SIZE(sb) == EXT2_GOOD_OLD_INODE_SIZE) {
342 /* this isn't large inode. so, nothing to check */
347 printf("inode #%u, i_extra_size %d\n", pctx->ino,
348 inode->i_extra_isize);
350 /* i_extra_isize must cover i_extra_isize + i_pad1 at least */
351 min = sizeof(inode->i_extra_isize) + sizeof(inode->i_pad1);
352 max = EXT2_INODE_SIZE(sb) - EXT2_GOOD_OLD_INODE_SIZE;
354 * For now we will allow i_extra_isize to be 0, but really
355 * implementations should never allow i_extra_isize to be 0
357 if (inode->i_extra_isize &&
358 (inode->i_extra_isize < min || inode->i_extra_isize > max)) {
359 if (!fix_problem(ctx, PR_1_EXTRA_ISIZE, pctx))
361 inode->i_extra_isize = min;
362 e2fsck_write_inode_full(ctx, pctx->ino, pctx->inode,
363 EXT2_INODE_SIZE(sb), "pass1");
367 eamagic = (__u32 *) (((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE +
368 inode->i_extra_isize);
369 if (*eamagic == EXT2_EXT_ATTR_MAGIC) {
370 /* it seems inode has an extended attribute(s) in body */
371 check_ea_in_inode(ctx, pctx);
376 * Check to see if the inode might really be a directory, despite i_mode
378 * This is a lot of complexity for something for which I'm not really
379 * convinced happens frequently in the wild. If for any reason this
380 * causes any problems, take this code out.
381 * [tytso:20070331.0827EDT]
383 static void check_is_really_dir(e2fsck_t ctx, struct problem_context *pctx,
386 struct ext2_inode *inode = pctx->inode;
387 int i, not_device = 0;
389 struct ext2_dir_entry *dirent;
391 if (LINUX_S_ISDIR(inode->i_mode) || LINUX_S_ISREG(inode->i_mode) ||
392 inode->i_block[0] == 0)
395 for (i=1; i < EXT2_N_BLOCKS; i++) {
396 blk = inode->i_block[i];
402 if (blk < ctx->fs->super->s_first_data_block ||
403 blk >= ctx->fs->super->s_blocks_count ||
404 ext2fs_fast_test_block_bitmap(ctx->block_found_map, blk))
405 return; /* Invalid block, can't be dir */
408 if ((LINUX_S_ISCHR(inode->i_mode) || LINUX_S_ISBLK(inode->i_mode)) &&
409 (inode->i_links_count == 1) && !not_device)
412 if (LINUX_S_ISLNK(inode->i_mode) && inode->i_links_count == 1)
415 if (ext2fs_read_dir_block(ctx->fs, inode->i_block[0], buf))
418 dirent = (struct ext2_dir_entry *) buf;
419 if (((dirent->name_len & 0xFF) != 1) ||
420 (dirent->name[0] != '.') ||
421 (dirent->inode != pctx->ino) ||
422 (dirent->rec_len < 12) ||
423 (dirent->rec_len % 4) ||
424 (dirent->rec_len >= ctx->fs->blocksize - 12))
427 dirent = (struct ext2_dir_entry *) (buf + dirent->rec_len);
428 if (((dirent->name_len & 0xFF) != 2) ||
429 (dirent->name[0] != '.') ||
430 (dirent->name[1] != '.') ||
431 (dirent->rec_len < 12) ||
432 (dirent->rec_len % 4))
435 if (fix_problem(ctx, PR_1_TREAT_AS_DIRECTORY, pctx)) {
436 inode->i_mode = (inode->i_mode & 07777) | LINUX_S_IFDIR;
437 e2fsck_write_inode_full(ctx, pctx->ino, inode,
438 EXT2_INODE_SIZE(ctx->fs->super),
439 "check_is_really_dir");
443 extern void e2fsck_setup_tdb_icount(e2fsck_t ctx, int flags,
448 char *tdb_dir, uuid[40];
449 int fd, threshold, enable;
453 profile_get_string(ctx->profile, "scratch_files", "directory", 0, 0,
455 profile_get_integer(ctx->profile, "scratch_files",
456 "numdirs_threshold", 0, 0, &threshold);
457 profile_get_boolean(ctx->profile, "scratch_files",
458 "icount", 0, 1, &enable);
460 retval = ext2fs_get_num_dirs(ctx->fs, &num_dirs);
462 num_dirs = 1024; /* Guess */
464 if (!enable || !tdb_dir || access(tdb_dir, W_OK) ||
465 (threshold && num_dirs <= threshold))
468 retval = ext2fs_create_icount_tdb(ctx->fs, tdb_dir, flags, ret);
473 void e2fsck_pass1(e2fsck_t ctx)
477 ext2_filsys fs = ctx->fs;
479 struct ext2_inode *inode;
480 ext2_inode_scan scan;
482 #ifdef RESOURCE_TRACK
483 struct resource_track rtrack;
485 unsigned char frag, fsize;
486 struct problem_context pctx;
487 struct scan_callback_struct scan_struct;
488 struct ext2_super_block *sb = ctx->fs->super;
490 int busted_fs_time = 0;
493 #ifdef RESOURCE_TRACK
494 init_resource_track(&rtrack);
496 clear_problem_context(&pctx);
498 if (!(ctx->options & E2F_OPT_PREEN))
499 fix_problem(ctx, PR_1_PASS_HEADER, &pctx);
501 if ((fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_DIR_INDEX) &&
502 !(ctx->options & E2F_OPT_NO)) {
503 if (ext2fs_u32_list_create(&ctx->dirs_to_hash, 50))
504 ctx->dirs_to_hash = 0;
508 mtrace_print("Pass 1");
511 #define EXT2_BPP(bits) (1ULL << ((bits) - 2))
513 for (i = EXT2_MIN_BLOCK_LOG_SIZE; i <= EXT2_MAX_BLOCK_LOG_SIZE; i++) {
514 max_sizes = EXT2_NDIR_BLOCKS + EXT2_BPP(i);
515 max_sizes = max_sizes + EXT2_BPP(i) * EXT2_BPP(i);
516 max_sizes = max_sizes + EXT2_BPP(i) * EXT2_BPP(i) * EXT2_BPP(i);
517 max_sizes = (max_sizes * (1UL << i)) - 1;
518 ext2_max_sizes[i - EXT2_MIN_BLOCK_LOG_SIZE] = max_sizes;
522 imagic_fs = (sb->s_feature_compat & EXT2_FEATURE_COMPAT_IMAGIC_INODES);
525 * Allocate bitmaps structures
527 pctx.errcode = ext2fs_allocate_inode_bitmap(fs, _("in-use inode map"),
528 &ctx->inode_used_map);
531 fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx);
532 ctx->flags |= E2F_FLAG_ABORT;
535 pctx.errcode = ext2fs_allocate_inode_bitmap(fs,
536 _("directory inode map"), &ctx->inode_dir_map);
539 fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx);
540 ctx->flags |= E2F_FLAG_ABORT;
543 pctx.errcode = ext2fs_allocate_inode_bitmap(fs,
544 _("regular file inode map"), &ctx->inode_reg_map);
547 fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx);
548 ctx->flags |= E2F_FLAG_ABORT;
551 pctx.errcode = ext2fs_allocate_block_bitmap(fs, _("in-use block map"),
552 &ctx->block_found_map);
555 fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, &pctx);
556 ctx->flags |= E2F_FLAG_ABORT;
559 e2fsck_setup_tdb_icount(ctx, 0, &ctx->inode_link_info);
560 if (!ctx->inode_link_info)
561 pctx.errcode = ext2fs_create_icount2(fs, 0, 0, 0,
562 &ctx->inode_link_info);
564 fix_problem(ctx, PR_1_ALLOCATE_ICOUNT, &pctx);
565 ctx->flags |= E2F_FLAG_ABORT;
568 inode_size = EXT2_INODE_SIZE(fs->super);
569 inode = (struct ext2_inode *)
570 e2fsck_allocate_memory(ctx, inode_size, "scratch inode");
572 inodes_to_process = (struct process_inode_block *)
573 e2fsck_allocate_memory(ctx,
574 (ctx->process_inode_size *
575 sizeof(struct process_inode_block)),
576 "array of inodes to process");
577 process_inode_count = 0;
579 pctx.errcode = ext2fs_init_dblist(fs, 0);
581 fix_problem(ctx, PR_1_ALLOCATE_DBCOUNT, &pctx);
582 ctx->flags |= E2F_FLAG_ABORT;
583 ext2fs_free_mem(&inode);
588 * If the last orphan field is set, clear it, since the pass1
589 * processing will automatically find and clear the orphans.
590 * In the future, we may want to try using the last_orphan
591 * linked list ourselves, but for now, we clear it so that the
592 * ext3 mount code won't get confused.
594 if (!(ctx->options & E2F_OPT_READONLY)) {
595 if (fs->super->s_last_orphan) {
596 fs->super->s_last_orphan = 0;
597 ext2fs_mark_super_dirty(fs);
601 mark_table_blocks(ctx);
602 block_buf = (char *) e2fsck_allocate_memory(ctx, fs->blocksize * 3,
603 "block interate buffer");
604 e2fsck_use_inode_shortcuts(ctx, 1);
605 ehandler_operation(_("doing inode scan"));
606 pctx.errcode = ext2fs_open_inode_scan(fs, ctx->inode_buffer_blocks,
609 fix_problem(ctx, PR_1_ISCAN_ERROR, &pctx);
610 ctx->flags |= E2F_FLAG_ABORT;
611 ext2fs_free_mem(&block_buf);
612 ext2fs_free_mem(&inode);
615 ext2fs_inode_scan_flags(scan, EXT2_SF_SKIP_MISSING_ITABLE, 0);
616 ctx->stashed_inode = inode;
617 scan_struct.ctx = ctx;
618 scan_struct.block_buf = block_buf;
619 ext2fs_set_inode_callback(scan, scan_callback, &scan_struct);
621 if ((ctx->progress)(ctx, 1, 0, ctx->fs->group_desc_count))
623 if ((fs->super->s_wtime < fs->super->s_inodes_count) ||
624 (fs->super->s_mtime < fs->super->s_inodes_count))
628 pctx.errcode = ext2fs_get_next_inode_full(scan, &ino,
630 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
632 if (pctx.errcode == EXT2_ET_BAD_BLOCK_IN_INODE_TABLE) {
633 if (!ctx->inode_bb_map)
635 ext2fs_mark_inode_bitmap(ctx->inode_bb_map, ino);
636 ext2fs_mark_inode_bitmap(ctx->inode_used_map, ino);
640 fix_problem(ctx, PR_1_ISCAN_ERROR, &pctx);
641 ctx->flags |= E2F_FLAG_ABORT;
648 ctx->stashed_ino = ino;
649 if (inode->i_links_count) {
650 pctx.errcode = ext2fs_icount_store(ctx->inode_link_info,
651 ino, inode->i_links_count);
653 pctx.num = inode->i_links_count;
654 fix_problem(ctx, PR_1_ICOUNT_STORE, &pctx);
655 ctx->flags |= E2F_FLAG_ABORT;
659 if (ino == EXT2_BAD_INO) {
660 struct process_block_struct pb;
662 pctx.errcode = ext2fs_copy_bitmap(ctx->block_found_map,
666 fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, &pctx);
667 ctx->flags |= E2F_FLAG_ABORT;
670 pb.ino = EXT2_BAD_INO;
671 pb.num_blocks = pb.last_block = 0;
672 pb.num_illegal_blocks = 0;
673 pb.suppress = 0; pb.clear = 0; pb.is_dir = 0;
674 pb.is_reg = 0; pb.fragmented = 0; pb.bbcheck = 0;
678 pctx.errcode = ext2fs_block_iterate2(fs, ino, 0,
679 block_buf, process_bad_block, &pb);
680 ext2fs_free_block_bitmap(pb.fs_meta_blocks);
682 fix_problem(ctx, PR_1_BLOCK_ITERATE, &pctx);
683 ctx->flags |= E2F_FLAG_ABORT;
687 if (!fix_problem(ctx, PR_1_BBINODE_BAD_METABLOCK_PROMPT, &pctx)) {
688 ctx->flags |= E2F_FLAG_ABORT;
691 ext2fs_mark_inode_bitmap(ctx->inode_used_map, ino);
692 clear_problem_context(&pctx);
694 } else if (ino == EXT2_ROOT_INO) {
696 * Make sure the root inode is a directory; if
697 * not, offer to clear it. It will be
698 * regnerated in pass #3.
700 if (!LINUX_S_ISDIR(inode->i_mode)) {
701 if (fix_problem(ctx, PR_1_ROOT_NO_DIR, &pctx)) {
702 inode->i_dtime = ctx->now;
703 inode->i_links_count = 0;
704 ext2fs_icount_store(ctx->inode_link_info,
706 e2fsck_write_inode(ctx, ino, inode,
712 * If dtime is set, offer to clear it. mke2fs
713 * version 0.2b created filesystems with the
714 * dtime field set for the root and lost+found
715 * directories. We won't worry about
716 * /lost+found, since that can be regenerated
717 * easily. But we will fix the root directory
720 if (inode->i_dtime && inode->i_links_count) {
721 if (fix_problem(ctx, PR_1_ROOT_DTIME, &pctx)) {
723 e2fsck_write_inode(ctx, ino, inode,
727 } else if (ino == EXT2_JOURNAL_INO) {
728 ext2fs_mark_inode_bitmap(ctx->inode_used_map, ino);
729 if (fs->super->s_journal_inum == EXT2_JOURNAL_INO) {
730 if (!LINUX_S_ISREG(inode->i_mode) &&
731 fix_problem(ctx, PR_1_JOURNAL_BAD_MODE,
733 inode->i_mode = LINUX_S_IFREG;
734 e2fsck_write_inode(ctx, ino, inode,
737 check_blocks(ctx, &pctx, block_buf);
740 if ((inode->i_links_count || inode->i_blocks ||
741 inode->i_blocks || inode->i_block[0]) &&
742 fix_problem(ctx, PR_1_JOURNAL_INODE_NOT_CLEAR,
744 memset(inode, 0, inode_size);
745 ext2fs_icount_store(ctx->inode_link_info,
747 e2fsck_write_inode_full(ctx, ino, inode,
748 inode_size, "pass1");
750 } else if (ino < EXT2_FIRST_INODE(fs->super)) {
753 ext2fs_mark_inode_bitmap(ctx->inode_used_map, ino);
754 if (ino == EXT2_BOOT_LOADER_INO) {
755 if (LINUX_S_ISDIR(inode->i_mode))
756 problem = PR_1_RESERVED_BAD_MODE;
757 } else if (ino == EXT2_RESIZE_INO) {
759 !LINUX_S_ISREG(inode->i_mode))
760 problem = PR_1_RESERVED_BAD_MODE;
762 if (inode->i_mode != 0)
763 problem = PR_1_RESERVED_BAD_MODE;
766 if (fix_problem(ctx, problem, &pctx)) {
768 e2fsck_write_inode(ctx, ino, inode,
772 check_blocks(ctx, &pctx, block_buf);
776 * Check for inodes who might have been part of the
777 * orphaned list linked list. They should have gotten
778 * dealt with by now, unless the list had somehow been
781 * FIXME: In the future, inodes which are still in use
782 * (and which are therefore) pending truncation should
783 * be handled specially. Right now we just clear the
784 * dtime field, and the normal e2fsck handling of
785 * inodes where i_size and the inode blocks are
786 * inconsistent is to fix i_size, instead of releasing
787 * the extra blocks. This won't catch the inodes that
788 * was at the end of the orphan list, but it's better
789 * than nothing. The right answer is that there
790 * shouldn't be any bugs in the orphan list handling. :-)
792 if (inode->i_dtime && !busted_fs_time &&
793 inode->i_dtime < ctx->fs->super->s_inodes_count) {
794 if (fix_problem(ctx, PR_1_LOW_DTIME, &pctx)) {
795 inode->i_dtime = inode->i_links_count ?
797 e2fsck_write_inode(ctx, ino, inode,
803 * This code assumes that deleted inodes have
804 * i_links_count set to 0.
806 if (!inode->i_links_count) {
807 if (!inode->i_dtime && inode->i_mode) {
809 PR_1_ZERO_DTIME, &pctx)) {
810 inode->i_dtime = ctx->now;
811 e2fsck_write_inode(ctx, ino, inode,
818 * n.b. 0.3c ext2fs code didn't clear i_links_count for
819 * deleted files. Oops.
821 * Since all new ext2 implementations get this right,
822 * we now assume that the case of non-zero
823 * i_links_count and non-zero dtime means that we
824 * should keep the file, not delete it.
827 if (inode->i_dtime) {
828 if (fix_problem(ctx, PR_1_SET_DTIME, &pctx)) {
830 e2fsck_write_inode(ctx, ino, inode, "pass1");
834 ext2fs_mark_inode_bitmap(ctx->inode_used_map, ino);
835 switch (fs->super->s_creator_os) {
837 frag = inode->osd2.hurd2.h_i_frag;
838 fsize = inode->osd2.hurd2.h_i_fsize;
841 frag = inode->osd2.masix2.m_i_frag;
842 fsize = inode->osd2.masix2.m_i_fsize;
848 if (inode->i_faddr || frag || fsize ||
849 (LINUX_S_ISDIR(inode->i_mode) && inode->i_dir_acl))
850 mark_inode_bad(ctx, ino);
851 if ((fs->super->s_creator_os == EXT2_OS_LINUX) &&
852 !(fs->super->s_feature_ro_compat &
853 EXT4_FEATURE_RO_COMPAT_HUGE_FILE) &&
854 (inode->osd2.linux2.l_i_blocks_hi != 0))
855 mark_inode_bad(ctx, ino);
856 if (inode->i_flags & EXT2_IMAGIC_FL) {
858 if (!ctx->inode_imagic_map)
859 alloc_imagic_map(ctx);
860 ext2fs_mark_inode_bitmap(ctx->inode_imagic_map,
863 if (fix_problem(ctx, PR_1_SET_IMAGIC, &pctx)) {
864 inode->i_flags &= ~EXT2_IMAGIC_FL;
865 e2fsck_write_inode(ctx, ino,
871 check_inode_extra_space(ctx, &pctx);
872 check_is_really_dir(ctx, &pctx, block_buf);
874 if (LINUX_S_ISDIR(inode->i_mode)) {
875 ext2fs_mark_inode_bitmap(ctx->inode_dir_map, ino);
876 e2fsck_add_dir_info(ctx, ino, 0);
877 ctx->fs_directory_count++;
878 } else if (LINUX_S_ISREG (inode->i_mode)) {
879 ext2fs_mark_inode_bitmap(ctx->inode_reg_map, ino);
880 ctx->fs_regular_count++;
881 } else if (LINUX_S_ISCHR (inode->i_mode) &&
882 e2fsck_pass1_check_device_inode(fs, inode)) {
883 check_immutable(ctx, &pctx);
884 check_size(ctx, &pctx);
885 ctx->fs_chardev_count++;
886 } else if (LINUX_S_ISBLK (inode->i_mode) &&
887 e2fsck_pass1_check_device_inode(fs, inode)) {
888 check_immutable(ctx, &pctx);
889 check_size(ctx, &pctx);
890 ctx->fs_blockdev_count++;
891 } else if (LINUX_S_ISLNK (inode->i_mode) &&
892 e2fsck_pass1_check_symlink(fs, inode, block_buf)) {
893 check_immutable(ctx, &pctx);
894 ctx->fs_symlinks_count++;
895 if (ext2fs_inode_data_blocks(fs, inode) == 0) {
896 ctx->fs_fast_symlinks_count++;
897 check_blocks(ctx, &pctx, block_buf);
901 else if (LINUX_S_ISFIFO (inode->i_mode) &&
902 e2fsck_pass1_check_device_inode(fs, inode)) {
903 check_immutable(ctx, &pctx);
904 check_size(ctx, &pctx);
905 ctx->fs_fifo_count++;
906 } else if ((LINUX_S_ISSOCK (inode->i_mode)) &&
907 e2fsck_pass1_check_device_inode(fs, inode)) {
908 check_immutable(ctx, &pctx);
909 check_size(ctx, &pctx);
910 ctx->fs_sockets_count++;
912 mark_inode_bad(ctx, ino);
913 if (inode->i_block[EXT2_IND_BLOCK])
915 if (inode->i_block[EXT2_DIND_BLOCK])
916 ctx->fs_dind_count++;
917 if (inode->i_block[EXT2_TIND_BLOCK])
918 ctx->fs_tind_count++;
919 if (inode->i_block[EXT2_IND_BLOCK] ||
920 inode->i_block[EXT2_DIND_BLOCK] ||
921 inode->i_block[EXT2_TIND_BLOCK] ||
923 inodes_to_process[process_inode_count].ino = ino;
924 inodes_to_process[process_inode_count].inode = *inode;
925 process_inode_count++;
927 check_blocks(ctx, &pctx, block_buf);
929 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
932 if (process_inode_count >= ctx->process_inode_size) {
933 process_inodes(ctx, block_buf);
935 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
939 process_inodes(ctx, block_buf);
940 ext2fs_close_inode_scan(scan);
941 ehandler_operation(0);
944 * If any extended attribute blocks' reference counts need to
945 * be adjusted, either up (ctx->refcount_extra), or down
946 * (ctx->refcount), then fix them.
949 adjust_extattr_refcount(ctx, ctx->refcount, block_buf, -1);
950 ea_refcount_free(ctx->refcount);
953 if (ctx->refcount_extra) {
954 adjust_extattr_refcount(ctx, ctx->refcount_extra,
956 ea_refcount_free(ctx->refcount_extra);
957 ctx->refcount_extra = 0;
960 if (ctx->invalid_bitmaps)
961 handle_fs_bad_blocks(ctx);
963 /* We don't need the block_ea_map any more */
964 if (ctx->block_ea_map) {
965 ext2fs_free_block_bitmap(ctx->block_ea_map);
966 ctx->block_ea_map = 0;
969 if (ctx->flags & E2F_FLAG_RESIZE_INODE) {
970 ext2fs_block_bitmap save_bmap;
972 save_bmap = fs->block_map;
973 fs->block_map = ctx->block_found_map;
974 clear_problem_context(&pctx);
975 pctx.errcode = ext2fs_create_resize_inode(fs);
977 fix_problem(ctx, PR_1_RESIZE_INODE_CREATE, &pctx);
978 /* Should never get here */
979 ctx->flags |= E2F_FLAG_ABORT;
982 e2fsck_read_inode(ctx, EXT2_RESIZE_INO, inode,
984 inode->i_mtime = ctx->now;
985 e2fsck_write_inode(ctx, EXT2_RESIZE_INO, inode,
987 fs->block_map = save_bmap;
988 ctx->flags &= ~E2F_FLAG_RESIZE_INODE;
991 if (ctx->flags & E2F_FLAG_RESTART) {
993 * Only the master copy of the superblock and block
994 * group descriptors are going to be written during a
995 * restart, so set the superblock to be used to be the
998 ctx->use_superblock = 0;
1003 if (ctx->block_dup_map) {
1004 if (ctx->options & E2F_OPT_PREEN) {
1005 clear_problem_context(&pctx);
1006 fix_problem(ctx, PR_1_DUP_BLOCKS_PREENSTOP, &pctx);
1008 e2fsck_pass1_dupblocks(ctx, block_buf);
1010 ext2fs_free_mem(&inodes_to_process);
1012 e2fsck_use_inode_shortcuts(ctx, 0);
1014 ext2fs_free_mem(&block_buf);
1015 ext2fs_free_mem(&inode);
1017 #ifdef RESOURCE_TRACK
1018 if (ctx->options & E2F_OPT_TIME2) {
1019 e2fsck_clear_progbar(ctx);
1020 print_resource_track(_("Pass 1"), &rtrack);
1026 * When the inode_scan routines call this callback at the end of the
1027 * glock group, call process_inodes.
1029 static errcode_t scan_callback(ext2_filsys fs,
1030 ext2_inode_scan scan EXT2FS_ATTR((unused)),
1031 dgrp_t group, void * priv_data)
1033 struct scan_callback_struct *scan_struct;
1036 scan_struct = (struct scan_callback_struct *) priv_data;
1037 ctx = scan_struct->ctx;
1039 process_inodes((e2fsck_t) fs->priv_data, scan_struct->block_buf);
1042 if ((ctx->progress)(ctx, 1, group+1,
1043 ctx->fs->group_desc_count))
1044 return EXT2_ET_CANCEL_REQUESTED;
1050 * Process the inodes in the "inodes to process" list.
1052 static void process_inodes(e2fsck_t ctx, char *block_buf)
1055 struct ext2_inode *old_stashed_inode;
1056 ext2_ino_t old_stashed_ino;
1057 const char *old_operation;
1059 struct problem_context pctx;
1062 printf("begin process_inodes: ");
1064 if (process_inode_count == 0)
1066 old_operation = ehandler_operation(0);
1067 old_stashed_inode = ctx->stashed_inode;
1068 old_stashed_ino = ctx->stashed_ino;
1069 qsort(inodes_to_process, process_inode_count,
1070 sizeof(struct process_inode_block), process_inode_cmp);
1071 clear_problem_context(&pctx);
1072 for (i=0; i < process_inode_count; i++) {
1073 pctx.inode = ctx->stashed_inode = &inodes_to_process[i].inode;
1074 pctx.ino = ctx->stashed_ino = inodes_to_process[i].ino;
1077 printf("%u ", pctx.ino);
1079 sprintf(buf, _("reading indirect blocks of inode %u"),
1081 ehandler_operation(buf);
1082 check_blocks(ctx, &pctx, block_buf);
1083 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
1086 ctx->stashed_inode = old_stashed_inode;
1087 ctx->stashed_ino = old_stashed_ino;
1088 process_inode_count = 0;
1090 printf("end process inodes\n");
1092 ehandler_operation(old_operation);
1095 static EXT2_QSORT_TYPE process_inode_cmp(const void *a, const void *b)
1097 const struct process_inode_block *ib_a =
1098 (const struct process_inode_block *) a;
1099 const struct process_inode_block *ib_b =
1100 (const struct process_inode_block *) b;
1103 ret = (ib_a->inode.i_block[EXT2_IND_BLOCK] -
1104 ib_b->inode.i_block[EXT2_IND_BLOCK]);
1106 ret = ib_a->inode.i_file_acl - ib_b->inode.i_file_acl;
1111 * Mark an inode as being bad in some what
1113 static void mark_inode_bad(e2fsck_t ctx, ino_t ino)
1115 struct problem_context pctx;
1117 if (!ctx->inode_bad_map) {
1118 clear_problem_context(&pctx);
1120 pctx.errcode = ext2fs_allocate_inode_bitmap(ctx->fs,
1121 _("bad inode map"), &ctx->inode_bad_map);
1124 fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx);
1125 /* Should never get here */
1126 ctx->flags |= E2F_FLAG_ABORT;
1130 ext2fs_mark_inode_bitmap(ctx->inode_bad_map, ino);
1135 * This procedure will allocate the inode "bb" (badblock) map table
1137 static void alloc_bb_map(e2fsck_t ctx)
1139 struct problem_context pctx;
1141 clear_problem_context(&pctx);
1142 pctx.errcode = ext2fs_allocate_inode_bitmap(ctx->fs,
1143 _("inode in bad block map"),
1144 &ctx->inode_bb_map);
1147 fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx);
1148 /* Should never get here */
1149 ctx->flags |= E2F_FLAG_ABORT;
1155 * This procedure will allocate the inode imagic table
1157 static void alloc_imagic_map(e2fsck_t ctx)
1159 struct problem_context pctx;
1161 clear_problem_context(&pctx);
1162 pctx.errcode = ext2fs_allocate_inode_bitmap(ctx->fs,
1163 _("imagic inode map"),
1164 &ctx->inode_imagic_map);
1167 fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx);
1168 /* Should never get here */
1169 ctx->flags |= E2F_FLAG_ABORT;
1175 * Marks a block as in use, setting the dup_map if it's been set
1176 * already. Called by process_block and process_bad_block.
1178 * WARNING: Assumes checks have already been done to make sure block
1179 * is valid. This is true in both process_block and process_bad_block.
1181 static _INLINE_ void mark_block_used(e2fsck_t ctx, blk_t block)
1183 struct problem_context pctx;
1185 clear_problem_context(&pctx);
1187 if (ext2fs_fast_test_block_bitmap(ctx->block_found_map, block)) {
1188 if (!ctx->block_dup_map) {
1189 pctx.errcode = ext2fs_allocate_block_bitmap(ctx->fs,
1190 _("multiply claimed block map"),
1191 &ctx->block_dup_map);
1194 fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR,
1196 /* Should never get here */
1197 ctx->flags |= E2F_FLAG_ABORT;
1201 ext2fs_fast_mark_block_bitmap(ctx->block_dup_map, block);
1203 ext2fs_fast_mark_block_bitmap(ctx->block_found_map, block);
1208 * Adjust the extended attribute block's reference counts at the end
1209 * of pass 1, either by subtracting out references for EA blocks that
1210 * are still referenced in ctx->refcount, or by adding references for
1211 * EA blocks that had extra references as accounted for in
1212 * ctx->refcount_extra.
1214 static void adjust_extattr_refcount(e2fsck_t ctx, ext2_refcount_t refcount,
1215 char *block_buf, int adjust_sign)
1217 struct ext2_ext_attr_header *header;
1218 struct problem_context pctx;
1219 ext2_filsys fs = ctx->fs;
1224 clear_problem_context(&pctx);
1226 ea_refcount_intr_begin(refcount);
1228 if ((blk = ea_refcount_intr_next(refcount, &count)) == 0)
1231 pctx.errcode = ext2fs_read_ext_attr(fs, blk, block_buf);
1233 fix_problem(ctx, PR_1_EXTATTR_READ_ABORT, &pctx);
1236 header = (struct ext2_ext_attr_header *) block_buf;
1237 pctx.blkcount = header->h_refcount;
1238 should_be = header->h_refcount + adjust_sign * count;
1239 pctx.num = should_be;
1240 if (fix_problem(ctx, PR_1_EXTATTR_REFCOUNT, &pctx)) {
1241 header->h_refcount = should_be;
1242 pctx.errcode = ext2fs_write_ext_attr(fs, blk,
1245 fix_problem(ctx, PR_1_EXTATTR_WRITE, &pctx);
1253 * Handle processing the extended attribute blocks
1255 static int check_ext_attr(e2fsck_t ctx, struct problem_context *pctx,
1258 ext2_filsys fs = ctx->fs;
1259 ext2_ino_t ino = pctx->ino;
1260 struct ext2_inode *inode = pctx->inode;
1263 struct ext2_ext_attr_header *header;
1264 struct ext2_ext_attr_entry *entry;
1266 region_t region = 0;
1268 blk = inode->i_file_acl;
1273 * If the Extended attribute flag isn't set, then a non-zero
1274 * file acl means that the inode is corrupted.
1276 * Or if the extended attribute block is an invalid block,
1277 * then the inode is also corrupted.
1279 if (!(fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_EXT_ATTR) ||
1280 (blk < fs->super->s_first_data_block) ||
1281 (blk >= fs->super->s_blocks_count)) {
1282 mark_inode_bad(ctx, ino);
1286 /* If ea bitmap hasn't been allocated, create it */
1287 if (!ctx->block_ea_map) {
1288 pctx->errcode = ext2fs_allocate_block_bitmap(fs,
1289 _("ext attr block map"),
1290 &ctx->block_ea_map);
1291 if (pctx->errcode) {
1293 fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, pctx);
1294 ctx->flags |= E2F_FLAG_ABORT;
1299 /* Create the EA refcount structure if necessary */
1300 if (!ctx->refcount) {
1301 pctx->errcode = ea_refcount_create(0, &ctx->refcount);
1302 if (pctx->errcode) {
1304 fix_problem(ctx, PR_1_ALLOCATE_REFCOUNT, pctx);
1305 ctx->flags |= E2F_FLAG_ABORT;
1311 /* Debugging text */
1312 printf("Inode %u has EA block %u\n", ino, blk);
1315 /* Have we seen this EA block before? */
1316 if (ext2fs_fast_test_block_bitmap(ctx->block_ea_map, blk)) {
1317 if (ea_refcount_decrement(ctx->refcount, blk, 0) == 0)
1319 /* Ooops, this EA was referenced more than it stated */
1320 if (!ctx->refcount_extra) {
1321 pctx->errcode = ea_refcount_create(0,
1322 &ctx->refcount_extra);
1323 if (pctx->errcode) {
1325 fix_problem(ctx, PR_1_ALLOCATE_REFCOUNT, pctx);
1326 ctx->flags |= E2F_FLAG_ABORT;
1330 ea_refcount_increment(ctx->refcount_extra, blk, 0);
1335 * OK, we haven't seen this EA block yet. So we need to
1339 pctx->errcode = ext2fs_read_ext_attr(fs, blk, block_buf);
1340 if (pctx->errcode && fix_problem(ctx, PR_1_READ_EA_BLOCK, pctx))
1342 header = (struct ext2_ext_attr_header *) block_buf;
1343 pctx->blk = inode->i_file_acl;
1344 if (((ctx->ext_attr_ver == 1) &&
1345 (header->h_magic != EXT2_EXT_ATTR_MAGIC_v1)) ||
1346 ((ctx->ext_attr_ver == 2) &&
1347 (header->h_magic != EXT2_EXT_ATTR_MAGIC))) {
1348 if (fix_problem(ctx, PR_1_BAD_EA_BLOCK, pctx))
1352 if (header->h_blocks != 1) {
1353 if (fix_problem(ctx, PR_1_EA_MULTI_BLOCK, pctx))
1357 region = region_create(0, fs->blocksize);
1359 fix_problem(ctx, PR_1_EA_ALLOC_REGION, pctx);
1360 ctx->flags |= E2F_FLAG_ABORT;
1363 if (region_allocate(region, 0, sizeof(struct ext2_ext_attr_header))) {
1364 if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, pctx))
1368 entry = (struct ext2_ext_attr_entry *)(header+1);
1369 end = block_buf + fs->blocksize;
1370 while ((char *)entry < end && *(__u32 *)entry) {
1371 if (region_allocate(region, (char *)entry - (char *)header,
1372 EXT2_EXT_ATTR_LEN(entry->e_name_len))) {
1373 if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, pctx))
1376 if ((ctx->ext_attr_ver == 1 &&
1377 (entry->e_name_len == 0 || entry->e_name_index != 0)) ||
1378 (ctx->ext_attr_ver == 2 &&
1379 entry->e_name_index == 0)) {
1380 if (fix_problem(ctx, PR_1_EA_BAD_NAME, pctx))
1383 if (entry->e_value_block != 0) {
1384 if (fix_problem(ctx, PR_1_EA_BAD_VALUE, pctx))
1387 if (entry->e_value_size &&
1388 region_allocate(region, entry->e_value_offs,
1389 EXT2_EXT_ATTR_SIZE(entry->e_value_size))) {
1390 if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, pctx))
1393 entry = EXT2_EXT_ATTR_NEXT(entry);
1395 if (region_allocate(region, (char *)entry - (char *)header, 4)) {
1396 if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, pctx))
1399 region_free(region);
1401 count = header->h_refcount - 1;
1403 ea_refcount_store(ctx->refcount, blk, count);
1404 mark_block_used(ctx, blk);
1405 ext2fs_fast_mark_block_bitmap(ctx->block_ea_map, blk);
1410 region_free(region);
1411 inode->i_file_acl = 0;
1412 e2fsck_write_inode(ctx, ino, inode, "check_ext_attr");
1416 /* Returns 1 if bad htree, 0 if OK */
1417 static int handle_htree(e2fsck_t ctx, struct problem_context *pctx,
1418 ext2_ino_t ino EXT2FS_ATTR((unused)),
1419 struct ext2_inode *inode,
1422 struct ext2_dx_root_info *root;
1423 ext2_filsys fs = ctx->fs;
1427 if ((!LINUX_S_ISDIR(inode->i_mode) &&
1428 fix_problem(ctx, PR_1_HTREE_NODIR, pctx)) ||
1429 (!(fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_DIR_INDEX) &&
1430 fix_problem(ctx, PR_1_HTREE_SET, pctx)))
1433 blk = inode->i_block[0];
1435 (blk < fs->super->s_first_data_block) ||
1436 (blk >= fs->super->s_blocks_count)) &&
1437 fix_problem(ctx, PR_1_HTREE_BADROOT, pctx))
1440 retval = io_channel_read_blk(fs->io, blk, 1, block_buf);
1441 if (retval && fix_problem(ctx, PR_1_HTREE_BADROOT, pctx))
1444 /* XXX should check that beginning matches a directory */
1445 root = (struct ext2_dx_root_info *) (block_buf + 24);
1447 if ((root->reserved_zero || root->info_length < 8) &&
1448 fix_problem(ctx, PR_1_HTREE_BADROOT, pctx))
1451 pctx->num = root->hash_version;
1452 if ((root->hash_version != EXT2_HASH_LEGACY) &&
1453 (root->hash_version != EXT2_HASH_HALF_MD4) &&
1454 (root->hash_version != EXT2_HASH_TEA) &&
1455 fix_problem(ctx, PR_1_HTREE_HASHV, pctx))
1458 if ((root->unused_flags & EXT2_HASH_FLAG_INCOMPAT) &&
1459 fix_problem(ctx, PR_1_HTREE_INCOMPAT, pctx))
1462 pctx->num = root->indirect_levels;
1463 if ((root->indirect_levels > 1) &&
1464 fix_problem(ctx, PR_1_HTREE_DEPTH, pctx))
1471 * This subroutine is called on each inode to account for all of the
1472 * blocks used by that inode.
1474 static void check_blocks(e2fsck_t ctx, struct problem_context *pctx,
1477 ext2_filsys fs = ctx->fs;
1478 struct process_block_struct pb;
1479 ext2_ino_t ino = pctx->ino;
1480 struct ext2_inode *inode = pctx->inode;
1482 int dirty_inode = 0;
1488 pb.num_illegal_blocks = 0;
1489 pb.suppress = 0; pb.clear = 0;
1492 pb.previous_block = 0;
1493 pb.is_dir = LINUX_S_ISDIR(inode->i_mode);
1494 pb.is_reg = LINUX_S_ISREG(inode->i_mode);
1495 pb.max_blocks = 1 << (31 - fs->super->s_log_block_size);
1502 if (inode->i_flags & EXT2_COMPRBLK_FL) {
1503 if (fs->super->s_feature_incompat &
1504 EXT2_FEATURE_INCOMPAT_COMPRESSION)
1507 if (fix_problem(ctx, PR_1_COMPR_SET, pctx)) {
1508 inode->i_flags &= ~EXT2_COMPRBLK_FL;
1514 if (inode->i_file_acl && check_ext_attr(ctx, pctx, block_buf))
1517 if (ext2fs_inode_has_valid_blocks(inode))
1518 pctx->errcode = ext2fs_block_iterate2(fs, ino,
1519 pb.is_dir ? BLOCK_FLAG_HOLE : 0,
1520 block_buf, process_block, &pb);
1521 end_problem_latch(ctx, PR_LATCH_BLOCK);
1522 end_problem_latch(ctx, PR_LATCH_TOOBIG);
1523 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
1526 fix_problem(ctx, PR_1_BLOCK_ITERATE, pctx);
1528 if (pb.fragmented && pb.num_blocks < fs->super->s_blocks_per_group)
1529 ctx->fs_fragmented++;
1532 inode->i_links_count = 0;
1533 ext2fs_icount_store(ctx->inode_link_info, ino, 0);
1534 inode->i_dtime = ctx->now;
1536 ext2fs_unmark_inode_bitmap(ctx->inode_dir_map, ino);
1537 ext2fs_unmark_inode_bitmap(ctx->inode_reg_map, ino);
1538 ext2fs_unmark_inode_bitmap(ctx->inode_used_map, ino);
1540 * The inode was probably partially accounted for
1541 * before processing was aborted, so we need to
1542 * restart the pass 1 scan.
1544 ctx->flags |= E2F_FLAG_RESTART;
1548 if (inode->i_flags & EXT2_INDEX_FL) {
1549 if (handle_htree(ctx, pctx, ino, inode, block_buf)) {
1550 inode->i_flags &= ~EXT2_INDEX_FL;
1554 e2fsck_add_dx_dir(ctx, ino, pb.last_block+1);
1558 if (ctx->dirs_to_hash && pb.is_dir &&
1559 !(inode->i_flags & EXT2_INDEX_FL) &&
1560 ((inode->i_size / fs->blocksize) >= 3))
1561 ext2fs_u32_list_add(ctx->dirs_to_hash, ino);
1563 if (!pb.num_blocks && pb.is_dir) {
1564 if (fix_problem(ctx, PR_1_ZERO_LENGTH_DIR, pctx)) {
1565 inode->i_links_count = 0;
1566 ext2fs_icount_store(ctx->inode_link_info, ino, 0);
1567 inode->i_dtime = ctx->now;
1569 ext2fs_unmark_inode_bitmap(ctx->inode_dir_map, ino);
1570 ext2fs_unmark_inode_bitmap(ctx->inode_reg_map, ino);
1571 ext2fs_unmark_inode_bitmap(ctx->inode_used_map, ino);
1572 ctx->fs_directory_count--;
1577 pb.num_blocks *= (fs->blocksize / 512);
1579 printf("inode %u, i_size = %lu, last_block = %lld, i_blocks=%lu, num_blocks = %lu\n",
1580 ino, inode->i_size, pb.last_block, inode->i_blocks,
1584 int nblock = inode->i_size >> EXT2_BLOCK_SIZE_BITS(fs->super);
1585 if (nblock > (pb.last_block + 1))
1587 else if (nblock < (pb.last_block + 1)) {
1588 if (((pb.last_block + 1) - nblock) >
1589 fs->super->s_prealloc_dir_blocks)
1593 size = EXT2_I_SIZE(inode);
1594 if ((pb.last_block >= 0) &&
1595 (size < (__u64) pb.last_block * fs->blocksize))
1597 else if (size > ext2_max_sizes[fs->super->s_log_block_size])
1600 /* i_size for symlinks is checked elsewhere */
1601 if (bad_size && !LINUX_S_ISLNK(inode->i_mode)) {
1602 pctx->num = (pb.last_block+1) * fs->blocksize;
1603 if (fix_problem(ctx, PR_1_BAD_I_SIZE, pctx)) {
1604 inode->i_size = pctx->num;
1605 if (!LINUX_S_ISDIR(inode->i_mode))
1606 inode->i_size_high = pctx->num >> 32;
1611 if (LINUX_S_ISREG(inode->i_mode) &&
1612 (inode->i_size_high || inode->i_size & 0x80000000UL))
1614 if (pb.num_blocks != inode->i_blocks) {
1615 pctx->num = pb.num_blocks;
1616 if (fix_problem(ctx, PR_1_BAD_I_BLOCKS, pctx)) {
1617 inode->i_blocks = pb.num_blocks;
1624 e2fsck_write_inode(ctx, ino, inode, "check_blocks");
1629 * Helper function called by process block when an illegal block is
1630 * found. It returns a description about why the block is illegal
1632 static char *describe_illegal_block(ext2_filsys fs, blk_t block)
1636 static char problem[80];
1638 super = fs->super->s_first_data_block;
1639 strcpy(problem, "PROGRAMMING ERROR: Unknown reason for illegal block");
1640 if (block < super) {
1641 sprintf(problem, "< FIRSTBLOCK (%u)", super);
1643 } else if (block >= fs->super->s_blocks_count) {
1644 sprintf(problem, "> BLOCKS (%u)", fs->super->s_blocks_count);
1647 for (i = 0; i < fs->group_desc_count; i++) {
1648 if (block == super) {
1649 sprintf(problem, "is the superblock in group %d", i);
1652 if (block > super &&
1653 block <= (super + fs->desc_blocks)) {
1654 sprintf(problem, "is in the group descriptors "
1658 if (block == fs->group_desc[i].bg_block_bitmap) {
1659 sprintf(problem, "is the block bitmap of group %d", i);
1662 if (block == fs->group_desc[i].bg_inode_bitmap) {
1663 sprintf(problem, "is the inode bitmap of group %d", i);
1666 if (block >= fs->group_desc[i].bg_inode_table &&
1667 (block < fs->group_desc[i].bg_inode_table
1668 + fs->inode_blocks_per_group)) {
1669 sprintf(problem, "is in the inode table of group %d",
1673 super += fs->super->s_blocks_per_group;
1680 * This is a helper function for check_blocks().
1682 static int process_block(ext2_filsys fs,
1684 e2_blkcnt_t blockcnt,
1685 blk_t ref_block EXT2FS_ATTR((unused)),
1686 int ref_offset EXT2FS_ATTR((unused)),
1689 struct process_block_struct *p;
1690 struct problem_context *pctx;
1691 blk_t blk = *block_nr;
1696 p = (struct process_block_struct *) priv_data;
1700 if (p->compressed && (blk == EXT2FS_COMPRESSED_BLKADDR)) {
1701 /* todo: Check that the comprblk_fl is high, that the
1702 blkaddr pattern looks right (all non-holes up to
1703 first EXT2FS_COMPRESSED_BLKADDR, then all
1704 EXT2FS_COMPRESSED_BLKADDR up to end of cluster),
1705 that the feature_incompat bit is high, and that the
1706 inode is a regular file. If we're doing a "full
1707 check" (a concept introduced to e2fsck by e2compr,
1708 meaning that we look at data blocks as well as
1709 metadata) then call some library routine that
1710 checks the compressed data. I'll have to think
1711 about this, because one particularly important
1712 problem to be able to fix is to recalculate the
1713 cluster size if necessary. I think that perhaps
1714 we'd better do most/all e2compr-specific checks
1715 separately, after the non-e2compr checks. If not
1716 doing a full check, it may be useful to test that
1717 the personality is linux; e.g. if it isn't then
1718 perhaps this really is just an illegal block. */
1723 if (p->is_dir == 0) {
1725 * Should never happen, since only directories
1726 * get called with BLOCK_FLAG_HOLE
1729 printf("process_block() called with blk == 0, "
1730 "blockcnt=%d, inode %lu???\n",
1737 if (blockcnt * fs->blocksize < p->inode->i_size) {
1739 printf("Missing block (#%d) in directory inode %lu!\n",
1748 printf("Process_block, inode %lu, block %u, #%d\n", p->ino, blk,
1753 * Simplistic fragmentation check. We merely require that the
1754 * file be contiguous. (Which can never be true for really
1755 * big files that are greater than a block group.)
1757 if (!HOLE_BLKADDR(p->previous_block)) {
1758 if (p->previous_block+1 != blk)
1761 p->previous_block = blk;
1763 if (p->is_dir && blockcnt > (1 << (21 - fs->super->s_log_block_size)))
1764 problem = PR_1_TOOBIG_DIR;
1765 if (p->is_reg && p->num_blocks+1 >= p->max_blocks)
1766 problem = PR_1_TOOBIG_REG;
1767 if (!p->is_dir && !p->is_reg && blockcnt > 0)
1768 problem = PR_1_TOOBIG_SYMLINK;
1770 if (blk < fs->super->s_first_data_block ||
1771 blk >= fs->super->s_blocks_count)
1772 problem = PR_1_ILLEGAL_BLOCK_NUM;
1775 p->num_illegal_blocks++;
1776 if (!p->suppress && (p->num_illegal_blocks % 12) == 0) {
1777 if (fix_problem(ctx, PR_1_TOO_MANY_BAD_BLOCKS, pctx)) {
1781 if (fix_problem(ctx, PR_1_SUPPRESS_MESSAGES, pctx)) {
1783 set_latch_flags(PR_LATCH_BLOCK,
1788 pctx->blkcount = blockcnt;
1789 if (fix_problem(ctx, problem, pctx)) {
1790 blk = *block_nr = 0;
1791 ret_code = BLOCK_CHANGED;
1797 if (p->ino == EXT2_RESIZE_INO) {
1799 * The resize inode has already be sanity checked
1800 * during pass #0 (the superblock checks). All we
1801 * have to do is mark the double indirect block as
1802 * being in use; all of the other blocks are handled
1803 * by mark_table_blocks()).
1805 if (blockcnt == BLOCK_COUNT_DIND)
1806 mark_block_used(ctx, blk);
1808 mark_block_used(ctx, blk);
1811 p->last_block = blockcnt;
1813 if (p->is_dir && (blockcnt >= 0)) {
1814 pctx->errcode = ext2fs_add_dir_block(fs->dblist, p->ino,
1816 if (pctx->errcode) {
1818 pctx->num = blockcnt;
1819 fix_problem(ctx, PR_1_ADD_DBLOCK, pctx);
1820 /* Should never get here */
1821 ctx->flags |= E2F_FLAG_ABORT;
1828 static int process_bad_block(ext2_filsys fs,
1830 e2_blkcnt_t blockcnt,
1831 blk_t ref_block EXT2FS_ATTR((unused)),
1832 int ref_offset EXT2FS_ATTR((unused)),
1835 struct process_block_struct *p;
1836 blk_t blk = *block_nr;
1839 struct problem_context *pctx;
1843 * Note: This function processes blocks for the bad blocks
1844 * inode, which is never compressed. So we don't use HOLE_BLKADDR().
1850 p = (struct process_block_struct *) priv_data;
1854 pctx->ino = EXT2_BAD_INO;
1856 pctx->blkcount = blockcnt;
1858 if ((blk < fs->super->s_first_data_block) ||
1859 (blk >= fs->super->s_blocks_count)) {
1860 if (fix_problem(ctx, PR_1_BB_ILLEGAL_BLOCK_NUM, pctx)) {
1862 return BLOCK_CHANGED;
1868 if (ext2fs_test_block_bitmap(p->fs_meta_blocks, blk)) {
1870 if (fix_problem(ctx, PR_1_BB_FS_BLOCK, pctx)) {
1872 return BLOCK_CHANGED;
1874 } else if (ext2fs_test_block_bitmap(ctx->block_found_map,
1877 if (fix_problem(ctx, PR_1_BBINODE_BAD_METABLOCK,
1880 return BLOCK_CHANGED;
1882 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
1885 mark_block_used(ctx, blk);
1889 printf ("DEBUG: Marking %u as bad.\n", blk);
1891 ctx->fs_badblocks_count++;
1893 * If the block is not used, then mark it as used and return.
1894 * If it is already marked as found, this must mean that
1895 * there's an overlap between the filesystem table blocks
1896 * (bitmaps and inode table) and the bad block list.
1898 if (!ext2fs_test_block_bitmap(ctx->block_found_map, blk)) {
1899 ext2fs_mark_block_bitmap(ctx->block_found_map, blk);
1903 * Try to find the where the filesystem block was used...
1905 first_block = fs->super->s_first_data_block;
1907 for (i = 0; i < fs->group_desc_count; i++ ) {
1910 if (!ext2fs_bg_has_super(fs, i))
1912 if (blk == first_block) {
1914 if (fix_problem(ctx,
1915 PR_1_BAD_PRIMARY_SUPERBLOCK,
1918 return BLOCK_CHANGED;
1922 fix_problem(ctx, PR_1_BAD_SUPERBLOCK, pctx);
1925 if ((blk > first_block) &&
1926 (blk <= first_block + fs->desc_blocks)) {
1928 pctx->blk = *block_nr;
1929 if (fix_problem(ctx,
1930 PR_1_BAD_PRIMARY_GROUP_DESCRIPTOR, pctx)) {
1932 return BLOCK_CHANGED;
1936 fix_problem(ctx, PR_1_BAD_GROUP_DESCRIPTORS, pctx);
1940 if (blk == fs->group_desc[i].bg_block_bitmap) {
1941 if (fix_problem(ctx, PR_1_BB_BAD_BLOCK, pctx)) {
1942 ctx->invalid_block_bitmap_flag[i]++;
1943 ctx->invalid_bitmaps++;
1947 if (blk == fs->group_desc[i].bg_inode_bitmap) {
1948 if (fix_problem(ctx, PR_1_IB_BAD_BLOCK, pctx)) {
1949 ctx->invalid_inode_bitmap_flag[i]++;
1950 ctx->invalid_bitmaps++;
1954 if ((blk >= fs->group_desc[i].bg_inode_table) &&
1955 (blk < (fs->group_desc[i].bg_inode_table +
1956 fs->inode_blocks_per_group))) {
1958 * If there are bad blocks in the inode table,
1959 * the inode scan code will try to do
1960 * something reasonable automatically.
1964 first_block += fs->super->s_blocks_per_group;
1967 * If we've gotten to this point, then the only
1968 * possibility is that the bad block inode meta data
1969 * is using a bad block.
1971 if ((blk == p->inode->i_block[EXT2_IND_BLOCK]) ||
1972 (blk == p->inode->i_block[EXT2_DIND_BLOCK]) ||
1973 (blk == p->inode->i_block[EXT2_TIND_BLOCK])) {
1975 if (fix_problem(ctx, PR_1_BBINODE_BAD_METABLOCK, pctx)) {
1977 return BLOCK_CHANGED;
1979 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
1986 /* Warn user that the block wasn't claimed */
1987 fix_problem(ctx, PR_1_PROGERR_CLAIMED_BLOCK, pctx);
1992 static void new_table_block(e2fsck_t ctx, blk_t first_block, int group,
1993 const char *name, int num, blk_t *new_block)
1995 ext2_filsys fs = ctx->fs;
1996 blk_t old_block = *new_block;
2000 struct problem_context pctx;
2002 clear_problem_context(&pctx);
2005 pctx.blk = old_block;
2008 last_block = ext2fs_group_last_block(fs, group);
2009 pctx.errcode = ext2fs_get_free_blocks(fs, first_block, last_block,
2010 num, ctx->block_found_map, new_block);
2013 fix_problem(ctx, PR_1_RELOC_BLOCK_ALLOCATE, &pctx);
2014 ext2fs_unmark_valid(fs);
2017 pctx.errcode = ext2fs_get_mem(fs->blocksize, &buf);
2019 fix_problem(ctx, PR_1_RELOC_MEMORY_ALLOCATE, &pctx);
2020 ext2fs_unmark_valid(fs);
2023 ext2fs_mark_super_dirty(fs);
2024 fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY;
2025 pctx.blk2 = *new_block;
2026 fix_problem(ctx, (old_block ? PR_1_RELOC_FROM_TO :
2027 PR_1_RELOC_TO), &pctx);
2029 for (i = 0; i < num; i++) {
2031 ext2fs_mark_block_bitmap(ctx->block_found_map, (*new_block)+i);
2033 pctx.errcode = io_channel_read_blk(fs->io,
2034 old_block + i, 1, buf);
2036 fix_problem(ctx, PR_1_RELOC_READ_ERR, &pctx);
2038 memset(buf, 0, fs->blocksize);
2040 pctx.blk = (*new_block) + i;
2041 pctx.errcode = io_channel_write_blk(fs->io, pctx.blk,
2044 fix_problem(ctx, PR_1_RELOC_WRITE_ERR, &pctx);
2046 ext2fs_free_mem(&buf);
2050 * This routine gets called at the end of pass 1 if bad blocks are
2051 * detected in the superblock, group descriptors, inode_bitmaps, or
2052 * block bitmaps. At this point, all of the blocks have been mapped
2053 * out, so we can try to allocate new block(s) to replace the bad
2056 static void handle_fs_bad_blocks(e2fsck_t ctx)
2058 ext2_filsys fs = ctx->fs;
2062 for (i = 0; i < fs->group_desc_count; i++) {
2063 first_block = ext2fs_group_first_block(fs, i);
2065 if (ctx->invalid_block_bitmap_flag[i]) {
2066 new_table_block(ctx, first_block, i, _("block bitmap"),
2067 1, &fs->group_desc[i].bg_block_bitmap);
2069 if (ctx->invalid_inode_bitmap_flag[i]) {
2070 new_table_block(ctx, first_block, i, _("inode bitmap"),
2071 1, &fs->group_desc[i].bg_inode_bitmap);
2073 if (ctx->invalid_inode_table_flag[i]) {
2074 new_table_block(ctx, first_block, i, _("inode table"),
2075 fs->inode_blocks_per_group,
2076 &fs->group_desc[i].bg_inode_table);
2077 ctx->flags |= E2F_FLAG_RESTART;
2080 ctx->invalid_bitmaps = 0;
2084 * This routine marks all blocks which are used by the superblock,
2085 * group descriptors, inode bitmaps, and block bitmaps.
2087 static void mark_table_blocks(e2fsck_t ctx)
2089 ext2_filsys fs = ctx->fs;
2093 struct problem_context pctx;
2095 clear_problem_context(&pctx);
2097 for (i = 0; i < fs->group_desc_count; i++) {
2100 ext2fs_reserve_super_and_bgd(fs, i, ctx->block_found_map);
2103 * Mark the blocks used for the inode table
2105 if (fs->group_desc[i].bg_inode_table) {
2106 for (j = 0, b = fs->group_desc[i].bg_inode_table;
2107 j < fs->inode_blocks_per_group;
2109 if (ext2fs_test_block_bitmap(ctx->block_found_map,
2112 if (fix_problem(ctx,
2113 PR_1_ITABLE_CONFLICT, &pctx)) {
2114 ctx->invalid_inode_table_flag[i]++;
2115 ctx->invalid_bitmaps++;
2118 ext2fs_mark_block_bitmap(ctx->block_found_map,
2125 * Mark block used for the block bitmap
2127 if (fs->group_desc[i].bg_block_bitmap) {
2128 if (ext2fs_test_block_bitmap(ctx->block_found_map,
2129 fs->group_desc[i].bg_block_bitmap)) {
2130 pctx.blk = fs->group_desc[i].bg_block_bitmap;
2131 if (fix_problem(ctx, PR_1_BB_CONFLICT, &pctx)) {
2132 ctx->invalid_block_bitmap_flag[i]++;
2133 ctx->invalid_bitmaps++;
2136 ext2fs_mark_block_bitmap(ctx->block_found_map,
2137 fs->group_desc[i].bg_block_bitmap);
2142 * Mark block used for the inode bitmap
2144 if (fs->group_desc[i].bg_inode_bitmap) {
2145 if (ext2fs_test_block_bitmap(ctx->block_found_map,
2146 fs->group_desc[i].bg_inode_bitmap)) {
2147 pctx.blk = fs->group_desc[i].bg_inode_bitmap;
2148 if (fix_problem(ctx, PR_1_IB_CONFLICT, &pctx)) {
2149 ctx->invalid_inode_bitmap_flag[i]++;
2150 ctx->invalid_bitmaps++;
2153 ext2fs_mark_block_bitmap(ctx->block_found_map,
2154 fs->group_desc[i].bg_inode_bitmap);
2161 * Thes subroutines short circuits ext2fs_get_blocks and
2162 * ext2fs_check_directory; we use them since we already have the inode
2163 * structure, so there's no point in letting the ext2fs library read
2166 static errcode_t pass1_get_blocks(ext2_filsys fs, ext2_ino_t ino,
2169 e2fsck_t ctx = (e2fsck_t) fs->priv_data;
2172 if ((ino != ctx->stashed_ino) || !ctx->stashed_inode)
2173 return EXT2_ET_CALLBACK_NOTHANDLED;
2175 for (i=0; i < EXT2_N_BLOCKS; i++)
2176 blocks[i] = ctx->stashed_inode->i_block[i];
2180 static errcode_t pass1_read_inode(ext2_filsys fs, ext2_ino_t ino,
2181 struct ext2_inode *inode)
2183 e2fsck_t ctx = (e2fsck_t) fs->priv_data;
2185 if ((ino != ctx->stashed_ino) || !ctx->stashed_inode)
2186 return EXT2_ET_CALLBACK_NOTHANDLED;
2187 *inode = *ctx->stashed_inode;
2191 static errcode_t pass1_write_inode(ext2_filsys fs, ext2_ino_t ino,
2192 struct ext2_inode *inode)
2194 e2fsck_t ctx = (e2fsck_t) fs->priv_data;
2196 if ((ino == ctx->stashed_ino) && ctx->stashed_inode &&
2197 (inode != ctx->stashed_inode))
2198 *ctx->stashed_inode = *inode;
2199 return EXT2_ET_CALLBACK_NOTHANDLED;
2202 static errcode_t pass1_check_directory(ext2_filsys fs, ext2_ino_t ino)
2204 e2fsck_t ctx = (e2fsck_t) fs->priv_data;
2206 if ((ino != ctx->stashed_ino) || !ctx->stashed_inode)
2207 return EXT2_ET_CALLBACK_NOTHANDLED;
2209 if (!LINUX_S_ISDIR(ctx->stashed_inode->i_mode))
2210 return EXT2_ET_NO_DIRECTORY;
2214 void e2fsck_use_inode_shortcuts(e2fsck_t ctx, int bool)
2216 ext2_filsys fs = ctx->fs;
2219 fs->get_blocks = pass1_get_blocks;
2220 fs->check_directory = pass1_check_directory;
2221 fs->read_inode = pass1_read_inode;
2222 fs->write_inode = pass1_write_inode;
2223 ctx->stashed_ino = 0;
2226 fs->check_directory = 0;
2228 fs->write_inode = 0;