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 EXT2FS_ATTR((unused)),
132 struct ext2_inode *inode)
137 * If the index flag is set, then this is a bogus
140 if (inode->i_flags & EXT2_INDEX_FL)
144 * We should be able to do the test below all the time, but
145 * because the kernel doesn't forcibly clear the device
146 * inode's additional i_block fields, there are some rare
147 * occasions when a legitimate device inode will have non-zero
148 * additional i_block fields. So for now, we only complain
149 * when the immutable flag is set, which should never happen
150 * for devices. (And that's when the problem is caused, since
151 * you can't set or clear immutable flags for devices.) Once
152 * the kernel has been fixed we can change this...
154 if (inode->i_flags & (EXT2_IMMUTABLE_FL | EXT2_APPEND_FL)) {
155 for (i=4; i < EXT2_N_BLOCKS; i++)
156 if (inode->i_block[i])
163 * Check to make sure a symlink inode is real. Returns 1 if the symlink
164 * checks out, 0 if not.
166 int e2fsck_pass1_check_symlink(ext2_filsys fs, ext2_ino_t ino,
167 struct ext2_inode *inode, char *buf)
172 ext2_extent_handle_t handle;
173 struct ext2_extent_info info;
174 struct ext2fs_extent extent;
176 if ((inode->i_size_high || inode->i_size == 0) ||
177 (inode->i_flags & EXT2_INDEX_FL))
180 if (inode->i_flags & EXT4_EXTENTS_FL) {
181 if (inode->i_size > fs->blocksize)
183 if (ext2fs_extent_open2(fs, ino, inode, &handle))
186 if (ext2fs_extent_get_info(handle, &info) ||
187 (info.num_entries != 1) ||
188 (info.max_depth != 0))
190 if (ext2fs_extent_get(handle, EXT2_EXTENT_ROOT, &extent) ||
191 (extent.e_lblk != 0) ||
192 (extent.e_len != 1) ||
193 (extent.e_pblk < fs->super->s_first_data_block) ||
194 (extent.e_pblk >= fs->super->s_blocks_count))
198 ext2fs_extent_free(handle);
202 blocks = ext2fs_inode_data_blocks(fs, inode);
204 if ((inode->i_size >= fs->blocksize) ||
205 (blocks != fs->blocksize >> 9) ||
206 (inode->i_block[0] < fs->super->s_first_data_block) ||
207 (inode->i_block[0] >= fs->super->s_blocks_count))
210 for (i = 1; i < EXT2_N_BLOCKS; i++)
211 if (inode->i_block[i])
214 if (io_channel_read_blk64(fs->io, inode->i_block[0], 1, buf))
217 len = strnlen(buf, fs->blocksize);
218 if (len == fs->blocksize)
221 if (inode->i_size >= sizeof(inode->i_block))
224 len = strnlen((char *)inode->i_block, sizeof(inode->i_block));
225 if (len == sizeof(inode->i_block))
228 if (len != inode->i_size)
234 * If the immutable (or append-only) flag is set on the inode, offer
237 #define BAD_SPECIAL_FLAGS (EXT2_IMMUTABLE_FL | EXT2_APPEND_FL)
238 static void check_immutable(e2fsck_t ctx, struct problem_context *pctx)
240 if (!(pctx->inode->i_flags & BAD_SPECIAL_FLAGS))
243 if (!fix_problem(ctx, PR_1_SET_IMMUTABLE, pctx))
246 pctx->inode->i_flags &= ~BAD_SPECIAL_FLAGS;
247 e2fsck_write_inode(ctx, pctx->ino, pctx->inode, "pass1");
251 * If device, fifo or socket, check size is zero -- if not offer to
254 static void check_size(e2fsck_t ctx, struct problem_context *pctx)
256 struct ext2_inode *inode = pctx->inode;
258 if ((inode->i_size == 0) && (inode->i_size_high == 0))
261 if (!fix_problem(ctx, PR_1_SET_NONZSIZE, pctx))
265 inode->i_size_high = 0;
266 e2fsck_write_inode(ctx, pctx->ino, pctx->inode, "pass1");
269 static void check_ea_in_inode(e2fsck_t ctx, struct problem_context *pctx)
271 struct ext2_super_block *sb = ctx->fs->super;
272 struct ext2_inode_large *inode;
273 struct ext2_ext_attr_entry *entry;
275 unsigned int storage_size, remain;
278 inode = (struct ext2_inode_large *) pctx->inode;
279 storage_size = EXT2_INODE_SIZE(ctx->fs->super) - EXT2_GOOD_OLD_INODE_SIZE -
280 inode->i_extra_isize;
281 start = ((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE +
282 inode->i_extra_isize + sizeof(__u32);
283 end = (char *) inode + EXT2_INODE_SIZE(ctx->fs->super);
284 entry = (struct ext2_ext_attr_entry *) start;
286 /* scan all entry's headers first */
288 /* take finish entry 0UL into account */
289 remain = storage_size - sizeof(__u32);
291 while (!EXT2_EXT_IS_LAST_ENTRY(entry)) {
294 /* header eats this space */
295 remain -= sizeof(struct ext2_ext_attr_entry);
297 /* is attribute name valid? */
298 if (EXT2_EXT_ATTR_SIZE(entry->e_name_len) > remain) {
299 pctx->num = entry->e_name_len;
300 problem = PR_1_ATTR_NAME_LEN;
304 /* attribute len eats this space */
305 remain -= EXT2_EXT_ATTR_SIZE(entry->e_name_len);
307 /* check value size */
308 if (entry->e_value_size == 0 || entry->e_value_size > remain) {
309 pctx->num = entry->e_value_size;
310 problem = PR_1_ATTR_VALUE_SIZE;
314 /* e_value_block must be 0 in inode's ea */
315 if (entry->e_value_block != 0) {
316 pctx->num = entry->e_value_block;
317 problem = PR_1_ATTR_VALUE_BLOCK;
321 hash = ext2fs_ext_attr_hash_entry(entry,
322 start + entry->e_value_offs);
324 /* e_hash may be 0 in older inode's ea */
325 if (entry->e_hash != 0 && entry->e_hash != hash) {
326 pctx->num = entry->e_hash;
327 problem = PR_1_ATTR_HASH;
331 remain -= entry->e_value_size;
333 entry = EXT2_EXT_ATTR_NEXT(entry);
337 * it seems like a corruption. it's very unlikely we could repair
338 * EA(s) in automatic fashion -bzzz
340 if (problem == 0 || !fix_problem(ctx, problem, pctx))
343 /* simply remove all possible EA(s) */
344 *((__u32 *)start) = 0UL;
345 e2fsck_write_inode_full(ctx, pctx->ino, pctx->inode,
346 EXT2_INODE_SIZE(sb), "pass1");
349 static void check_inode_extra_space(e2fsck_t ctx, struct problem_context *pctx)
351 struct ext2_super_block *sb = ctx->fs->super;
352 struct ext2_inode_large *inode;
356 inode = (struct ext2_inode_large *) pctx->inode;
357 if (EXT2_INODE_SIZE(sb) == EXT2_GOOD_OLD_INODE_SIZE) {
358 /* this isn't large inode. so, nothing to check */
363 printf("inode #%u, i_extra_size %d\n", pctx->ino,
364 inode->i_extra_isize);
366 /* i_extra_isize must cover i_extra_isize + i_pad1 at least */
367 min = sizeof(inode->i_extra_isize) + sizeof(inode->i_pad1);
368 max = EXT2_INODE_SIZE(sb) - EXT2_GOOD_OLD_INODE_SIZE;
370 * For now we will allow i_extra_isize to be 0, but really
371 * implementations should never allow i_extra_isize to be 0
373 if (inode->i_extra_isize &&
374 (inode->i_extra_isize < min || inode->i_extra_isize > max)) {
375 if (!fix_problem(ctx, PR_1_EXTRA_ISIZE, pctx))
377 inode->i_extra_isize = min;
378 e2fsck_write_inode_full(ctx, pctx->ino, pctx->inode,
379 EXT2_INODE_SIZE(sb), "pass1");
383 eamagic = (__u32 *) (((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE +
384 inode->i_extra_isize);
385 if (*eamagic == EXT2_EXT_ATTR_MAGIC) {
386 /* it seems inode has an extended attribute(s) in body */
387 check_ea_in_inode(ctx, pctx);
392 * Check to see if the inode might really be a directory, despite i_mode
394 * This is a lot of complexity for something for which I'm not really
395 * convinced happens frequently in the wild. If for any reason this
396 * causes any problems, take this code out.
397 * [tytso:20070331.0827EDT]
399 static void check_is_really_dir(e2fsck_t ctx, struct problem_context *pctx,
402 struct ext2_inode *inode = pctx->inode;
403 struct ext2_dir_entry *dirent;
407 unsigned int i, rec_len, not_device = 0;
409 if (LINUX_S_ISDIR(inode->i_mode) || LINUX_S_ISREG(inode->i_mode) ||
410 LINUX_S_ISLNK(inode->i_mode) || inode->i_block[0] == 0)
413 for (i=0; i < EXT2_N_BLOCKS; i++) {
414 blk = inode->i_block[i];
420 if (blk < ctx->fs->super->s_first_data_block ||
421 blk >= ctx->fs->super->s_blocks_count ||
422 ext2fs_fast_test_block_bitmap2(ctx->block_found_map, blk))
423 return; /* Invalid block, can't be dir */
426 if ((LINUX_S_ISCHR(inode->i_mode) || LINUX_S_ISBLK(inode->i_mode)) &&
427 (inode->i_links_count == 1) && !not_device)
430 old_op = ehandler_operation(_("reading directory block"));
431 retval = ext2fs_read_dir_block(ctx->fs, inode->i_block[0], buf);
432 ehandler_operation(0);
436 dirent = (struct ext2_dir_entry *) buf;
437 retval = ext2fs_get_rec_len(ctx->fs, dirent, &rec_len);
440 if (((dirent->name_len & 0xFF) != 1) ||
441 (dirent->name[0] != '.') ||
442 (dirent->inode != pctx->ino) ||
445 (rec_len >= ctx->fs->blocksize - 12))
448 dirent = (struct ext2_dir_entry *) (buf + rec_len);
449 retval = ext2fs_get_rec_len(ctx->fs, dirent, &rec_len);
452 if (((dirent->name_len & 0xFF) != 2) ||
453 (dirent->name[0] != '.') ||
454 (dirent->name[1] != '.') ||
459 if (fix_problem(ctx, PR_1_TREAT_AS_DIRECTORY, pctx)) {
460 inode->i_mode = (inode->i_mode & 07777) | LINUX_S_IFDIR;
461 e2fsck_write_inode_full(ctx, pctx->ino, inode,
462 EXT2_INODE_SIZE(ctx->fs->super),
463 "check_is_really_dir");
467 extern void e2fsck_setup_tdb_icount(e2fsck_t ctx, int flags,
470 unsigned int threshold;
478 profile_get_string(ctx->profile, "scratch_files", "directory", 0, 0,
480 profile_get_uint(ctx->profile, "scratch_files",
481 "numdirs_threshold", 0, 0, &threshold);
482 profile_get_boolean(ctx->profile, "scratch_files",
483 "icount", 0, 1, &enable);
485 retval = ext2fs_get_num_dirs(ctx->fs, &num_dirs);
487 num_dirs = 1024; /* Guess */
489 if (!enable || !tdb_dir || access(tdb_dir, W_OK) ||
490 (threshold && num_dirs <= threshold))
493 retval = ext2fs_create_icount_tdb(ctx->fs, tdb_dir, flags, ret);
498 void e2fsck_pass1(e2fsck_t ctx)
502 ext2_filsys fs = ctx->fs;
504 struct ext2_inode *inode;
505 ext2_inode_scan scan;
507 #ifdef RESOURCE_TRACK
508 struct resource_track rtrack;
510 unsigned char frag, fsize;
511 struct problem_context pctx;
512 struct scan_callback_struct scan_struct;
513 struct ext2_super_block *sb = ctx->fs->super;
515 int imagic_fs, extent_fs;
516 int busted_fs_time = 0;
519 init_resource_track(&rtrack, ctx->fs->io);
520 clear_problem_context(&pctx);
522 if (!(ctx->options & E2F_OPT_PREEN))
523 fix_problem(ctx, PR_1_PASS_HEADER, &pctx);
525 if ((fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_DIR_INDEX) &&
526 !(ctx->options & E2F_OPT_NO)) {
527 if (ext2fs_u32_list_create(&ctx->dirs_to_hash, 50))
528 ctx->dirs_to_hash = 0;
532 mtrace_print("Pass 1");
535 #define EXT2_BPP(bits) (1ULL << ((bits) - 2))
537 for (i = EXT2_MIN_BLOCK_LOG_SIZE; i <= EXT2_MAX_BLOCK_LOG_SIZE; i++) {
538 max_sizes = EXT2_NDIR_BLOCKS + EXT2_BPP(i);
539 max_sizes = max_sizes + EXT2_BPP(i) * EXT2_BPP(i);
540 max_sizes = max_sizes + EXT2_BPP(i) * EXT2_BPP(i) * EXT2_BPP(i);
541 max_sizes = (max_sizes * (1UL << i)) - 1;
542 ext2_max_sizes[i - EXT2_MIN_BLOCK_LOG_SIZE] = max_sizes;
546 imagic_fs = (sb->s_feature_compat & EXT2_FEATURE_COMPAT_IMAGIC_INODES);
547 extent_fs = (sb->s_feature_incompat & EXT3_FEATURE_INCOMPAT_EXTENTS);
550 * Allocate bitmaps structures
552 pctx.errcode = ext2fs_allocate_inode_bitmap(fs, _("in-use inode map"),
553 &ctx->inode_used_map);
556 fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx);
557 ctx->flags |= E2F_FLAG_ABORT;
560 pctx.errcode = ext2fs_allocate_inode_bitmap(fs,
561 _("directory inode map"), &ctx->inode_dir_map);
564 fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx);
565 ctx->flags |= E2F_FLAG_ABORT;
568 pctx.errcode = ext2fs_allocate_inode_bitmap(fs,
569 _("regular file inode map"), &ctx->inode_reg_map);
572 fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx);
573 ctx->flags |= E2F_FLAG_ABORT;
576 pctx.errcode = ext2fs_allocate_block_bitmap(fs, _("in-use block map"),
577 &ctx->block_found_map);
580 fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, &pctx);
581 ctx->flags |= E2F_FLAG_ABORT;
584 e2fsck_setup_tdb_icount(ctx, 0, &ctx->inode_link_info);
585 if (!ctx->inode_link_info)
586 pctx.errcode = ext2fs_create_icount2(fs, 0, 0, 0,
587 &ctx->inode_link_info);
589 fix_problem(ctx, PR_1_ALLOCATE_ICOUNT, &pctx);
590 ctx->flags |= E2F_FLAG_ABORT;
593 inode_size = EXT2_INODE_SIZE(fs->super);
594 inode = (struct ext2_inode *)
595 e2fsck_allocate_memory(ctx, inode_size, "scratch inode");
597 inodes_to_process = (struct process_inode_block *)
598 e2fsck_allocate_memory(ctx,
599 (ctx->process_inode_size *
600 sizeof(struct process_inode_block)),
601 "array of inodes to process");
602 process_inode_count = 0;
604 pctx.errcode = ext2fs_init_dblist(fs, 0);
606 fix_problem(ctx, PR_1_ALLOCATE_DBCOUNT, &pctx);
607 ctx->flags |= E2F_FLAG_ABORT;
608 ext2fs_free_mem(&inode);
613 * If the last orphan field is set, clear it, since the pass1
614 * processing will automatically find and clear the orphans.
615 * In the future, we may want to try using the last_orphan
616 * linked list ourselves, but for now, we clear it so that the
617 * ext3 mount code won't get confused.
619 if (!(ctx->options & E2F_OPT_READONLY)) {
620 if (fs->super->s_last_orphan) {
621 fs->super->s_last_orphan = 0;
622 ext2fs_mark_super_dirty(fs);
626 mark_table_blocks(ctx);
627 block_buf = (char *) e2fsck_allocate_memory(ctx, fs->blocksize * 3,
628 "block interate buffer");
629 e2fsck_use_inode_shortcuts(ctx, 1);
630 old_op = ehandler_operation(_("opening inode scan"));
631 pctx.errcode = ext2fs_open_inode_scan(fs, ctx->inode_buffer_blocks,
633 ehandler_operation(old_op);
635 fix_problem(ctx, PR_1_ISCAN_ERROR, &pctx);
636 ctx->flags |= E2F_FLAG_ABORT;
637 ext2fs_free_mem(&block_buf);
638 ext2fs_free_mem(&inode);
641 ext2fs_inode_scan_flags(scan, EXT2_SF_SKIP_MISSING_ITABLE, 0);
642 ctx->stashed_inode = inode;
643 scan_struct.ctx = ctx;
644 scan_struct.block_buf = block_buf;
645 ext2fs_set_inode_callback(scan, scan_callback, &scan_struct);
647 if ((ctx->progress)(ctx, 1, 0, ctx->fs->group_desc_count))
649 if ((fs->super->s_wtime < fs->super->s_inodes_count) ||
650 (fs->super->s_mtime < fs->super->s_inodes_count))
654 old_op = ehandler_operation(_("getting next inode from scan"));
655 pctx.errcode = ext2fs_get_next_inode_full(scan, &ino,
657 ehandler_operation(old_op);
658 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
660 if (pctx.errcode == EXT2_ET_BAD_BLOCK_IN_INODE_TABLE) {
661 if (!ctx->inode_bb_map)
663 ext2fs_mark_inode_bitmap2(ctx->inode_bb_map, ino);
664 ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino);
668 fix_problem(ctx, PR_1_ISCAN_ERROR, &pctx);
669 ctx->flags |= E2F_FLAG_ABORT;
676 ctx->stashed_ino = ino;
677 if (inode->i_links_count) {
678 pctx.errcode = ext2fs_icount_store(ctx->inode_link_info,
679 ino, inode->i_links_count);
681 pctx.num = inode->i_links_count;
682 fix_problem(ctx, PR_1_ICOUNT_STORE, &pctx);
683 ctx->flags |= E2F_FLAG_ABORT;
689 * Test for incorrect extent flag settings.
691 * On big-endian machines we must be careful:
692 * When the inode is read, the i_block array is not swapped
693 * if the extent flag is set. Therefore if we are testing
694 * for or fixing a wrongly-set flag, we must potentially
695 * (un)swap before testing, or after fixing.
699 * In this case the extents flag was set when read, so
700 * extent_header_verify is ok. If the inode is cleared,
701 * no need to swap... so no extra swapping here.
703 if ((inode->i_flags & EXT4_EXTENTS_FL) && !extent_fs &&
704 (inode->i_links_count || (ino == EXT2_BAD_INO) ||
705 (ino == EXT2_ROOT_INO) || (ino == EXT2_JOURNAL_INO))) {
706 if ((ext2fs_extent_header_verify(inode->i_block,
707 sizeof(inode->i_block)) == 0) &&
708 fix_problem(ctx, PR_1_EXTENT_FEATURE, &pctx)) {
709 sb->s_feature_incompat |= EXT3_FEATURE_INCOMPAT_EXTENTS;
710 ext2fs_mark_super_dirty(fs);
712 } else if (fix_problem(ctx, PR_1_EXTENTS_SET, &pctx)) {
714 e2fsck_clear_inode(ctx, ino, inode, 0, "pass1");
715 if (ino == EXT2_BAD_INO)
716 ext2fs_mark_inode_bitmap2(ctx->inode_used_map,
723 * For big-endian machines:
724 * If the inode didn't have the extents flag set when it
725 * was read, then the i_blocks array was swapped. To test
726 * as an extents header, we must swap it back first.
727 * IF we then set the extents flag, the entire i_block
728 * array must be un/re-swapped to make it proper extents data.
730 if (extent_fs && !(inode->i_flags & EXT4_EXTENTS_FL) &&
731 (inode->i_links_count || (ino == EXT2_BAD_INO) ||
732 (ino == EXT2_ROOT_INO) || (ino == EXT2_JOURNAL_INO)) &&
733 (LINUX_S_ISREG(inode->i_mode) ||
734 LINUX_S_ISDIR(inode->i_mode))) {
736 #ifdef WORDS_BIGENDIAN
737 __u32 tmp_block[EXT2_N_BLOCKS];
739 for (i = 0; i < EXT2_N_BLOCKS; i++)
740 tmp_block[i] = ext2fs_swab32(inode->i_block[i]);
743 ehp = inode->i_block;
745 if ((ext2fs_extent_header_verify(ehp,
746 sizeof(inode->i_block)) == 0) &&
747 (fix_problem(ctx, PR_1_UNSET_EXTENT_FL, &pctx))) {
748 inode->i_flags |= EXT4_EXTENTS_FL;
749 #ifdef WORDS_BIGENDIAN
750 memcpy(inode->i_block, tmp_block,
751 sizeof(inode->i_block));
753 e2fsck_write_inode(ctx, ino, inode, "pass1");
757 if (ino == EXT2_BAD_INO) {
758 struct process_block_struct pb;
760 pctx.errcode = ext2fs_copy_bitmap(ctx->block_found_map,
764 fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, &pctx);
765 ctx->flags |= E2F_FLAG_ABORT;
768 pb.ino = EXT2_BAD_INO;
769 pb.num_blocks = pb.last_block = 0;
770 pb.num_illegal_blocks = 0;
771 pb.suppress = 0; pb.clear = 0; pb.is_dir = 0;
772 pb.is_reg = 0; pb.fragmented = 0; pb.bbcheck = 0;
776 pctx.errcode = ext2fs_block_iterate2(fs, ino, 0,
777 block_buf, process_bad_block, &pb);
778 ext2fs_free_block_bitmap(pb.fs_meta_blocks);
780 fix_problem(ctx, PR_1_BLOCK_ITERATE, &pctx);
781 ctx->flags |= E2F_FLAG_ABORT;
785 if (!fix_problem(ctx, PR_1_BBINODE_BAD_METABLOCK_PROMPT, &pctx)) {
786 ctx->flags |= E2F_FLAG_ABORT;
789 ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino);
790 clear_problem_context(&pctx);
792 } else if (ino == EXT2_ROOT_INO) {
794 * Make sure the root inode is a directory; if
795 * not, offer to clear it. It will be
796 * regnerated in pass #3.
798 if (!LINUX_S_ISDIR(inode->i_mode)) {
799 if (fix_problem(ctx, PR_1_ROOT_NO_DIR, &pctx))
803 * If dtime is set, offer to clear it. mke2fs
804 * version 0.2b created filesystems with the
805 * dtime field set for the root and lost+found
806 * directories. We won't worry about
807 * /lost+found, since that can be regenerated
808 * easily. But we will fix the root directory
811 if (inode->i_dtime && inode->i_links_count) {
812 if (fix_problem(ctx, PR_1_ROOT_DTIME, &pctx)) {
814 e2fsck_write_inode(ctx, ino, inode,
818 } else if (ino == EXT2_JOURNAL_INO) {
819 ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino);
820 if (fs->super->s_journal_inum == EXT2_JOURNAL_INO) {
821 if (!LINUX_S_ISREG(inode->i_mode) &&
822 fix_problem(ctx, PR_1_JOURNAL_BAD_MODE,
824 inode->i_mode = LINUX_S_IFREG;
825 e2fsck_write_inode(ctx, ino, inode,
828 check_blocks(ctx, &pctx, block_buf);
831 if ((inode->i_links_count || inode->i_blocks ||
832 inode->i_blocks || inode->i_block[0]) &&
833 fix_problem(ctx, PR_1_JOURNAL_INODE_NOT_CLEAR,
835 memset(inode, 0, inode_size);
836 ext2fs_icount_store(ctx->inode_link_info,
838 e2fsck_write_inode_full(ctx, ino, inode,
839 inode_size, "pass1");
841 } else if (ino < EXT2_FIRST_INODE(fs->super)) {
844 ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino);
845 if (ino == EXT2_BOOT_LOADER_INO) {
846 if (LINUX_S_ISDIR(inode->i_mode))
847 problem = PR_1_RESERVED_BAD_MODE;
848 } else if (ino == EXT2_RESIZE_INO) {
850 !LINUX_S_ISREG(inode->i_mode))
851 problem = PR_1_RESERVED_BAD_MODE;
853 if (inode->i_mode != 0)
854 problem = PR_1_RESERVED_BAD_MODE;
857 if (fix_problem(ctx, problem, &pctx)) {
859 e2fsck_write_inode(ctx, ino, inode,
863 check_blocks(ctx, &pctx, block_buf);
867 * Check for inodes who might have been part of the
868 * orphaned list linked list. They should have gotten
869 * dealt with by now, unless the list had somehow been
872 * FIXME: In the future, inodes which are still in use
873 * (and which are therefore) pending truncation should
874 * be handled specially. Right now we just clear the
875 * dtime field, and the normal e2fsck handling of
876 * inodes where i_size and the inode blocks are
877 * inconsistent is to fix i_size, instead of releasing
878 * the extra blocks. This won't catch the inodes that
879 * was at the end of the orphan list, but it's better
880 * than nothing. The right answer is that there
881 * shouldn't be any bugs in the orphan list handling. :-)
883 if (inode->i_dtime && !busted_fs_time &&
884 inode->i_dtime < ctx->fs->super->s_inodes_count) {
885 if (fix_problem(ctx, PR_1_LOW_DTIME, &pctx)) {
886 inode->i_dtime = inode->i_links_count ?
888 e2fsck_write_inode(ctx, ino, inode,
894 * This code assumes that deleted inodes have
895 * i_links_count set to 0.
897 if (!inode->i_links_count) {
898 if (!inode->i_dtime && inode->i_mode) {
900 PR_1_ZERO_DTIME, &pctx)) {
901 inode->i_dtime = ctx->now;
902 e2fsck_write_inode(ctx, ino, inode,
909 * n.b. 0.3c ext2fs code didn't clear i_links_count for
910 * deleted files. Oops.
912 * Since all new ext2 implementations get this right,
913 * we now assume that the case of non-zero
914 * i_links_count and non-zero dtime means that we
915 * should keep the file, not delete it.
918 if (inode->i_dtime) {
919 if (fix_problem(ctx, PR_1_SET_DTIME, &pctx)) {
921 e2fsck_write_inode(ctx, ino, inode, "pass1");
925 ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino);
926 switch (fs->super->s_creator_os) {
928 frag = inode->osd2.hurd2.h_i_frag;
929 fsize = inode->osd2.hurd2.h_i_fsize;
935 if (inode->i_faddr || frag || fsize ||
936 (LINUX_S_ISDIR(inode->i_mode) && inode->i_dir_acl))
937 mark_inode_bad(ctx, ino);
938 if (!(fs->super->s_feature_incompat &
939 EXT4_FEATURE_INCOMPAT_64BIT) &&
940 inode->osd2.linux2.l_i_file_acl_high != 0)
941 mark_inode_bad(ctx, ino);
942 if ((fs->super->s_creator_os == EXT2_OS_LINUX) &&
943 !(fs->super->s_feature_ro_compat &
944 EXT4_FEATURE_RO_COMPAT_HUGE_FILE) &&
945 (inode->osd2.linux2.l_i_blocks_hi != 0))
946 mark_inode_bad(ctx, ino);
947 if (inode->i_flags & EXT2_IMAGIC_FL) {
949 if (!ctx->inode_imagic_map)
950 alloc_imagic_map(ctx);
951 ext2fs_mark_inode_bitmap2(ctx->inode_imagic_map,
954 if (fix_problem(ctx, PR_1_SET_IMAGIC, &pctx)) {
955 inode->i_flags &= ~EXT2_IMAGIC_FL;
956 e2fsck_write_inode(ctx, ino,
962 check_inode_extra_space(ctx, &pctx);
963 check_is_really_dir(ctx, &pctx, block_buf);
966 * ext2fs_inode_has_valid_blocks does not actually look
967 * at i_block[] values, so not endian-sensitive here.
969 if (extent_fs && (inode->i_flags & EXT4_EXTENTS_FL) &&
970 LINUX_S_ISLNK(inode->i_mode) &&
971 !ext2fs_inode_has_valid_blocks(inode) &&
972 fix_problem(ctx, PR_1_FAST_SYMLINK_EXTENT_FL, &pctx)) {
973 inode->i_flags &= ~EXT4_EXTENTS_FL;
974 e2fsck_write_inode(ctx, ino, inode, "pass1");
977 if (LINUX_S_ISDIR(inode->i_mode)) {
978 ext2fs_mark_inode_bitmap2(ctx->inode_dir_map, ino);
979 e2fsck_add_dir_info(ctx, ino, 0);
980 ctx->fs_directory_count++;
981 } else if (LINUX_S_ISREG (inode->i_mode)) {
982 ext2fs_mark_inode_bitmap2(ctx->inode_reg_map, ino);
983 ctx->fs_regular_count++;
984 } else if (LINUX_S_ISCHR (inode->i_mode) &&
985 e2fsck_pass1_check_device_inode(fs, inode)) {
986 check_immutable(ctx, &pctx);
987 check_size(ctx, &pctx);
988 ctx->fs_chardev_count++;
989 } else if (LINUX_S_ISBLK (inode->i_mode) &&
990 e2fsck_pass1_check_device_inode(fs, inode)) {
991 check_immutable(ctx, &pctx);
992 check_size(ctx, &pctx);
993 ctx->fs_blockdev_count++;
994 } else if (LINUX_S_ISLNK (inode->i_mode) &&
995 e2fsck_pass1_check_symlink(fs, ino, inode,
997 check_immutable(ctx, &pctx);
998 ctx->fs_symlinks_count++;
999 if (ext2fs_inode_data_blocks(fs, inode) == 0) {
1000 ctx->fs_fast_symlinks_count++;
1001 check_blocks(ctx, &pctx, block_buf);
1005 else if (LINUX_S_ISFIFO (inode->i_mode) &&
1006 e2fsck_pass1_check_device_inode(fs, inode)) {
1007 check_immutable(ctx, &pctx);
1008 check_size(ctx, &pctx);
1009 ctx->fs_fifo_count++;
1010 } else if ((LINUX_S_ISSOCK (inode->i_mode)) &&
1011 e2fsck_pass1_check_device_inode(fs, inode)) {
1012 check_immutable(ctx, &pctx);
1013 check_size(ctx, &pctx);
1014 ctx->fs_sockets_count++;
1016 mark_inode_bad(ctx, ino);
1017 if (!(inode->i_flags & EXT4_EXTENTS_FL)) {
1018 if (inode->i_block[EXT2_IND_BLOCK])
1019 ctx->fs_ind_count++;
1020 if (inode->i_block[EXT2_DIND_BLOCK])
1021 ctx->fs_dind_count++;
1022 if (inode->i_block[EXT2_TIND_BLOCK])
1023 ctx->fs_tind_count++;
1025 if (!(inode->i_flags & EXT4_EXTENTS_FL) &&
1026 (inode->i_block[EXT2_IND_BLOCK] ||
1027 inode->i_block[EXT2_DIND_BLOCK] ||
1028 inode->i_block[EXT2_TIND_BLOCK] ||
1029 inode->i_file_acl)) {
1030 inodes_to_process[process_inode_count].ino = ino;
1031 inodes_to_process[process_inode_count].inode = *inode;
1032 process_inode_count++;
1034 check_blocks(ctx, &pctx, block_buf);
1036 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
1039 if (process_inode_count >= ctx->process_inode_size) {
1040 process_inodes(ctx, block_buf);
1042 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
1046 process_inodes(ctx, block_buf);
1047 ext2fs_close_inode_scan(scan);
1050 * If any extended attribute blocks' reference counts need to
1051 * be adjusted, either up (ctx->refcount_extra), or down
1052 * (ctx->refcount), then fix them.
1054 if (ctx->refcount) {
1055 adjust_extattr_refcount(ctx, ctx->refcount, block_buf, -1);
1056 ea_refcount_free(ctx->refcount);
1059 if (ctx->refcount_extra) {
1060 adjust_extattr_refcount(ctx, ctx->refcount_extra,
1062 ea_refcount_free(ctx->refcount_extra);
1063 ctx->refcount_extra = 0;
1066 if (ctx->invalid_bitmaps)
1067 handle_fs_bad_blocks(ctx);
1069 /* We don't need the block_ea_map any more */
1070 if (ctx->block_ea_map) {
1071 ext2fs_free_block_bitmap(ctx->block_ea_map);
1072 ctx->block_ea_map = 0;
1075 if (ctx->flags & E2F_FLAG_RESIZE_INODE) {
1076 ext2fs_block_bitmap save_bmap;
1078 save_bmap = fs->block_map;
1079 fs->block_map = ctx->block_found_map;
1080 clear_problem_context(&pctx);
1081 pctx.errcode = ext2fs_create_resize_inode(fs);
1083 fix_problem(ctx, PR_1_RESIZE_INODE_CREATE, &pctx);
1084 /* Should never get here */
1085 ctx->flags |= E2F_FLAG_ABORT;
1088 e2fsck_read_inode(ctx, EXT2_RESIZE_INO, inode,
1090 inode->i_mtime = ctx->now;
1091 e2fsck_write_inode(ctx, EXT2_RESIZE_INO, inode,
1093 fs->block_map = save_bmap;
1094 ctx->flags &= ~E2F_FLAG_RESIZE_INODE;
1097 if (ctx->flags & E2F_FLAG_RESTART) {
1099 * Only the master copy of the superblock and block
1100 * group descriptors are going to be written during a
1101 * restart, so set the superblock to be used to be the
1102 * master superblock.
1104 ctx->use_superblock = 0;
1109 if (ctx->block_dup_map) {
1110 if (ctx->options & E2F_OPT_PREEN) {
1111 clear_problem_context(&pctx);
1112 fix_problem(ctx, PR_1_DUP_BLOCKS_PREENSTOP, &pctx);
1114 e2fsck_pass1_dupblocks(ctx, block_buf);
1116 ext2fs_free_mem(&inodes_to_process);
1118 e2fsck_use_inode_shortcuts(ctx, 0);
1120 ext2fs_free_mem(&block_buf);
1121 ext2fs_free_mem(&inode);
1123 print_resource_track(ctx, _("Pass 1"), &rtrack, ctx->fs->io);
1127 * When the inode_scan routines call this callback at the end of the
1128 * glock group, call process_inodes.
1130 static errcode_t scan_callback(ext2_filsys fs,
1131 ext2_inode_scan scan EXT2FS_ATTR((unused)),
1132 dgrp_t group, void * priv_data)
1134 struct scan_callback_struct *scan_struct;
1137 scan_struct = (struct scan_callback_struct *) priv_data;
1138 ctx = scan_struct->ctx;
1140 process_inodes((e2fsck_t) fs->priv_data, scan_struct->block_buf);
1143 if ((ctx->progress)(ctx, 1, group+1,
1144 ctx->fs->group_desc_count))
1145 return EXT2_ET_CANCEL_REQUESTED;
1151 * Process the inodes in the "inodes to process" list.
1153 static void process_inodes(e2fsck_t ctx, char *block_buf)
1156 struct ext2_inode *old_stashed_inode;
1157 ext2_ino_t old_stashed_ino;
1158 const char *old_operation;
1160 struct problem_context pctx;
1163 printf("begin process_inodes: ");
1165 if (process_inode_count == 0)
1167 old_operation = ehandler_operation(0);
1168 old_stashed_inode = ctx->stashed_inode;
1169 old_stashed_ino = ctx->stashed_ino;
1170 qsort(inodes_to_process, process_inode_count,
1171 sizeof(struct process_inode_block), process_inode_cmp);
1172 clear_problem_context(&pctx);
1173 for (i=0; i < process_inode_count; i++) {
1174 pctx.inode = ctx->stashed_inode = &inodes_to_process[i].inode;
1175 pctx.ino = ctx->stashed_ino = inodes_to_process[i].ino;
1178 printf("%u ", pctx.ino);
1180 sprintf(buf, _("reading indirect blocks of inode %u"),
1182 ehandler_operation(buf);
1183 check_blocks(ctx, &pctx, block_buf);
1184 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
1187 ctx->stashed_inode = old_stashed_inode;
1188 ctx->stashed_ino = old_stashed_ino;
1189 process_inode_count = 0;
1191 printf("end process inodes\n");
1193 ehandler_operation(old_operation);
1196 static EXT2_QSORT_TYPE process_inode_cmp(const void *a, const void *b)
1198 const struct process_inode_block *ib_a =
1199 (const struct process_inode_block *) a;
1200 const struct process_inode_block *ib_b =
1201 (const struct process_inode_block *) b;
1204 ret = (ib_a->inode.i_block[EXT2_IND_BLOCK] -
1205 ib_b->inode.i_block[EXT2_IND_BLOCK]);
1207 ret = ib_a->inode.i_file_acl - ib_b->inode.i_file_acl;
1209 ret = ib_a->ino - ib_b->ino;
1214 * Mark an inode as being bad in some what
1216 static void mark_inode_bad(e2fsck_t ctx, ino_t ino)
1218 struct problem_context pctx;
1220 if (!ctx->inode_bad_map) {
1221 clear_problem_context(&pctx);
1223 pctx.errcode = ext2fs_allocate_inode_bitmap(ctx->fs,
1224 _("bad inode map"), &ctx->inode_bad_map);
1227 fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx);
1228 /* Should never get here */
1229 ctx->flags |= E2F_FLAG_ABORT;
1233 ext2fs_mark_inode_bitmap2(ctx->inode_bad_map, ino);
1238 * This procedure will allocate the inode "bb" (badblock) map table
1240 static void alloc_bb_map(e2fsck_t ctx)
1242 struct problem_context pctx;
1244 clear_problem_context(&pctx);
1245 pctx.errcode = ext2fs_allocate_inode_bitmap(ctx->fs,
1246 _("inode in bad block map"),
1247 &ctx->inode_bb_map);
1250 fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx);
1251 /* Should never get here */
1252 ctx->flags |= E2F_FLAG_ABORT;
1258 * This procedure will allocate the inode imagic table
1260 static void alloc_imagic_map(e2fsck_t ctx)
1262 struct problem_context pctx;
1264 clear_problem_context(&pctx);
1265 pctx.errcode = ext2fs_allocate_inode_bitmap(ctx->fs,
1266 _("imagic inode map"),
1267 &ctx->inode_imagic_map);
1270 fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx);
1271 /* Should never get here */
1272 ctx->flags |= E2F_FLAG_ABORT;
1278 * Marks a block as in use, setting the dup_map if it's been set
1279 * already. Called by process_block and process_bad_block.
1281 * WARNING: Assumes checks have already been done to make sure block
1282 * is valid. This is true in both process_block and process_bad_block.
1284 static _INLINE_ void mark_block_used(e2fsck_t ctx, blk_t block)
1286 struct problem_context pctx;
1288 clear_problem_context(&pctx);
1290 if (ext2fs_fast_test_block_bitmap2(ctx->block_found_map, block)) {
1291 if (!ctx->block_dup_map) {
1292 pctx.errcode = ext2fs_allocate_block_bitmap(ctx->fs,
1293 _("multiply claimed block map"),
1294 &ctx->block_dup_map);
1297 fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR,
1299 /* Should never get here */
1300 ctx->flags |= E2F_FLAG_ABORT;
1304 ext2fs_fast_mark_block_bitmap2(ctx->block_dup_map, block);
1306 ext2fs_fast_mark_block_bitmap2(ctx->block_found_map, block);
1311 * Adjust the extended attribute block's reference counts at the end
1312 * of pass 1, either by subtracting out references for EA blocks that
1313 * are still referenced in ctx->refcount, or by adding references for
1314 * EA blocks that had extra references as accounted for in
1315 * ctx->refcount_extra.
1317 static void adjust_extattr_refcount(e2fsck_t ctx, ext2_refcount_t refcount,
1318 char *block_buf, int adjust_sign)
1320 struct ext2_ext_attr_header *header;
1321 struct problem_context pctx;
1322 ext2_filsys fs = ctx->fs;
1327 clear_problem_context(&pctx);
1329 ea_refcount_intr_begin(refcount);
1331 if ((blk = ea_refcount_intr_next(refcount, &count)) == 0)
1334 pctx.errcode = ext2fs_read_ext_attr(fs, blk, block_buf);
1336 fix_problem(ctx, PR_1_EXTATTR_READ_ABORT, &pctx);
1339 header = (struct ext2_ext_attr_header *) block_buf;
1340 pctx.blkcount = header->h_refcount;
1341 should_be = header->h_refcount + adjust_sign * count;
1342 pctx.num = should_be;
1343 if (fix_problem(ctx, PR_1_EXTATTR_REFCOUNT, &pctx)) {
1344 header->h_refcount = should_be;
1345 pctx.errcode = ext2fs_write_ext_attr(fs, blk,
1348 fix_problem(ctx, PR_1_EXTATTR_WRITE, &pctx);
1356 * Handle processing the extended attribute blocks
1358 static int check_ext_attr(e2fsck_t ctx, struct problem_context *pctx,
1361 ext2_filsys fs = ctx->fs;
1362 ext2_ino_t ino = pctx->ino;
1363 struct ext2_inode *inode = pctx->inode;
1366 struct ext2_ext_attr_header *header;
1367 struct ext2_ext_attr_entry *entry;
1369 region_t region = 0;
1371 blk = inode->i_file_acl;
1376 * If the Extended attribute flag isn't set, then a non-zero
1377 * file acl means that the inode is corrupted.
1379 * Or if the extended attribute block is an invalid block,
1380 * then the inode is also corrupted.
1382 if (!(fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_EXT_ATTR) ||
1383 (blk < fs->super->s_first_data_block) ||
1384 (blk >= fs->super->s_blocks_count)) {
1385 mark_inode_bad(ctx, ino);
1389 /* If ea bitmap hasn't been allocated, create it */
1390 if (!ctx->block_ea_map) {
1391 pctx->errcode = ext2fs_allocate_block_bitmap(fs,
1392 _("ext attr block map"),
1393 &ctx->block_ea_map);
1394 if (pctx->errcode) {
1396 fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, pctx);
1397 ctx->flags |= E2F_FLAG_ABORT;
1402 /* Create the EA refcount structure if necessary */
1403 if (!ctx->refcount) {
1404 pctx->errcode = ea_refcount_create(0, &ctx->refcount);
1405 if (pctx->errcode) {
1407 fix_problem(ctx, PR_1_ALLOCATE_REFCOUNT, pctx);
1408 ctx->flags |= E2F_FLAG_ABORT;
1414 /* Debugging text */
1415 printf("Inode %u has EA block %u\n", ino, blk);
1418 /* Have we seen this EA block before? */
1419 if (ext2fs_fast_test_block_bitmap2(ctx->block_ea_map, blk)) {
1420 if (ea_refcount_decrement(ctx->refcount, blk, 0) == 0)
1422 /* Ooops, this EA was referenced more than it stated */
1423 if (!ctx->refcount_extra) {
1424 pctx->errcode = ea_refcount_create(0,
1425 &ctx->refcount_extra);
1426 if (pctx->errcode) {
1428 fix_problem(ctx, PR_1_ALLOCATE_REFCOUNT, pctx);
1429 ctx->flags |= E2F_FLAG_ABORT;
1433 ea_refcount_increment(ctx->refcount_extra, blk, 0);
1438 * OK, we haven't seen this EA block yet. So we need to
1442 pctx->errcode = ext2fs_read_ext_attr(fs, blk, block_buf);
1443 if (pctx->errcode && fix_problem(ctx, PR_1_READ_EA_BLOCK, pctx))
1445 header = (struct ext2_ext_attr_header *) block_buf;
1446 pctx->blk = inode->i_file_acl;
1447 if (((ctx->ext_attr_ver == 1) &&
1448 (header->h_magic != EXT2_EXT_ATTR_MAGIC_v1)) ||
1449 ((ctx->ext_attr_ver == 2) &&
1450 (header->h_magic != EXT2_EXT_ATTR_MAGIC))) {
1451 if (fix_problem(ctx, PR_1_BAD_EA_BLOCK, pctx))
1455 if (header->h_blocks != 1) {
1456 if (fix_problem(ctx, PR_1_EA_MULTI_BLOCK, pctx))
1460 region = region_create(0, fs->blocksize);
1462 fix_problem(ctx, PR_1_EA_ALLOC_REGION, pctx);
1463 ctx->flags |= E2F_FLAG_ABORT;
1466 if (region_allocate(region, 0, sizeof(struct ext2_ext_attr_header))) {
1467 if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, pctx))
1471 entry = (struct ext2_ext_attr_entry *)(header+1);
1472 end = block_buf + fs->blocksize;
1473 while ((char *)entry < end && *(__u32 *)entry) {
1476 if (region_allocate(region, (char *)entry - (char *)header,
1477 EXT2_EXT_ATTR_LEN(entry->e_name_len))) {
1478 if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, pctx))
1482 if ((ctx->ext_attr_ver == 1 &&
1483 (entry->e_name_len == 0 || entry->e_name_index != 0)) ||
1484 (ctx->ext_attr_ver == 2 &&
1485 entry->e_name_index == 0)) {
1486 if (fix_problem(ctx, PR_1_EA_BAD_NAME, pctx))
1490 if (entry->e_value_block != 0) {
1491 if (fix_problem(ctx, PR_1_EA_BAD_VALUE, pctx))
1494 if (entry->e_value_offs + entry->e_value_size > fs->blocksize) {
1495 if (fix_problem(ctx, PR_1_EA_BAD_VALUE, pctx))
1499 if (entry->e_value_size &&
1500 region_allocate(region, entry->e_value_offs,
1501 EXT2_EXT_ATTR_SIZE(entry->e_value_size))) {
1502 if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, pctx))
1506 hash = ext2fs_ext_attr_hash_entry(entry, block_buf +
1507 entry->e_value_offs);
1509 if (entry->e_hash != hash) {
1510 pctx->num = entry->e_hash;
1511 if (fix_problem(ctx, PR_1_ATTR_HASH, pctx))
1513 entry->e_hash = hash;
1516 entry = EXT2_EXT_ATTR_NEXT(entry);
1518 if (region_allocate(region, (char *)entry - (char *)header, 4)) {
1519 if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, pctx))
1522 region_free(region);
1524 count = header->h_refcount - 1;
1526 ea_refcount_store(ctx->refcount, blk, count);
1527 mark_block_used(ctx, blk);
1528 ext2fs_fast_mark_block_bitmap2(ctx->block_ea_map, blk);
1533 region_free(region);
1534 inode->i_file_acl = 0;
1535 e2fsck_write_inode(ctx, ino, inode, "check_ext_attr");
1539 /* Returns 1 if bad htree, 0 if OK */
1540 static int handle_htree(e2fsck_t ctx, struct problem_context *pctx,
1541 ext2_ino_t ino, struct ext2_inode *inode,
1544 struct ext2_dx_root_info *root;
1545 ext2_filsys fs = ctx->fs;
1549 if ((!LINUX_S_ISDIR(inode->i_mode) &&
1550 fix_problem(ctx, PR_1_HTREE_NODIR, pctx)) ||
1551 (!(fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_DIR_INDEX) &&
1552 fix_problem(ctx, PR_1_HTREE_SET, pctx)))
1555 pctx->errcode = ext2fs_bmap(fs, ino, inode, 0, 0, 0, &blk);
1557 if ((pctx->errcode) ||
1559 (blk < fs->super->s_first_data_block) ||
1560 (blk >= fs->super->s_blocks_count)) {
1561 if (fix_problem(ctx, PR_1_HTREE_BADROOT, pctx))
1567 retval = io_channel_read_blk64(fs->io, blk, 1, block_buf);
1568 if (retval && fix_problem(ctx, PR_1_HTREE_BADROOT, pctx))
1571 /* XXX should check that beginning matches a directory */
1572 root = (struct ext2_dx_root_info *) (block_buf + 24);
1574 if ((root->reserved_zero || root->info_length < 8) &&
1575 fix_problem(ctx, PR_1_HTREE_BADROOT, pctx))
1578 pctx->num = root->hash_version;
1579 if ((root->hash_version != EXT2_HASH_LEGACY) &&
1580 (root->hash_version != EXT2_HASH_HALF_MD4) &&
1581 (root->hash_version != EXT2_HASH_TEA) &&
1582 fix_problem(ctx, PR_1_HTREE_HASHV, pctx))
1585 if ((root->unused_flags & EXT2_HASH_FLAG_INCOMPAT) &&
1586 fix_problem(ctx, PR_1_HTREE_INCOMPAT, pctx))
1589 pctx->num = root->indirect_levels;
1590 if ((root->indirect_levels > 1) &&
1591 fix_problem(ctx, PR_1_HTREE_DEPTH, pctx))
1597 void e2fsck_clear_inode(e2fsck_t ctx, ext2_ino_t ino,
1598 struct ext2_inode *inode, int restart_flag,
1602 inode->i_links_count = 0;
1603 ext2fs_icount_store(ctx->inode_link_info, ino, 0);
1604 inode->i_dtime = ctx->now;
1606 ext2fs_unmark_inode_bitmap2(ctx->inode_dir_map, ino);
1607 ext2fs_unmark_inode_bitmap2(ctx->inode_used_map, ino);
1608 if (ctx->inode_reg_map)
1609 ext2fs_unmark_inode_bitmap2(ctx->inode_reg_map, ino);
1610 if (ctx->inode_bad_map)
1611 ext2fs_unmark_inode_bitmap2(ctx->inode_bad_map, ino);
1614 * If the inode was partially accounted for before processing
1615 * was aborted, we need to restart the pass 1 scan.
1617 ctx->flags |= restart_flag;
1619 e2fsck_write_inode(ctx, ino, inode, source);
1622 static void scan_extent_node(e2fsck_t ctx, struct problem_context *pctx,
1623 struct process_block_struct *pb,
1624 blk64_t start_block,
1625 ext2_extent_handle_t ehandle)
1627 struct ext2fs_extent extent;
1629 e2_blkcnt_t blockcnt;
1631 int is_dir, is_leaf;
1633 struct ext2_extent_info info;
1635 pctx->errcode = ext2fs_extent_get_info(ehandle, &info);
1639 pctx->errcode = ext2fs_extent_get(ehandle, EXT2_EXTENT_FIRST_SIB,
1641 while (!pctx->errcode && info.num_entries-- > 0) {
1642 is_leaf = extent.e_flags & EXT2_EXTENT_FLAGS_LEAF;
1643 is_dir = LINUX_S_ISDIR(pctx->inode->i_mode);
1646 if (extent.e_pblk < ctx->fs->super->s_first_data_block ||
1647 extent.e_pblk >= ctx->fs->super->s_blocks_count)
1648 problem = PR_1_EXTENT_BAD_START_BLK;
1649 else if (extent.e_lblk < start_block)
1650 problem = PR_1_OUT_OF_ORDER_EXTENTS;
1652 (extent.e_pblk + extent.e_len) >
1653 ctx->fs->super->s_blocks_count)
1654 problem = PR_1_EXTENT_ENDS_BEYOND;
1658 pctx->blk = extent.e_pblk;
1659 pctx->blk2 = extent.e_lblk;
1660 pctx->num = extent.e_len;
1661 if (fix_problem(ctx, problem, pctx)) {
1663 ext2fs_extent_delete(ehandle, 0);
1664 if (pctx->errcode) {
1665 pctx->str = "ext2fs_extent_delete";
1668 pctx->errcode = ext2fs_extent_get(ehandle,
1669 EXT2_EXTENT_CURRENT,
1671 if (pctx->errcode == EXT2_ET_NO_CURRENT_NODE) {
1681 blk = extent.e_pblk;
1682 pctx->errcode = ext2fs_extent_get(ehandle,
1683 EXT2_EXTENT_DOWN, &extent);
1684 if (pctx->errcode) {
1685 pctx->str = "EXT2_EXTENT_DOWN";
1686 problem = PR_1_EXTENT_HEADER_INVALID;
1687 if (pctx->errcode == EXT2_ET_EXTENT_HEADER_BAD)
1688 goto report_problem;
1691 scan_extent_node(ctx, pctx, pb, extent.e_lblk, ehandle);
1694 pctx->errcode = ext2fs_extent_get(ehandle,
1695 EXT2_EXTENT_UP, &extent);
1696 if (pctx->errcode) {
1697 pctx->str = "EXT2_EXTENT_UP";
1700 mark_block_used(ctx, blk);
1705 if ((pb->previous_block != 0) &&
1706 (pb->previous_block+1 != extent.e_pblk)) {
1707 if (ctx->options & E2F_OPT_FRAGCHECK) {
1712 else if (pb->is_reg)
1715 printf(("%6lu(%c): expecting %6lu "
1717 "phys %6lu log %lu len %lu\n"),
1718 (unsigned long) pctx->ino, type,
1719 (unsigned long) pb->previous_block+1,
1720 (unsigned long) extent.e_pblk,
1721 (unsigned long) extent.e_lblk,
1722 (unsigned long) extent.e_len);
1726 for (blk = extent.e_pblk, blockcnt = extent.e_lblk, i = 0;
1728 blk++, blockcnt++, i++) {
1729 mark_block_used(ctx, blk);
1732 pctx->errcode = ext2fs_add_dir_block(ctx->fs->dblist, pctx->ino, blk, blockcnt);
1733 if (pctx->errcode) {
1735 pctx->num = blockcnt;
1736 fix_problem(ctx, PR_1_ADD_DBLOCK, pctx);
1737 /* Should never get here */
1738 ctx->flags |= E2F_FLAG_ABORT;
1743 pb->num_blocks += extent.e_len;
1744 pb->previous_block = extent.e_pblk + extent.e_len - 1;
1745 start_block = extent.e_lblk + extent.e_len - 1;
1746 if (!(extent.e_flags & EXT2_EXTENT_FLAGS_UNINIT))
1747 pb->last_block = start_block;
1749 pctx->errcode = ext2fs_extent_get(ehandle,
1750 EXT2_EXTENT_NEXT_SIB,
1753 if (pctx->errcode == EXT2_ET_EXTENT_NO_NEXT)
1757 static void check_blocks_extents(e2fsck_t ctx, struct problem_context *pctx,
1758 struct process_block_struct *pb)
1760 struct ext2_extent_info info;
1761 struct ext2_inode *inode = pctx->inode;
1762 ext2_extent_handle_t ehandle;
1763 ext2_filsys fs = ctx->fs;
1764 ext2_ino_t ino = pctx->ino;
1767 pctx->errcode = ext2fs_extent_open2(fs, ino, inode, &ehandle);
1768 if (pctx->errcode) {
1769 if (fix_problem(ctx, PR_1_READ_EXTENT, pctx))
1770 e2fsck_clear_inode(ctx, ino, inode, 0,
1771 "check_blocks_extents");
1776 retval = ext2fs_extent_get_info(ehandle, &info);
1778 if (info.max_depth >= MAX_EXTENT_DEPTH_COUNT)
1779 info.max_depth = MAX_EXTENT_DEPTH_COUNT-1;
1780 ctx->extent_depth_count[info.max_depth]++;
1783 scan_extent_node(ctx, pctx, pb, 0, ehandle);
1784 if (pctx->errcode &&
1785 fix_problem(ctx, PR_1_EXTENT_ITERATE_FAILURE, pctx)) {
1787 inode->i_blocks = 0;
1788 e2fsck_clear_inode(ctx, ino, inode, E2F_FLAG_RESTART,
1789 "check_blocks_extents");
1792 ext2fs_extent_free(ehandle);
1796 * This subroutine is called on each inode to account for all of the
1797 * blocks used by that inode.
1799 static void check_blocks(e2fsck_t ctx, struct problem_context *pctx,
1802 ext2_filsys fs = ctx->fs;
1803 struct process_block_struct pb;
1804 ext2_ino_t ino = pctx->ino;
1805 struct ext2_inode *inode = pctx->inode;
1807 int dirty_inode = 0;
1814 pb.num_illegal_blocks = 0;
1815 pb.suppress = 0; pb.clear = 0;
1818 pb.previous_block = 0;
1819 pb.is_dir = LINUX_S_ISDIR(inode->i_mode);
1820 pb.is_reg = LINUX_S_ISREG(inode->i_mode);
1821 pb.max_blocks = 1 << (31 - fs->super->s_log_block_size);
1828 extent_fs = (ctx->fs->super->s_feature_incompat &
1829 EXT3_FEATURE_INCOMPAT_EXTENTS);
1831 if (inode->i_flags & EXT2_COMPRBLK_FL) {
1832 if (fs->super->s_feature_incompat &
1833 EXT2_FEATURE_INCOMPAT_COMPRESSION)
1836 if (fix_problem(ctx, PR_1_COMPR_SET, pctx)) {
1837 inode->i_flags &= ~EXT2_COMPRBLK_FL;
1843 if (inode->i_file_acl && check_ext_attr(ctx, pctx, block_buf)) {
1844 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
1849 if (ext2fs_inode_has_valid_blocks(inode)) {
1850 if (extent_fs && (inode->i_flags & EXT4_EXTENTS_FL))
1851 check_blocks_extents(ctx, pctx, &pb);
1853 pctx->errcode = ext2fs_block_iterate2(fs, ino,
1854 pb.is_dir ? BLOCK_FLAG_HOLE : 0,
1855 block_buf, process_block, &pb);
1857 end_problem_latch(ctx, PR_LATCH_BLOCK);
1858 end_problem_latch(ctx, PR_LATCH_TOOBIG);
1859 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
1862 fix_problem(ctx, PR_1_BLOCK_ITERATE, pctx);
1864 if (pb.fragmented && pb.num_blocks < fs->super->s_blocks_per_group) {
1865 if (LINUX_S_ISDIR(inode->i_mode))
1866 ctx->fs_fragmented_dir++;
1868 ctx->fs_fragmented++;
1872 e2fsck_clear_inode(ctx, ino, inode, E2F_FLAG_RESTART,
1879 struct ext2_db_entry *entry;
1881 if (ext2fs_dblist_get_last(fs->dblist, &entry) ||
1882 (entry->ino != ino) ||
1883 (entry->blk != 0) ||
1884 (entry->blockcnt == 0))
1886 /* printf("Dropping ino %lu blk %lu blockcnt %d\n",
1887 entry->ino, entry->blk, entry->blockcnt); */
1888 ext2fs_dblist_drop_last(fs->dblist);
1889 if (ext2fs_dblist_get_last(fs->dblist, &entry) ||
1890 (entry->ino != ino))
1893 pb.last_block = entry->blockcnt;
1897 if (inode->i_flags & EXT2_INDEX_FL) {
1898 if (handle_htree(ctx, pctx, ino, inode, block_buf)) {
1899 inode->i_flags &= ~EXT2_INDEX_FL;
1903 e2fsck_add_dx_dir(ctx, ino, pb.last_block+1);
1907 if (ctx->dirs_to_hash && pb.is_dir &&
1908 !(inode->i_flags & EXT2_INDEX_FL) &&
1909 ((inode->i_size / fs->blocksize) >= 3))
1910 ext2fs_u32_list_add(ctx->dirs_to_hash, ino);
1912 if (!pb.num_blocks && pb.is_dir) {
1913 if (fix_problem(ctx, PR_1_ZERO_LENGTH_DIR, pctx)) {
1914 e2fsck_clear_inode(ctx, ino, inode, 0, "check_blocks");
1915 ctx->fs_directory_count--;
1920 if (!(fs->super->s_feature_ro_compat &
1921 EXT4_FEATURE_RO_COMPAT_HUGE_FILE) ||
1922 !(inode->i_flags & EXT4_HUGE_FILE_FL))
1923 pb.num_blocks *= (fs->blocksize / 512);
1925 printf("inode %u, i_size = %lu, last_block = %lld, i_blocks=%lu, num_blocks = %lu\n",
1926 ino, inode->i_size, pb.last_block, inode->i_blocks,
1930 int nblock = inode->i_size >> EXT2_BLOCK_SIZE_BITS(fs->super);
1931 if (inode->i_size & (fs->blocksize - 1))
1933 else if (nblock > (pb.last_block + 1))
1935 else if (nblock < (pb.last_block + 1)) {
1936 if (((pb.last_block + 1) - nblock) >
1937 fs->super->s_prealloc_dir_blocks)
1941 e2_blkcnt_t blkpg = ctx->blocks_per_page;
1943 size = EXT2_I_SIZE(inode);
1944 if ((pb.last_block >= 0) &&
1945 /* allow allocated blocks to end of PAGE_SIZE */
1946 (size < (__u64)pb.last_block * fs->blocksize) &&
1947 (pb.last_block / blkpg * blkpg != pb.last_block ||
1948 size < (__u64)(pb.last_block & ~(blkpg-1)) *fs->blocksize))
1950 else if (!(extent_fs && (inode->i_flags & EXT4_EXTENTS_FL)) &&
1951 size > ext2_max_sizes[fs->super->s_log_block_size])
1952 /* too big for a direct/indirect-mapped file */
1954 else if ((extent_fs && (inode->i_flags & EXT4_EXTENTS_FL)) &&
1956 ((1ULL << (32 + EXT2_BLOCK_SIZE_BITS(fs->super))) - 1))
1957 /* too big for an extent-based file - 32bit ee_block */
1960 /* i_size for symlinks is checked elsewhere */
1961 if (bad_size && !LINUX_S_ISLNK(inode->i_mode)) {
1962 pctx->num = (pb.last_block+1) * fs->blocksize;
1963 pctx->group = bad_size;
1964 if (fix_problem(ctx, PR_1_BAD_I_SIZE, pctx)) {
1965 inode->i_size = pctx->num;
1966 if (!LINUX_S_ISDIR(inode->i_mode))
1967 inode->i_size_high = pctx->num >> 32;
1972 if (LINUX_S_ISREG(inode->i_mode) &&
1973 (inode->i_size_high || inode->i_size & 0x80000000UL))
1975 if ((pb.num_blocks != inode->i_blocks) ||
1976 ((fs->super->s_feature_ro_compat &
1977 EXT4_FEATURE_RO_COMPAT_HUGE_FILE) &&
1978 (inode->i_flags & EXT4_HUGE_FILE_FL) &&
1979 (inode->osd2.linux2.l_i_blocks_hi != 0))) {
1980 pctx->num = pb.num_blocks;
1981 if (fix_problem(ctx, PR_1_BAD_I_BLOCKS, pctx)) {
1982 inode->i_blocks = pb.num_blocks;
1983 inode->osd2.linux2.l_i_blocks_hi = 0;
1990 e2fsck_write_inode(ctx, ino, inode, "check_blocks");
1995 * Helper function called by process block when an illegal block is
1996 * found. It returns a description about why the block is illegal
1998 static char *describe_illegal_block(ext2_filsys fs, blk_t block)
2002 static char problem[80];
2004 super = fs->super->s_first_data_block;
2005 strcpy(problem, "PROGRAMMING ERROR: Unknown reason for illegal block");
2006 if (block < super) {
2007 sprintf(problem, "< FIRSTBLOCK (%u)", super);
2009 } else if (block >= fs->super->s_blocks_count) {
2010 sprintf(problem, "> BLOCKS (%u)", fs->super->s_blocks_count);
2013 for (i = 0; i < fs->group_desc_count; i++) {
2014 if (block == super) {
2015 sprintf(problem, "is the superblock in group %d", i);
2018 if (block > super &&
2019 block <= (super + fs->desc_blocks)) {
2020 sprintf(problem, "is in the group descriptors "
2024 if (block == fs->group_desc[i].bg_block_bitmap) {
2025 sprintf(problem, "is the block bitmap of group %d", i);
2028 if (block == fs->group_desc[i].bg_inode_bitmap) {
2029 sprintf(problem, "is the inode bitmap of group %d", i);
2032 if (block >= fs->group_desc[i].bg_inode_table &&
2033 (block < fs->group_desc[i].bg_inode_table
2034 + fs->inode_blocks_per_group)) {
2035 sprintf(problem, "is in the inode table of group %d",
2039 super += fs->super->s_blocks_per_group;
2046 * This is a helper function for check_blocks().
2048 static int process_block(ext2_filsys fs,
2050 e2_blkcnt_t blockcnt,
2051 blk_t ref_block EXT2FS_ATTR((unused)),
2052 int ref_offset EXT2FS_ATTR((unused)),
2055 struct process_block_struct *p;
2056 struct problem_context *pctx;
2057 blk_t blk = *block_nr;
2062 p = (struct process_block_struct *) priv_data;
2066 if (p->compressed && (blk == EXT2FS_COMPRESSED_BLKADDR)) {
2067 /* todo: Check that the comprblk_fl is high, that the
2068 blkaddr pattern looks right (all non-holes up to
2069 first EXT2FS_COMPRESSED_BLKADDR, then all
2070 EXT2FS_COMPRESSED_BLKADDR up to end of cluster),
2071 that the feature_incompat bit is high, and that the
2072 inode is a regular file. If we're doing a "full
2073 check" (a concept introduced to e2fsck by e2compr,
2074 meaning that we look at data blocks as well as
2075 metadata) then call some library routine that
2076 checks the compressed data. I'll have to think
2077 about this, because one particularly important
2078 problem to be able to fix is to recalculate the
2079 cluster size if necessary. I think that perhaps
2080 we'd better do most/all e2compr-specific checks
2081 separately, after the non-e2compr checks. If not
2082 doing a full check, it may be useful to test that
2083 the personality is linux; e.g. if it isn't then
2084 perhaps this really is just an illegal block. */
2089 if (p->is_dir == 0) {
2091 * Should never happen, since only directories
2092 * get called with BLOCK_FLAG_HOLE
2095 printf("process_block() called with blk == 0, "
2096 "blockcnt=%d, inode %lu???\n",
2103 if (blockcnt * fs->blocksize < p->inode->i_size) {
2105 printf("Missing block (#%d) in directory inode %lu!\n",
2108 p->last_block = blockcnt;
2115 printf("Process_block, inode %lu, block %u, #%d\n", p->ino, blk,
2120 * Simplistic fragmentation check. We merely require that the
2121 * file be contiguous. (Which can never be true for really
2122 * big files that are greater than a block group.)
2124 if (!HOLE_BLKADDR(p->previous_block) && p->ino != EXT2_RESIZE_INO) {
2125 if (p->previous_block+1 != blk) {
2126 if (ctx->options & E2F_OPT_FRAGCHECK) {
2134 printf(_("%6lu(%c): expecting %6lu "
2135 "got phys %6lu (blkcnt %lld)\n"),
2136 (unsigned long) pctx->ino, type,
2137 (unsigned long) p->previous_block+1,
2138 (unsigned long) blk,
2144 p->previous_block = blk;
2146 if (p->is_dir && blockcnt > (1 << (21 - fs->super->s_log_block_size)))
2147 problem = PR_1_TOOBIG_DIR;
2148 if (p->is_reg && p->num_blocks+1 >= p->max_blocks)
2149 problem = PR_1_TOOBIG_REG;
2150 if (!p->is_dir && !p->is_reg && blockcnt > 0)
2151 problem = PR_1_TOOBIG_SYMLINK;
2153 if (blk < fs->super->s_first_data_block ||
2154 blk >= fs->super->s_blocks_count)
2155 problem = PR_1_ILLEGAL_BLOCK_NUM;
2158 p->num_illegal_blocks++;
2159 if (!p->suppress && (p->num_illegal_blocks % 12) == 0) {
2160 if (fix_problem(ctx, PR_1_TOO_MANY_BAD_BLOCKS, pctx)) {
2164 if (fix_problem(ctx, PR_1_SUPPRESS_MESSAGES, pctx)) {
2166 set_latch_flags(PR_LATCH_BLOCK,
2171 pctx->blkcount = blockcnt;
2172 if (fix_problem(ctx, problem, pctx)) {
2173 blk = *block_nr = 0;
2174 ret_code = BLOCK_CHANGED;
2180 if (p->ino == EXT2_RESIZE_INO) {
2182 * The resize inode has already be sanity checked
2183 * during pass #0 (the superblock checks). All we
2184 * have to do is mark the double indirect block as
2185 * being in use; all of the other blocks are handled
2186 * by mark_table_blocks()).
2188 if (blockcnt == BLOCK_COUNT_DIND)
2189 mark_block_used(ctx, blk);
2191 mark_block_used(ctx, blk);
2194 p->last_block = blockcnt;
2196 if (p->is_dir && (blockcnt >= 0)) {
2197 pctx->errcode = ext2fs_add_dir_block(fs->dblist, p->ino,
2199 if (pctx->errcode) {
2201 pctx->num = blockcnt;
2202 fix_problem(ctx, PR_1_ADD_DBLOCK, pctx);
2203 /* Should never get here */
2204 ctx->flags |= E2F_FLAG_ABORT;
2211 static int process_bad_block(ext2_filsys fs,
2213 e2_blkcnt_t blockcnt,
2214 blk_t ref_block EXT2FS_ATTR((unused)),
2215 int ref_offset EXT2FS_ATTR((unused)),
2218 struct process_block_struct *p;
2219 blk_t blk = *block_nr;
2222 struct problem_context *pctx;
2226 * Note: This function processes blocks for the bad blocks
2227 * inode, which is never compressed. So we don't use HOLE_BLKADDR().
2233 p = (struct process_block_struct *) priv_data;
2237 pctx->ino = EXT2_BAD_INO;
2239 pctx->blkcount = blockcnt;
2241 if ((blk < fs->super->s_first_data_block) ||
2242 (blk >= fs->super->s_blocks_count)) {
2243 if (fix_problem(ctx, PR_1_BB_ILLEGAL_BLOCK_NUM, pctx)) {
2245 return BLOCK_CHANGED;
2251 if (ext2fs_test_block_bitmap2(p->fs_meta_blocks, blk)) {
2253 if (fix_problem(ctx, PR_1_BB_FS_BLOCK, pctx)) {
2255 return BLOCK_CHANGED;
2257 } else if (ext2fs_test_block_bitmap2(ctx->block_found_map,
2260 if (fix_problem(ctx, PR_1_BBINODE_BAD_METABLOCK,
2263 return BLOCK_CHANGED;
2265 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
2268 mark_block_used(ctx, blk);
2272 printf ("DEBUG: Marking %u as bad.\n", blk);
2274 ctx->fs_badblocks_count++;
2276 * If the block is not used, then mark it as used and return.
2277 * If it is already marked as found, this must mean that
2278 * there's an overlap between the filesystem table blocks
2279 * (bitmaps and inode table) and the bad block list.
2281 if (!ext2fs_test_block_bitmap2(ctx->block_found_map, blk)) {
2282 ext2fs_mark_block_bitmap2(ctx->block_found_map, blk);
2286 * Try to find the where the filesystem block was used...
2288 first_block = fs->super->s_first_data_block;
2290 for (i = 0; i < fs->group_desc_count; i++ ) {
2293 if (!ext2fs_bg_has_super(fs, i))
2295 if (blk == first_block) {
2297 if (fix_problem(ctx,
2298 PR_1_BAD_PRIMARY_SUPERBLOCK,
2301 return BLOCK_CHANGED;
2305 fix_problem(ctx, PR_1_BAD_SUPERBLOCK, pctx);
2308 if ((blk > first_block) &&
2309 (blk <= first_block + fs->desc_blocks)) {
2311 pctx->blk = *block_nr;
2312 if (fix_problem(ctx,
2313 PR_1_BAD_PRIMARY_GROUP_DESCRIPTOR, pctx)) {
2315 return BLOCK_CHANGED;
2319 fix_problem(ctx, PR_1_BAD_GROUP_DESCRIPTORS, pctx);
2323 if (blk == fs->group_desc[i].bg_block_bitmap) {
2324 if (fix_problem(ctx, PR_1_BB_BAD_BLOCK, pctx)) {
2325 ctx->invalid_block_bitmap_flag[i]++;
2326 ctx->invalid_bitmaps++;
2330 if (blk == fs->group_desc[i].bg_inode_bitmap) {
2331 if (fix_problem(ctx, PR_1_IB_BAD_BLOCK, pctx)) {
2332 ctx->invalid_inode_bitmap_flag[i]++;
2333 ctx->invalid_bitmaps++;
2337 if ((blk >= fs->group_desc[i].bg_inode_table) &&
2338 (blk < (fs->group_desc[i].bg_inode_table +
2339 fs->inode_blocks_per_group))) {
2341 * If there are bad blocks in the inode table,
2342 * the inode scan code will try to do
2343 * something reasonable automatically.
2347 first_block += fs->super->s_blocks_per_group;
2350 * If we've gotten to this point, then the only
2351 * possibility is that the bad block inode meta data
2352 * is using a bad block.
2354 if ((blk == p->inode->i_block[EXT2_IND_BLOCK]) ||
2355 (blk == p->inode->i_block[EXT2_DIND_BLOCK]) ||
2356 (blk == p->inode->i_block[EXT2_TIND_BLOCK])) {
2358 if (fix_problem(ctx, PR_1_BBINODE_BAD_METABLOCK, pctx)) {
2360 return BLOCK_CHANGED;
2362 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
2369 /* Warn user that the block wasn't claimed */
2370 fix_problem(ctx, PR_1_PROGERR_CLAIMED_BLOCK, pctx);
2375 static void new_table_block(e2fsck_t ctx, blk_t first_block, int group,
2376 const char *name, int num, blk64_t *new_block)
2378 ext2_filsys fs = ctx->fs;
2380 blk64_t old_block = *new_block;
2382 int i, is_flexbg, flexbg, flexbg_size;
2384 struct problem_context pctx;
2386 clear_problem_context(&pctx);
2389 pctx.blk = old_block;
2393 * For flex_bg filesystems, first try to allocate the metadata
2394 * within the flex_bg, and if that fails then try finding the
2395 * space anywhere in the filesystem.
2397 is_flexbg = EXT2_HAS_INCOMPAT_FEATURE(fs->super,
2398 EXT4_FEATURE_INCOMPAT_FLEX_BG);
2400 flexbg_size = 1 << fs->super->s_log_groups_per_flex;
2401 flexbg = group / flexbg_size;
2402 first_block = ext2fs_group_first_block(fs,
2403 flexbg_size * flexbg);
2404 last_grp = group | (flexbg_size - 1);
2405 if (last_grp > fs->group_desc_count)
2406 last_grp = fs->group_desc_count;
2407 last_block = ext2fs_group_last_block(fs, last_grp);
2409 last_block = ext2fs_group_last_block(fs, group);
2410 pctx.errcode = ext2fs_get_free_blocks2(fs, first_block, last_block,
2411 num, ctx->block_found_map,
2413 if (is_flexbg && (pctx.errcode == EXT2_ET_BLOCK_ALLOC_FAIL))
2414 pctx.errcode = ext2fs_get_free_blocks2(fs,
2415 fs->super->s_first_data_block,
2416 fs->super->s_blocks_count,
2417 num, ctx->block_found_map, new_block);
2420 fix_problem(ctx, PR_1_RELOC_BLOCK_ALLOCATE, &pctx);
2421 ext2fs_unmark_valid(fs);
2422 ctx->flags |= E2F_FLAG_ABORT;
2425 pctx.errcode = ext2fs_get_mem(fs->blocksize, &buf);
2427 fix_problem(ctx, PR_1_RELOC_MEMORY_ALLOCATE, &pctx);
2428 ext2fs_unmark_valid(fs);
2429 ctx->flags |= E2F_FLAG_ABORT;
2432 ext2fs_mark_super_dirty(fs);
2433 fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY;
2434 pctx.blk2 = *new_block;
2435 fix_problem(ctx, (old_block ? PR_1_RELOC_FROM_TO :
2436 PR_1_RELOC_TO), &pctx);
2438 for (i = 0; i < num; i++) {
2440 ext2fs_mark_block_bitmap2(ctx->block_found_map, (*new_block)+i);
2442 pctx.errcode = io_channel_read_blk64(fs->io,
2443 old_block + i, 1, buf);
2445 fix_problem(ctx, PR_1_RELOC_READ_ERR, &pctx);
2447 memset(buf, 0, fs->blocksize);
2449 pctx.blk = (*new_block) + i;
2450 pctx.errcode = io_channel_write_blk64(fs->io, pctx.blk,
2453 fix_problem(ctx, PR_1_RELOC_WRITE_ERR, &pctx);
2455 ext2fs_free_mem(&buf);
2459 * This routine gets called at the end of pass 1 if bad blocks are
2460 * detected in the superblock, group descriptors, inode_bitmaps, or
2461 * block bitmaps. At this point, all of the blocks have been mapped
2462 * out, so we can try to allocate new block(s) to replace the bad
2465 static void handle_fs_bad_blocks(e2fsck_t ctx)
2467 ext2_filsys fs = ctx->fs;
2469 blk64_t first_block;
2472 for (i = 0; i < fs->group_desc_count; i++) {
2473 first_block = ext2fs_group_first_block(fs, i);
2475 if (ctx->invalid_block_bitmap_flag[i]) {
2476 new_blk = ext2fs_block_bitmap_loc(fs, i);
2477 new_table_block(ctx, first_block, i, _("block bitmap"),
2479 ext2fs_block_bitmap_loc_set(fs, i, new_blk);
2481 if (ctx->invalid_inode_bitmap_flag[i]) {
2482 new_blk = ext2fs_inode_bitmap_loc(fs, i);
2483 new_table_block(ctx, first_block, i, _("inode bitmap"),
2485 ext2fs_inode_bitmap_loc_set(fs, i, new_blk);
2487 if (ctx->invalid_inode_table_flag[i]) {
2488 new_blk = ext2fs_inode_table_loc(fs, i);
2489 new_table_block(ctx, first_block, i, _("inode table"),
2490 fs->inode_blocks_per_group,
2492 ext2fs_inode_table_loc_set(fs, i, new_blk);
2493 ctx->flags |= E2F_FLAG_RESTART;
2496 ctx->invalid_bitmaps = 0;
2500 * This routine marks all blocks which are used by the superblock,
2501 * group descriptors, inode bitmaps, and block bitmaps.
2503 static void mark_table_blocks(e2fsck_t ctx)
2505 ext2_filsys fs = ctx->fs;
2509 struct problem_context pctx;
2511 clear_problem_context(&pctx);
2513 for (i = 0; i < fs->group_desc_count; i++) {
2516 ext2fs_reserve_super_and_bgd(fs, i, ctx->block_found_map);
2519 * Mark the blocks used for the inode table
2521 if (fs->group_desc[i].bg_inode_table) {
2522 for (j = 0, b = fs->group_desc[i].bg_inode_table;
2523 j < fs->inode_blocks_per_group;
2525 if (ext2fs_test_block_bitmap2(ctx->block_found_map,
2528 if (!ctx->invalid_inode_table_flag[i] &&
2530 PR_1_ITABLE_CONFLICT, &pctx)) {
2531 ctx->invalid_inode_table_flag[i]++;
2532 ctx->invalid_bitmaps++;
2535 ext2fs_mark_block_bitmap2(ctx->block_found_map,
2542 * Mark block used for the block bitmap
2544 if (fs->group_desc[i].bg_block_bitmap) {
2545 if (ext2fs_test_block_bitmap2(ctx->block_found_map,
2546 fs->group_desc[i].bg_block_bitmap)) {
2547 pctx.blk = fs->group_desc[i].bg_block_bitmap;
2548 if (fix_problem(ctx, PR_1_BB_CONFLICT, &pctx)) {
2549 ctx->invalid_block_bitmap_flag[i]++;
2550 ctx->invalid_bitmaps++;
2553 ext2fs_mark_block_bitmap2(ctx->block_found_map,
2554 fs->group_desc[i].bg_block_bitmap);
2559 * Mark block used for the inode bitmap
2561 if (fs->group_desc[i].bg_inode_bitmap) {
2562 if (ext2fs_test_block_bitmap2(ctx->block_found_map,
2563 fs->group_desc[i].bg_inode_bitmap)) {
2564 pctx.blk = fs->group_desc[i].bg_inode_bitmap;
2565 if (fix_problem(ctx, PR_1_IB_CONFLICT, &pctx)) {
2566 ctx->invalid_inode_bitmap_flag[i]++;
2567 ctx->invalid_bitmaps++;
2570 ext2fs_mark_block_bitmap2(ctx->block_found_map,
2571 fs->group_desc[i].bg_inode_bitmap);
2578 * Thes subroutines short circuits ext2fs_get_blocks and
2579 * ext2fs_check_directory; we use them since we already have the inode
2580 * structure, so there's no point in letting the ext2fs library read
2583 static errcode_t pass1_get_blocks(ext2_filsys fs, ext2_ino_t ino,
2586 e2fsck_t ctx = (e2fsck_t) fs->priv_data;
2589 if ((ino != ctx->stashed_ino) || !ctx->stashed_inode)
2590 return EXT2_ET_CALLBACK_NOTHANDLED;
2592 for (i=0; i < EXT2_N_BLOCKS; i++)
2593 blocks[i] = ctx->stashed_inode->i_block[i];
2597 static errcode_t pass1_read_inode(ext2_filsys fs, ext2_ino_t ino,
2598 struct ext2_inode *inode)
2600 e2fsck_t ctx = (e2fsck_t) fs->priv_data;
2602 if ((ino != ctx->stashed_ino) || !ctx->stashed_inode)
2603 return EXT2_ET_CALLBACK_NOTHANDLED;
2604 *inode = *ctx->stashed_inode;
2608 static errcode_t pass1_write_inode(ext2_filsys fs, ext2_ino_t ino,
2609 struct ext2_inode *inode)
2611 e2fsck_t ctx = (e2fsck_t) fs->priv_data;
2613 if ((ino == ctx->stashed_ino) && ctx->stashed_inode &&
2614 (inode != ctx->stashed_inode))
2615 *ctx->stashed_inode = *inode;
2616 return EXT2_ET_CALLBACK_NOTHANDLED;
2619 static errcode_t pass1_check_directory(ext2_filsys fs, ext2_ino_t ino)
2621 e2fsck_t ctx = (e2fsck_t) fs->priv_data;
2623 if ((ino != ctx->stashed_ino) || !ctx->stashed_inode)
2624 return EXT2_ET_CALLBACK_NOTHANDLED;
2626 if (!LINUX_S_ISDIR(ctx->stashed_inode->i_mode))
2627 return EXT2_ET_NO_DIRECTORY;
2631 static errcode_t e2fsck_get_alloc_block(ext2_filsys fs, blk64_t goal,
2634 e2fsck_t ctx = (e2fsck_t) fs->priv_data;
2638 if (ctx->block_found_map) {
2639 retval = ext2fs_new_block2(fs, (blk_t) goal,
2640 ctx->block_found_map, &new_block);
2644 if (!fs->block_map) {
2645 retval = ext2fs_read_block_bitmap(fs);
2650 retval = ext2fs_new_block2(fs, (blk_t) goal, 0, &new_block);
2659 static void e2fsck_block_alloc_stats(ext2_filsys fs, blk64_t blk, int inuse)
2661 e2fsck_t ctx = (e2fsck_t) fs->priv_data;
2663 if (ctx->block_found_map) {
2665 ext2fs_mark_block_bitmap2(ctx->block_found_map,
2668 ext2fs_unmark_block_bitmap2(ctx->block_found_map,
2673 void e2fsck_use_inode_shortcuts(e2fsck_t ctx, int bool)
2675 ext2_filsys fs = ctx->fs;
2678 fs->get_blocks = pass1_get_blocks;
2679 fs->check_directory = pass1_check_directory;
2680 fs->read_inode = pass1_read_inode;
2681 fs->write_inode = pass1_write_inode;
2682 ctx->stashed_ino = 0;
2683 ext2fs_set_alloc_block_callback(fs, e2fsck_get_alloc_block,
2685 ext2fs_set_block_alloc_stats_callback(fs,
2686 e2fsck_block_alloc_stats,
2690 fs->check_directory = 0;
2692 fs->write_inode = 0;