From: "Vladimir N. Oleynik" Date: Tue, 27 Sep 2005 11:43:29 +0000 (-0000) Subject: move e2fsck/* to e2fsck.c, one e2fsck_main and jornal exported, small automatic size... X-Git-Tag: 1_1_0~628 X-Git-Url: https://git.librecmc.org/?a=commitdiff_plain;h=3978e5576e1675c2fac631fcba07a976405b5e4b;p=oweals%2Fbusybox.git move e2fsck/* to e2fsck.c, one e2fsck_main and jornal exported, small automatic size reduction --- diff --git a/e2fsprogs/Makefile.in b/e2fsprogs/Makefile.in index e1459e05f..f7dbba30f 100644 --- a/e2fsprogs/Makefile.in +++ b/e2fsprogs/Makefile.in @@ -11,37 +11,33 @@ E2FSPROGS_DIR:=$(top_builddir)/e2fsprogs E2FSPROGS_CFLAGS := -I$(E2FSPROGS_DIR) -include $(E2FSPROGS_DIR)/e2fsbb.h BLKID_SRC := cache.c dev.c devname.c devno.c blkid_getsize.c \ - probe.c read.c resolve.c save.c tag.c resolve.c + probe.c read.c resolve.c save.c tag.c resolve.c BLKID_SRCS := $(patsubst %,blkid/%, $(BLKID_SRC)) BLKID_OBJS := $(patsubst %.c,%.o, $(BLKID_SRCS)) -E2FSCK_SRC := badblocks.c dict.c dirinfo.c dx_dirinfo.c e2fsck.c \ - ea_refcount.c ehandler.c journal.c message.c pass1.c pass1b.c \ - pass2.c pass3.c pass4.c pass5.c problem.c recovery.c region.c \ - rehash.c revoke.c super.c swapfs.c util.c -E2FSCK_SRCS := $(patsubst %,e2fsck/%, $(E2FSCK_SRC)) +E2FSCK_SRCS := e2fsck.c E2FSCK_OBJS := $(patsubst %.c,%.o, $(E2FSCK_SRCS)) E2P_SRC := fgetsetflags.c fgetsetversion.c pf.c iod.c mntopts.c \ - feature.c ls.c uuid.c pe.c ostype.c ps.c hashstr.c \ - parse_num.c + feature.c ls.c uuid.c pe.c ostype.c ps.c hashstr.c \ + parse_num.c E2P_SRCS := $(patsubst %,e2p/%, $(E2P_SRC)) E2P_OBJS := $(patsubst %.c,%.o, $(E2P_SRCS)) EXT2FS_SRC := gen_bitmap.c bitops.c ismounted.c mkjournal.c unix_io.c \ - rw_bitmaps.c initialize.c bitmaps.c block.c \ - ind_block.c inode.c freefs.c alloc_stats.c closefs.c \ - openfs.c io_manager.c finddev.c read_bb.c alloc.c badblocks.c \ - getsize.c getsectsize.c alloc_tables.c read_bb_file.c mkdir.c \ - bb_inode.c newdir.c alloc_sb.c lookup.c dirblock.c expanddir.c \ - dir_iterate.c link.c res_gdt.c icount.c get_pathname.c dblist.c \ - dirhash.c version.c flushb.c unlink.c check_desc.c valid_blk.c \ - ext_attr.c bmap.c dblist_dir.c ext2fs_inline.c + rw_bitmaps.c initialize.c bitmaps.c block.c \ + ind_block.c inode.c freefs.c alloc_stats.c closefs.c \ + openfs.c io_manager.c finddev.c read_bb.c alloc.c badblocks.c \ + getsize.c getsectsize.c alloc_tables.c read_bb_file.c mkdir.c \ + bb_inode.c newdir.c alloc_sb.c lookup.c dirblock.c expanddir.c \ + dir_iterate.c link.c res_gdt.c icount.c get_pathname.c dblist.c \ + dirhash.c version.c flushb.c unlink.c check_desc.c valid_blk.c \ + ext_attr.c bmap.c dblist_dir.c ext2fs_inline.c EXT2FS_SRCS := $(patsubst %,ext2fs/%, $(EXT2FS_SRC)) EXT2FS_OBJS := $(patsubst %.c,%.o, $(EXT2FS_SRCS)) UUID_SRC := compare.c gen_uuid.c pack.c parse.c unpack.c unparse.c \ - uuid_time.c + uuid_time.c UUID_SRCS := $(patsubst %,uuid/%, $(UUID_SRC)) UUID_OBJS := $(patsubst %.c,%.o, $(UUID_SRCS)) diff --git a/e2fsprogs/e2fsck.c b/e2fsprogs/e2fsck.c index db93ea0ce..74bc9f7b8 100644 --- a/e2fsprogs/e2fsck.c +++ b/e2fsprogs/e2fsck.c @@ -1,6 +1,14932 @@ /* - * unix.c - The unix-specific code for e2fsck - * + * e2fsck + * + * Copyright (C) 1993, 1994 Theodore Ts'o. This file may be + * redistributed under the terms of the GNU Public License. + * + */ + +#ifndef _GNU_SOURCE +#define _GNU_SOURCE 1 /* get strnlen() */ +#endif +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "e2fsbb.h" + +#include "ext2fs/ext2_fs.h" +#include "ext2fs/ext2fs.h" +#include "blkid/blkid.h" +#include "ext2fs/ext2_ext_attr.h" +#include "uuid/uuid.h" + +#ifdef __GNUC__ +#define _INLINE_ __inline__ +#define EXT2FS_ATTR(x) __attribute__(x) +#else +#define _INLINE_ +#define EXT2FS_ATTR(x) +#endif + +/* + * Exit codes used by fsck-type programs + */ +#define FSCK_OK 0 /* No errors */ +#define FSCK_NONDESTRUCT 1 /* File system errors corrected */ +#define FSCK_REBOOT 2 /* System should be rebooted */ +#define FSCK_UNCORRECTED 4 /* File system errors left uncorrected */ +#define FSCK_ERROR 8 /* Operational error */ +#define FSCK_USAGE 16 /* Usage or syntax error */ +#define FSCK_CANCELED 32 /* Aborted with a signal or ^C */ +#define FSCK_LIBRARY 128 /* Shared library error */ + +/* + * The last ext2fs revision level that this version of e2fsck is able to + * support + */ +#define E2FSCK_CURRENT_REV 1 + +/* + * The directory information structure; stores directory information + * collected in earlier passes, to avoid disk i/o in fetching the + * directory information. + */ +struct dir_info { + ext2_ino_t ino; /* Inode number */ + ext2_ino_t dotdot; /* Parent according to '..' */ + ext2_ino_t parent; /* Parent according to treewalk */ +}; + + +/* + * The indexed directory information structure; stores information for + * directories which contain a hash tree index. + */ +struct dx_dir_info { + ext2_ino_t ino; /* Inode number */ + int numblocks; /* number of blocks */ + int hashversion; + short depth; /* depth of tree */ + struct dx_dirblock_info *dx_block; /* Array of size numblocks */ +}; + +#define DX_DIRBLOCK_ROOT 1 +#define DX_DIRBLOCK_LEAF 2 +#define DX_DIRBLOCK_NODE 3 +#define DX_DIRBLOCK_CORRUPT 4 +#define DX_DIRBLOCK_CLEARED 8 + +struct dx_dirblock_info { + int type; + blk_t phys; + int flags; + blk_t parent; + ext2_dirhash_t min_hash; + ext2_dirhash_t max_hash; + ext2_dirhash_t node_min_hash; + ext2_dirhash_t node_max_hash; +}; + +#define DX_FLAG_REFERENCED 1 +#define DX_FLAG_DUP_REF 2 +#define DX_FLAG_FIRST 4 +#define DX_FLAG_LAST 8 + +#ifdef RESOURCE_TRACK +/* + * This structure is used for keeping track of how much resources have + * been used for a particular pass of e2fsck. + */ +struct resource_track { + struct timeval time_start; + struct timeval user_start; + struct timeval system_start; + void *brk_start; +}; +#endif + +/* + * E2fsck options + */ +#define E2F_OPT_READONLY 0x0001 +#define E2F_OPT_PREEN 0x0002 +#define E2F_OPT_YES 0x0004 +#define E2F_OPT_NO 0x0008 +#define E2F_OPT_TIME 0x0010 +#define E2F_OPT_TIME2 0x0020 +#define E2F_OPT_CHECKBLOCKS 0x0040 +#define E2F_OPT_DEBUG 0x0080 +#define E2F_OPT_FORCE 0x0100 +#define E2F_OPT_WRITECHECK 0x0200 +#define E2F_OPT_COMPRESS_DIRS 0x0400 + +/* + * E2fsck flags + */ +#define E2F_FLAG_ABORT 0x0001 /* Abort signaled */ +#define E2F_FLAG_CANCEL 0x0002 /* Cancel signaled */ +#define E2F_FLAG_SIGNAL_MASK 0x0003 +#define E2F_FLAG_RESTART 0x0004 /* Restart signaled */ + +#define E2F_FLAG_SETJMP_OK 0x0010 /* Setjmp valid for abort */ + +#define E2F_FLAG_PROG_BAR 0x0020 /* Progress bar on screen */ +#define E2F_FLAG_PROG_SUPPRESS 0x0040 /* Progress suspended */ +#define E2F_FLAG_JOURNAL_INODE 0x0080 /* Create a new ext3 journal inode */ +#define E2F_FLAG_SB_SPECIFIED 0x0100 /* The superblock was explicitly + * specified by the user */ +#define E2F_FLAG_RESTARTED 0x0200 /* E2fsck has been restarted */ +#define E2F_FLAG_RESIZE_INODE 0x0400 /* Request to recreate resize inode */ + +/* + * Defines for indicating the e2fsck pass number + */ +#define E2F_PASS_1 1 +#define E2F_PASS_2 2 +#define E2F_PASS_3 3 +#define E2F_PASS_4 4 +#define E2F_PASS_5 5 +#define E2F_PASS_1B 6 + +/* + * Define the extended attribute refcount structure + */ +typedef struct ea_refcount *ext2_refcount_t; + +/* + * This is the global e2fsck structure. + */ +typedef struct e2fsck_struct *e2fsck_t; + +struct e2fsck_struct { + ext2_filsys fs; + const char *program_name; + char *filesystem_name; + char *device_name; + char *io_options; + int flags; /* E2fsck internal flags */ + int options; + blk_t use_superblock; /* sb requested by user */ + blk_t superblock; /* sb used to open fs */ + int blocksize; /* blocksize */ + blk_t num_blocks; /* Total number of blocks */ + int mount_flags; + blkid_cache blkid; /* blkid cache */ + + jmp_buf abort_loc; + + unsigned long abort_code; + + int (*progress)(e2fsck_t ctx, int pass, unsigned long cur, + unsigned long max); + + ext2fs_inode_bitmap inode_used_map; /* Inodes which are in use */ + ext2fs_inode_bitmap inode_bad_map; /* Inodes which are bad somehow */ + ext2fs_inode_bitmap inode_dir_map; /* Inodes which are directories */ + ext2fs_inode_bitmap inode_bb_map; /* Inodes which are in bad blocks */ + ext2fs_inode_bitmap inode_imagic_map; /* AFS inodes */ + ext2fs_inode_bitmap inode_reg_map; /* Inodes which are regular files*/ + + ext2fs_block_bitmap block_found_map; /* Blocks which are in use */ + ext2fs_block_bitmap block_dup_map; /* Blks referenced more than once */ + ext2fs_block_bitmap block_ea_map; /* Blocks which are used by EA's */ + + /* + * Inode count arrays + */ + ext2_icount_t inode_count; + ext2_icount_t inode_link_info; + + ext2_refcount_t refcount; + ext2_refcount_t refcount_extra; + + /* + * Array of flags indicating whether an inode bitmap, block + * bitmap, or inode table is invalid + */ + int *invalid_inode_bitmap_flag; + int *invalid_block_bitmap_flag; + int *invalid_inode_table_flag; + int invalid_bitmaps; /* There are invalid bitmaps/itable */ + + /* + * Block buffer + */ + char *block_buf; + + /* + * For pass1_check_directory and pass1_get_blocks + */ + ext2_ino_t stashed_ino; + struct ext2_inode *stashed_inode; + + /* + * Location of the lost and found directory + */ + ext2_ino_t lost_and_found; + int bad_lost_and_found; + + /* + * Directory information + */ + int dir_info_count; + int dir_info_size; + struct dir_info *dir_info; + + /* + * Indexed directory information + */ + int dx_dir_info_count; + int dx_dir_info_size; + struct dx_dir_info *dx_dir_info; + + /* + * Directories to hash + */ + ext2_u32_list dirs_to_hash; + + /* + * Tuning parameters + */ + int process_inode_size; + int inode_buffer_blocks; + + /* + * ext3 journal support + */ + io_channel journal_io; + char *journal_name; + +#ifdef RESOURCE_TRACK + /* + * For timing purposes + */ + struct resource_track global_rtrack; +#endif + + /* + * How we display the progress update (for unix) + */ + int progress_fd; + int progress_pos; + int progress_last_percent; + unsigned int progress_last_time; + int interactive; /* Are we connected directly to a tty? */ + char start_meta[2], stop_meta[2]; + + /* File counts */ + int fs_directory_count; + int fs_regular_count; + int fs_blockdev_count; + int fs_chardev_count; + int fs_links_count; + int fs_symlinks_count; + int fs_fast_symlinks_count; + int fs_fifo_count; + int fs_total_count; + int fs_badblocks_count; + int fs_sockets_count; + int fs_ind_count; + int fs_dind_count; + int fs_tind_count; + int fs_fragmented; + int large_files; + int fs_ext_attr_inodes; + int fs_ext_attr_blocks; + + int ext_attr_ver; + + /* + * For the use of callers of the e2fsck functions; not used by + * e2fsck functions themselves. + */ + void *priv_data; +}; + +/* Used by the region allocation code */ +typedef __u32 region_addr_t; +typedef struct region_struct *region_t; + +/* + * Procedure declarations + */ + +static void e2fsck_pass1(e2fsck_t ctx); +static void e2fsck_pass1_dupblocks(e2fsck_t ctx, char *block_buf); +static void e2fsck_pass2(e2fsck_t ctx); +static void e2fsck_pass3(e2fsck_t ctx); +static void e2fsck_pass4(e2fsck_t ctx); +static void e2fsck_pass5(e2fsck_t ctx); + +/* e2fsck.c */ +static errcode_t e2fsck_allocate_context(e2fsck_t *ret); +static errcode_t e2fsck_reset_context(e2fsck_t ctx); +static void e2fsck_free_context(e2fsck_t ctx); +static int e2fsck_run(e2fsck_t ctx); + + +/* badblock.c */ +static void read_bad_blocks_file(e2fsck_t ctx, const char *bad_blocks_file, + int replace_bad_blocks); + +/* dirinfo.c */ +static void e2fsck_add_dir_info(e2fsck_t ctx, ext2_ino_t ino, ext2_ino_t parent); +static struct dir_info *e2fsck_get_dir_info(e2fsck_t ctx, ext2_ino_t ino); +static void e2fsck_free_dir_info(e2fsck_t ctx); +static int e2fsck_get_num_dirinfo(e2fsck_t ctx); +static struct dir_info *e2fsck_dir_info_iter(e2fsck_t ctx, int *control); + +/* dx_dirinfo.c */ +static void e2fsck_add_dx_dir(e2fsck_t ctx, ext2_ino_t ino, int num_blocks); +static struct dx_dir_info *e2fsck_get_dx_dir_info(e2fsck_t ctx, ext2_ino_t ino); +static void e2fsck_free_dx_dir_info(e2fsck_t ctx); +static struct dx_dir_info *e2fsck_dx_dir_info_iter(e2fsck_t ctx, int *control); + +/* ea_refcount.c */ +static errcode_t ea_refcount_create(int size, ext2_refcount_t *ret); +static void ea_refcount_free(ext2_refcount_t refcount); +static errcode_t ea_refcount_increment(ext2_refcount_t refcount, + blk_t blk, int *ret); +static errcode_t ea_refcount_decrement(ext2_refcount_t refcount, + blk_t blk, int *ret); +static errcode_t ea_refcount_store(ext2_refcount_t refcount, + blk_t blk, int count); +static void ea_refcount_intr_begin(ext2_refcount_t refcount); +static blk_t ea_refcount_intr_next(ext2_refcount_t refcount, int *ret); + +/* ehandler.c */ +static const char *ehandler_operation(const char *op); +static void ehandler_init(io_channel channel); + +/* journal.c */ +static int e2fsck_check_ext3_journal(e2fsck_t ctx); +static int e2fsck_run_ext3_journal(e2fsck_t ctx); +static void e2fsck_move_ext3_journal(e2fsck_t ctx); + +/* pass1.c */ +static void e2fsck_use_inode_shortcuts(e2fsck_t ctx, int bool); +static int e2fsck_pass1_check_device_inode(ext2_filsys fs, + struct ext2_inode *inode); +static int e2fsck_pass1_check_symlink(ext2_filsys fs, + struct ext2_inode *inode, char *buf); + +/* pass2.c */ +static int e2fsck_process_bad_inode(e2fsck_t ctx, ext2_ino_t dir, + ext2_ino_t ino, char *buf); + +/* pass3.c */ +static int e2fsck_reconnect_file(e2fsck_t ctx, ext2_ino_t inode); +static errcode_t e2fsck_expand_directory(e2fsck_t ctx, ext2_ino_t dir, + int num, int gauranteed_size); +static ext2_ino_t e2fsck_get_lost_and_found(e2fsck_t ctx, int fix); +static errcode_t e2fsck_adjust_inode_count(e2fsck_t ctx, ext2_ino_t ino, + int adj); + + +/* region.c */ +static region_t region_create(region_addr_t min, region_addr_t max); +static void region_free(region_t region); +static int region_allocate(region_t region, region_addr_t start, int n); + +/* rehash.c */ +static errcode_t e2fsck_rehash_dir(e2fsck_t ctx, ext2_ino_t ino); +static void e2fsck_rehash_directories(e2fsck_t ctx); + +/* super.c */ +static void check_super_block(e2fsck_t ctx); +static errcode_t e2fsck_get_device_size(e2fsck_t ctx); + +#ifdef ENABLE_SWAPFS +/* swapfs.c */ +static void swap_filesys(e2fsck_t ctx); +#endif + +/* util.c */ +static void *e2fsck_allocate_memory(e2fsck_t ctx, unsigned int size, + const char *description); +static int ask(e2fsck_t ctx, const char * string, int def); +static int ask_yn(const char * string, int def); +static void e2fsck_read_bitmaps(e2fsck_t ctx); +static void e2fsck_write_bitmaps(e2fsck_t ctx); +static void preenhalt(e2fsck_t ctx); +static char *string_copy(e2fsck_t ctx, const char *str, int len); +#ifdef RESOURCE_TRACK +static void print_resource_track(const char *desc, + struct resource_track *track); +static void init_resource_track(struct resource_track *track); +#endif +static void e2fsck_read_inode(e2fsck_t ctx, unsigned long ino, + struct ext2_inode * inode, const char * proc); +static void e2fsck_write_inode(e2fsck_t ctx, unsigned long ino, + struct ext2_inode * inode, const char * proc); +#ifdef MTRACE +static void mtrace_print(char *mesg); +#endif +static blk_t get_backup_sb(e2fsck_t ctx, ext2_filsys fs, + const char *name, io_manager manager); +static int ext2_file_type(unsigned int mode); + +/* unix.c */ +static void e2fsck_clear_progbar(e2fsck_t ctx); +static int e2fsck_simple_progress(e2fsck_t ctx, const char *label, + float percent, unsigned int dpynum); +/* + * problem.h --- e2fsck problem error codes + */ + +typedef __u32 problem_t; + +struct problem_context { + errcode_t errcode; + ext2_ino_t ino, ino2, dir; + struct ext2_inode *inode; + struct ext2_dir_entry *dirent; + blk_t blk, blk2; + e2_blkcnt_t blkcount; + int group; + __u64 num; + const char *str; +}; + +/* + * We define a set of "latch groups"; these are problems which are + * handled as a set. The user answers once for a particular latch + * group. + */ +#define PR_LATCH_MASK 0x0ff0 /* Latch mask */ +#define PR_LATCH_BLOCK 0x0010 /* Latch for illegal blocks (pass 1) */ +#define PR_LATCH_BBLOCK 0x0020 /* Latch for bad block inode blocks (pass 1) */ +#define PR_LATCH_IBITMAP 0x0030 /* Latch for pass 5 inode bitmap proc. */ +#define PR_LATCH_BBITMAP 0x0040 /* Latch for pass 5 inode bitmap proc. */ +#define PR_LATCH_RELOC 0x0050 /* Latch for superblock relocate hint */ +#define PR_LATCH_DBLOCK 0x0060 /* Latch for pass 1b dup block headers */ +#define PR_LATCH_LOW_DTIME 0x0070 /* Latch for pass1 orphaned list refugees */ +#define PR_LATCH_TOOBIG 0x0080 /* Latch for file to big errors */ +#define PR_LATCH_OPTIMIZE_DIR 0x0090 /* Latch for optimize directories */ + +#define PR_LATCH(x) ((((x) & PR_LATCH_MASK) >> 4) - 1) + +/* + * Latch group descriptor flags + */ +#define PRL_YES 0x0001 /* Answer yes */ +#define PRL_NO 0x0002 /* Answer no */ +#define PRL_LATCHED 0x0004 /* The latch group is latched */ +#define PRL_SUPPRESS 0x0008 /* Suppress all latch group questions */ + +#define PRL_VARIABLE 0x000f /* All the flags that need to be reset */ + +/* + * Pre-Pass 1 errors + */ + +/* Block bitmap not in group */ +#define PR_0_BB_NOT_GROUP 0x000001 + +/* Inode bitmap not in group */ +#define PR_0_IB_NOT_GROUP 0x000002 + +/* Inode table not in group */ +#define PR_0_ITABLE_NOT_GROUP 0x000003 + +/* Superblock corrupt */ +#define PR_0_SB_CORRUPT 0x000004 + +/* Filesystem size is wrong */ +#define PR_0_FS_SIZE_WRONG 0x000005 + +/* Fragments not supported */ +#define PR_0_NO_FRAGMENTS 0x000006 + +/* Bad blocks_per_group */ +#define PR_0_BLOCKS_PER_GROUP 0x000007 + +/* Bad first_data_block */ +#define PR_0_FIRST_DATA_BLOCK 0x000008 + +/* Adding UUID to filesystem */ +#define PR_0_ADD_UUID 0x000009 + +/* Relocate hint */ +#define PR_0_RELOCATE_HINT 0x00000A + +/* Miscellaneous superblock corruption */ +#define PR_0_MISC_CORRUPT_SUPER 0x00000B + +/* Error determing physical device size of filesystem */ +#define PR_0_GETSIZE_ERROR 0x00000C + +/* Inode count in the superblock incorrect */ +#define PR_0_INODE_COUNT_WRONG 0x00000D + +/* The Hurd does not support the filetype feature */ +#define PR_0_HURD_CLEAR_FILETYPE 0x00000E + +/* Journal inode is invalid */ +#define PR_0_JOURNAL_BAD_INODE 0x00000F + +/* The external journal has multiple filesystems (which we can't handle yet) */ +#define PR_0_JOURNAL_UNSUPP_MULTIFS 0x000010 + +/* Can't find external journal */ +#define PR_0_CANT_FIND_JOURNAL 0x000011 + +/* External journal has bad superblock */ +#define PR_0_EXT_JOURNAL_BAD_SUPER 0x000012 + +/* Superblock has a bad journal UUID */ +#define PR_0_JOURNAL_BAD_UUID 0x000013 + +/* Journal has an unknown superblock type */ +#define PR_0_JOURNAL_UNSUPP_SUPER 0x000014 + +/* Journal superblock is corrupt */ +#define PR_0_JOURNAL_BAD_SUPER 0x000015 + +/* Journal superblock is corrupt */ +#define PR_0_JOURNAL_HAS_JOURNAL 0x000016 + +/* Superblock has recovery flag set but no journal */ +#define PR_0_JOURNAL_RECOVER_SET 0x000017 + +/* Journal has data, but recovery flag is clear */ +#define PR_0_JOURNAL_RECOVERY_CLEAR 0x000018 + +/* Ask if we should clear the journal */ +#define PR_0_JOURNAL_RESET_JOURNAL 0x000019 + +/* Filesystem revision is 0, but feature flags are set */ +#define PR_0_FS_REV_LEVEL 0x00001A + +/* Clearing orphan inode */ +#define PR_0_ORPHAN_CLEAR_INODE 0x000020 + +/* Illegal block found in orphaned inode */ +#define PR_0_ORPHAN_ILLEGAL_BLOCK_NUM 0x000021 + +/* Already cleared block found in orphaned inode */ +#define PR_0_ORPHAN_ALREADY_CLEARED_BLOCK 0x000022 + +/* Illegal orphan inode in superblock */ +#define PR_0_ORPHAN_ILLEGAL_HEAD_INODE 0x000023 + +/* Illegal inode in orphaned inode list */ +#define PR_0_ORPHAN_ILLEGAL_INODE 0x000024 + +/* Journal has unsupported read-only feature - abort */ +#define PR_0_JOURNAL_UNSUPP_ROCOMPAT 0x000025 + +/* Journal has unsupported incompatible feature - abort */ +#define PR_0_JOURNAL_UNSUPP_INCOMPAT 0x000026 + +/* Journal has unsupported version number */ +#define PR_0_JOURNAL_UNSUPP_VERSION 0x000027 + +/* Moving journal to hidden file */ +#define PR_0_MOVE_JOURNAL 0x000028 + +/* Error moving journal */ +#define PR_0_ERR_MOVE_JOURNAL 0x000029 + +/* Clearing V2 journal superblock */ +#define PR_0_CLEAR_V2_JOURNAL 0x00002A + +/* Run journal anyway */ +#define PR_0_JOURNAL_RUN 0x00002B + +/* Run journal anyway by default */ +#define PR_0_JOURNAL_RUN_DEFAULT 0x00002C + +/* Backup journal inode blocks */ +#define PR_0_BACKUP_JNL 0x00002D + +/* Reserved blocks w/o resize_inode */ +#define PR_0_NONZERO_RESERVED_GDT_BLOCKS 0x00002E + +/* Resize_inode not enabled, but resize inode is non-zero */ +#define PR_0_CLEAR_RESIZE_INODE 0x00002F + +/* Resize inode invalid */ +#define PR_0_RESIZE_INODE_INVALID 0x000030 + +/* + * Pass 1 errors + */ + +/* Pass 1: Checking inodes, blocks, and sizes */ +#define PR_1_PASS_HEADER 0x010000 + +/* Root directory is not an inode */ +#define PR_1_ROOT_NO_DIR 0x010001 + +/* Root directory has dtime set */ +#define PR_1_ROOT_DTIME 0x010002 + +/* Reserved inode has bad mode */ +#define PR_1_RESERVED_BAD_MODE 0x010003 + +/* Deleted inode has zero dtime */ +#define PR_1_ZERO_DTIME 0x010004 + +/* Inode in use, but dtime set */ +#define PR_1_SET_DTIME 0x010005 + +/* Zero-length directory */ +#define PR_1_ZERO_LENGTH_DIR 0x010006 + +/* Block bitmap conflicts with some other fs block */ +#define PR_1_BB_CONFLICT 0x010007 + +/* Inode bitmap conflicts with some other fs block */ +#define PR_1_IB_CONFLICT 0x010008 + +/* Inode table conflicts with some other fs block */ +#define PR_1_ITABLE_CONFLICT 0x010009 + +/* Block bitmap is on a bad block */ +#define PR_1_BB_BAD_BLOCK 0x01000A + +/* Inode bitmap is on a bad block */ +#define PR_1_IB_BAD_BLOCK 0x01000B + +/* Inode has incorrect i_size */ +#define PR_1_BAD_I_SIZE 0x01000C + +/* Inode has incorrect i_blocks */ +#define PR_1_BAD_I_BLOCKS 0x01000D + +/* Illegal block number in inode */ +#define PR_1_ILLEGAL_BLOCK_NUM 0x01000E + +/* Block number overlaps fs metadata */ +#define PR_1_BLOCK_OVERLAPS_METADATA 0x01000F + +/* Inode has illegal blocks (latch question) */ +#define PR_1_INODE_BLOCK_LATCH 0x010010 + +/* Too many bad blocks in inode */ +#define PR_1_TOO_MANY_BAD_BLOCKS 0x010011 + +/* Illegal block number in bad block inode */ +#define PR_1_BB_ILLEGAL_BLOCK_NUM 0x010012 + +/* Bad block inode has illegal blocks (latch question) */ +#define PR_1_INODE_BBLOCK_LATCH 0x010013 + +/* Duplicate or bad blocks in use! */ +#define PR_1_DUP_BLOCKS_PREENSTOP 0x010014 + +/* Bad block used as bad block indirect block */ +#define PR_1_BBINODE_BAD_METABLOCK 0x010015 + +/* Inconsistency can't be fixed prompt */ +#define PR_1_BBINODE_BAD_METABLOCK_PROMPT 0x010016 + +/* Bad primary block */ +#define PR_1_BAD_PRIMARY_BLOCK 0x010017 + +/* Bad primary block prompt */ +#define PR_1_BAD_PRIMARY_BLOCK_PROMPT 0x010018 + +/* Bad primary superblock */ +#define PR_1_BAD_PRIMARY_SUPERBLOCK 0x010019 + +/* Bad primary block group descriptors */ +#define PR_1_BAD_PRIMARY_GROUP_DESCRIPTOR 0x01001A + +/* Bad superblock in group */ +#define PR_1_BAD_SUPERBLOCK 0x01001B + +/* Bad block group descriptors in group */ +#define PR_1_BAD_GROUP_DESCRIPTORS 0x01001C + +/* Block claimed for no reason */ +#define PR_1_PROGERR_CLAIMED_BLOCK 0x01001D + +/* Error allocating blocks for relocating metadata */ +#define PR_1_RELOC_BLOCK_ALLOCATE 0x01001E + +/* Error allocating block buffer during relocation process */ +#define PR_1_RELOC_MEMORY_ALLOCATE 0x01001F + +/* Relocating metadata group information from X to Y */ +#define PR_1_RELOC_FROM_TO 0x010020 + +/* Relocating metatdata group information to X */ +#define PR_1_RELOC_TO 0x010021 + +/* Block read error during relocation process */ +#define PR_1_RELOC_READ_ERR 0x010022 + +/* Block write error during relocation process */ +#define PR_1_RELOC_WRITE_ERR 0x010023 + +/* Error allocating inode bitmap */ +#define PR_1_ALLOCATE_IBITMAP_ERROR 0x010024 + +/* Error allocating block bitmap */ +#define PR_1_ALLOCATE_BBITMAP_ERROR 0x010025 + +/* Error allocating icount structure */ +#define PR_1_ALLOCATE_ICOUNT 0x010026 + +/* Error allocating dbcount */ +#define PR_1_ALLOCATE_DBCOUNT 0x010027 + +/* Error while scanning inodes */ +#define PR_1_ISCAN_ERROR 0x010028 + +/* Error while iterating over blocks */ +#define PR_1_BLOCK_ITERATE 0x010029 + +/* Error while storing inode count information */ +#define PR_1_ICOUNT_STORE 0x01002A + +/* Error while storing directory block information */ +#define PR_1_ADD_DBLOCK 0x01002B + +/* Error while reading inode (for clearing) */ +#define PR_1_READ_INODE 0x01002C + +/* Suppress messages prompt */ +#define PR_1_SUPPRESS_MESSAGES 0x01002D + +/* Imagic flag set on an inode when filesystem doesn't support it */ +#define PR_1_SET_IMAGIC 0x01002F + +/* Immutable flag set on a device or socket inode */ +#define PR_1_SET_IMMUTABLE 0x010030 + +/* Compression flag set on a non-compressed filesystem */ +#define PR_1_COMPR_SET 0x010031 + +/* Non-zero size on on device, fifo or socket inode */ +#define PR_1_SET_NONZSIZE 0x010032 + +/* Filesystem revision is 0, but feature flags are set */ +#define PR_1_FS_REV_LEVEL 0x010033 + +/* Journal inode not in use, needs clearing */ +#define PR_1_JOURNAL_INODE_NOT_CLEAR 0x010034 + +/* Journal inode has wrong mode */ +#define PR_1_JOURNAL_BAD_MODE 0x010035 + +/* Inode that was part of orphan linked list */ +#define PR_1_LOW_DTIME 0x010036 + +/* Latch question which asks how to deal with low dtime inodes */ +#define PR_1_ORPHAN_LIST_REFUGEES 0x010037 + +/* Error allocating refcount structure */ +#define PR_1_ALLOCATE_REFCOUNT 0x010038 + +/* Error reading Extended Attribute block */ +#define PR_1_READ_EA_BLOCK 0x010039 + +/* Invalid Extended Attribute block */ +#define PR_1_BAD_EA_BLOCK 0x01003A + +/* Error reading Extended Attribute block while fixing refcount -- abort */ +#define PR_1_EXTATTR_READ_ABORT 0x01003B + +/* Extended attribute reference count incorrect */ +#define PR_1_EXTATTR_REFCOUNT 0x01003C + +/* Error writing Extended Attribute block while fixing refcount */ +#define PR_1_EXTATTR_WRITE 0x01003D + +/* Multiple EA blocks not supported */ +#define PR_1_EA_MULTI_BLOCK 0x01003E + +/* Error allocating EA region allocation structure */ +#define PR_1_EA_ALLOC_REGION 0x01003F + +/* Error EA allocation collision */ +#define PR_1_EA_ALLOC_COLLISION 0x010040 + +/* Bad extended attribute name */ +#define PR_1_EA_BAD_NAME 0x010041 + +/* Bad extended attribute value */ +#define PR_1_EA_BAD_VALUE 0x010042 + +/* Inode too big (latch question) */ +#define PR_1_INODE_TOOBIG 0x010043 + +/* Directory too big */ +#define PR_1_TOOBIG_DIR 0x010044 + +/* Regular file too big */ +#define PR_1_TOOBIG_REG 0x010045 + +/* Symlink too big */ +#define PR_1_TOOBIG_SYMLINK 0x010046 + +/* INDEX_FL flag set on a non-HTREE filesystem */ +#define PR_1_HTREE_SET 0x010047 + +/* INDEX_FL flag set on a non-directory */ +#define PR_1_HTREE_NODIR 0x010048 + +/* Invalid root node in HTREE directory */ +#define PR_1_HTREE_BADROOT 0x010049 + +/* Unsupported hash version in HTREE directory */ +#define PR_1_HTREE_HASHV 0x01004A + +/* Incompatible flag in HTREE root node */ +#define PR_1_HTREE_INCOMPAT 0x01004B + +/* HTREE too deep */ +#define PR_1_HTREE_DEPTH 0x01004C + +/* Bad block has indirect block that conflicts with filesystem block */ +#define PR_1_BB_FS_BLOCK 0x01004D + +/* Resize inode failed */ +#define PR_1_RESIZE_INODE_CREATE 0x01004E + +/* inode->i_size is too long */ +#define PR_1_EXTRA_ISIZE 0x01004F + +/* attribute name is too long */ +#define PR_1_ATTR_NAME_LEN 0x010050 + +/* wrong EA value offset */ +#define PR_1_ATTR_VALUE_OFFSET 0x010051 + +/* wrong EA blocknumber */ +#define PR_1_ATTR_VALUE_BLOCK 0x010052 + +/* wrong EA value size */ +#define PR_1_ATTR_VALUE_SIZE 0x010053 + +/* wrong EA hash value */ +#define PR_1_ATTR_HASH 0x010054 + +/* + * Pass 1b errors + */ + +/* Pass 1B: Rescan for duplicate/bad blocks */ +#define PR_1B_PASS_HEADER 0x011000 + +/* Duplicate/bad block(s) header */ +#define PR_1B_DUP_BLOCK_HEADER 0x011001 + +/* Duplicate/bad block(s) in inode */ +#define PR_1B_DUP_BLOCK 0x011002 + +/* Duplicate/bad block(s) end */ +#define PR_1B_DUP_BLOCK_END 0x011003 + +/* Error while scanning inodes */ +#define PR_1B_ISCAN_ERROR 0x011004 + +/* Error allocating inode bitmap */ +#define PR_1B_ALLOCATE_IBITMAP_ERROR 0x011005 + +/* Error while iterating over blocks */ +#define PR_1B_BLOCK_ITERATE 0x0110006 + +/* Error adjusting EA refcount */ +#define PR_1B_ADJ_EA_REFCOUNT 0x0110007 + + +/* Pass 1C: Scan directories for inodes with dup blocks. */ +#define PR_1C_PASS_HEADER 0x012000 + + +/* Pass 1D: Reconciling duplicate blocks */ +#define PR_1D_PASS_HEADER 0x013000 + +/* File has duplicate blocks */ +#define PR_1D_DUP_FILE 0x013001 + +/* List of files sharing duplicate blocks */ +#define PR_1D_DUP_FILE_LIST 0x013002 + +/* File sharing blocks with filesystem metadata */ +#define PR_1D_SHARE_METADATA 0x013003 + +/* Report of how many duplicate/bad inodes */ +#define PR_1D_NUM_DUP_INODES 0x013004 + +/* Duplicated blocks already reassigned or cloned. */ +#define PR_1D_DUP_BLOCKS_DEALT 0x013005 + +/* Clone duplicate/bad blocks? */ +#define PR_1D_CLONE_QUESTION 0x013006 + +/* Delete file? */ +#define PR_1D_DELETE_QUESTION 0x013007 + +/* Couldn't clone file (error) */ +#define PR_1D_CLONE_ERROR 0x013008 + +/* + * Pass 2 errors + */ + +/* Pass 2: Checking directory structure */ +#define PR_2_PASS_HEADER 0x020000 + +/* Bad inode number for '.' */ +#define PR_2_BAD_INODE_DOT 0x020001 + +/* Directory entry has bad inode number */ +#define PR_2_BAD_INO 0x020002 + +/* Directory entry has deleted or unused inode */ +#define PR_2_UNUSED_INODE 0x020003 + +/* Directry entry is link to '.' */ +#define PR_2_LINK_DOT 0x020004 + +/* Directory entry points to inode now located in a bad block */ +#define PR_2_BB_INODE 0x020005 + +/* Directory entry contains a link to a directory */ +#define PR_2_LINK_DIR 0x020006 + +/* Directory entry contains a link to the root directry */ +#define PR_2_LINK_ROOT 0x020007 + +/* Directory entry has illegal characters in its name */ +#define PR_2_BAD_NAME 0x020008 + +/* Missing '.' in directory inode */ +#define PR_2_MISSING_DOT 0x020009 + +/* Missing '..' in directory inode */ +#define PR_2_MISSING_DOT_DOT 0x02000A + +/* First entry in directory inode doesn't contain '.' */ +#define PR_2_1ST_NOT_DOT 0x02000B + +/* Second entry in directory inode doesn't contain '..' */ +#define PR_2_2ND_NOT_DOT_DOT 0x02000C + +/* i_faddr should be zero */ +#define PR_2_FADDR_ZERO 0x02000D + +/* i_file_acl should be zero */ +#define PR_2_FILE_ACL_ZERO 0x02000E + +/* i_dir_acl should be zero */ +#define PR_2_DIR_ACL_ZERO 0x02000F + +/* i_frag should be zero */ +#define PR_2_FRAG_ZERO 0x020010 + +/* i_fsize should be zero */ +#define PR_2_FSIZE_ZERO 0x020011 + +/* inode has bad mode */ +#define PR_2_BAD_MODE 0x020012 + +/* directory corrupted */ +#define PR_2_DIR_CORRUPTED 0x020013 + +/* filename too long */ +#define PR_2_FILENAME_LONG 0x020014 + +/* Directory inode has a missing block (hole) */ +#define PR_2_DIRECTORY_HOLE 0x020015 + +/* '.' is not NULL terminated */ +#define PR_2_DOT_NULL_TERM 0x020016 + +/* '..' is not NULL terminated */ +#define PR_2_DOT_DOT_NULL_TERM 0x020017 + +/* Illegal character device in inode */ +#define PR_2_BAD_CHAR_DEV 0x020018 + +/* Illegal block device in inode */ +#define PR_2_BAD_BLOCK_DEV 0x020019 + +/* Duplicate '.' entry */ +#define PR_2_DUP_DOT 0x02001A + +/* Duplicate '..' entry */ +#define PR_2_DUP_DOT_DOT 0x02001B + +/* Internal error: couldn't find dir_info */ +#define PR_2_NO_DIRINFO 0x02001C + +/* Final rec_len is wrong */ +#define PR_2_FINAL_RECLEN 0x02001D + +/* Error allocating icount structure */ +#define PR_2_ALLOCATE_ICOUNT 0x02001E + +/* Error iterating over directory blocks */ +#define PR_2_DBLIST_ITERATE 0x02001F + +/* Error reading directory block */ +#define PR_2_READ_DIRBLOCK 0x020020 + +/* Error writing directory block */ +#define PR_2_WRITE_DIRBLOCK 0x020021 + +/* Error allocating new directory block */ +#define PR_2_ALLOC_DIRBOCK 0x020022 + +/* Error deallocating inode */ +#define PR_2_DEALLOC_INODE 0x020023 + +/* Directory entry for '.' is big. Split? */ +#define PR_2_SPLIT_DOT 0x020024 + +/* Illegal FIFO */ +#define PR_2_BAD_FIFO 0x020025 + +/* Illegal socket */ +#define PR_2_BAD_SOCKET 0x020026 + +/* Directory filetype not set */ +#define PR_2_SET_FILETYPE 0x020027 + +/* Directory filetype incorrect */ +#define PR_2_BAD_FILETYPE 0x020028 + +/* Directory filetype set when it shouldn't be */ +#define PR_2_CLEAR_FILETYPE 0x020029 + +/* Directory filename can't be zero-length */ +#define PR_2_NULL_NAME 0x020030 + +/* Invalid symlink */ +#define PR_2_INVALID_SYMLINK 0x020031 + +/* i_file_acl (extended attribute) is bad */ +#define PR_2_FILE_ACL_BAD 0x020032 + +/* Filesystem contains large files, but has no such flag in sb */ +#define PR_2_FEATURE_LARGE_FILES 0x020033 + +/* Node in HTREE directory not referenced */ +#define PR_2_HTREE_NOTREF 0x020034 + +/* Node in HTREE directory referenced twice */ +#define PR_2_HTREE_DUPREF 0x020035 + +/* Node in HTREE directory has bad min hash */ +#define PR_2_HTREE_MIN_HASH 0x020036 + +/* Node in HTREE directory has bad max hash */ +#define PR_2_HTREE_MAX_HASH 0x020037 + +/* Clear invalid HTREE directory */ +#define PR_2_HTREE_CLEAR 0x020038 + +/* Clear the htree flag forcibly */ +/* #define PR_2_HTREE_FCLR 0x020039 */ + +/* Bad block in htree interior node */ +#define PR_2_HTREE_BADBLK 0x02003A + +/* Error adjusting EA refcount */ +#define PR_2_ADJ_EA_REFCOUNT 0x02003B + +/* Invalid HTREE root node */ +#define PR_2_HTREE_BAD_ROOT 0x02003C + +/* Invalid HTREE limit */ +#define PR_2_HTREE_BAD_LIMIT 0x02003D + +/* Invalid HTREE count */ +#define PR_2_HTREE_BAD_COUNT 0x02003E + +/* HTREE interior node has out-of-order hashes in table */ +#define PR_2_HTREE_HASH_ORDER 0x02003F + +/* Node in HTREE directory has bad depth */ +#define PR_2_HTREE_BAD_DEPTH 0x020040 + +/* Duplicate directory entry found */ +#define PR_2_DUPLICATE_DIRENT 0x020041 + +/* Non-unique filename found */ +#define PR_2_NON_UNIQUE_FILE 0x020042 + +/* Duplicate directory entry found */ +#define PR_2_REPORT_DUP_DIRENT 0x020043 + +/* + * Pass 3 errors + */ + +/* Pass 3: Checking directory connectivity */ +#define PR_3_PASS_HEADER 0x030000 + +/* Root inode not allocated */ +#define PR_3_NO_ROOT_INODE 0x030001 + +/* No room in lost+found */ +#define PR_3_EXPAND_LF_DIR 0x030002 + +/* Unconnected directory inode */ +#define PR_3_UNCONNECTED_DIR 0x030003 + +/* /lost+found not found */ +#define PR_3_NO_LF_DIR 0x030004 + +/* .. entry is incorrect */ +#define PR_3_BAD_DOT_DOT 0x030005 + +/* Bad or non-existent /lost+found. Cannot reconnect */ +#define PR_3_NO_LPF 0x030006 + +/* Could not expand /lost+found */ +#define PR_3_CANT_EXPAND_LPF 0x030007 + +/* Could not reconnect inode */ +#define PR_3_CANT_RECONNECT 0x030008 + +/* Error while trying to find /lost+found */ +#define PR_3_ERR_FIND_LPF 0x030009 + +/* Error in ext2fs_new_block while creating /lost+found */ +#define PR_3_ERR_LPF_NEW_BLOCK 0x03000A + +/* Error in ext2fs_new_inode while creating /lost+found */ +#define PR_3_ERR_LPF_NEW_INODE 0x03000B + +/* Error in ext2fs_new_dir_block while creating /lost+found */ +#define PR_3_ERR_LPF_NEW_DIR_BLOCK 0x03000C + +/* Error while writing directory block for /lost+found */ +#define PR_3_ERR_LPF_WRITE_BLOCK 0x03000D + +/* Error while adjusting inode count */ +#define PR_3_ADJUST_INODE 0x03000E + +/* Couldn't fix parent directory -- error */ +#define PR_3_FIX_PARENT_ERR 0x03000F + +/* Couldn't fix parent directory -- couldn't find it */ +#define PR_3_FIX_PARENT_NOFIND 0x030010 + +/* Error allocating inode bitmap */ +#define PR_3_ALLOCATE_IBITMAP_ERROR 0x030011 + +/* Error creating root directory */ +#define PR_3_CREATE_ROOT_ERROR 0x030012 + +/* Error creating lost and found directory */ +#define PR_3_CREATE_LPF_ERROR 0x030013 + +/* Root inode is not directory; aborting */ +#define PR_3_ROOT_NOT_DIR_ABORT 0x030014 + +/* Cannot proceed without a root inode. */ +#define PR_3_NO_ROOT_INODE_ABORT 0x030015 + +/* Internal error: couldn't find dir_info */ +#define PR_3_NO_DIRINFO 0x030016 + +/* Lost+found is not a directory */ +#define PR_3_LPF_NOTDIR 0x030017 + +/* + * Pass 3a --- rehashing diretories + */ +/* Pass 3a: Reindexing directories */ +#define PR_3A_PASS_HEADER 0x031000 + +/* Error iterating over directories */ +#define PR_3A_OPTIMIZE_ITER 0x031001 + +/* Error rehash directory */ +#define PR_3A_OPTIMIZE_DIR_ERR 0x031002 + +/* Rehashing dir header */ +#define PR_3A_OPTIMIZE_DIR_HEADER 0x031003 + +/* Rehashing directory %d */ +#define PR_3A_OPTIMIZE_DIR 0x031004 + +/* Rehashing dir end */ +#define PR_3A_OPTIMIZE_DIR_END 0x031005 + +/* + * Pass 4 errors + */ + +/* Pass 4: Checking reference counts */ +#define PR_4_PASS_HEADER 0x040000 + +/* Unattached zero-length inode */ +#define PR_4_ZERO_LEN_INODE 0x040001 + +/* Unattached inode */ +#define PR_4_UNATTACHED_INODE 0x040002 + +/* Inode ref count wrong */ +#define PR_4_BAD_REF_COUNT 0x040003 + +/* Inconsistent inode count information cached */ +#define PR_4_INCONSISTENT_COUNT 0x040004 + +/* + * Pass 5 errors + */ + +/* Pass 5: Checking group summary information */ +#define PR_5_PASS_HEADER 0x050000 + +/* Padding at end of inode bitmap is not set. */ +#define PR_5_INODE_BMAP_PADDING 0x050001 + +/* Padding at end of block bitmap is not set. */ +#define PR_5_BLOCK_BMAP_PADDING 0x050002 + +/* Block bitmap differences header */ +#define PR_5_BLOCK_BITMAP_HEADER 0x050003 + +/* Block not used, but marked in bitmap */ +#define PR_5_BLOCK_UNUSED 0x050004 + +/* Block used, but not marked used in bitmap */ +#define PR_5_BLOCK_USED 0x050005 + +/* Block bitmap differences end */ +#define PR_5_BLOCK_BITMAP_END 0x050006 + +/* Inode bitmap differences header */ +#define PR_5_INODE_BITMAP_HEADER 0x050007 + +/* Inode not used, but marked in bitmap */ +#define PR_5_INODE_UNUSED 0x050008 + +/* Inode used, but not marked used in bitmap */ +#define PR_5_INODE_USED 0x050009 + +/* Inode bitmap differences end */ +#define PR_5_INODE_BITMAP_END 0x05000A + +/* Free inodes count for group wrong */ +#define PR_5_FREE_INODE_COUNT_GROUP 0x05000B + +/* Directories count for group wrong */ +#define PR_5_FREE_DIR_COUNT_GROUP 0x05000C + +/* Free inodes count wrong */ +#define PR_5_FREE_INODE_COUNT 0x05000D + +/* Free blocks count for group wrong */ +#define PR_5_FREE_BLOCK_COUNT_GROUP 0x05000E + +/* Free blocks count wrong */ +#define PR_5_FREE_BLOCK_COUNT 0x05000F + +/* Programming error: bitmap endpoints don't match */ +#define PR_5_BMAP_ENDPOINTS 0x050010 + +/* Internal error: fudging end of bitmap */ +#define PR_5_FUDGE_BITMAP_ERROR 0x050011 + +/* Error copying in replacement inode bitmap */ +#define PR_5_COPY_IBITMAP_ERROR 0x050012 + +/* Error copying in replacement block bitmap */ +#define PR_5_COPY_BBITMAP_ERROR 0x050013 + +/* Block range not used, but marked in bitmap */ +#define PR_5_BLOCK_RANGE_UNUSED 0x050014 + +/* Block range used, but not marked used in bitmap */ +#define PR_5_BLOCK_RANGE_USED 0x050015 + +/* Inode range not used, but marked in bitmap */ +#define PR_5_INODE_RANGE_UNUSED 0x050016 + +/* Inode rangeused, but not marked used in bitmap */ +#define PR_5_INODE_RANGE_USED 0x050017 + +/* + * Function declarations + */ +static int fix_problem(e2fsck_t ctx, problem_t code, struct problem_context *pctx); +static int end_problem_latch(e2fsck_t ctx, int mask); +static int set_latch_flags(int mask, int setflags, int clearflags); +static void clear_problem_context(struct problem_context *ctx); + +/* message.c */ +static void print_e2fsck_message(e2fsck_t ctx, const char *msg, + struct problem_context *pctx, int first); + +/* + * Dictionary Abstract Data Type + * Copyright (C) 1997 Kaz Kylheku + * + * Free Software License: + * + * All rights are reserved by the author, with the following exceptions: + * Permission is granted to freely reproduce and distribute this software, + * possibly in exchange for a fee, provided that this copyright notice appears + * intact. Permission is also granted to adapt this software to produce + * derivative works, as long as the modified versions carry this copyright + * notice and additional notices stating that the work has been modified. + * This source code may be translated into executable form and incorporated + * into proprietary software; there is no requirement for such software to + * contain a copyright notice related to this source. + * + * $Id: dict.h,v 1.22.2.6 2000/11/13 01:36:44 kaz Exp $ + * $Name: kazlib_1_20 $ + */ + +#ifndef DICT_H +#define DICT_H + +/* + * Blurb for inclusion into C++ translation units + */ + +typedef unsigned long dictcount_t; +#define DICTCOUNT_T_MAX ULONG_MAX + +/* + * The dictionary is implemented as a red-black tree + */ + +typedef enum { dnode_red, dnode_black } dnode_color_t; + +typedef struct dnode_t { + struct dnode_t *dict_left; + struct dnode_t *dict_right; + struct dnode_t *dict_parent; + dnode_color_t dict_color; + const void *dict_key; + void *dict_data; +} dnode_t; + +typedef int (*dict_comp_t)(const void *, const void *); +typedef dnode_t *(*dnode_alloc_t)(void *); +typedef void (*dnode_free_t)(dnode_t *, void *); + +typedef struct dict_t { + dnode_t dict_nilnode; + dictcount_t dict_nodecount; + dictcount_t dict_maxcount; + dict_comp_t dict_compare; + dnode_alloc_t dict_allocnode; + dnode_free_t dict_freenode; + void *dict_context; + int dict_dupes; +} dict_t; + +typedef void (*dnode_process_t)(dict_t *, dnode_t *, void *); + +typedef struct dict_load_t { + dict_t *dict_dictptr; + dnode_t dict_nilnode; +} dict_load_t; + +static void dict_set_allocator(dict_t *, dnode_alloc_t, dnode_free_t, void *); +static void dict_free_nodes(dict_t *); +static dict_t *dict_init(dict_t *, dictcount_t, dict_comp_t); +static dnode_t *dict_lookup(dict_t *, const void *); +static void dict_insert(dict_t *, dnode_t *, const void *); +static int dict_alloc_insert(dict_t *, const void *, void *); +static dnode_t *dict_first(dict_t *); +static dnode_t *dict_next(dict_t *, dnode_t *); +static dictcount_t dict_count(dict_t *); +static dnode_t *dnode_init(dnode_t *, void *); +static void *dnode_get(dnode_t *); +static const void *dnode_getkey(dnode_t *); + +#define dict_count(D) ((D)->dict_nodecount) +#define dnode_get(N) ((N)->dict_data) +#define dnode_getkey(N) ((N)->dict_key) + +#endif + +/* + * Compatibility header file for e2fsck which should be included + * instead of linux/jfs.h + * + * Copyright (C) 2000 Stephen C. Tweedie + */ + +/* + * Pull in the definition of the e2fsck context structure + */ + + +struct buffer_head { + char b_data[8192]; + e2fsck_t b_ctx; + io_channel b_io; + int b_size; + blk_t b_blocknr; + int b_dirty; + int b_uptodate; + int b_err; +}; + +struct inode { + e2fsck_t i_ctx; + ext2_ino_t i_ino; + struct ext2_inode i_ext2; +}; + +struct kdev_s { + e2fsck_t k_ctx; + int k_dev; +}; + +#define K_DEV_FS 1 +#define K_DEV_JOURNAL 2 + +typedef struct kdev_s *kdev_t; + +#define lock_buffer(bh) do {} while(0) +#define unlock_buffer(bh) do {} while(0) +#define buffer_req(bh) 1 +#define do_readahead(journal, start) do {} while(0) + +static e2fsck_t e2fsck_global_ctx; /* Try your very best not to use this! */ + +typedef struct { + int object_length; +} kmem_cache_t; + +#define kmem_cache_alloc(cache,flags) malloc((cache)->object_length) +#define kmem_cache_free(cache,obj) free(obj) +#define kmem_cache_create(name,len,a,b,c,d) do_cache_create(len) +#define kmem_cache_destroy(cache) do_cache_destroy(cache) +#define kmalloc(len,flags) malloc(len) +#define kfree(p) free(p) + +/* + * We use the standard libext2fs portability tricks for inline + * functions. + */ + +static _INLINE_ kmem_cache_t * do_cache_create(int len) +{ + kmem_cache_t *new_cache; + new_cache = malloc(sizeof(*new_cache)); + if (new_cache) + new_cache->object_length = len; + return new_cache; +} + +static _INLINE_ void do_cache_destroy(kmem_cache_t *cache) +{ + free(cache); +} + +/* + * Now pull in the real linux/jfs.h definitions. + */ +#include "ext2fs/kernel-jbd.h" + +/* + * Kernel compatibility functions are defined in journal.c + */ +static int journal_bmap(journal_t *journal, blk_t block, unsigned long *phys); +static struct buffer_head *getblk(kdev_t ctx, blk_t blocknr, int blocksize); +static void sync_blockdev(kdev_t kdev); +static void ll_rw_block(int rw, int dummy, struct buffer_head *bh[]); +static void mark_buffer_dirty(struct buffer_head *bh); +static void mark_buffer_uptodate(struct buffer_head *bh, int val); +static void brelse(struct buffer_head *bh); +static int buffer_uptodate(struct buffer_head *bh); +static void wait_on_buffer(struct buffer_head *bh); + +/* + * Define newer 2.5 interfaces + */ +#define __getblk(dev, blocknr, blocksize) getblk(dev, blocknr, blocksize) +#define set_buffer_uptodate(bh) mark_buffer_uptodate(bh, 1) + +/* + * badblocks.c --- replace/append bad blocks to the bad block inode + * + * Copyright (C) 1993, 1994 Theodore Ts'o. This file may be + * redistributed under the terms of the GNU Public License. + */ + +static int check_bb_inode_blocks(ext2_filsys fs, blk_t *block_nr, int blockcnt, + void *priv_data); + + +static void invalid_block(ext2_filsys fs EXT2FS_ATTR((unused)), blk_t blk) +{ + printf(_("Bad block %u out of range; ignored.\n"), blk); + return; +} + +void read_bad_blocks_file(e2fsck_t ctx, const char *bad_blocks_file, + int replace_bad_blocks) +{ + ext2_filsys fs = ctx->fs; + errcode_t retval; + badblocks_list bb_list = 0; + FILE *f; + char buf[1024]; + + e2fsck_read_bitmaps(ctx); + + /* + * Make sure the bad block inode is sane. If there are any + * illegal blocks, clear them. + */ + retval = ext2fs_block_iterate(fs, EXT2_BAD_INO, 0, 0, + check_bb_inode_blocks, 0); + if (retval) { + com_err("ext2fs_block_iterate", retval, + _("while sanity checking the bad blocks inode")); + goto fatal; + } + + /* + * If we're appending to the bad blocks inode, read in the + * current bad blocks. + */ + if (!replace_bad_blocks) { + retval = ext2fs_read_bb_inode(fs, &bb_list); + if (retval) { + com_err("ext2fs_read_bb_inode", retval, + _("while reading the bad blocks inode")); + goto fatal; + } + } + + /* + * Now read in the bad blocks from the file; if + * bad_blocks_file is null, then try to run the badblocks + * command. + */ + if (bad_blocks_file) { + f = fopen(bad_blocks_file, "r"); + if (!f) { + com_err("read_bad_blocks_file", errno, + _("while trying to open %s"), bad_blocks_file); + goto fatal; + } + } else { + sprintf(buf, "badblocks -b %d %s%s%s %d", fs->blocksize, + (ctx->options & E2F_OPT_PREEN) ? "" : "-s ", + (ctx->options & E2F_OPT_WRITECHECK) ? "-n " : "", + fs->device_name, fs->super->s_blocks_count); + f = popen(buf, "r"); + if (!f) { + com_err("read_bad_blocks_file", errno, + _("while trying popen '%s'"), buf); + goto fatal; + } + } + retval = ext2fs_read_bb_FILE(fs, f, &bb_list, invalid_block); + if (bad_blocks_file) + fclose(f); + else + pclose(f); + if (retval) { + com_err("ext2fs_read_bb_FILE", retval, + _("while reading in list of bad blocks from file")); + goto fatal; + } + + /* + * Finally, update the bad blocks from the bad_block_map + */ + retval = ext2fs_update_bb_inode(fs, bb_list); + if (retval) { + com_err("ext2fs_update_bb_inode", retval, + _("while updating bad block inode")); + goto fatal; + } + + ext2fs_badblocks_list_free(bb_list); + return; + +fatal: + ctx->flags |= E2F_FLAG_ABORT; + return; + +} + +static int check_bb_inode_blocks(ext2_filsys fs, + blk_t *block_nr, + int blockcnt EXT2FS_ATTR((unused)), + void *priv_data EXT2FS_ATTR((unused))) +{ + if (!*block_nr) + return 0; + + /* + * If the block number is outrageous, clear it and ignore it. + */ + if (*block_nr >= fs->super->s_blocks_count || + *block_nr < fs->super->s_first_data_block) { + printf(_("Warning illegal block %u found in bad block inode. Cleared.\n"), *block_nr); + *block_nr = 0; + return BLOCK_CHANGED; + } + + return 0; +} + +/* + * Dictionary Abstract Data Type + * Copyright (C) 1997 Kaz Kylheku + * + * Free Software License: + * + * All rights are reserved by the author, with the following exceptions: + * Permission is granted to freely reproduce and distribute this software, + * possibly in exchange for a fee, provided that this copyright notice appears + * intact. Permission is also granted to adapt this software to produce + * derivative works, as long as the modified versions carry this copyright + * notice and additional notices stating that the work has been modified. + * This source code may be translated into executable form and incorporated + * into proprietary software; there is no requirement for such software to + * contain a copyright notice related to this source. + * + * $Id: dict.c,v 1.40.2.7 2000/11/13 01:36:44 kaz Exp $ + * $Name: kazlib_1_20 $ + */ + + +/* + * These macros provide short convenient names for structure members, + * which are embellished with dict_ prefixes so that they are + * properly confined to the documented namespace. It's legal for a + * program which uses dict to define, for instance, a macro called ``parent''. + * Such a macro would interfere with the dnode_t struct definition. + * In general, highly portable and reusable C modules which expose their + * structures need to confine structure member names to well-defined spaces. + * The resulting identifiers aren't necessarily convenient to use, nor + * readable, in the implementation, however! + */ + +#define left dict_left +#define right dict_right +#define parent dict_parent +#define color dict_color +#define key dict_key +#define data dict_data + +#define nilnode dict_nilnode +#define nodecount dict_nodecount +#define maxcount dict_maxcount +#define compare dict_compare +#define allocnode dict_allocnode +#define freenode dict_freenode +#define context dict_context +#define dupes dict_dupes + +#define dictptr dict_dictptr + +#define dict_root(D) ((D)->nilnode.left) +#define dict_nil(D) (&(D)->nilnode) +#define DICT_DEPTH_MAX 64 + +static dnode_t *dnode_alloc(void *context); +static void dnode_free(dnode_t *node, void *context); + +/* + * Perform a ``left rotation'' adjustment on the tree. The given node P and + * its right child C are rearranged so that the P instead becomes the left + * child of C. The left subtree of C is inherited as the new right subtree + * for P. The ordering of the keys within the tree is thus preserved. + */ + +static void rotate_left(dnode_t *upper) +{ + dnode_t *lower, *lowleft, *upparent; + + lower = upper->right; + upper->right = lowleft = lower->left; + lowleft->parent = upper; + + lower->parent = upparent = upper->parent; + + /* don't need to check for root node here because root->parent is + the sentinel nil node, and root->parent->left points back to root */ + + if (upper == upparent->left) { + upparent->left = lower; + } else { + assert (upper == upparent->right); + upparent->right = lower; + } + + lower->left = upper; + upper->parent = lower; +} + +/* + * This operation is the ``mirror'' image of rotate_left. It is + * the same procedure, but with left and right interchanged. + */ + +static void rotate_right(dnode_t *upper) +{ + dnode_t *lower, *lowright, *upparent; + + lower = upper->left; + upper->left = lowright = lower->right; + lowright->parent = upper; + + lower->parent = upparent = upper->parent; + + if (upper == upparent->right) { + upparent->right = lower; + } else { + assert (upper == upparent->left); + upparent->left = lower; + } + + lower->right = upper; + upper->parent = lower; +} + +/* + * Do a postorder traversal of the tree rooted at the specified + * node and free everything under it. Used by dict_free(). + */ + +static void free_nodes(dict_t *dict, dnode_t *node, dnode_t *nil) +{ + if (node == nil) + return; + free_nodes(dict, node->left, nil); + free_nodes(dict, node->right, nil); + dict->freenode(node, dict->context); +} + +/* + * Verify that the tree contains the given node. This is done by + * traversing all of the nodes and comparing their pointers to the + * given pointer. Returns 1 if the node is found, otherwise + * returns zero. It is intended for debugging purposes. + */ + +static int verify_dict_has_node(dnode_t *nil, dnode_t *root, dnode_t *node) +{ + if (root != nil) { + return root == node + || verify_dict_has_node(nil, root->left, node) + || verify_dict_has_node(nil, root->right, node); + } + return 0; +} + + +/* + * Select a different set of node allocator routines. + */ + +void dict_set_allocator(dict_t *dict, dnode_alloc_t al, + dnode_free_t fr, void *context) +{ + assert (dict_count(dict) == 0); + assert ((al == NULL && fr == NULL) || (al != NULL && fr != NULL)); + + dict->allocnode = al ? al : dnode_alloc; + dict->freenode = fr ? fr : dnode_free; + dict->context = context; +} + +/* + * Free all the nodes in the dictionary by using the dictionary's + * installed free routine. The dictionary is emptied. + */ + +void dict_free_nodes(dict_t *dict) +{ + dnode_t *nil = dict_nil(dict), *root = dict_root(dict); + free_nodes(dict, root, nil); + dict->nodecount = 0; + dict->nilnode.left = &dict->nilnode; + dict->nilnode.right = &dict->nilnode; +} + +/* + * Initialize a user-supplied dictionary object. + */ + +dict_t *dict_init(dict_t *dict, dictcount_t maxcount, dict_comp_t comp) +{ + dict->compare = comp; + dict->allocnode = dnode_alloc; + dict->freenode = dnode_free; + dict->context = NULL; + dict->nodecount = 0; + dict->maxcount = maxcount; + dict->nilnode.left = &dict->nilnode; + dict->nilnode.right = &dict->nilnode; + dict->nilnode.parent = &dict->nilnode; + dict->nilnode.color = dnode_black; + dict->dupes = 0; + return dict; +} + +/* + * Locate a node in the dictionary having the given key. + * If the node is not found, a null a pointer is returned (rather than + * a pointer that dictionary's nil sentinel node), otherwise a pointer to the + * located node is returned. + */ + +dnode_t *dict_lookup(dict_t *dict, const void *key) +{ + dnode_t *root = dict_root(dict); + dnode_t *nil = dict_nil(dict); + dnode_t *saved; + int result; + + /* simple binary search adapted for trees that contain duplicate keys */ + + while (root != nil) { + result = dict->compare(key, root->key); + if (result < 0) + root = root->left; + else if (result > 0) + root = root->right; + else { + if (!dict->dupes) { /* no duplicates, return match */ + return root; + } else { /* could be dupes, find leftmost one */ + do { + saved = root; + root = root->left; + while (root != nil && dict->compare(key, root->key)) + root = root->right; + } while (root != nil); + return saved; + } + } + } + + return NULL; +} + +/* + * Insert a node into the dictionary. The node should have been + * initialized with a data field. All other fields are ignored. + * The behavior is undefined if the user attempts to insert into + * a dictionary that is already full (for which the dict_isfull() + * function returns true). + */ + +void dict_insert(dict_t *dict, dnode_t *node, const void *key) +{ + dnode_t *where = dict_root(dict), *nil = dict_nil(dict); + dnode_t *parent = nil, *uncle, *grandpa; + int result = -1; + + node->key = key; + + /* basic binary tree insert */ + + while (where != nil) { + parent = where; + result = dict->compare(key, where->key); + /* trap attempts at duplicate key insertion unless it's explicitly allowed */ + assert (dict->dupes || result != 0); + if (result < 0) + where = where->left; + else + where = where->right; + } + + assert (where == nil); + + if (result < 0) + parent->left = node; + else + parent->right = node; + + node->parent = parent; + node->left = nil; + node->right = nil; + + dict->nodecount++; + + /* red black adjustments */ + + node->color = dnode_red; + + while (parent->color == dnode_red) { + grandpa = parent->parent; + if (parent == grandpa->left) { + uncle = grandpa->right; + if (uncle->color == dnode_red) { /* red parent, red uncle */ + parent->color = dnode_black; + uncle->color = dnode_black; + grandpa->color = dnode_red; + node = grandpa; + parent = grandpa->parent; + } else { /* red parent, black uncle */ + if (node == parent->right) { + rotate_left(parent); + parent = node; + assert (grandpa == parent->parent); + /* rotation between parent and child preserves grandpa */ + } + parent->color = dnode_black; + grandpa->color = dnode_red; + rotate_right(grandpa); + break; + } + } else { /* symmetric cases: parent == parent->parent->right */ + uncle = grandpa->left; + if (uncle->color == dnode_red) { + parent->color = dnode_black; + uncle->color = dnode_black; + grandpa->color = dnode_red; + node = grandpa; + parent = grandpa->parent; + } else { + if (node == parent->left) { + rotate_right(parent); + parent = node; + assert (grandpa == parent->parent); + } + parent->color = dnode_black; + grandpa->color = dnode_red; + rotate_left(grandpa); + break; + } + } + } + + dict_root(dict)->color = dnode_black; + +} + +/* + * Allocate a node using the dictionary's allocator routine, give it + * the data item. + */ + +int dict_alloc_insert(dict_t *dict, const void *key, void *data) +{ + dnode_t *node = dict->allocnode(dict->context); + + if (node) { + dnode_init(node, data); + dict_insert(dict, node, key); + return 1; + } + return 0; +} + +/* + * Return the node with the lowest (leftmost) key. If the dictionary is empty + * (that is, dict_isempty(dict) returns 1) a null pointer is returned. + */ + +dnode_t *dict_first(dict_t *dict) +{ + dnode_t *nil = dict_nil(dict), *root = dict_root(dict), *left; + + if (root != nil) + while ((left = root->left) != nil) + root = left; + + return (root == nil) ? NULL : root; +} + +/* + * Return the given node's successor node---the node which has the + * next key in the the left to right ordering. If the node has + * no successor, a null pointer is returned rather than a pointer to + * the nil node. + */ + +dnode_t *dict_next(dict_t *dict, dnode_t *curr) +{ + dnode_t *nil = dict_nil(dict), *parent, *left; + + if (curr->right != nil) { + curr = curr->right; + while ((left = curr->left) != nil) + curr = left; + return curr; + } + + parent = curr->parent; + + while (parent != nil && curr == parent->right) { + curr = parent; + parent = curr->parent; + } + + return (parent == nil) ? NULL : parent; +} + +#undef dict_count +#undef dnode_get +#undef dnode_getkey + +dictcount_t dict_count(dict_t *dict) +{ + return dict->nodecount; +} + +static dnode_t *dnode_alloc(void *context EXT2FS_ATTR((unused))) +{ + return malloc(sizeof *dnode_alloc(NULL)); +} + +static void dnode_free(dnode_t *node, void *context EXT2FS_ATTR((unused))) +{ + free(node); +} + +dnode_t *dnode_init(dnode_t *dnode, void *data) +{ + dnode->data = data; + dnode->parent = NULL; + dnode->left = NULL; + dnode->right = NULL; + return dnode; +} + +void *dnode_get(dnode_t *dnode) +{ + return dnode->data; +} + +const void *dnode_getkey(dnode_t *dnode) +{ + return dnode->key; +} + +#undef left +#undef right +#undef parent +#undef color +#undef key +#undef data + +#undef nilnode +#undef nodecount +#undef maxcount +#undef compare +#undef allocnode +#undef freenode +#undef context +#undef dupes + +#undef dictptr + + +/* + * dirinfo.c --- maintains the directory information table for e2fsck. + * + * Copyright (C) 1993 Theodore Ts'o. This file may be redistributed + * under the terms of the GNU Public License. + */ + +/* + * This subroutine is called during pass1 to create a directory info + * entry. During pass1, the passed-in parent is 0; it will get filled + * in during pass2. + */ +void e2fsck_add_dir_info(e2fsck_t ctx, ext2_ino_t ino, ext2_ino_t parent) +{ + struct dir_info *dir; + int i, j; + ext2_ino_t num_dirs; + errcode_t retval; + unsigned long old_size; + +#if 0 + printf("add_dir_info for inode %lu...\n", ino); +#endif + if (!ctx->dir_info) { + ctx->dir_info_count = 0; + retval = ext2fs_get_num_dirs(ctx->fs, &num_dirs); + if (retval) + num_dirs = 1024; /* Guess */ + ctx->dir_info_size = num_dirs + 10; + ctx->dir_info = (struct dir_info *) + e2fsck_allocate_memory(ctx, ctx->dir_info_size + * sizeof (struct dir_info), + "directory map"); + } + + if (ctx->dir_info_count >= ctx->dir_info_size) { + old_size = ctx->dir_info_size * sizeof(struct dir_info); + ctx->dir_info_size += 10; + retval = ext2fs_resize_mem(old_size, ctx->dir_info_size * + sizeof(struct dir_info), + &ctx->dir_info); + if (retval) { + ctx->dir_info_size -= 10; + return; + } + } + + /* + * Normally, add_dir_info is called with each inode in + * sequential order; but once in a while (like when pass 3 + * needs to recreate the root directory or lost+found + * directory) it is called out of order. In those cases, we + * need to move the dir_info entries down to make room, since + * the dir_info array needs to be sorted by inode number for + * get_dir_info()'s sake. + */ + if (ctx->dir_info_count && + ctx->dir_info[ctx->dir_info_count-1].ino >= ino) { + for (i = ctx->dir_info_count-1; i > 0; i--) + if (ctx->dir_info[i-1].ino < ino) + break; + dir = &ctx->dir_info[i]; + if (dir->ino != ino) + for (j = ctx->dir_info_count++; j > i; j--) + ctx->dir_info[j] = ctx->dir_info[j-1]; + } else + dir = &ctx->dir_info[ctx->dir_info_count++]; + + dir->ino = ino; + dir->dotdot = parent; + dir->parent = parent; +} + +/* + * get_dir_info() --- given an inode number, try to find the directory + * information entry for it. + */ +struct dir_info *e2fsck_get_dir_info(e2fsck_t ctx, ext2_ino_t ino) +{ + int low, high, mid; + + low = 0; + high = ctx->dir_info_count-1; + if (!ctx->dir_info) + return 0; + if (ino == ctx->dir_info[low].ino) + return &ctx->dir_info[low]; + if (ino == ctx->dir_info[high].ino) + return &ctx->dir_info[high]; + + while (low < high) { + mid = (low+high)/2; + if (mid == low || mid == high) + break; + if (ino == ctx->dir_info[mid].ino) + return &ctx->dir_info[mid]; + if (ino < ctx->dir_info[mid].ino) + high = mid; + else + low = mid; + } + return 0; +} + +/* + * Free the dir_info structure when it isn't needed any more. + */ +void e2fsck_free_dir_info(e2fsck_t ctx) +{ + if (ctx->dir_info) { + ext2fs_free_mem(&ctx->dir_info); + ctx->dir_info = 0; + } + ctx->dir_info_size = 0; + ctx->dir_info_count = 0; +} + +/* + * Return the count of number of directories in the dir_info structure + */ +int e2fsck_get_num_dirinfo(e2fsck_t ctx) +{ + return ctx->dir_info_count; +} + +/* + * A simple interator function + */ +struct dir_info *e2fsck_dir_info_iter(e2fsck_t ctx, int *control) +{ + if (*control >= ctx->dir_info_count) + return 0; + + return(ctx->dir_info + (*control)++); +} +/* + * dirinfo.c --- maintains the directory information table for e2fsck. + * + * Copyright (C) 1993 Theodore Ts'o. This file may be redistributed + * under the terms of the GNU Public License. + */ + +#ifdef ENABLE_HTREE + +/* + * This subroutine is called during pass1 to create a directory info + * entry. During pass1, the passed-in parent is 0; it will get filled + * in during pass2. + */ +void e2fsck_add_dx_dir(e2fsck_t ctx, ext2_ino_t ino, int num_blocks) +{ + struct dx_dir_info *dir; + int i, j; + errcode_t retval; + unsigned long old_size; + +#if 0 + printf("add_dx_dir_info for inode %lu...\n", ino); +#endif + if (!ctx->dx_dir_info) { + ctx->dx_dir_info_count = 0; + ctx->dx_dir_info_size = 100; /* Guess */ + ctx->dx_dir_info = (struct dx_dir_info *) + e2fsck_allocate_memory(ctx, ctx->dx_dir_info_size + * sizeof (struct dx_dir_info), + "directory map"); + } + + if (ctx->dx_dir_info_count >= ctx->dx_dir_info_size) { + old_size = ctx->dx_dir_info_size * sizeof(struct dx_dir_info); + ctx->dx_dir_info_size += 10; + retval = ext2fs_resize_mem(old_size, ctx->dx_dir_info_size * + sizeof(struct dx_dir_info), + &ctx->dx_dir_info); + if (retval) { + ctx->dx_dir_info_size -= 10; + return; + } + } + + /* + * Normally, add_dx_dir_info is called with each inode in + * sequential order; but once in a while (like when pass 3 + * needs to recreate the root directory or lost+found + * directory) it is called out of order. In those cases, we + * need to move the dx_dir_info entries down to make room, since + * the dx_dir_info array needs to be sorted by inode number for + * get_dx_dir_info()'s sake. + */ + if (ctx->dx_dir_info_count && + ctx->dx_dir_info[ctx->dx_dir_info_count-1].ino >= ino) { + for (i = ctx->dx_dir_info_count-1; i > 0; i--) + if (ctx->dx_dir_info[i-1].ino < ino) + break; + dir = &ctx->dx_dir_info[i]; + if (dir->ino != ino) + for (j = ctx->dx_dir_info_count++; j > i; j--) + ctx->dx_dir_info[j] = ctx->dx_dir_info[j-1]; + } else + dir = &ctx->dx_dir_info[ctx->dx_dir_info_count++]; + + dir->ino = ino; + dir->numblocks = num_blocks; + dir->hashversion = 0; + dir->dx_block = e2fsck_allocate_memory(ctx, num_blocks + * sizeof (struct dx_dirblock_info), + "dx_block info array"); + +} + +/* + * get_dx_dir_info() --- given an inode number, try to find the directory + * information entry for it. + */ +struct dx_dir_info *e2fsck_get_dx_dir_info(e2fsck_t ctx, ext2_ino_t ino) +{ + int low, high, mid; + + low = 0; + high = ctx->dx_dir_info_count-1; + if (!ctx->dx_dir_info) + return 0; + if (ino == ctx->dx_dir_info[low].ino) + return &ctx->dx_dir_info[low]; + if (ino == ctx->dx_dir_info[high].ino) + return &ctx->dx_dir_info[high]; + + while (low < high) { + mid = (low+high)/2; + if (mid == low || mid == high) + break; + if (ino == ctx->dx_dir_info[mid].ino) + return &ctx->dx_dir_info[mid]; + if (ino < ctx->dx_dir_info[mid].ino) + high = mid; + else + low = mid; + } + return 0; +} + +/* + * Free the dx_dir_info structure when it isn't needed any more. + */ +void e2fsck_free_dx_dir_info(e2fsck_t ctx) +{ + int i; + struct dx_dir_info *dir; + + if (ctx->dx_dir_info) { + dir = ctx->dx_dir_info; + for (i=0; i < ctx->dx_dir_info_count; i++) { + if (dir->dx_block) { + ext2fs_free_mem(&dir->dx_block); + dir->dx_block = 0; + } + } + ext2fs_free_mem(&ctx->dx_dir_info); + ctx->dx_dir_info = 0; + } + ctx->dx_dir_info_size = 0; + ctx->dx_dir_info_count = 0; +} + +/* + * A simple interator function + */ +struct dx_dir_info *e2fsck_dx_dir_info_iter(e2fsck_t ctx, int *control) +{ + if (*control >= ctx->dx_dir_info_count) + return 0; + + return(ctx->dx_dir_info + (*control)++); +} + +#endif /* ENABLE_HTREE */ +/* + * e2fsck.c - a consistency checker for the new extended file system. + * + * Copyright (C) 1993, 1994, 1995, 1996, 1997 Theodore Ts'o. + * + * %Begin-Header% + * This file may be redistributed under the terms of the GNU Public + * License. + * %End-Header% + */ + +/* + * This function allocates an e2fsck context + */ +errcode_t e2fsck_allocate_context(e2fsck_t *ret) +{ + e2fsck_t context; + errcode_t retval; + + retval = ext2fs_get_mem(sizeof(struct e2fsck_struct), &context); + if (retval) + return retval; + + memset(context, 0, sizeof(struct e2fsck_struct)); + + context->process_inode_size = 256; + context->ext_attr_ver = 2; + + *ret = context; + return 0; +} + +/* + * This function resets an e2fsck context; it is called when e2fsck + * needs to be restarted. + */ +errcode_t e2fsck_reset_context(e2fsck_t ctx) +{ + ctx->flags = 0; + ctx->lost_and_found = 0; + ctx->bad_lost_and_found = 0; + if (ctx->inode_used_map) { + ext2fs_free_inode_bitmap(ctx->inode_used_map); + ctx->inode_used_map = 0; + } + if (ctx->inode_dir_map) { + ext2fs_free_inode_bitmap(ctx->inode_dir_map); + ctx->inode_dir_map = 0; + } + if (ctx->inode_reg_map) { + ext2fs_free_inode_bitmap(ctx->inode_reg_map); + ctx->inode_reg_map = 0; + } + if (ctx->block_found_map) { + ext2fs_free_block_bitmap(ctx->block_found_map); + ctx->block_found_map = 0; + } + if (ctx->inode_link_info) { + ext2fs_free_icount(ctx->inode_link_info); + ctx->inode_link_info = 0; + } + if (ctx->journal_io) { + if (ctx->fs && ctx->fs->io != ctx->journal_io) + io_channel_close(ctx->journal_io); + ctx->journal_io = 0; + } + if (ctx->fs && ctx->fs->dblist) { + ext2fs_free_dblist(ctx->fs->dblist); + ctx->fs->dblist = 0; + } + e2fsck_free_dir_info(ctx); +#ifdef ENABLE_HTREE + e2fsck_free_dx_dir_info(ctx); +#endif + if (ctx->refcount) { + ea_refcount_free(ctx->refcount); + ctx->refcount = 0; + } + if (ctx->refcount_extra) { + ea_refcount_free(ctx->refcount_extra); + ctx->refcount_extra = 0; + } + if (ctx->block_dup_map) { + ext2fs_free_block_bitmap(ctx->block_dup_map); + ctx->block_dup_map = 0; + } + if (ctx->block_ea_map) { + ext2fs_free_block_bitmap(ctx->block_ea_map); + ctx->block_ea_map = 0; + } + if (ctx->inode_bb_map) { + ext2fs_free_inode_bitmap(ctx->inode_bb_map); + ctx->inode_bb_map = 0; + } + if (ctx->inode_bad_map) { + ext2fs_free_inode_bitmap(ctx->inode_bad_map); + ctx->inode_bad_map = 0; + } + if (ctx->inode_imagic_map) { + ext2fs_free_inode_bitmap(ctx->inode_imagic_map); + ctx->inode_imagic_map = 0; + } + if (ctx->dirs_to_hash) { + ext2fs_u32_list_free(ctx->dirs_to_hash); + ctx->dirs_to_hash = 0; + } + + /* + * Clear the array of invalid meta-data flags + */ + if (ctx->invalid_inode_bitmap_flag) { + ext2fs_free_mem(&ctx->invalid_inode_bitmap_flag); + ctx->invalid_inode_bitmap_flag = 0; + } + if (ctx->invalid_block_bitmap_flag) { + ext2fs_free_mem(&ctx->invalid_block_bitmap_flag); + ctx->invalid_block_bitmap_flag = 0; + } + if (ctx->invalid_inode_table_flag) { + ext2fs_free_mem(&ctx->invalid_inode_table_flag); + ctx->invalid_inode_table_flag = 0; + } + + /* Clear statistic counters */ + ctx->fs_directory_count = 0; + ctx->fs_regular_count = 0; + ctx->fs_blockdev_count = 0; + ctx->fs_chardev_count = 0; + ctx->fs_links_count = 0; + ctx->fs_symlinks_count = 0; + ctx->fs_fast_symlinks_count = 0; + ctx->fs_fifo_count = 0; + ctx->fs_total_count = 0; + ctx->fs_badblocks_count = 0; + ctx->fs_sockets_count = 0; + ctx->fs_ind_count = 0; + ctx->fs_dind_count = 0; + ctx->fs_tind_count = 0; + ctx->fs_fragmented = 0; + ctx->large_files = 0; + + /* Reset the superblock to the user's requested value */ + ctx->superblock = ctx->use_superblock; + + return 0; +} + +void e2fsck_free_context(e2fsck_t ctx) +{ + if (!ctx) + return; + + e2fsck_reset_context(ctx); + if (ctx->blkid) + blkid_put_cache(ctx->blkid); + + ext2fs_free_mem(&ctx); +} + +/* + * This function runs through the e2fsck passes and calls them all, + * returning restart, abort, or cancel as necessary... + */ +typedef void (*pass_t)(e2fsck_t ctx); + +static pass_t e2fsck_passes[] = { + e2fsck_pass1, e2fsck_pass2, e2fsck_pass3, e2fsck_pass4, + e2fsck_pass5, 0 }; + +#define E2F_FLAG_RUN_RETURN (E2F_FLAG_SIGNAL_MASK|E2F_FLAG_RESTART) + +int e2fsck_run(e2fsck_t ctx) +{ + int i; + pass_t e2fsck_pass; + + if (setjmp(ctx->abort_loc)) { + ctx->flags &= ~E2F_FLAG_SETJMP_OK; + return (ctx->flags & E2F_FLAG_RUN_RETURN); + } + ctx->flags |= E2F_FLAG_SETJMP_OK; + + for (i=0; (e2fsck_pass = e2fsck_passes[i]); i++) { + if (ctx->flags & E2F_FLAG_RUN_RETURN) + break; + e2fsck_pass(ctx); + if (ctx->progress) + (void) (ctx->progress)(ctx, 0, 0, 0); + } + ctx->flags &= ~E2F_FLAG_SETJMP_OK; + + if (ctx->flags & E2F_FLAG_RUN_RETURN) + return (ctx->flags & E2F_FLAG_RUN_RETURN); + return 0; +} +/* + * ea_refcount.c + * + * Copyright (C) 2001 Theodore Ts'o. This file may be + * redistributed under the terms of the GNU Public License. + */ + +/* + * The strategy we use for keeping track of EA refcounts is as + * follows. We keep a sorted array of first EA blocks and its + * reference counts. Once the refcount has dropped to zero, it is + * removed from the array to save memory space. Once the EA block is + * checked, its bit is set in the block_ea_map bitmap. + */ +struct ea_refcount_el { + blk_t ea_blk; + int ea_count; +}; + +struct ea_refcount { + blk_t count; + blk_t size; + blk_t cursor; + struct ea_refcount_el *list; +}; + +void ea_refcount_free(ext2_refcount_t refcount) +{ + if (!refcount) + return; + + if (refcount->list) + ext2fs_free_mem(&refcount->list); + ext2fs_free_mem(&refcount); +} + +errcode_t ea_refcount_create(int size, ext2_refcount_t *ret) +{ + ext2_refcount_t refcount; + errcode_t retval; + size_t bytes; + + retval = ext2fs_get_mem(sizeof(struct ea_refcount), &refcount); + if (retval) + return retval; + memset(refcount, 0, sizeof(struct ea_refcount)); + + if (!size) + size = 500; + refcount->size = size; + bytes = (size_t) (size * sizeof(struct ea_refcount_el)); +#ifdef DEBUG + printf("Refcount allocated %d entries, %d bytes.\n", + refcount->size, bytes); +#endif + retval = ext2fs_get_mem(bytes, &refcount->list); + if (retval) + goto errout; + memset(refcount->list, 0, bytes); + + refcount->count = 0; + refcount->cursor = 0; + + *ret = refcount; + return 0; + +errout: + ea_refcount_free(refcount); + return(retval); +} + +/* + * collapse_refcount() --- go through the refcount array, and get rid + * of any count == zero entries + */ +static void refcount_collapse(ext2_refcount_t refcount) +{ + unsigned int i, j; + struct ea_refcount_el *list; + + list = refcount->list; + for (i = 0, j = 0; i < refcount->count; i++) { + if (list[i].ea_count) { + if (i != j) + list[j] = list[i]; + j++; + } + } +#if defined(DEBUG) || defined(TEST_PROGRAM) + printf("Refcount_collapse: size was %d, now %d\n", + refcount->count, j); +#endif + refcount->count = j; +} + + +/* + * insert_refcount_el() --- Insert a new entry into the sorted list at a + * specified position. + */ +static struct ea_refcount_el *insert_refcount_el(ext2_refcount_t refcount, + blk_t blk, int pos) +{ + struct ea_refcount_el *el; + errcode_t retval; + blk_t new_size = 0; + int num; + + if (refcount->count >= refcount->size) { + new_size = refcount->size + 100; +#ifdef DEBUG + printf("Reallocating refcount %d entries...\n", new_size); +#endif + retval = ext2fs_resize_mem((size_t) refcount->size * + sizeof(struct ea_refcount_el), + (size_t) new_size * + sizeof(struct ea_refcount_el), + &refcount->list); + if (retval) + return 0; + refcount->size = new_size; + } + num = (int) refcount->count - pos; + if (num < 0) + return 0; /* should never happen */ + if (num) { + memmove(&refcount->list[pos+1], &refcount->list[pos], + sizeof(struct ea_refcount_el) * num); + } + refcount->count++; + el = &refcount->list[pos]; + el->ea_count = 0; + el->ea_blk = blk; + return el; +} + + +/* + * get_refcount_el() --- given an block number, try to find refcount + * information in the sorted list. If the create flag is set, + * and we can't find an entry, create one in the sorted list. + */ +static struct ea_refcount_el *get_refcount_el(ext2_refcount_t refcount, + blk_t blk, int create) +{ + float range; + int low, high, mid; + blk_t lowval, highval; + + if (!refcount || !refcount->list) + return 0; +retry: + low = 0; + high = (int) refcount->count-1; + if (create && ((refcount->count == 0) || + (blk > refcount->list[high].ea_blk))) { + if (refcount->count >= refcount->size) + refcount_collapse(refcount); + + return insert_refcount_el(refcount, blk, + (unsigned) refcount->count); + } + if (refcount->count == 0) + return 0; + + if (refcount->cursor >= refcount->count) + refcount->cursor = 0; + if (blk == refcount->list[refcount->cursor].ea_blk) + return &refcount->list[refcount->cursor++]; +#ifdef DEBUG + printf("Non-cursor get_refcount_el: %u\n", blk); +#endif + while (low <= high) { +#if 0 + mid = (low+high)/2; +#else + if (low == high) + mid = low; + else { + /* Interpolate for efficiency */ + lowval = refcount->list[low].ea_blk; + highval = refcount->list[high].ea_blk; + + if (blk < lowval) + range = 0; + else if (blk > highval) + range = 1; + else + range = ((float) (blk - lowval)) / + (highval - lowval); + mid = low + ((int) (range * (high-low))); + } +#endif + if (blk == refcount->list[mid].ea_blk) { + refcount->cursor = mid+1; + return &refcount->list[mid]; + } + if (blk < refcount->list[mid].ea_blk) + high = mid-1; + else + low = mid+1; + } + /* + * If we need to create a new entry, it should be right at + * low (where high will be left at low-1). + */ + if (create) { + if (refcount->count >= refcount->size) { + refcount_collapse(refcount); + if (refcount->count < refcount->size) + goto retry; + } + return insert_refcount_el(refcount, blk, low); + } + return 0; +} + +errcode_t ea_refcount_increment(ext2_refcount_t refcount, blk_t blk, int *ret) +{ + struct ea_refcount_el *el; + + el = get_refcount_el(refcount, blk, 1); + if (!el) + return EXT2_ET_NO_MEMORY; + el->ea_count++; + + if (ret) + *ret = el->ea_count; + return 0; +} + +errcode_t ea_refcount_decrement(ext2_refcount_t refcount, blk_t blk, int *ret) +{ + struct ea_refcount_el *el; + + el = get_refcount_el(refcount, blk, 0); + if (!el || el->ea_count == 0) + return EXT2_ET_INVALID_ARGUMENT; + + el->ea_count--; + + if (ret) + *ret = el->ea_count; + return 0; +} + +errcode_t ea_refcount_store(ext2_refcount_t refcount, blk_t blk, int count) +{ + struct ea_refcount_el *el; + + /* + * Get the refcount element + */ + el = get_refcount_el(refcount, blk, count ? 1 : 0); + if (!el) + return count ? EXT2_ET_NO_MEMORY : 0; + el->ea_count = count; + return 0; +} + +void ea_refcount_intr_begin(ext2_refcount_t refcount) +{ + refcount->cursor = 0; +} + + +blk_t ea_refcount_intr_next(ext2_refcount_t refcount, + int *ret) +{ + struct ea_refcount_el *list; + + while (1) { + if (refcount->cursor >= refcount->count) + return 0; + list = refcount->list; + if (list[refcount->cursor].ea_count) { + if (ret) + *ret = list[refcount->cursor].ea_count; + return list[refcount->cursor++].ea_blk; + } + refcount->cursor++; + } +} + + +/* + * ehandler.c --- handle bad block errors which come up during the + * course of an e2fsck session. + * + * Copyright (C) 1994 Theodore Ts'o. This file may be redistributed + * under the terms of the GNU Public License. + */ + + +static const char *operation; + +static errcode_t e2fsck_handle_read_error(io_channel channel, + unsigned long block, + int count, + void *data, + size_t size EXT2FS_ATTR((unused)), + int actual EXT2FS_ATTR((unused)), + errcode_t error) +{ + int i; + char *p; + ext2_filsys fs = (ext2_filsys) channel->app_data; + e2fsck_t ctx; + + ctx = (e2fsck_t) fs->priv_data; + + /* + * If more than one block was read, try reading each block + * separately. We could use the actual bytes read to figure + * out where to start, but we don't bother. + */ + if (count > 1) { + p = (char *) data; + for (i=0; i < count; i++, p += channel->block_size, block++) { + error = io_channel_read_blk(channel, block, + 1, p); + if (error) + return error; + } + return 0; + } + if (operation) + printf(_("Error reading block %lu (%s) while %s. "), block, + error_message(error), operation); + else + printf(_("Error reading block %lu (%s). "), block, + error_message(error)); + preenhalt(ctx); + if (ask(ctx, _("Ignore error"), 1)) { + if (ask(ctx, _("Force rewrite"), 1)) + io_channel_write_blk(channel, block, 1, data); + return 0; + } + + return error; +} + +static errcode_t e2fsck_handle_write_error(io_channel channel, + unsigned long block, + int count, + const void *data, + size_t size EXT2FS_ATTR((unused)), + int actual EXT2FS_ATTR((unused)), + errcode_t error) +{ + int i; + const char *p; + ext2_filsys fs = (ext2_filsys) channel->app_data; + e2fsck_t ctx; + + ctx = (e2fsck_t) fs->priv_data; + + /* + * If more than one block was written, try writing each block + * separately. We could use the actual bytes read to figure + * out where to start, but we don't bother. + */ + if (count > 1) { + p = (const char *) data; + for (i=0; i < count; i++, p += channel->block_size, block++) { + error = io_channel_write_blk(channel, block, + 1, p); + if (error) + return error; + } + return 0; + } + + if (operation) + printf(_("Error writing block %lu (%s) while %s. "), block, + error_message(error), operation); + else + printf(_("Error writing block %lu (%s). "), block, + error_message(error)); + preenhalt(ctx); + if (ask(ctx, _("Ignore error"), 1)) + return 0; + + return error; +} + +const char *ehandler_operation(const char *op) +{ + const char *ret = operation; + + operation = op; + return ret; +} + +void ehandler_init(io_channel channel) +{ + channel->read_error = e2fsck_handle_read_error; + channel->write_error = e2fsck_handle_write_error; +} +/* + * journal.c --- code for handling the "ext3" journal + * + * Copyright (C) 2000 Andreas Dilger + * Copyright (C) 2000 Theodore Ts'o + * + * Parts of the code are based on fs/jfs/journal.c by Stephen C. Tweedie + * Copyright (C) 1999 Red Hat Software + * + * This file may be redistributed under the terms of the + * GNU General Public License version 2 or at your discretion + * any later version. + */ + +#define MNT_FL (MS_MGC_VAL | MS_RDONLY) + + +#ifdef __CONFIG_JBD_DEBUG__E2FS /* Enabled by configure --enable-jfs-debug */ +static int bh_count = 0; +#endif + +/* + * Define USE_INODE_IO to use the inode_io.c / fileio.c codepaths. + * This creates a larger static binary, and a smaller binary using + * shared libraries. It's also probably slightly less CPU-efficient, + * which is why it's not on by default. But, it's a good way of + * testing the functions in inode_io.c and fileio.c. + */ +#undef USE_INODE_IO + +/* Kernel compatibility functions for handling the journal. These allow us + * to use the recovery.c file virtually unchanged from the kernel, so we + * don't have to do much to keep kernel and user recovery in sync. + */ +int journal_bmap(journal_t *journal, blk_t block, unsigned long *phys) +{ +#ifdef USE_INODE_IO + *phys = block; + return 0; +#else + struct inode *inode = journal->j_inode; + errcode_t retval; + blk_t pblk; + + if (!inode) { + *phys = block; + return 0; + } + + retval= ext2fs_bmap(inode->i_ctx->fs, inode->i_ino, + &inode->i_ext2, NULL, 0, block, &pblk); + *phys = pblk; + return (retval); +#endif +} + +struct buffer_head *getblk(kdev_t kdev, blk_t blocknr, int blocksize) +{ + struct buffer_head *bh; + + bh = e2fsck_allocate_memory(kdev->k_ctx, sizeof(*bh), "block buffer"); + if (!bh) + return NULL; + + jfs_debug(4, "getblk for block %lu (%d bytes)(total %d)\n", + (unsigned long) blocknr, blocksize, ++bh_count); + + bh->b_ctx = kdev->k_ctx; + if (kdev->k_dev == K_DEV_FS) + bh->b_io = kdev->k_ctx->fs->io; + else + bh->b_io = kdev->k_ctx->journal_io; + bh->b_size = blocksize; + bh->b_blocknr = blocknr; + + return bh; +} + +void sync_blockdev(kdev_t kdev) +{ + io_channel io; + + if (kdev->k_dev == K_DEV_FS) + io = kdev->k_ctx->fs->io; + else + io = kdev->k_ctx->journal_io; + + io_channel_flush(io); +} + +void ll_rw_block(int rw, int nr, struct buffer_head *bhp[]) +{ + int retval; + struct buffer_head *bh; + + for (; nr > 0; --nr) { + bh = *bhp++; + if (rw == READ && !bh->b_uptodate) { + jfs_debug(3, "reading block %lu/%p\n", + (unsigned long) bh->b_blocknr, (void *) bh); + retval = io_channel_read_blk(bh->b_io, + bh->b_blocknr, + 1, bh->b_data); + if (retval) { + com_err(bh->b_ctx->device_name, retval, + "while reading block %lu\n", + (unsigned long) bh->b_blocknr); + bh->b_err = retval; + continue; + } + bh->b_uptodate = 1; + } else if (rw == WRITE && bh->b_dirty) { + jfs_debug(3, "writing block %lu/%p\n", + (unsigned long) bh->b_blocknr, (void *) bh); + retval = io_channel_write_blk(bh->b_io, + bh->b_blocknr, + 1, bh->b_data); + if (retval) { + com_err(bh->b_ctx->device_name, retval, + "while writing block %lu\n", + (unsigned long) bh->b_blocknr); + bh->b_err = retval; + continue; + } + bh->b_dirty = 0; + bh->b_uptodate = 1; + } else { + jfs_debug(3, "no-op %s for block %lu\n", + rw == READ ? "read" : "write", + (unsigned long) bh->b_blocknr); + } + } +} + +void mark_buffer_dirty(struct buffer_head *bh) +{ + bh->b_dirty = 1; +} + +static void mark_buffer_clean(struct buffer_head * bh) +{ + bh->b_dirty = 0; +} + +void brelse(struct buffer_head *bh) +{ + if (bh->b_dirty) + ll_rw_block(WRITE, 1, &bh); + jfs_debug(3, "freeing block %lu/%p (total %d)\n", + (unsigned long) bh->b_blocknr, (void *) bh, --bh_count); + ext2fs_free_mem(&bh); +} + +int buffer_uptodate(struct buffer_head *bh) +{ + return bh->b_uptodate; +} + +void mark_buffer_uptodate(struct buffer_head *bh, int val) +{ + bh->b_uptodate = val; +} + +void wait_on_buffer(struct buffer_head *bh) +{ + if (!bh->b_uptodate) + ll_rw_block(READ, 1, &bh); +} + + +static void e2fsck_clear_recover(e2fsck_t ctx, int error) +{ + ctx->fs->super->s_feature_incompat &= ~EXT3_FEATURE_INCOMPAT_RECOVER; + + /* if we had an error doing journal recovery, we need a full fsck */ + if (error) + ctx->fs->super->s_state &= ~EXT2_VALID_FS; + ext2fs_mark_super_dirty(ctx->fs); +} + +static errcode_t e2fsck_get_journal(e2fsck_t ctx, journal_t **ret_journal) +{ + struct ext2_super_block *sb = ctx->fs->super; + struct ext2_super_block jsuper; + struct problem_context pctx; + struct buffer_head *bh; + struct inode *j_inode = NULL; + struct kdev_s *dev_fs = NULL, *dev_journal; + const char *journal_name = 0; + journal_t *journal = NULL; + errcode_t retval = 0; + io_manager io_ptr = 0; + unsigned long start = 0; + blk_t blk; + int ext_journal = 0; + int tried_backup_jnl = 0; + int i; + + clear_problem_context(&pctx); + + journal = e2fsck_allocate_memory(ctx, sizeof(journal_t), "journal"); + if (!journal) { + return EXT2_ET_NO_MEMORY; + } + + dev_fs = e2fsck_allocate_memory(ctx, 2*sizeof(struct kdev_s), "kdev"); + if (!dev_fs) { + retval = EXT2_ET_NO_MEMORY; + goto errout; + } + dev_journal = dev_fs+1; + + dev_fs->k_ctx = dev_journal->k_ctx = ctx; + dev_fs->k_dev = K_DEV_FS; + dev_journal->k_dev = K_DEV_JOURNAL; + + journal->j_dev = dev_journal; + journal->j_fs_dev = dev_fs; + journal->j_inode = NULL; + journal->j_blocksize = ctx->fs->blocksize; + + if (uuid_is_null(sb->s_journal_uuid)) { + if (!sb->s_journal_inum) + return EXT2_ET_BAD_INODE_NUM; + j_inode = e2fsck_allocate_memory(ctx, sizeof(*j_inode), + "journal inode"); + if (!j_inode) { + retval = EXT2_ET_NO_MEMORY; + goto errout; + } + + j_inode->i_ctx = ctx; + j_inode->i_ino = sb->s_journal_inum; + + if ((retval = ext2fs_read_inode(ctx->fs, + sb->s_journal_inum, + &j_inode->i_ext2))) { + try_backup_journal: + if (sb->s_jnl_backup_type != EXT3_JNL_BACKUP_BLOCKS || + tried_backup_jnl) + goto errout; + memset(&j_inode->i_ext2, 0, sizeof(struct ext2_inode)); + memcpy(&j_inode->i_ext2.i_block[0], sb->s_jnl_blocks, + EXT2_N_BLOCKS*4); + j_inode->i_ext2.i_size = sb->s_jnl_blocks[16]; + j_inode->i_ext2.i_links_count = 1; + j_inode->i_ext2.i_mode = LINUX_S_IFREG | 0600; + tried_backup_jnl++; + } + if (!j_inode->i_ext2.i_links_count || + !LINUX_S_ISREG(j_inode->i_ext2.i_mode)) { + retval = EXT2_ET_NO_JOURNAL; + goto try_backup_journal; + } + if (j_inode->i_ext2.i_size / journal->j_blocksize < + JFS_MIN_JOURNAL_BLOCKS) { + retval = EXT2_ET_JOURNAL_TOO_SMALL; + goto try_backup_journal; + } + for (i=0; i < EXT2_N_BLOCKS; i++) { + blk = j_inode->i_ext2.i_block[i]; + if (!blk) { + if (i < EXT2_NDIR_BLOCKS) { + retval = EXT2_ET_JOURNAL_TOO_SMALL; + goto try_backup_journal; + } + continue; + } + if (blk < sb->s_first_data_block || + blk >= sb->s_blocks_count) { + retval = EXT2_ET_BAD_BLOCK_NUM; + goto try_backup_journal; + } + } + journal->j_maxlen = j_inode->i_ext2.i_size / journal->j_blocksize; + +#ifdef USE_INODE_IO + retval = ext2fs_inode_io_intern2(ctx->fs, sb->s_journal_inum, + &j_inode->i_ext2, + &journal_name); + if (retval) + goto errout; + + io_ptr = inode_io_manager; +#else + journal->j_inode = j_inode; + ctx->journal_io = ctx->fs->io; + if ((retval = journal_bmap(journal, 0, &start)) != 0) + goto errout; +#endif + } else { + ext_journal = 1; + if (!ctx->journal_name) { + char uuid[37]; + + uuid_unparse(sb->s_journal_uuid, uuid); + ctx->journal_name = blkid_get_devname(ctx->blkid, + "UUID", uuid); + if (!ctx->journal_name) + ctx->journal_name = blkid_devno_to_devname(sb->s_journal_dev); + } + journal_name = ctx->journal_name; + + if (!journal_name) { + fix_problem(ctx, PR_0_CANT_FIND_JOURNAL, &pctx); + return EXT2_ET_LOAD_EXT_JOURNAL; + } + + jfs_debug(1, "Using journal file %s\n", journal_name); + io_ptr = unix_io_manager; + } + +#if 0 + test_io_backing_manager = io_ptr; + io_ptr = test_io_manager; +#endif +#ifndef USE_INODE_IO + if (ext_journal) +#endif + retval = io_ptr->open(journal_name, IO_FLAG_RW, + &ctx->journal_io); + if (retval) + goto errout; + + io_channel_set_blksize(ctx->journal_io, ctx->fs->blocksize); + + if (ext_journal) { + if (ctx->fs->blocksize == 1024) + start = 1; + bh = getblk(dev_journal, start, ctx->fs->blocksize); + if (!bh) { + retval = EXT2_ET_NO_MEMORY; + goto errout; + } + ll_rw_block(READ, 1, &bh); + if ((retval = bh->b_err) != 0) + goto errout; + memcpy(&jsuper, start ? bh->b_data : bh->b_data + 1024, + sizeof(jsuper)); + brelse(bh); +#ifdef EXT2FS_ENABLE_SWAPFS + if (jsuper.s_magic == ext2fs_swab16(EXT2_SUPER_MAGIC)) + ext2fs_swap_super(&jsuper); +#endif + if (jsuper.s_magic != EXT2_SUPER_MAGIC || + !(jsuper.s_feature_incompat & EXT3_FEATURE_INCOMPAT_JOURNAL_DEV)) { + fix_problem(ctx, PR_0_EXT_JOURNAL_BAD_SUPER, &pctx); + retval = EXT2_ET_LOAD_EXT_JOURNAL; + goto errout; + } + /* Make sure the journal UUID is correct */ + if (memcmp(jsuper.s_uuid, ctx->fs->super->s_journal_uuid, + sizeof(jsuper.s_uuid))) { + fix_problem(ctx, PR_0_JOURNAL_BAD_UUID, &pctx); + retval = EXT2_ET_LOAD_EXT_JOURNAL; + goto errout; + } + + journal->j_maxlen = jsuper.s_blocks_count; + start++; + } + + if (!(bh = getblk(dev_journal, start, journal->j_blocksize))) { + retval = EXT2_ET_NO_MEMORY; + goto errout; + } + + journal->j_sb_buffer = bh; + journal->j_superblock = (journal_superblock_t *)bh->b_data; + +#ifdef USE_INODE_IO + if (j_inode) + ext2fs_free_mem(&j_inode); +#endif + + *ret_journal = journal; + return 0; + +errout: + if (dev_fs) + ext2fs_free_mem(&dev_fs); + if (j_inode) + ext2fs_free_mem(&j_inode); + if (journal) + ext2fs_free_mem(&journal); + return retval; + +} + +static errcode_t e2fsck_journal_fix_bad_inode(e2fsck_t ctx, + struct problem_context *pctx) +{ + struct ext2_super_block *sb = ctx->fs->super; + int recover = ctx->fs->super->s_feature_incompat & + EXT3_FEATURE_INCOMPAT_RECOVER; + int has_journal = ctx->fs->super->s_feature_compat & + EXT3_FEATURE_COMPAT_HAS_JOURNAL; + + if (has_journal || sb->s_journal_inum) { + /* The journal inode is bogus, remove and force full fsck */ + pctx->ino = sb->s_journal_inum; + if (fix_problem(ctx, PR_0_JOURNAL_BAD_INODE, pctx)) { + if (has_journal && sb->s_journal_inum) + printf("*** ext3 journal has been deleted - " + "filesystem is now ext2 only ***\n\n"); + sb->s_feature_compat &= ~EXT3_FEATURE_COMPAT_HAS_JOURNAL; + sb->s_journal_inum = 0; + ctx->flags |= E2F_FLAG_JOURNAL_INODE; /* FIXME: todo */ + e2fsck_clear_recover(ctx, 1); + return 0; + } + return EXT2_ET_BAD_INODE_NUM; + } else if (recover) { + if (fix_problem(ctx, PR_0_JOURNAL_RECOVER_SET, pctx)) { + e2fsck_clear_recover(ctx, 1); + return 0; + } + return EXT2_ET_UNSUPP_FEATURE; + } + return 0; +} + +#define V1_SB_SIZE 0x0024 +static void clear_v2_journal_fields(journal_t *journal) +{ + e2fsck_t ctx = journal->j_dev->k_ctx; + struct problem_context pctx; + + clear_problem_context(&pctx); + + if (!fix_problem(ctx, PR_0_CLEAR_V2_JOURNAL, &pctx)) + return; + + memset(((char *) journal->j_superblock) + V1_SB_SIZE, 0, + ctx->fs->blocksize-V1_SB_SIZE); + mark_buffer_dirty(journal->j_sb_buffer); +} + + +static errcode_t e2fsck_journal_load(journal_t *journal) +{ + e2fsck_t ctx = journal->j_dev->k_ctx; + journal_superblock_t *jsb; + struct buffer_head *jbh = journal->j_sb_buffer; + struct problem_context pctx; + + clear_problem_context(&pctx); + + ll_rw_block(READ, 1, &jbh); + if (jbh->b_err) { + com_err(ctx->device_name, jbh->b_err, + _("reading journal superblock\n")); + return jbh->b_err; + } + + jsb = journal->j_superblock; + /* If we don't even have JFS_MAGIC, we probably have a wrong inode */ + if (jsb->s_header.h_magic != htonl(JFS_MAGIC_NUMBER)) + return e2fsck_journal_fix_bad_inode(ctx, &pctx); + + switch (ntohl(jsb->s_header.h_blocktype)) { + case JFS_SUPERBLOCK_V1: + journal->j_format_version = 1; + if (jsb->s_feature_compat || + jsb->s_feature_incompat || + jsb->s_feature_ro_compat || + jsb->s_nr_users) + clear_v2_journal_fields(journal); + break; + + case JFS_SUPERBLOCK_V2: + journal->j_format_version = 2; + if (ntohl(jsb->s_nr_users) > 1 && + uuid_is_null(ctx->fs->super->s_journal_uuid)) + clear_v2_journal_fields(journal); + if (ntohl(jsb->s_nr_users) > 1) { + fix_problem(ctx, PR_0_JOURNAL_UNSUPP_MULTIFS, &pctx); + return EXT2_ET_JOURNAL_UNSUPP_VERSION; + } + break; + + /* + * These should never appear in a journal super block, so if + * they do, the journal is badly corrupted. + */ + case JFS_DESCRIPTOR_BLOCK: + case JFS_COMMIT_BLOCK: + case JFS_REVOKE_BLOCK: + return EXT2_ET_CORRUPT_SUPERBLOCK; + + /* If we don't understand the superblock major type, but there + * is a magic number, then it is likely to be a new format we + * just don't understand, so leave it alone. */ + default: + return EXT2_ET_JOURNAL_UNSUPP_VERSION; + } + + if (JFS_HAS_INCOMPAT_FEATURE(journal, ~JFS_KNOWN_INCOMPAT_FEATURES)) + return EXT2_ET_UNSUPP_FEATURE; + + if (JFS_HAS_RO_COMPAT_FEATURE(journal, ~JFS_KNOWN_ROCOMPAT_FEATURES)) + return EXT2_ET_RO_UNSUPP_FEATURE; + + /* We have now checked whether we know enough about the journal + * format to be able to proceed safely, so any other checks that + * fail we should attempt to recover from. */ + if (jsb->s_blocksize != htonl(journal->j_blocksize)) { + com_err(ctx->program_name, EXT2_ET_CORRUPT_SUPERBLOCK, + _("%s: no valid journal superblock found\n"), + ctx->device_name); + return EXT2_ET_CORRUPT_SUPERBLOCK; + } + + if (ntohl(jsb->s_maxlen) < journal->j_maxlen) + journal->j_maxlen = ntohl(jsb->s_maxlen); + else if (ntohl(jsb->s_maxlen) > journal->j_maxlen) { + com_err(ctx->program_name, EXT2_ET_CORRUPT_SUPERBLOCK, + _("%s: journal too short\n"), + ctx->device_name); + return EXT2_ET_CORRUPT_SUPERBLOCK; + } + + journal->j_tail_sequence = ntohl(jsb->s_sequence); + journal->j_transaction_sequence = journal->j_tail_sequence; + journal->j_tail = ntohl(jsb->s_start); + journal->j_first = ntohl(jsb->s_first); + journal->j_last = ntohl(jsb->s_maxlen); + + return 0; +} + +static void e2fsck_journal_reset_super(e2fsck_t ctx, journal_superblock_t *jsb, + journal_t *journal) +{ + char *p; + union { + uuid_t uuid; + __u32 val[4]; + } u; + __u32 new_seq = 0; + int i; + + /* Leave a valid existing V1 superblock signature alone. + * Anything unrecognisable we overwrite with a new V2 + * signature. */ + + if (jsb->s_header.h_magic != htonl(JFS_MAGIC_NUMBER) || + jsb->s_header.h_blocktype != htonl(JFS_SUPERBLOCK_V1)) { + jsb->s_header.h_magic = htonl(JFS_MAGIC_NUMBER); + jsb->s_header.h_blocktype = htonl(JFS_SUPERBLOCK_V2); + } + + /* Zero out everything else beyond the superblock header */ + + p = ((char *) jsb) + sizeof(journal_header_t); + memset (p, 0, ctx->fs->blocksize-sizeof(journal_header_t)); + + jsb->s_blocksize = htonl(ctx->fs->blocksize); + jsb->s_maxlen = htonl(journal->j_maxlen); + jsb->s_first = htonl(1); + + /* Initialize the journal sequence number so that there is "no" + * chance we will find old "valid" transactions in the journal. + * This avoids the need to zero the whole journal (slow to do, + * and risky when we are just recovering the filesystem). + */ + uuid_generate(u.uuid); + for (i = 0; i < 4; i ++) + new_seq ^= u.val[i]; + jsb->s_sequence = htonl(new_seq); + + mark_buffer_dirty(journal->j_sb_buffer); + ll_rw_block(WRITE, 1, &journal->j_sb_buffer); +} + +static errcode_t e2fsck_journal_fix_corrupt_super(e2fsck_t ctx, + journal_t *journal, + struct problem_context *pctx) +{ + struct ext2_super_block *sb = ctx->fs->super; + int recover = ctx->fs->super->s_feature_incompat & + EXT3_FEATURE_INCOMPAT_RECOVER; + + if (sb->s_feature_compat & EXT3_FEATURE_COMPAT_HAS_JOURNAL) { + if (fix_problem(ctx, PR_0_JOURNAL_BAD_SUPER, pctx)) { + e2fsck_journal_reset_super(ctx, journal->j_superblock, + journal); + journal->j_transaction_sequence = 1; + e2fsck_clear_recover(ctx, recover); + return 0; + } + return EXT2_ET_CORRUPT_SUPERBLOCK; + } else if (e2fsck_journal_fix_bad_inode(ctx, pctx)) + return EXT2_ET_CORRUPT_SUPERBLOCK; + + return 0; +} + +static void e2fsck_journal_release(e2fsck_t ctx, journal_t *journal, + int reset, int drop) +{ + journal_superblock_t *jsb; + + if (drop) + mark_buffer_clean(journal->j_sb_buffer); + else if (!(ctx->options & E2F_OPT_READONLY)) { + jsb = journal->j_superblock; + jsb->s_sequence = htonl(journal->j_transaction_sequence); + if (reset) + jsb->s_start = 0; /* this marks the journal as empty */ + mark_buffer_dirty(journal->j_sb_buffer); + } + brelse(journal->j_sb_buffer); + + if (ctx->journal_io) { + if (ctx->fs && ctx->fs->io != ctx->journal_io) + io_channel_close(ctx->journal_io); + ctx->journal_io = 0; + } + +#ifndef USE_INODE_IO + if (journal->j_inode) + ext2fs_free_mem(&journal->j_inode); +#endif + if (journal->j_fs_dev) + ext2fs_free_mem(&journal->j_fs_dev); + ext2fs_free_mem(&journal); +} + +/* + * This function makes sure that the superblock fields regarding the + * journal are consistent. + */ +int e2fsck_check_ext3_journal(e2fsck_t ctx) +{ + struct ext2_super_block *sb = ctx->fs->super; + journal_t *journal; + int recover = ctx->fs->super->s_feature_incompat & + EXT3_FEATURE_INCOMPAT_RECOVER; + struct problem_context pctx; + problem_t problem; + int reset = 0, force_fsck = 0; + int retval; + + /* If we don't have any journal features, don't do anything more */ + if (!(sb->s_feature_compat & EXT3_FEATURE_COMPAT_HAS_JOURNAL) && + !recover && sb->s_journal_inum == 0 && sb->s_journal_dev == 0 && + uuid_is_null(sb->s_journal_uuid)) + return 0; + + clear_problem_context(&pctx); + pctx.num = sb->s_journal_inum; + + retval = e2fsck_get_journal(ctx, &journal); + if (retval) { + if ((retval == EXT2_ET_BAD_INODE_NUM) || + (retval == EXT2_ET_BAD_BLOCK_NUM) || + (retval == EXT2_ET_JOURNAL_TOO_SMALL) || + (retval == EXT2_ET_NO_JOURNAL)) + return e2fsck_journal_fix_bad_inode(ctx, &pctx); + return retval; + } + + retval = e2fsck_journal_load(journal); + if (retval) { + if ((retval == EXT2_ET_CORRUPT_SUPERBLOCK) || + ((retval == EXT2_ET_UNSUPP_FEATURE) && + (!fix_problem(ctx, PR_0_JOURNAL_UNSUPP_INCOMPAT, + &pctx))) || + ((retval == EXT2_ET_RO_UNSUPP_FEATURE) && + (!fix_problem(ctx, PR_0_JOURNAL_UNSUPP_ROCOMPAT, + &pctx))) || + ((retval == EXT2_ET_JOURNAL_UNSUPP_VERSION) && + (!fix_problem(ctx, PR_0_JOURNAL_UNSUPP_VERSION, &pctx)))) + retval = e2fsck_journal_fix_corrupt_super(ctx, journal, + &pctx); + e2fsck_journal_release(ctx, journal, 0, 1); + return retval; + } + + /* + * We want to make the flags consistent here. We will not leave with + * needs_recovery set but has_journal clear. We can't get in a loop + * with -y, -n, or -p, only if a user isn't making up their mind. + */ +no_has_journal: + if (!(sb->s_feature_compat & EXT3_FEATURE_COMPAT_HAS_JOURNAL)) { + recover = sb->s_feature_incompat & EXT3_FEATURE_INCOMPAT_RECOVER; + pctx.str = "inode"; + if (fix_problem(ctx, PR_0_JOURNAL_HAS_JOURNAL, &pctx)) { + if (recover && + !fix_problem(ctx, PR_0_JOURNAL_RECOVER_SET, &pctx)) + goto no_has_journal; + /* + * Need a full fsck if we are releasing a + * journal stored on a reserved inode. + */ + force_fsck = recover || + (sb->s_journal_inum < EXT2_FIRST_INODE(sb)); + /* Clear all of the journal fields */ + sb->s_journal_inum = 0; + sb->s_journal_dev = 0; + memset(sb->s_journal_uuid, 0, + sizeof(sb->s_journal_uuid)); + e2fsck_clear_recover(ctx, force_fsck); + } else if (!(ctx->options & E2F_OPT_READONLY)) { + sb->s_feature_compat |= EXT3_FEATURE_COMPAT_HAS_JOURNAL; + ext2fs_mark_super_dirty(ctx->fs); + } + } + + if (sb->s_feature_compat & EXT3_FEATURE_COMPAT_HAS_JOURNAL && + !(sb->s_feature_incompat & EXT3_FEATURE_INCOMPAT_RECOVER) && + journal->j_superblock->s_start != 0) { + /* Print status information */ + fix_problem(ctx, PR_0_JOURNAL_RECOVERY_CLEAR, &pctx); + if (ctx->superblock) + problem = PR_0_JOURNAL_RUN_DEFAULT; + else + problem = PR_0_JOURNAL_RUN; + if (fix_problem(ctx, problem, &pctx)) { + ctx->options |= E2F_OPT_FORCE; + sb->s_feature_incompat |= + EXT3_FEATURE_INCOMPAT_RECOVER; + ext2fs_mark_super_dirty(ctx->fs); + } else if (fix_problem(ctx, + PR_0_JOURNAL_RESET_JOURNAL, &pctx)) { + reset = 1; + sb->s_state &= ~EXT2_VALID_FS; + ext2fs_mark_super_dirty(ctx->fs); + } + /* + * If the user answers no to the above question, we + * ignore the fact that journal apparently has data; + * accidentally replaying over valid data would be far + * worse than skipping a questionable recovery. + * + * XXX should we abort with a fatal error here? What + * will the ext3 kernel code do if a filesystem with + * !NEEDS_RECOVERY but with a non-zero + * journal->j_superblock->s_start is mounted? + */ + } + + e2fsck_journal_release(ctx, journal, reset, 0); + return retval; +} + +static errcode_t recover_ext3_journal(e2fsck_t ctx) +{ + journal_t *journal; + int retval; + + journal_init_revoke_caches(); + retval = e2fsck_get_journal(ctx, &journal); + if (retval) + return retval; + + retval = e2fsck_journal_load(journal); + if (retval) + goto errout; + + retval = journal_init_revoke(journal, 1024); + if (retval) + goto errout; + + retval = -journal_recover(journal); + if (retval) + goto errout; + + if (journal->j_superblock->s_errno) { + ctx->fs->super->s_state |= EXT2_ERROR_FS; + ext2fs_mark_super_dirty(ctx->fs); + journal->j_superblock->s_errno = 0; + mark_buffer_dirty(journal->j_sb_buffer); + } + +errout: + journal_destroy_revoke(journal); + journal_destroy_revoke_caches(); + e2fsck_journal_release(ctx, journal, 1, 0); + return retval; +} + +int e2fsck_run_ext3_journal(e2fsck_t ctx) +{ + io_manager io_ptr = ctx->fs->io->manager; + int blocksize = ctx->fs->blocksize; + errcode_t retval, recover_retval; + + printf(_("%s: recovering journal\n"), ctx->device_name); + if (ctx->options & E2F_OPT_READONLY) { + printf(_("%s: won't do journal recovery while read-only\n"), + ctx->device_name); + return EXT2_ET_FILE_RO; + } + + if (ctx->fs->flags & EXT2_FLAG_DIRTY) + ext2fs_flush(ctx->fs); /* Force out any modifications */ + + recover_retval = recover_ext3_journal(ctx); + + /* + * Reload the filesystem context to get up-to-date data from disk + * because journal recovery will change the filesystem under us. + */ + ext2fs_close(ctx->fs); + retval = ext2fs_open(ctx->filesystem_name, EXT2_FLAG_RW, + ctx->superblock, blocksize, io_ptr, + &ctx->fs); + + if (retval) { + com_err(ctx->program_name, retval, + _("while trying to re-open %s"), + ctx->device_name); + fatal_error(ctx, 0); + } + ctx->fs->priv_data = ctx; + + /* Set the superblock flags */ + e2fsck_clear_recover(ctx, recover_retval); + return recover_retval; +} + +/* + * This function will move the journal inode from a visible file in + * the filesystem directory hierarchy to the reserved inode if necessary. + */ +static const char * const journal_names[] = { + ".journal", "journal", ".journal.dat", "journal.dat", 0 }; + +void e2fsck_move_ext3_journal(e2fsck_t ctx) +{ + struct ext2_super_block *sb = ctx->fs->super; + struct problem_context pctx; + struct ext2_inode inode; + ext2_filsys fs = ctx->fs; + ext2_ino_t ino; + errcode_t retval; + const char * const * cpp; + int group, mount_flags; + + clear_problem_context(&pctx); + + /* + * If the filesystem is opened read-only, or there is no + * journal, then do nothing. + */ + if ((ctx->options & E2F_OPT_READONLY) || + (sb->s_journal_inum == 0) || + !(sb->s_feature_compat & EXT3_FEATURE_COMPAT_HAS_JOURNAL)) + return; + + /* + * Read in the journal inode + */ + if (ext2fs_read_inode(fs, sb->s_journal_inum, &inode) != 0) + return; + + /* + * If it's necessary to backup the journal inode, do so. + */ + if ((sb->s_jnl_backup_type == 0) || + ((sb->s_jnl_backup_type == EXT3_JNL_BACKUP_BLOCKS) && + memcmp(inode.i_block, sb->s_jnl_blocks, EXT2_N_BLOCKS*4))) { + if (fix_problem(ctx, PR_0_BACKUP_JNL, &pctx)) { + memcpy(sb->s_jnl_blocks, inode.i_block, + EXT2_N_BLOCKS*4); + sb->s_jnl_blocks[16] = inode.i_size; + sb->s_jnl_backup_type = EXT3_JNL_BACKUP_BLOCKS; + ext2fs_mark_super_dirty(fs); + fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY; + } + } + + /* + * If the journal is already the hidden inode, then do nothing + */ + if (sb->s_journal_inum == EXT2_JOURNAL_INO) + return; + + /* + * The journal inode had better have only one link and not be readable. + */ + if (inode.i_links_count != 1) + return; + + /* + * If the filesystem is mounted, or we can't tell whether + * or not it's mounted, do nothing. + */ + retval = ext2fs_check_if_mounted(ctx->filesystem_name, &mount_flags); + if (retval || (mount_flags & EXT2_MF_MOUNTED)) + return; + + /* + * If we can't find the name of the journal inode, then do + * nothing. + */ + for (cpp = journal_names; *cpp; cpp++) { + retval = ext2fs_lookup(fs, EXT2_ROOT_INO, *cpp, + strlen(*cpp), 0, &ino); + if ((retval == 0) && (ino == sb->s_journal_inum)) + break; + } + if (*cpp == 0) + return; + + /* We need the inode bitmap to be loaded */ + retval = ext2fs_read_bitmaps(fs); + if (retval) + return; + + pctx.str = *cpp; + if (!fix_problem(ctx, PR_0_MOVE_JOURNAL, &pctx)) + return; + + /* + * OK, we've done all the checks, let's actually move the + * journal inode. Errors at this point mean we need to force + * an ext2 filesystem check. + */ + if ((retval = ext2fs_unlink(fs, EXT2_ROOT_INO, *cpp, ino, 0)) != 0) + goto err_out; + if ((retval = ext2fs_write_inode(fs, EXT2_JOURNAL_INO, &inode)) != 0) + goto err_out; + sb->s_journal_inum = EXT2_JOURNAL_INO; + ext2fs_mark_super_dirty(fs); + fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY; + inode.i_links_count = 0; + inode.i_dtime = time(0); + if ((retval = ext2fs_write_inode(fs, ino, &inode)) != 0) + goto err_out; + + group = ext2fs_group_of_ino(fs, ino); + ext2fs_unmark_inode_bitmap(fs->inode_map, ino); + ext2fs_mark_ib_dirty(fs); + fs->group_desc[group].bg_free_inodes_count++; + fs->super->s_free_inodes_count++; + return; + +err_out: + pctx.errcode = retval; + fix_problem(ctx, PR_0_ERR_MOVE_JOURNAL, &pctx); + fs->super->s_state &= ~EXT2_VALID_FS; + ext2fs_mark_super_dirty(fs); + return; +} + +/* + * message.c --- print e2fsck messages (with compression) + * + * Copyright 1996, 1997 by Theodore Ts'o + * + * %Begin-Header% + * This file may be redistributed under the terms of the GNU Public + * License. + * %End-Header% + * + * print_e2fsck_message() prints a message to the user, using + * compression techniques and expansions of abbreviations. + * + * The following % expansions are supported: + * + * %b block number + * %B integer + * %c block number + * %Di ->ino inode number + * %Dn ->name string + * %Dr ->rec_len + * %Dl ->name_len + * %Dt ->filetype + * %d inode number + * %g integer + * %i inode number + * %Is -> i_size + * %IS -> i_extra_isize + * %Ib -> i_blocks + * %Il -> i_links_count + * %Im -> i_mode + * %IM -> i_mtime + * %IF -> i_faddr + * %If -> i_file_acl + * %Id -> i_dir_acl + * %Iu -> i_uid + * %Ig -> i_gid + * %j inode number + * %m + * %N + * %p ext2fs_get_pathname of directory + * %P ext2fs_get_pathname of ->ino with as + * the containing directory. (If dirent is NULL + * then return the pathname of directory ) + * %q ext2fs_get_pathname of directory + * %Q ext2fs_get_pathname of directory with as + * the containing directory. + * %s miscellaneous string + * %S backup superblock + * %X hexadecimal format + * + * The following '@' expansions are supported: + * + * @a extended attribute + * @A error allocating + * @b block + * @B bitmap + * @c compress + * @C conflicts with some other fs block + * @D deleted + * @d directory + * @e entry + * @E Entry '%Dn' in %p (%i) + * @f filesystem + * @F for @i %i (%Q) is + * @g group + * @h HTREE directory inode + * @i inode + * @I illegal + * @j journal + * @l lost+found + * @L is a link + * @o orphaned + * @p problem in + * @r root inode + * @s should be + * @S superblock + * @u unattached + * @v device + * @z zero-length + */ + + +/* + * This structure defines the abbreviations used by the text strings + * below. The first character in the string is the index letter. An + * abbreviation of the form '@' is expanded by looking up the index + * letter in the table below. + */ +static const char *abbrevs[] = { + N_("aextended attribute"), + N_("Aerror allocating"), + N_("bblock"), + N_("Bbitmap"), + N_("ccompress"), + N_("Cconflicts with some other fs @b"), + N_("iinode"), + N_("Iillegal"), + N_("jjournal"), + N_("Ddeleted"), + N_("ddirectory"), + N_("eentry"), + N_("E@e '%Dn' in %p (%i)"), + N_("ffilesystem"), + N_("Ffor @i %i (%Q) is"), + N_("ggroup"), + N_("hHTREE @d @i"), + N_("llost+found"), + N_("Lis a link"), + N_("oorphaned"), + N_("pproblem in"), + N_("rroot @i"), + N_("sshould be"), + N_("Ssuper@b"), + N_("uunattached"), + N_("vdevice"), + N_("zzero-length"), + "@@", + 0 + }; + +/* + * Give more user friendly names to the "special" inodes. + */ +#define num_special_inodes 11 +static const char *special_inode_name[] = +{ + N_(""), /* 0 */ + N_(""), /* 1 */ + "/", /* 2 */ + N_(""), /* 3 */ + N_(""), /* 4 */ + N_(""), /* 5 */ + N_(""), /* 6 */ + N_(""), /* 7 */ + N_(""), /* 8 */ + N_(""), /* 9 */ + N_(""), /* 10 */ +}; + +/* + * This function does "safe" printing. It will convert non-printable + * ASCII characters using '^' and M- notation. + */ +static void safe_print(const char *cp, int len) +{ + unsigned char ch; + + if (len < 0) + len = strlen(cp); + + while (len--) { + ch = *cp++; + if (ch > 128) { + fputs("M-", stdout); + ch -= 128; + } + if ((ch < 32) || (ch == 0x7f)) { + fputc('^', stdout); + ch ^= 0x40; /* ^@, ^A, ^B; ^? for DEL */ + } + fputc(ch, stdout); + } +} + + +/* + * This function prints a pathname, using the ext2fs_get_pathname + * function + */ +static void print_pathname(ext2_filsys fs, ext2_ino_t dir, ext2_ino_t ino) +{ + errcode_t retval; + char *path; + + if (!dir && (ino < num_special_inodes)) { + fputs(_(special_inode_name[ino]), stdout); + return; + } + + retval = ext2fs_get_pathname(fs, dir, ino, &path); + if (retval) + fputs("???", stdout); + else { + safe_print(path, -1); + ext2fs_free_mem(&path); + } +} + +/* + * This function handles the '@' expansion. We allow recursive + * expansion; an @ expression can contain further '@' and '%' + * expressions. + */ +static _INLINE_ void expand_at_expression(e2fsck_t ctx, char ch, + struct problem_context *pctx, + int *first) +{ + const char **cpp, *str; + + /* Search for the abbreviation */ + for (cpp = abbrevs; *cpp; cpp++) { + if (ch == *cpp[0]) + break; + } + if (*cpp) { + str = _(*cpp) + 1; + if (*first && islower(*str)) { + *first = 0; + fputc(toupper(*str++), stdout); + } + print_e2fsck_message(ctx, str, pctx, *first); + } else + printf("@%c", ch); +} + +/* + * This function expands '%IX' expressions + */ +static _INLINE_ void expand_inode_expression(char ch, + struct problem_context *ctx) +{ + struct ext2_inode *inode; + struct ext2_inode_large *large_inode; + char * time_str; + time_t t; + int do_gmt = -1; + + if (!ctx || !ctx->inode) + goto no_inode; + + inode = ctx->inode; + large_inode = (struct ext2_inode_large *) inode; + + switch (ch) { + case 's': + if (LINUX_S_ISDIR(inode->i_mode)) + printf("%u", inode->i_size); + else { +#ifdef EXT2_NO_64_TYPE + if (inode->i_size_high) + printf("0x%x%08x", inode->i_size_high, + inode->i_size); + else + printf("%u", inode->i_size); +#else + printf("%llu", (inode->i_size | + ((__u64) inode->i_size_high << 32))); +#endif + } + break; + case 'S': + printf("%u", large_inode->i_extra_isize); + break; + case 'b': + printf("%u", inode->i_blocks); + break; + case 'l': + printf("%d", inode->i_links_count); + break; + case 'm': + printf("0%o", inode->i_mode); + break; + case 'M': + /* The diet libc doesn't respect the TZ environemnt variable */ + if (do_gmt == -1) { + time_str = getenv("TZ"); + if (!time_str) + time_str = ""; + do_gmt = !strcmp(time_str, "GMT"); + } + t = inode->i_mtime; + time_str = asctime(do_gmt ? gmtime(&t) : localtime(&t)); + printf("%.24s", time_str); + break; + case 'F': + printf("%u", inode->i_faddr); + break; + case 'f': + printf("%u", inode->i_file_acl); + break; + case 'd': + printf("%u", (LINUX_S_ISDIR(inode->i_mode) ? + inode->i_dir_acl : 0)); + break; + case 'u': + printf("%d", (inode->i_uid | + (inode->osd2.linux2.l_i_uid_high << 16))); + break; + case 'g': + printf("%d", (inode->i_gid | + (inode->osd2.linux2.l_i_gid_high << 16))); + break; + default: + no_inode: + printf("%%I%c", ch); + break; + } +} + +/* + * This function expands '%dX' expressions + */ +static _INLINE_ void expand_dirent_expression(char ch, + struct problem_context *ctx) +{ + struct ext2_dir_entry *dirent; + int len; + + if (!ctx || !ctx->dirent) + goto no_dirent; + + dirent = ctx->dirent; + + switch (ch) { + case 'i': + printf("%u", dirent->inode); + break; + case 'n': + len = dirent->name_len & 0xFF; + if (len > EXT2_NAME_LEN) + len = EXT2_NAME_LEN; + if (len > dirent->rec_len) + len = dirent->rec_len; + safe_print(dirent->name, len); + break; + case 'r': + printf("%u", dirent->rec_len); + break; + case 'l': + printf("%u", dirent->name_len & 0xFF); + break; + case 't': + printf("%u", dirent->name_len >> 8); + break; + default: + no_dirent: + printf("%%D%c", ch); + break; + } +} + +static _INLINE_ void expand_percent_expression(ext2_filsys fs, char ch, + struct problem_context *ctx) +{ + if (!ctx) + goto no_context; + + switch (ch) { + case '%': + fputc('%', stdout); + break; + case 'b': + printf("%u", ctx->blk); + break; + case 'B': +#ifdef EXT2_NO_64_TYPE + printf("%d", ctx->blkcount); +#else + printf("%lld", ctx->blkcount); +#endif + break; + case 'c': + printf("%u", ctx->blk2); + break; + case 'd': + printf("%u", ctx->dir); + break; + case 'g': + printf("%d", ctx->group); + break; + case 'i': + printf("%u", ctx->ino); + break; + case 'j': + printf("%u", ctx->ino2); + break; + case 'm': + printf("%s", error_message(ctx->errcode)); + break; + case 'N': +#ifdef EXT2_NO_64_TYPE + printf("%u", ctx->num); +#else + printf("%llu", ctx->num); +#endif + break; + case 'p': + print_pathname(fs, ctx->ino, 0); + break; + case 'P': + print_pathname(fs, ctx->ino2, + ctx->dirent ? ctx->dirent->inode : 0); + break; + case 'q': + print_pathname(fs, ctx->dir, 0); + break; + case 'Q': + print_pathname(fs, ctx->dir, ctx->ino); + break; + case 'S': + printf("%d", get_backup_sb(NULL, fs, NULL, NULL)); + break; + case 's': + printf("%s", ctx->str ? ctx->str : "NULL"); + break; + case 'X': +#ifdef EXT2_NO_64_TYPE + printf("0x%x", ctx->num); +#else + printf("0x%llx", ctx->num); +#endif + break; + default: + no_context: + printf("%%%c", ch); + break; + } +} + +void print_e2fsck_message(e2fsck_t ctx, const char *msg, + struct problem_context *pctx, int first) +{ + ext2_filsys fs = ctx->fs; + const char * cp; + int i; + + e2fsck_clear_progbar(ctx); + for (cp = msg; *cp; cp++) { + if (cp[0] == '@') { + cp++; + expand_at_expression(ctx, *cp, pctx, &first); + } else if (cp[0] == '%' && cp[1] == 'I') { + cp += 2; + expand_inode_expression(*cp, pctx); + } else if (cp[0] == '%' && cp[1] == 'D') { + cp += 2; + expand_dirent_expression(*cp, pctx); + } else if ((cp[0] == '%')) { + cp++; + expand_percent_expression(fs, *cp, pctx); + } else { + for (i=0; cp[i]; i++) + if ((cp[i] == '@') || cp[i] == '%') + break; + printf("%.*s", i, cp); + cp += i-1; + } + first = 0; + } +} +/* + * pass1.c -- pass #1 of e2fsck: sequential scan of the inode table + * + * Copyright (C) 1993, 1994, 1995, 1996, 1997 Theodore Ts'o. + * + * %Begin-Header% + * This file may be redistributed under the terms of the GNU Public + * License. + * %End-Header% + * + * Pass 1 of e2fsck iterates over all the inodes in the filesystems, + * and applies the following tests to each inode: + * + * - The mode field of the inode must be legal. + * - The size and block count fields of the inode are correct. + * - A data block must not be used by another inode + * + * Pass 1 also gathers the collects the following information: + * + * - A bitmap of which inodes are in use. (inode_used_map) + * - A bitmap of which inodes are directories. (inode_dir_map) + * - A bitmap of which inodes are regular files. (inode_reg_map) + * - A bitmap of which inodes have bad fields. (inode_bad_map) + * - A bitmap of which inodes are in bad blocks. (inode_bb_map) + * - A bitmap of which inodes are imagic inodes. (inode_imagic_map) + * - A bitmap of which blocks are in use. (block_found_map) + * - A bitmap of which blocks are in use by two inodes (block_dup_map) + * - The data blocks of the directory inodes. (dir_map) + * + * Pass 1 is designed to stash away enough information so that the + * other passes should not need to read in the inode information + * during the normal course of a filesystem check. (Althogh if an + * inconsistency is detected, other passes may need to read in an + * inode to fix it.) + * + * Note that pass 1B will be invoked if there are any duplicate blocks + * found. + */ + + +static int process_block(ext2_filsys fs, blk_t *blocknr, + e2_blkcnt_t blockcnt, blk_t ref_blk, + int ref_offset, void *priv_data); +static int process_bad_block(ext2_filsys fs, blk_t *block_nr, + e2_blkcnt_t blockcnt, blk_t ref_blk, + int ref_offset, void *priv_data); +static void check_blocks(e2fsck_t ctx, struct problem_context *pctx, + char *block_buf); +static void mark_table_blocks(e2fsck_t ctx); +static void alloc_bb_map(e2fsck_t ctx); +static void alloc_imagic_map(e2fsck_t ctx); +static void mark_inode_bad(e2fsck_t ctx, ino_t ino); +static void handle_fs_bad_blocks(e2fsck_t ctx); +static void process_inodes(e2fsck_t ctx, char *block_buf); +static EXT2_QSORT_TYPE process_inode_cmp(const void *a, const void *b); +static errcode_t scan_callback(ext2_filsys fs, ext2_inode_scan scan, + dgrp_t group, void * priv_data); +static void adjust_extattr_refcount(e2fsck_t ctx, ext2_refcount_t refcount, + char *block_buf, int adjust_sign); +/* static char *describe_illegal_block(ext2_filsys fs, blk_t block); */ + +static void e2fsck_write_inode_full(e2fsck_t ctx, unsigned long ino, + struct ext2_inode * inode, int bufsize, + const char *proc); + +struct process_block_struct_1 { + ext2_ino_t ino; + unsigned is_dir:1, is_reg:1, clear:1, suppress:1, + fragmented:1, compressed:1, bbcheck:1; + blk_t num_blocks; + blk_t max_blocks; + e2_blkcnt_t last_block; + int num_illegal_blocks; + blk_t previous_block; + struct ext2_inode *inode; + struct problem_context *pctx; + ext2fs_block_bitmap fs_meta_blocks; + e2fsck_t ctx; +}; + +struct process_inode_block { + ext2_ino_t ino; + struct ext2_inode inode; +}; + +struct scan_callback_struct { + e2fsck_t ctx; + char *block_buf; +}; + +/* + * For the inodes to process list. + */ +static struct process_inode_block *inodes_to_process; +static int process_inode_count; + +static __u64 ext2_max_sizes[EXT2_MAX_BLOCK_LOG_SIZE - + EXT2_MIN_BLOCK_LOG_SIZE + 1]; + +/* + * Free all memory allocated by pass1 in preparation for restarting + * things. + */ +static void unwind_pass1(ext2_filsys fs EXT2FS_ATTR((unused))) +{ + ext2fs_free_mem(&inodes_to_process); + inodes_to_process = 0; +} + +/* + * Check to make sure a device inode is real. Returns 1 if the device + * checks out, 0 if not. + * + * Note: this routine is now also used to check FIFO's and Sockets, + * since they have the same requirement; the i_block fields should be + * zero. + */ +int e2fsck_pass1_check_device_inode(ext2_filsys fs, struct ext2_inode *inode) +{ + int i; + + /* + * If i_blocks is non-zero, or the index flag is set, then + * this is a bogus device/fifo/socket + */ + if ((ext2fs_inode_data_blocks(fs, inode) != 0) || + (inode->i_flags & EXT2_INDEX_FL)) + return 0; + + /* + * We should be able to do the test below all the time, but + * because the kernel doesn't forcibly clear the device + * inode's additional i_block fields, there are some rare + * occasions when a legitimate device inode will have non-zero + * additional i_block fields. So for now, we only complain + * when the immutable flag is set, which should never happen + * for devices. (And that's when the problem is caused, since + * you can't set or clear immutable flags for devices.) Once + * the kernel has been fixed we can change this... + */ + if (inode->i_flags & (EXT2_IMMUTABLE_FL | EXT2_APPEND_FL)) { + for (i=4; i < EXT2_N_BLOCKS; i++) + if (inode->i_block[i]) + return 0; + } + return 1; +} + +/* + * Check to make sure a symlink inode is real. Returns 1 if the symlink + * checks out, 0 if not. + */ +int e2fsck_pass1_check_symlink(ext2_filsys fs, struct ext2_inode *inode, + char *buf) +{ + unsigned int len; + int i; + blk_t blocks; + + if ((inode->i_size_high || inode->i_size == 0) || + (inode->i_flags & EXT2_INDEX_FL)) + return 0; + + blocks = ext2fs_inode_data_blocks(fs, inode); + if (blocks) { + if ((inode->i_size >= fs->blocksize) || + (blocks != fs->blocksize >> 9) || + (inode->i_block[0] < fs->super->s_first_data_block) || + (inode->i_block[0] >= fs->super->s_blocks_count)) + return 0; + + for (i = 1; i < EXT2_N_BLOCKS; i++) + if (inode->i_block[i]) + return 0; + + if (io_channel_read_blk(fs->io, inode->i_block[0], 1, buf)) + return 0; + + len = strnlen(buf, fs->blocksize); + if (len == fs->blocksize) + return 0; + } else { + if (inode->i_size >= sizeof(inode->i_block)) + return 0; + + len = strnlen((char *)inode->i_block, sizeof(inode->i_block)); + if (len == sizeof(inode->i_block)) + return 0; + } + if (len != inode->i_size) + return 0; + return 1; +} + +/* + * If the immutable (or append-only) flag is set on the inode, offer + * to clear it. + */ +#define BAD_SPECIAL_FLAGS (EXT2_IMMUTABLE_FL | EXT2_APPEND_FL) +static void check_immutable(e2fsck_t ctx, struct problem_context *pctx) +{ + if (!(pctx->inode->i_flags & BAD_SPECIAL_FLAGS)) + return; + + if (!fix_problem(ctx, PR_1_SET_IMMUTABLE, pctx)) + return; + + pctx->inode->i_flags &= ~BAD_SPECIAL_FLAGS; + e2fsck_write_inode(ctx, pctx->ino, pctx->inode, "pass1"); +} + +/* + * If device, fifo or socket, check size is zero -- if not offer to + * clear it + */ +static void check_size(e2fsck_t ctx, struct problem_context *pctx) +{ + struct ext2_inode *inode = pctx->inode; + + if ((inode->i_size == 0) && (inode->i_size_high == 0)) + return; + + if (!fix_problem(ctx, PR_1_SET_NONZSIZE, pctx)) + return; + + inode->i_size = 0; + inode->i_size_high = 0; + e2fsck_write_inode(ctx, pctx->ino, pctx->inode, "pass1"); +} + +static void check_ea_in_inode(e2fsck_t ctx, struct problem_context *pctx) +{ + struct ext2_super_block *sb = ctx->fs->super; + struct ext2_inode_large *inode; + struct ext2_ext_attr_entry *entry; + char *start, *end; + int storage_size, remain, offs; + int problem = 0; + + inode = (struct ext2_inode_large *) pctx->inode; + storage_size = EXT2_INODE_SIZE(ctx->fs->super) - EXT2_GOOD_OLD_INODE_SIZE - + inode->i_extra_isize; + start = ((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE + + inode->i_extra_isize + sizeof(__u32); + end = (char *) inode + EXT2_INODE_SIZE(ctx->fs->super); + entry = (struct ext2_ext_attr_entry *) start; + + /* scan all entry's headers first */ + + /* take finish entry 0UL into account */ + remain = storage_size - sizeof(__u32); + offs = end - start; + + while (!EXT2_EXT_IS_LAST_ENTRY(entry)) { + + /* header eats this space */ + remain -= sizeof(struct ext2_ext_attr_entry); + + /* is attribute name valid? */ + if (EXT2_EXT_ATTR_SIZE(entry->e_name_len) > remain) { + pctx->num = entry->e_name_len; + problem = PR_1_ATTR_NAME_LEN; + goto fix; + } + + /* attribute len eats this space */ + remain -= EXT2_EXT_ATTR_SIZE(entry->e_name_len); + + /* check value size */ + if (entry->e_value_size == 0 || entry->e_value_size > remain) { + pctx->num = entry->e_value_size; + problem = PR_1_ATTR_VALUE_SIZE; + goto fix; + } + + /* check value placement */ + if (entry->e_value_offs + + EXT2_XATTR_SIZE(entry->e_value_size) != offs) { + printf("(entry->e_value_offs + entry->e_value_size: %d, offs: %d)\n", entry->e_value_offs + entry->e_value_size, offs); + pctx->num = entry->e_value_offs; + problem = PR_1_ATTR_VALUE_OFFSET; + goto fix; + } + + /* e_value_block must be 0 in inode's ea */ + if (entry->e_value_block != 0) { + pctx->num = entry->e_value_block; + problem = PR_1_ATTR_VALUE_BLOCK; + goto fix; + } + + /* e_hash must be 0 in inode's ea */ + if (entry->e_hash != 0) { + pctx->num = entry->e_hash; + problem = PR_1_ATTR_HASH; + goto fix; + } + + remain -= entry->e_value_size; + offs -= EXT2_XATTR_SIZE(entry->e_value_size); + + entry = EXT2_EXT_ATTR_NEXT(entry); + } +fix: + /* + * it seems like a corruption. it's very unlikely we could repair + * EA(s) in automatic fashion -bzzz + */ +#if 0 + problem = PR_1_ATTR_HASH; +#endif + if (problem == 0 || !fix_problem(ctx, problem, pctx)) + return; + + /* simple remove all possible EA(s) */ + *((__u32 *)start) = 0UL; + e2fsck_write_inode_full(ctx, pctx->ino, (struct ext2_inode *)inode, + EXT2_INODE_SIZE(sb), "pass1"); +} + +static void check_inode_extra_space(e2fsck_t ctx, struct problem_context *pctx) +{ + struct ext2_super_block *sb = ctx->fs->super; + struct ext2_inode_large *inode; + __u32 *eamagic; + int min, max; + + inode = (struct ext2_inode_large *) pctx->inode; + if (EXT2_INODE_SIZE(sb) == EXT2_GOOD_OLD_INODE_SIZE) { + /* this isn't large inode. so, nothing to check */ + return; + } + +#if 0 + printf("inode #%u, i_extra_size %d\n", pctx->ino, + inode->i_extra_isize); +#endif + /* i_extra_isize must cover i_extra_isize + i_pad1 at least */ + min = sizeof(inode->i_extra_isize) + sizeof(inode->i_pad1); + max = EXT2_INODE_SIZE(sb) - EXT2_GOOD_OLD_INODE_SIZE; + /* + * For now we will allow i_extra_isize to be 0, but really + * implementations should never allow i_extra_isize to be 0 + */ + if (inode->i_extra_isize && + (inode->i_extra_isize < min || inode->i_extra_isize > max)) { + if (!fix_problem(ctx, PR_1_EXTRA_ISIZE, pctx)) + return; + inode->i_extra_isize = min; + e2fsck_write_inode_full(ctx, pctx->ino, pctx->inode, + EXT2_INODE_SIZE(sb), "pass1"); + return; + } + + eamagic = (__u32 *) (((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE + + inode->i_extra_isize); + if (*eamagic == EXT2_EXT_ATTR_MAGIC) { + /* it seems inode has an extended attribute(s) in body */ + check_ea_in_inode(ctx, pctx); + } +} + +void e2fsck_pass1(e2fsck_t ctx) +{ + int i; + __u64 max_sizes; + ext2_filsys fs = ctx->fs; + ext2_ino_t ino; + struct ext2_inode *inode; + ext2_inode_scan scan; + char *block_buf; +#ifdef RESOURCE_TRACK + struct resource_track rtrack; +#endif + unsigned char frag, fsize; + struct problem_context pctx; + struct scan_callback_struct scan_struct; + struct ext2_super_block *sb = ctx->fs->super; + int imagic_fs; + int busted_fs_time = 0; + int inode_size; + +#ifdef RESOURCE_TRACK + init_resource_track(&rtrack); +#endif + clear_problem_context(&pctx); + + if (!(ctx->options & E2F_OPT_PREEN)) + fix_problem(ctx, PR_1_PASS_HEADER, &pctx); + + if ((fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_DIR_INDEX) && + !(ctx->options & E2F_OPT_NO)) { + if (ext2fs_u32_list_create(&ctx->dirs_to_hash, 50)) + ctx->dirs_to_hash = 0; + } + +#ifdef MTRACE + mtrace_print("Pass 1"); +#endif + +#define EXT2_BPP(bits) (1ULL << ((bits) - 2)) + + for (i = EXT2_MIN_BLOCK_LOG_SIZE; i <= EXT2_MAX_BLOCK_LOG_SIZE; i++) { + max_sizes = EXT2_NDIR_BLOCKS + EXT2_BPP(i); + max_sizes = max_sizes + EXT2_BPP(i) * EXT2_BPP(i); + max_sizes = max_sizes + EXT2_BPP(i) * EXT2_BPP(i) * EXT2_BPP(i); + max_sizes = (max_sizes * (1UL << i)) - 1; + ext2_max_sizes[i - EXT2_MIN_BLOCK_LOG_SIZE] = max_sizes; + } +#undef EXT2_BPP + + imagic_fs = (sb->s_feature_compat & EXT2_FEATURE_COMPAT_IMAGIC_INODES); + + /* + * Allocate bitmaps structures + */ + pctx.errcode = ext2fs_allocate_inode_bitmap(fs, _("in-use inode map"), + &ctx->inode_used_map); + if (pctx.errcode) { + pctx.num = 1; + fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx); + ctx->flags |= E2F_FLAG_ABORT; + return; + } + pctx.errcode = ext2fs_allocate_inode_bitmap(fs, + _("directory inode map"), &ctx->inode_dir_map); + if (pctx.errcode) { + pctx.num = 2; + fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx); + ctx->flags |= E2F_FLAG_ABORT; + return; + } + pctx.errcode = ext2fs_allocate_inode_bitmap(fs, + _("regular file inode map"), &ctx->inode_reg_map); + if (pctx.errcode) { + pctx.num = 6; + fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx); + ctx->flags |= E2F_FLAG_ABORT; + return; + } + pctx.errcode = ext2fs_allocate_block_bitmap(fs, _("in-use block map"), + &ctx->block_found_map); + if (pctx.errcode) { + pctx.num = 1; + fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, &pctx); + ctx->flags |= E2F_FLAG_ABORT; + return; + } + pctx.errcode = ext2fs_create_icount2(fs, 0, 0, 0, + &ctx->inode_link_info); + if (pctx.errcode) { + fix_problem(ctx, PR_1_ALLOCATE_ICOUNT, &pctx); + ctx->flags |= E2F_FLAG_ABORT; + return; + } + inode_size = EXT2_INODE_SIZE(fs->super); + inode = (struct ext2_inode *) + e2fsck_allocate_memory(ctx, inode_size, "scratch inode"); + + inodes_to_process = (struct process_inode_block *) + e2fsck_allocate_memory(ctx, + (ctx->process_inode_size * + sizeof(struct process_inode_block)), + "array of inodes to process"); + process_inode_count = 0; + + pctx.errcode = ext2fs_init_dblist(fs, 0); + if (pctx.errcode) { + fix_problem(ctx, PR_1_ALLOCATE_DBCOUNT, &pctx); + ctx->flags |= E2F_FLAG_ABORT; + return; + } + + /* + * If the last orphan field is set, clear it, since the pass1 + * processing will automatically find and clear the orphans. + * In the future, we may want to try using the last_orphan + * linked list ourselves, but for now, we clear it so that the + * ext3 mount code won't get confused. + */ + if (!(ctx->options & E2F_OPT_READONLY)) { + if (fs->super->s_last_orphan) { + fs->super->s_last_orphan = 0; + ext2fs_mark_super_dirty(fs); + } + } + + mark_table_blocks(ctx); + block_buf = (char *) e2fsck_allocate_memory(ctx, fs->blocksize * 3, + "block interate buffer"); + e2fsck_use_inode_shortcuts(ctx, 1); + ehandler_operation(_("doing inode scan")); + pctx.errcode = ext2fs_open_inode_scan(fs, ctx->inode_buffer_blocks, + &scan); + if (pctx.errcode) { + fix_problem(ctx, PR_1_ISCAN_ERROR, &pctx); + ctx->flags |= E2F_FLAG_ABORT; + return; + } + ext2fs_inode_scan_flags(scan, EXT2_SF_SKIP_MISSING_ITABLE, 0); + ctx->stashed_inode = inode; + scan_struct.ctx = ctx; + scan_struct.block_buf = block_buf; + ext2fs_set_inode_callback(scan, scan_callback, &scan_struct); + if (ctx->progress) + if ((ctx->progress)(ctx, 1, 0, ctx->fs->group_desc_count)) + return; + if (fs->super->s_wtime < fs->super->s_inodes_count) + busted_fs_time = 1; + + while (1) { + pctx.errcode = ext2fs_get_next_inode_full(scan, &ino, + inode, inode_size); + if (ctx->flags & E2F_FLAG_SIGNAL_MASK) + return; + if (pctx.errcode == EXT2_ET_BAD_BLOCK_IN_INODE_TABLE) { + if (!ctx->inode_bb_map) + alloc_bb_map(ctx); + ext2fs_mark_inode_bitmap(ctx->inode_bb_map, ino); + ext2fs_mark_inode_bitmap(ctx->inode_used_map, ino); + continue; + } + if (pctx.errcode) { + fix_problem(ctx, PR_1_ISCAN_ERROR, &pctx); + ctx->flags |= E2F_FLAG_ABORT; + return; + } + if (!ino) + break; + pctx.ino = ino; + pctx.inode = inode; + ctx->stashed_ino = ino; + if (inode->i_links_count) { + pctx.errcode = ext2fs_icount_store(ctx->inode_link_info, + ino, inode->i_links_count); + if (pctx.errcode) { + pctx.num = inode->i_links_count; + fix_problem(ctx, PR_1_ICOUNT_STORE, &pctx); + ctx->flags |= E2F_FLAG_ABORT; + return; + } + } + if (ino == EXT2_BAD_INO) { + struct process_block_struct_1 pb; + + pctx.errcode = ext2fs_copy_bitmap(ctx->block_found_map, + &pb.fs_meta_blocks); + if (pctx.errcode) { + pctx.num = 4; + fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, &pctx); + ctx->flags |= E2F_FLAG_ABORT; + return; + } + pb.ino = EXT2_BAD_INO; + pb.num_blocks = pb.last_block = 0; + pb.num_illegal_blocks = 0; + pb.suppress = 0; pb.clear = 0; pb.is_dir = 0; + pb.is_reg = 0; pb.fragmented = 0; pb.bbcheck = 0; + pb.inode = inode; + pb.pctx = &pctx; + pb.ctx = ctx; + pctx.errcode = ext2fs_block_iterate2(fs, ino, 0, + block_buf, process_bad_block, &pb); + ext2fs_free_block_bitmap(pb.fs_meta_blocks); + if (pctx.errcode) { + fix_problem(ctx, PR_1_BLOCK_ITERATE, &pctx); + ctx->flags |= E2F_FLAG_ABORT; + return; + } + if (pb.bbcheck) + if (!fix_problem(ctx, PR_1_BBINODE_BAD_METABLOCK_PROMPT, &pctx)) { + ctx->flags |= E2F_FLAG_ABORT; + return; + } + ext2fs_mark_inode_bitmap(ctx->inode_used_map, ino); + clear_problem_context(&pctx); + continue; + } else if (ino == EXT2_ROOT_INO) { + /* + * Make sure the root inode is a directory; if + * not, offer to clear it. It will be + * regnerated in pass #3. + */ + if (!LINUX_S_ISDIR(inode->i_mode)) { + if (fix_problem(ctx, PR_1_ROOT_NO_DIR, &pctx)) { + inode->i_dtime = time(0); + inode->i_links_count = 0; + ext2fs_icount_store(ctx->inode_link_info, + ino, 0); + e2fsck_write_inode(ctx, ino, inode, + "pass1"); + } + + } + /* + * If dtime is set, offer to clear it. mke2fs + * version 0.2b created filesystems with the + * dtime field set for the root and lost+found + * directories. We won't worry about + * /lost+found, since that can be regenerated + * easily. But we will fix the root directory + * as a special case. + */ + if (inode->i_dtime && inode->i_links_count) { + if (fix_problem(ctx, PR_1_ROOT_DTIME, &pctx)) { + inode->i_dtime = 0; + e2fsck_write_inode(ctx, ino, inode, + "pass1"); + } + } + } else if (ino == EXT2_JOURNAL_INO) { + ext2fs_mark_inode_bitmap(ctx->inode_used_map, ino); + if (fs->super->s_journal_inum == EXT2_JOURNAL_INO) { + if (!LINUX_S_ISREG(inode->i_mode) && + fix_problem(ctx, PR_1_JOURNAL_BAD_MODE, + &pctx)) { + inode->i_mode = LINUX_S_IFREG; + e2fsck_write_inode(ctx, ino, inode, + "pass1"); + } + check_blocks(ctx, &pctx, block_buf); + continue; + } + if ((inode->i_links_count || inode->i_blocks || + inode->i_blocks || inode->i_block[0]) && + fix_problem(ctx, PR_1_JOURNAL_INODE_NOT_CLEAR, + &pctx)) { + memset(inode, 0, inode_size); + ext2fs_icount_store(ctx->inode_link_info, + ino, 0); + e2fsck_write_inode_full(ctx, ino, inode, + inode_size, "pass1"); + } + } else if (ino < EXT2_FIRST_INODE(fs->super)) { + int problem = 0; + + ext2fs_mark_inode_bitmap(ctx->inode_used_map, ino); + if (ino == EXT2_BOOT_LOADER_INO) { + if (LINUX_S_ISDIR(inode->i_mode)) + problem = PR_1_RESERVED_BAD_MODE; + } else if (ino == EXT2_RESIZE_INO) { + if (inode->i_mode && + !LINUX_S_ISREG(inode->i_mode)) + problem = PR_1_RESERVED_BAD_MODE; + } else { + if (inode->i_mode != 0) + problem = PR_1_RESERVED_BAD_MODE; + } + if (problem) { + if (fix_problem(ctx, problem, &pctx)) { + inode->i_mode = 0; + e2fsck_write_inode(ctx, ino, inode, + "pass1"); + } + } + check_blocks(ctx, &pctx, block_buf); + continue; + } + /* + * Check for inodes who might have been part of the + * orphaned list linked list. They should have gotten + * dealt with by now, unless the list had somehow been + * corrupted. + * + * FIXME: In the future, inodes which are still in use + * (and which are therefore) pending truncation should + * be handled specially. Right now we just clear the + * dtime field, and the normal e2fsck handling of + * inodes where i_size and the inode blocks are + * inconsistent is to fix i_size, instead of releasing + * the extra blocks. This won't catch the inodes that + * was at the end of the orphan list, but it's better + * than nothing. The right answer is that there + * shouldn't be any bugs in the orphan list handling. :-) + */ + if (inode->i_dtime && !busted_fs_time && + inode->i_dtime < ctx->fs->super->s_inodes_count) { + if (fix_problem(ctx, PR_1_LOW_DTIME, &pctx)) { + inode->i_dtime = inode->i_links_count ? + 0 : time(0); + e2fsck_write_inode(ctx, ino, inode, + "pass1"); + } + } + + /* + * This code assumes that deleted inodes have + * i_links_count set to 0. + */ + if (!inode->i_links_count) { + if (!inode->i_dtime && inode->i_mode) { + if (fix_problem(ctx, + PR_1_ZERO_DTIME, &pctx)) { + inode->i_dtime = time(0); + e2fsck_write_inode(ctx, ino, inode, + "pass1"); + } + } + continue; + } + /* + * n.b. 0.3c ext2fs code didn't clear i_links_count for + * deleted files. Oops. + * + * Since all new ext2 implementations get this right, + * we now assume that the case of non-zero + * i_links_count and non-zero dtime means that we + * should keep the file, not delete it. + * + */ + if (inode->i_dtime) { + if (fix_problem(ctx, PR_1_SET_DTIME, &pctx)) { + inode->i_dtime = 0; + e2fsck_write_inode(ctx, ino, inode, "pass1"); + } + } + + ext2fs_mark_inode_bitmap(ctx->inode_used_map, ino); + switch (fs->super->s_creator_os) { + case EXT2_OS_LINUX: + frag = inode->osd2.linux2.l_i_frag; + fsize = inode->osd2.linux2.l_i_fsize; + break; + case EXT2_OS_HURD: + frag = inode->osd2.hurd2.h_i_frag; + fsize = inode->osd2.hurd2.h_i_fsize; + break; + case EXT2_OS_MASIX: + frag = inode->osd2.masix2.m_i_frag; + fsize = inode->osd2.masix2.m_i_fsize; + break; + default: + frag = fsize = 0; + } + + if (inode->i_faddr || frag || fsize || + (LINUX_S_ISDIR(inode->i_mode) && inode->i_dir_acl)) + mark_inode_bad(ctx, ino); + if (inode->i_flags & EXT2_IMAGIC_FL) { + if (imagic_fs) { + if (!ctx->inode_imagic_map) + alloc_imagic_map(ctx); + ext2fs_mark_inode_bitmap(ctx->inode_imagic_map, + ino); + } else { + if (fix_problem(ctx, PR_1_SET_IMAGIC, &pctx)) { + inode->i_flags &= ~EXT2_IMAGIC_FL; + e2fsck_write_inode(ctx, ino, + inode, "pass1"); + } + } + } + + check_inode_extra_space(ctx, &pctx); + + if (LINUX_S_ISDIR(inode->i_mode)) { + ext2fs_mark_inode_bitmap(ctx->inode_dir_map, ino); + e2fsck_add_dir_info(ctx, ino, 0); + ctx->fs_directory_count++; + } else if (LINUX_S_ISREG (inode->i_mode)) { + ext2fs_mark_inode_bitmap(ctx->inode_reg_map, ino); + ctx->fs_regular_count++; + } else if (LINUX_S_ISCHR (inode->i_mode) && + e2fsck_pass1_check_device_inode(fs, inode)) { + check_immutable(ctx, &pctx); + check_size(ctx, &pctx); + ctx->fs_chardev_count++; + } else if (LINUX_S_ISBLK (inode->i_mode) && + e2fsck_pass1_check_device_inode(fs, inode)) { + check_immutable(ctx, &pctx); + check_size(ctx, &pctx); + ctx->fs_blockdev_count++; + } else if (LINUX_S_ISLNK (inode->i_mode) && + e2fsck_pass1_check_symlink(fs, inode, block_buf)) { + check_immutable(ctx, &pctx); + ctx->fs_symlinks_count++; + if (ext2fs_inode_data_blocks(fs, inode) == 0) { + ctx->fs_fast_symlinks_count++; + check_blocks(ctx, &pctx, block_buf); + continue; + } + } + else if (LINUX_S_ISFIFO (inode->i_mode) && + e2fsck_pass1_check_device_inode(fs, inode)) { + check_immutable(ctx, &pctx); + check_size(ctx, &pctx); + ctx->fs_fifo_count++; + } else if ((LINUX_S_ISSOCK (inode->i_mode)) && + e2fsck_pass1_check_device_inode(fs, inode)) { + check_immutable(ctx, &pctx); + check_size(ctx, &pctx); + ctx->fs_sockets_count++; + } else + mark_inode_bad(ctx, ino); + if (inode->i_block[EXT2_IND_BLOCK]) + ctx->fs_ind_count++; + if (inode->i_block[EXT2_DIND_BLOCK]) + ctx->fs_dind_count++; + if (inode->i_block[EXT2_TIND_BLOCK]) + ctx->fs_tind_count++; + if (inode->i_block[EXT2_IND_BLOCK] || + inode->i_block[EXT2_DIND_BLOCK] || + inode->i_block[EXT2_TIND_BLOCK] || + inode->i_file_acl) { + inodes_to_process[process_inode_count].ino = ino; + inodes_to_process[process_inode_count].inode = *inode; + process_inode_count++; + } else + check_blocks(ctx, &pctx, block_buf); + + if (ctx->flags & E2F_FLAG_SIGNAL_MASK) + return; + + if (process_inode_count >= ctx->process_inode_size) { + process_inodes(ctx, block_buf); + + if (ctx->flags & E2F_FLAG_SIGNAL_MASK) + return; + } + } + process_inodes(ctx, block_buf); + ext2fs_close_inode_scan(scan); + ehandler_operation(0); + + /* + * If any extended attribute blocks' reference counts need to + * be adjusted, either up (ctx->refcount_extra), or down + * (ctx->refcount), then fix them. + */ + if (ctx->refcount) { + adjust_extattr_refcount(ctx, ctx->refcount, block_buf, -1); + ea_refcount_free(ctx->refcount); + ctx->refcount = 0; + } + if (ctx->refcount_extra) { + adjust_extattr_refcount(ctx, ctx->refcount_extra, + block_buf, +1); + ea_refcount_free(ctx->refcount_extra); + ctx->refcount_extra = 0; + } + + if (ctx->invalid_bitmaps) + handle_fs_bad_blocks(ctx); + + /* We don't need the block_ea_map any more */ + if (ctx->block_ea_map) { + ext2fs_free_block_bitmap(ctx->block_ea_map); + ctx->block_ea_map = 0; + } + + if (ctx->flags & E2F_FLAG_RESIZE_INODE) { + ext2fs_block_bitmap save_bmap; + + save_bmap = fs->block_map; + fs->block_map = ctx->block_found_map; + clear_problem_context(&pctx); + pctx.errcode = ext2fs_create_resize_inode(fs); + if (pctx.errcode) { + fix_problem(ctx, PR_1_RESIZE_INODE_CREATE, &pctx); + /* Should never get here */ + ctx->flags |= E2F_FLAG_ABORT; + return; + } + fs->block_map = save_bmap; + ctx->flags &= ~E2F_FLAG_RESIZE_INODE; + } + + if (ctx->flags & E2F_FLAG_RESTART) { + /* + * Only the master copy of the superblock and block + * group descriptors are going to be written during a + * restart, so set the superblock to be used to be the + * master superblock. + */ + ctx->use_superblock = 0; + unwind_pass1(fs); + goto endit; + } + + if (ctx->block_dup_map) { + if (ctx->options & E2F_OPT_PREEN) { + clear_problem_context(&pctx); + fix_problem(ctx, PR_1_DUP_BLOCKS_PREENSTOP, &pctx); + } + e2fsck_pass1_dupblocks(ctx, block_buf); + } + ext2fs_free_mem(&inodes_to_process); +endit: + e2fsck_use_inode_shortcuts(ctx, 0); + + ext2fs_free_mem(&block_buf); + ext2fs_free_mem(&inode); + +#ifdef RESOURCE_TRACK + if (ctx->options & E2F_OPT_TIME2) { + e2fsck_clear_progbar(ctx); + print_resource_track(_("Pass 1"), &rtrack); + } +#endif +} + +/* + * When the inode_scan routines call this callback at the end of the + * glock group, call process_inodes. + */ +static errcode_t scan_callback(ext2_filsys fs, + ext2_inode_scan scan EXT2FS_ATTR((unused)), + dgrp_t group, void * priv_data) +{ + struct scan_callback_struct *scan_struct; + e2fsck_t ctx; + + scan_struct = (struct scan_callback_struct *) priv_data; + ctx = scan_struct->ctx; + + process_inodes((e2fsck_t) fs->priv_data, scan_struct->block_buf); + + if (ctx->progress) + if ((ctx->progress)(ctx, 1, group+1, + ctx->fs->group_desc_count)) + return EXT2_ET_CANCEL_REQUESTED; + + return 0; +} + +/* + * Process the inodes in the "inodes to process" list. + */ +static void process_inodes(e2fsck_t ctx, char *block_buf) +{ + int i; + struct ext2_inode *old_stashed_inode; + ext2_ino_t old_stashed_ino; + const char *old_operation; + char buf[80]; + struct problem_context pctx; + +#if 0 + printf("begin process_inodes: "); +#endif + if (process_inode_count == 0) + return; + old_operation = ehandler_operation(0); + old_stashed_inode = ctx->stashed_inode; + old_stashed_ino = ctx->stashed_ino; + qsort(inodes_to_process, process_inode_count, + sizeof(struct process_inode_block), process_inode_cmp); + clear_problem_context(&pctx); + for (i=0; i < process_inode_count; i++) { + pctx.inode = ctx->stashed_inode = &inodes_to_process[i].inode; + pctx.ino = ctx->stashed_ino = inodes_to_process[i].ino; + +#if 0 + printf("%u ", pctx.ino); +#endif + sprintf(buf, _("reading indirect blocks of inode %u"), + pctx.ino); + ehandler_operation(buf); + check_blocks(ctx, &pctx, block_buf); + if (ctx->flags & E2F_FLAG_SIGNAL_MASK) + break; + } + ctx->stashed_inode = old_stashed_inode; + ctx->stashed_ino = old_stashed_ino; + process_inode_count = 0; +#if 0 + printf("end process inodes\n"); +#endif + ehandler_operation(old_operation); +} + +static EXT2_QSORT_TYPE process_inode_cmp(const void *a, const void *b) +{ + const struct process_inode_block *ib_a = + (const struct process_inode_block *) a; + const struct process_inode_block *ib_b = + (const struct process_inode_block *) b; + int ret; + + ret = (ib_a->inode.i_block[EXT2_IND_BLOCK] - + ib_b->inode.i_block[EXT2_IND_BLOCK]); + if (ret == 0) + ret = ib_a->inode.i_file_acl - ib_b->inode.i_file_acl; + return ret; +} + +/* + * Mark an inode as being bad in some what + */ +static void mark_inode_bad(e2fsck_t ctx, ino_t ino) +{ + struct problem_context pctx; + + if (!ctx->inode_bad_map) { + clear_problem_context(&pctx); + + pctx.errcode = ext2fs_allocate_inode_bitmap(ctx->fs, + _("bad inode map"), &ctx->inode_bad_map); + if (pctx.errcode) { + pctx.num = 3; + fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx); + /* Should never get here */ + ctx->flags |= E2F_FLAG_ABORT; + return; + } + } + ext2fs_mark_inode_bitmap(ctx->inode_bad_map, ino); +} + + +/* + * This procedure will allocate the inode "bb" (badblock) map table + */ +static void alloc_bb_map(e2fsck_t ctx) +{ + struct problem_context pctx; + + clear_problem_context(&pctx); + pctx.errcode = ext2fs_allocate_inode_bitmap(ctx->fs, + _("inode in bad block map"), + &ctx->inode_bb_map); + if (pctx.errcode) { + pctx.num = 4; + fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx); + /* Should never get here */ + ctx->flags |= E2F_FLAG_ABORT; + return; + } +} + +/* + * This procedure will allocate the inode imagic table + */ +static void alloc_imagic_map(e2fsck_t ctx) +{ + struct problem_context pctx; + + clear_problem_context(&pctx); + pctx.errcode = ext2fs_allocate_inode_bitmap(ctx->fs, + _("imagic inode map"), + &ctx->inode_imagic_map); + if (pctx.errcode) { + pctx.num = 5; + fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx); + /* Should never get here */ + ctx->flags |= E2F_FLAG_ABORT; + return; + } +} + +/* + * Marks a block as in use, setting the dup_map if it's been set + * already. Called by process_block and process_bad_block. + * + * WARNING: Assumes checks have already been done to make sure block + * is valid. This is true in both process_block and process_bad_block. + */ +static _INLINE_ void mark_block_used(e2fsck_t ctx, blk_t block) +{ + struct problem_context pctx; + + clear_problem_context(&pctx); + + if (ext2fs_fast_test_block_bitmap(ctx->block_found_map, block)) { + if (!ctx->block_dup_map) { + pctx.errcode = ext2fs_allocate_block_bitmap(ctx->fs, + _("multiply claimed block map"), + &ctx->block_dup_map); + if (pctx.errcode) { + pctx.num = 3; + fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, + &pctx); + /* Should never get here */ + ctx->flags |= E2F_FLAG_ABORT; + return; + } + } + ext2fs_fast_mark_block_bitmap(ctx->block_dup_map, block); + } else { + ext2fs_fast_mark_block_bitmap(ctx->block_found_map, block); + } +} + +/* + * Adjust the extended attribute block's reference counts at the end + * of pass 1, either by subtracting out references for EA blocks that + * are still referenced in ctx->refcount, or by adding references for + * EA blocks that had extra references as accounted for in + * ctx->refcount_extra. + */ +static void adjust_extattr_refcount(e2fsck_t ctx, ext2_refcount_t refcount, + char *block_buf, int adjust_sign) +{ + struct ext2_ext_attr_header *header; + struct problem_context pctx; + ext2_filsys fs = ctx->fs; + blk_t blk; + __u32 should_be; + int count; + + clear_problem_context(&pctx); + + ea_refcount_intr_begin(refcount); + while (1) { + if ((blk = ea_refcount_intr_next(refcount, &count)) == 0) + break; + pctx.blk = blk; + pctx.errcode = ext2fs_read_ext_attr(fs, blk, block_buf); + if (pctx.errcode) { + fix_problem(ctx, PR_1_EXTATTR_READ_ABORT, &pctx); + return; + } + header = (struct ext2_ext_attr_header *) block_buf; + pctx.blkcount = header->h_refcount; + should_be = header->h_refcount + adjust_sign * count; + pctx.num = should_be; + if (fix_problem(ctx, PR_1_EXTATTR_REFCOUNT, &pctx)) { + header->h_refcount = should_be; + pctx.errcode = ext2fs_write_ext_attr(fs, blk, + block_buf); + if (pctx.errcode) { + fix_problem(ctx, PR_1_EXTATTR_WRITE, &pctx); + continue; + } + } + } +} + +/* + * Handle processing the extended attribute blocks + */ +static int check_ext_attr(e2fsck_t ctx, struct problem_context *pctx, + char *block_buf) +{ + ext2_filsys fs = ctx->fs; + ext2_ino_t ino = pctx->ino; + struct ext2_inode *inode = pctx->inode; + blk_t blk; + char * end; + struct ext2_ext_attr_header *header; + struct ext2_ext_attr_entry *entry; + int count; + region_t region; + + blk = inode->i_file_acl; + if (blk == 0) + return 0; + + /* + * If the Extended attribute flag isn't set, then a non-zero + * file acl means that the inode is corrupted. + * + * Or if the extended attribute block is an invalid block, + * then the inode is also corrupted. + */ + if (!(fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_EXT_ATTR) || + (blk < fs->super->s_first_data_block) || + (blk >= fs->super->s_blocks_count)) { + mark_inode_bad(ctx, ino); + return 0; + } + + /* If ea bitmap hasn't been allocated, create it */ + if (!ctx->block_ea_map) { + pctx->errcode = ext2fs_allocate_block_bitmap(fs, + _("ext attr block map"), + &ctx->block_ea_map); + if (pctx->errcode) { + pctx->num = 2; + fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, pctx); + ctx->flags |= E2F_FLAG_ABORT; + return 0; + } + } + + /* Create the EA refcount structure if necessary */ + if (!ctx->refcount) { + pctx->errcode = ea_refcount_create(0, &ctx->refcount); + if (pctx->errcode) { + pctx->num = 1; + fix_problem(ctx, PR_1_ALLOCATE_REFCOUNT, pctx); + ctx->flags |= E2F_FLAG_ABORT; + return 0; + } + } + +#if 0 + /* Debugging text */ + printf("Inode %u has EA block %u\n", ino, blk); +#endif + + /* Have we seen this EA block before? */ + if (ext2fs_fast_test_block_bitmap(ctx->block_ea_map, blk)) { + if (ea_refcount_decrement(ctx->refcount, blk, 0) == 0) + return 1; + /* Ooops, this EA was referenced more than it stated */ + if (!ctx->refcount_extra) { + pctx->errcode = ea_refcount_create(0, + &ctx->refcount_extra); + if (pctx->errcode) { + pctx->num = 2; + fix_problem(ctx, PR_1_ALLOCATE_REFCOUNT, pctx); + ctx->flags |= E2F_FLAG_ABORT; + return 0; + } + } + ea_refcount_increment(ctx->refcount_extra, blk, 0); + return 1; + } + + /* + * OK, we haven't seen this EA block yet. So we need to + * validate it + */ + pctx->blk = blk; + pctx->errcode = ext2fs_read_ext_attr(fs, blk, block_buf); + if (pctx->errcode && fix_problem(ctx, PR_1_READ_EA_BLOCK, pctx)) + goto clear_extattr; + header = (struct ext2_ext_attr_header *) block_buf; + pctx->blk = inode->i_file_acl; + if (((ctx->ext_attr_ver == 1) && + (header->h_magic != EXT2_EXT_ATTR_MAGIC_v1)) || + ((ctx->ext_attr_ver == 2) && + (header->h_magic != EXT2_EXT_ATTR_MAGIC))) { + if (fix_problem(ctx, PR_1_BAD_EA_BLOCK, pctx)) + goto clear_extattr; + } + + if (header->h_blocks != 1) { + if (fix_problem(ctx, PR_1_EA_MULTI_BLOCK, pctx)) + goto clear_extattr; + } + + region = region_create(0, fs->blocksize); + if (!region) { + fix_problem(ctx, PR_1_EA_ALLOC_REGION, pctx); + ctx->flags |= E2F_FLAG_ABORT; + return 0; + } + if (region_allocate(region, 0, sizeof(struct ext2_ext_attr_header))) { + if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, pctx)) + goto clear_extattr; + } + + entry = (struct ext2_ext_attr_entry *)(header+1); + end = block_buf + fs->blocksize; + while ((char *)entry < end && *(__u32 *)entry) { + if (region_allocate(region, (char *)entry - (char *)header, + EXT2_EXT_ATTR_LEN(entry->e_name_len))) { + if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, pctx)) + goto clear_extattr; + } + if ((ctx->ext_attr_ver == 1 && + (entry->e_name_len == 0 || entry->e_name_index != 0)) || + (ctx->ext_attr_ver == 2 && + entry->e_name_index == 0)) { + if (fix_problem(ctx, PR_1_EA_BAD_NAME, pctx)) + goto clear_extattr; + } + if (entry->e_value_block != 0) { + if (fix_problem(ctx, PR_1_EA_BAD_VALUE, pctx)) + goto clear_extattr; + } + if (entry->e_value_size && + region_allocate(region, entry->e_value_offs, + EXT2_EXT_ATTR_SIZE(entry->e_value_size))) { + if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, pctx)) + goto clear_extattr; + } + entry = EXT2_EXT_ATTR_NEXT(entry); + } + if (region_allocate(region, (char *)entry - (char *)header, 4)) { + if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, pctx)) + goto clear_extattr; + } + region_free(region); + + count = header->h_refcount - 1; + if (count) + ea_refcount_store(ctx->refcount, blk, count); + mark_block_used(ctx, blk); + ext2fs_fast_mark_block_bitmap(ctx->block_ea_map, blk); + + return 1; + +clear_extattr: + inode->i_file_acl = 0; + e2fsck_write_inode(ctx, ino, inode, "check_ext_attr"); + return 0; +} + +/* Returns 1 if bad htree, 0 if OK */ +static int handle_htree(e2fsck_t ctx, struct problem_context *pctx, + ext2_ino_t ino EXT2FS_ATTR((unused)), + struct ext2_inode *inode, + char *block_buf) +{ + struct ext2_dx_root_info *root; + ext2_filsys fs = ctx->fs; + errcode_t retval; + blk_t blk; + + if ((!LINUX_S_ISDIR(inode->i_mode) && + fix_problem(ctx, PR_1_HTREE_NODIR, pctx)) || + (!(fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_DIR_INDEX) && + fix_problem(ctx, PR_1_HTREE_SET, pctx))) + return 1; + + blk = inode->i_block[0]; + if (((blk == 0) || + (blk < fs->super->s_first_data_block) || + (blk >= fs->super->s_blocks_count)) && + fix_problem(ctx, PR_1_HTREE_BADROOT, pctx)) + return 1; + + retval = io_channel_read_blk(fs->io, blk, 1, block_buf); + if (retval && fix_problem(ctx, PR_1_HTREE_BADROOT, pctx)) + return 1; + + /* XXX should check that beginning matches a directory */ + root = (struct ext2_dx_root_info *) (block_buf + 24); + + if ((root->reserved_zero || root->info_length < 8) && + fix_problem(ctx, PR_1_HTREE_BADROOT, pctx)) + return 1; + + pctx->num = root->hash_version; + if ((root->hash_version != EXT2_HASH_LEGACY) && + (root->hash_version != EXT2_HASH_HALF_MD4) && + (root->hash_version != EXT2_HASH_TEA) && + fix_problem(ctx, PR_1_HTREE_HASHV, pctx)) + return 1; + + if ((root->unused_flags & EXT2_HASH_FLAG_INCOMPAT) && + fix_problem(ctx, PR_1_HTREE_INCOMPAT, pctx)) + return 1; + + pctx->num = root->indirect_levels; + if ((root->indirect_levels > 1) && + fix_problem(ctx, PR_1_HTREE_DEPTH, pctx)) + return 1; + + return 0; +} + +/* + * This subroutine is called on each inode to account for all of the + * blocks used by that inode. + */ +static void check_blocks(e2fsck_t ctx, struct problem_context *pctx, + char *block_buf) +{ + ext2_filsys fs = ctx->fs; + struct process_block_struct_1 pb; + ext2_ino_t ino = pctx->ino; + struct ext2_inode *inode = pctx->inode; + int bad_size = 0; + int dirty_inode = 0; + __u64 size; + + pb.ino = ino; + pb.num_blocks = 0; + pb.last_block = -1; + pb.num_illegal_blocks = 0; + pb.suppress = 0; pb.clear = 0; + pb.fragmented = 0; + pb.compressed = 0; + pb.previous_block = 0; + pb.is_dir = LINUX_S_ISDIR(inode->i_mode); + pb.is_reg = LINUX_S_ISREG(inode->i_mode); + pb.max_blocks = 1 << (31 - fs->super->s_log_block_size); + pb.inode = inode; + pb.pctx = pctx; + pb.ctx = ctx; + pctx->ino = ino; + pctx->errcode = 0; + + if (inode->i_flags & EXT2_COMPRBLK_FL) { + if (fs->super->s_feature_incompat & + EXT2_FEATURE_INCOMPAT_COMPRESSION) + pb.compressed = 1; + else { + if (fix_problem(ctx, PR_1_COMPR_SET, pctx)) { + inode->i_flags &= ~EXT2_COMPRBLK_FL; + dirty_inode++; + } + } + } + + if (inode->i_file_acl && check_ext_attr(ctx, pctx, block_buf)) + pb.num_blocks++; + + if (ext2fs_inode_has_valid_blocks(inode)) + pctx->errcode = ext2fs_block_iterate2(fs, ino, + pb.is_dir ? BLOCK_FLAG_HOLE : 0, + block_buf, process_block, &pb); + end_problem_latch(ctx, PR_LATCH_BLOCK); + end_problem_latch(ctx, PR_LATCH_TOOBIG); + if (ctx->flags & E2F_FLAG_SIGNAL_MASK) + goto out; + if (pctx->errcode) + fix_problem(ctx, PR_1_BLOCK_ITERATE, pctx); + + if (pb.fragmented && pb.num_blocks < fs->super->s_blocks_per_group) + ctx->fs_fragmented++; + + if (pb.clear) { + inode->i_links_count = 0; + ext2fs_icount_store(ctx->inode_link_info, ino, 0); + inode->i_dtime = time(0); + dirty_inode++; + ext2fs_unmark_inode_bitmap(ctx->inode_dir_map, ino); + ext2fs_unmark_inode_bitmap(ctx->inode_reg_map, ino); + ext2fs_unmark_inode_bitmap(ctx->inode_used_map, ino); + /* + * The inode was probably partially accounted for + * before processing was aborted, so we need to + * restart the pass 1 scan. + */ + ctx->flags |= E2F_FLAG_RESTART; + goto out; + } + + if (inode->i_flags & EXT2_INDEX_FL) { + if (handle_htree(ctx, pctx, ino, inode, block_buf)) { + inode->i_flags &= ~EXT2_INDEX_FL; + dirty_inode++; + } else { +#ifdef ENABLE_HTREE + e2fsck_add_dx_dir(ctx, ino, pb.last_block+1); +#endif + } + } + if (ctx->dirs_to_hash && pb.is_dir && + !(inode->i_flags & EXT2_INDEX_FL) && + ((inode->i_size / fs->blocksize) >= 3)) + ext2fs_u32_list_add(ctx->dirs_to_hash, ino); + + if (!pb.num_blocks && pb.is_dir) { + if (fix_problem(ctx, PR_1_ZERO_LENGTH_DIR, pctx)) { + inode->i_links_count = 0; + ext2fs_icount_store(ctx->inode_link_info, ino, 0); + inode->i_dtime = time(0); + dirty_inode++; + ext2fs_unmark_inode_bitmap(ctx->inode_dir_map, ino); + ext2fs_unmark_inode_bitmap(ctx->inode_reg_map, ino); + ext2fs_unmark_inode_bitmap(ctx->inode_used_map, ino); + ctx->fs_directory_count--; + goto out; + } + } + + pb.num_blocks *= (fs->blocksize / 512); +#if 0 + printf("inode %u, i_size = %lu, last_block = %lld, i_blocks=%lu, num_blocks = %lu\n", + ino, inode->i_size, pb.last_block, inode->i_blocks, + pb.num_blocks); +#endif + if (pb.is_dir) { + int nblock = inode->i_size >> EXT2_BLOCK_SIZE_BITS(fs->super); + if (nblock > (pb.last_block + 1)) + bad_size = 1; + else if (nblock < (pb.last_block + 1)) { + if (((pb.last_block + 1) - nblock) > + fs->super->s_prealloc_dir_blocks) + bad_size = 2; + } + } else { + size = EXT2_I_SIZE(inode); + if ((pb.last_block >= 0) && + (size < (__u64) pb.last_block * fs->blocksize)) + bad_size = 3; + else if (size > ext2_max_sizes[fs->super->s_log_block_size]) + bad_size = 4; + } + /* i_size for symlinks is checked elsewhere */ + if (bad_size && !LINUX_S_ISLNK(inode->i_mode)) { + pctx->num = (pb.last_block+1) * fs->blocksize; + if (fix_problem(ctx, PR_1_BAD_I_SIZE, pctx)) { + inode->i_size = pctx->num; + if (!LINUX_S_ISDIR(inode->i_mode)) + inode->i_size_high = pctx->num >> 32; + dirty_inode++; + } + pctx->num = 0; + } + if (LINUX_S_ISREG(inode->i_mode) && + (inode->i_size_high || inode->i_size & 0x80000000UL)) + ctx->large_files++; + if (pb.num_blocks != inode->i_blocks) { + pctx->num = pb.num_blocks; + if (fix_problem(ctx, PR_1_BAD_I_BLOCKS, pctx)) { + inode->i_blocks = pb.num_blocks; + dirty_inode++; + } + pctx->num = 0; + } +out: + if (dirty_inode) + e2fsck_write_inode(ctx, ino, inode, "check_blocks"); +} + +#if 0 +/* + * Helper function called by process block when an illegal block is + * found. It returns a description about why the block is illegal + */ +static char *describe_illegal_block(ext2_filsys fs, blk_t block) +{ + blk_t super; + int i; + static char problem[80]; + + super = fs->super->s_first_data_block; + strcpy(problem, "PROGRAMMING ERROR: Unknown reason for illegal block"); + if (block < super) { + sprintf(problem, "< FIRSTBLOCK (%u)", super); + return(problem); + } else if (block >= fs->super->s_blocks_count) { + sprintf(problem, "> BLOCKS (%u)", fs->super->s_blocks_count); + return(problem); + } + for (i = 0; i < fs->group_desc_count; i++) { + if (block == super) { + sprintf(problem, "is the superblock in group %d", i); + break; + } + if (block > super && + block <= (super + fs->desc_blocks)) { + sprintf(problem, "is in the group descriptors " + "of group %d", i); + break; + } + if (block == fs->group_desc[i].bg_block_bitmap) { + sprintf(problem, "is the block bitmap of group %d", i); + break; + } + if (block == fs->group_desc[i].bg_inode_bitmap) { + sprintf(problem, "is the inode bitmap of group %d", i); + break; + } + if (block >= fs->group_desc[i].bg_inode_table && + (block < fs->group_desc[i].bg_inode_table + + fs->inode_blocks_per_group)) { + sprintf(problem, "is in the inode table of group %d", + i); + break; + } + super += fs->super->s_blocks_per_group; + } + return(problem); +} +#endif + +/* + * This is a helper function for check_blocks(). + */ +static int process_block(ext2_filsys fs, + blk_t *block_nr, + e2_blkcnt_t blockcnt, + blk_t ref_block EXT2FS_ATTR((unused)), + int ref_offset EXT2FS_ATTR((unused)), + void *priv_data) +{ + struct process_block_struct_1 *p; + struct problem_context *pctx; + blk_t blk = *block_nr; + int ret_code = 0; + int problem = 0; + e2fsck_t ctx; + + p = (struct process_block_struct_1 *) priv_data; + pctx = p->pctx; + ctx = p->ctx; + + if (p->compressed && (blk == EXT2FS_COMPRESSED_BLKADDR)) { + /* todo: Check that the comprblk_fl is high, that the + blkaddr pattern looks right (all non-holes up to + first EXT2FS_COMPRESSED_BLKADDR, then all + EXT2FS_COMPRESSED_BLKADDR up to end of cluster), + that the feature_incompat bit is high, and that the + inode is a regular file. If we're doing a "full + check" (a concept introduced to e2fsck by e2compr, + meaning that we look at data blocks as well as + metadata) then call some library routine that + checks the compressed data. I'll have to think + about this, because one particularly important + problem to be able to fix is to recalculate the + cluster size if necessary. I think that perhaps + we'd better do most/all e2compr-specific checks + separately, after the non-e2compr checks. If not + doing a full check, it may be useful to test that + the personality is linux; e.g. if it isn't then + perhaps this really is just an illegal block. */ + return 0; + } + + if (blk == 0) { + if (p->is_dir == 0) { + /* + * Should never happen, since only directories + * get called with BLOCK_FLAG_HOLE + */ +#if DEBUG_E2FSCK + printf("process_block() called with blk == 0, " + "blockcnt=%d, inode %lu???\n", + blockcnt, p->ino); +#endif + return 0; + } + if (blockcnt < 0) + return 0; + if (blockcnt * fs->blocksize < p->inode->i_size) { +#if 0 + printf("Missing block (#%d) in directory inode %lu!\n", + blockcnt, p->ino); +#endif + goto mark_dir; + } + return 0; + } + +#if 0 + printf("Process_block, inode %lu, block %u, #%d\n", p->ino, blk, + blockcnt); +#endif + + /* + * Simplistic fragmentation check. We merely require that the + * file be contiguous. (Which can never be true for really + * big files that are greater than a block group.) + */ + if (!HOLE_BLKADDR(p->previous_block)) { + if (p->previous_block+1 != blk) + p->fragmented = 1; + } + p->previous_block = blk; + + if (p->is_dir && blockcnt > (1 << (21 - fs->super->s_log_block_size))) + problem = PR_1_TOOBIG_DIR; + if (p->is_reg && p->num_blocks+1 >= p->max_blocks) + problem = PR_1_TOOBIG_REG; + if (!p->is_dir && !p->is_reg && blockcnt > 0) + problem = PR_1_TOOBIG_SYMLINK; + + if (blk < fs->super->s_first_data_block || + blk >= fs->super->s_blocks_count) + problem = PR_1_ILLEGAL_BLOCK_NUM; + + if (problem) { + p->num_illegal_blocks++; + if (!p->suppress && (p->num_illegal_blocks % 12) == 0) { + if (fix_problem(ctx, PR_1_TOO_MANY_BAD_BLOCKS, pctx)) { + p->clear = 1; + return BLOCK_ABORT; + } + if (fix_problem(ctx, PR_1_SUPPRESS_MESSAGES, pctx)) { + p->suppress = 1; + set_latch_flags(PR_LATCH_BLOCK, + PRL_SUPPRESS, 0); + } + } + pctx->blk = blk; + pctx->blkcount = blockcnt; + if (fix_problem(ctx, problem, pctx)) { + blk = *block_nr = 0; + ret_code = BLOCK_CHANGED; + goto mark_dir; + } else + return 0; + } + + if (p->ino == EXT2_RESIZE_INO) { + /* + * The resize inode has already be sanity checked + * during pass #0 (the superblock checks). All we + * have to do is mark the double indirect block as + * being in use; all of the other blocks are handled + * by mark_table_blocks()). + */ + if (blockcnt == BLOCK_COUNT_DIND) + mark_block_used(ctx, blk); + } else + mark_block_used(ctx, blk); + p->num_blocks++; + if (blockcnt >= 0) + p->last_block = blockcnt; +mark_dir: + if (p->is_dir && (blockcnt >= 0)) { + pctx->errcode = ext2fs_add_dir_block(fs->dblist, p->ino, + blk, blockcnt); + if (pctx->errcode) { + pctx->blk = blk; + pctx->num = blockcnt; + fix_problem(ctx, PR_1_ADD_DBLOCK, pctx); + /* Should never get here */ + ctx->flags |= E2F_FLAG_ABORT; + return BLOCK_ABORT; + } + } + return ret_code; +} + +static int process_bad_block(ext2_filsys fs, + blk_t *block_nr, + e2_blkcnt_t blockcnt, + blk_t ref_block EXT2FS_ATTR((unused)), + int ref_offset EXT2FS_ATTR((unused)), + void *priv_data) +{ + struct process_block_struct_1 *p; + blk_t blk = *block_nr; + blk_t first_block; + dgrp_t i; + struct problem_context *pctx; + e2fsck_t ctx; + + /* + * Note: This function processes blocks for the bad blocks + * inode, which is never compressed. So we don't use HOLE_BLKADDR(). + */ + + if (!blk) + return 0; + + p = (struct process_block_struct_1 *) priv_data; + ctx = p->ctx; + pctx = p->pctx; + + pctx->ino = EXT2_BAD_INO; + pctx->blk = blk; + pctx->blkcount = blockcnt; + + if ((blk < fs->super->s_first_data_block) || + (blk >= fs->super->s_blocks_count)) { + if (fix_problem(ctx, PR_1_BB_ILLEGAL_BLOCK_NUM, pctx)) { + *block_nr = 0; + return BLOCK_CHANGED; + } else + return 0; + } + + if (blockcnt < 0) { + if (ext2fs_test_block_bitmap(p->fs_meta_blocks, blk)) { + p->bbcheck = 1; + if (fix_problem(ctx, PR_1_BB_FS_BLOCK, pctx)) { + *block_nr = 0; + return BLOCK_CHANGED; + } + } else if (ext2fs_test_block_bitmap(ctx->block_found_map, + blk)) { + p->bbcheck = 1; + if (fix_problem(ctx, PR_1_BBINODE_BAD_METABLOCK, + pctx)) { + *block_nr = 0; + return BLOCK_CHANGED; + } + if (ctx->flags & E2F_FLAG_SIGNAL_MASK) + return BLOCK_ABORT; + } else + mark_block_used(ctx, blk); + return 0; + } +#if 0 + printf ("DEBUG: Marking %u as bad.\n", blk); +#endif + ctx->fs_badblocks_count++; + /* + * If the block is not used, then mark it as used and return. + * If it is already marked as found, this must mean that + * there's an overlap between the filesystem table blocks + * (bitmaps and inode table) and the bad block list. + */ + if (!ext2fs_test_block_bitmap(ctx->block_found_map, blk)) { + ext2fs_mark_block_bitmap(ctx->block_found_map, blk); + return 0; + } + /* + * Try to find the where the filesystem block was used... + */ + first_block = fs->super->s_first_data_block; + + for (i = 0; i < fs->group_desc_count; i++ ) { + pctx->group = i; + pctx->blk = blk; + if (!ext2fs_bg_has_super(fs, i)) + goto skip_super; + if (blk == first_block) { + if (i == 0) { + if (fix_problem(ctx, + PR_1_BAD_PRIMARY_SUPERBLOCK, + pctx)) { + *block_nr = 0; + return BLOCK_CHANGED; + } + return 0; + } + fix_problem(ctx, PR_1_BAD_SUPERBLOCK, pctx); + return 0; + } + if ((blk > first_block) && + (blk <= first_block + fs->desc_blocks)) { + if (i == 0) { + pctx->blk = *block_nr; + if (fix_problem(ctx, + PR_1_BAD_PRIMARY_GROUP_DESCRIPTOR, pctx)) { + *block_nr = 0; + return BLOCK_CHANGED; + } + return 0; + } + fix_problem(ctx, PR_1_BAD_GROUP_DESCRIPTORS, pctx); + return 0; + } + skip_super: + if (blk == fs->group_desc[i].bg_block_bitmap) { + if (fix_problem(ctx, PR_1_BB_BAD_BLOCK, pctx)) { + ctx->invalid_block_bitmap_flag[i]++; + ctx->invalid_bitmaps++; + } + return 0; + } + if (blk == fs->group_desc[i].bg_inode_bitmap) { + if (fix_problem(ctx, PR_1_IB_BAD_BLOCK, pctx)) { + ctx->invalid_inode_bitmap_flag[i]++; + ctx->invalid_bitmaps++; + } + return 0; + } + if ((blk >= fs->group_desc[i].bg_inode_table) && + (blk < (fs->group_desc[i].bg_inode_table + + fs->inode_blocks_per_group))) { + /* + * If there are bad blocks in the inode table, + * the inode scan code will try to do + * something reasonable automatically. + */ + return 0; + } + first_block += fs->super->s_blocks_per_group; + } + /* + * If we've gotten to this point, then the only + * possibility is that the bad block inode meta data + * is using a bad block. + */ + if ((blk == p->inode->i_block[EXT2_IND_BLOCK]) || + (blk == p->inode->i_block[EXT2_DIND_BLOCK]) || + (blk == p->inode->i_block[EXT2_TIND_BLOCK])) { + p->bbcheck = 1; + if (fix_problem(ctx, PR_1_BBINODE_BAD_METABLOCK, pctx)) { + *block_nr = 0; + return BLOCK_CHANGED; + } + if (ctx->flags & E2F_FLAG_SIGNAL_MASK) + return BLOCK_ABORT; + return 0; + } + + pctx->group = -1; + + /* Warn user that the block wasn't claimed */ + fix_problem(ctx, PR_1_PROGERR_CLAIMED_BLOCK, pctx); + + return 0; +} + +static void new_table_block(e2fsck_t ctx, blk_t first_block, int group, + const char *name, int num, blk_t *new_block) +{ + ext2_filsys fs = ctx->fs; + blk_t old_block = *new_block; + int i; + char *buf; + struct problem_context pctx; + + clear_problem_context(&pctx); + + pctx.group = group; + pctx.blk = old_block; + pctx.str = name; + + pctx.errcode = ext2fs_get_free_blocks(fs, first_block, + first_block + fs->super->s_blocks_per_group, + num, ctx->block_found_map, new_block); + if (pctx.errcode) { + pctx.num = num; + fix_problem(ctx, PR_1_RELOC_BLOCK_ALLOCATE, &pctx); + ext2fs_unmark_valid(fs); + return; + } + pctx.errcode = ext2fs_get_mem(fs->blocksize, &buf); + if (pctx.errcode) { + fix_problem(ctx, PR_1_RELOC_MEMORY_ALLOCATE, &pctx); + ext2fs_unmark_valid(fs); + return; + } + ext2fs_mark_super_dirty(fs); + fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY; + pctx.blk2 = *new_block; + fix_problem(ctx, (old_block ? PR_1_RELOC_FROM_TO : + PR_1_RELOC_TO), &pctx); + pctx.blk2 = 0; + for (i = 0; i < num; i++) { + pctx.blk = i; + ext2fs_mark_block_bitmap(ctx->block_found_map, (*new_block)+i); + if (old_block) { + pctx.errcode = io_channel_read_blk(fs->io, + old_block + i, 1, buf); + if (pctx.errcode) + fix_problem(ctx, PR_1_RELOC_READ_ERR, &pctx); + } else + memset(buf, 0, fs->blocksize); + + pctx.blk = (*new_block) + i; + pctx.errcode = io_channel_write_blk(fs->io, pctx.blk, + 1, buf); + if (pctx.errcode) + fix_problem(ctx, PR_1_RELOC_WRITE_ERR, &pctx); + } + ext2fs_free_mem(&buf); +} + +/* + * This routine gets called at the end of pass 1 if bad blocks are + * detected in the superblock, group descriptors, inode_bitmaps, or + * block bitmaps. At this point, all of the blocks have been mapped + * out, so we can try to allocate new block(s) to replace the bad + * blocks. + */ +static void handle_fs_bad_blocks(e2fsck_t ctx) +{ + ext2_filsys fs = ctx->fs; + dgrp_t i; + int first_block = fs->super->s_first_data_block; + + for (i = 0; i < fs->group_desc_count; i++) { + if (ctx->invalid_block_bitmap_flag[i]) { + new_table_block(ctx, first_block, i, _("block bitmap"), + 1, &fs->group_desc[i].bg_block_bitmap); + } + if (ctx->invalid_inode_bitmap_flag[i]) { + new_table_block(ctx, first_block, i, _("inode bitmap"), + 1, &fs->group_desc[i].bg_inode_bitmap); + } + if (ctx->invalid_inode_table_flag[i]) { + new_table_block(ctx, first_block, i, _("inode table"), + fs->inode_blocks_per_group, + &fs->group_desc[i].bg_inode_table); + ctx->flags |= E2F_FLAG_RESTART; + } + first_block += fs->super->s_blocks_per_group; + } + ctx->invalid_bitmaps = 0; +} + +/* + * This routine marks all blocks which are used by the superblock, + * group descriptors, inode bitmaps, and block bitmaps. + */ +static void mark_table_blocks(e2fsck_t ctx) +{ + ext2_filsys fs = ctx->fs; + blk_t block, b; + dgrp_t i; + int j; + struct problem_context pctx; + + clear_problem_context(&pctx); + + block = fs->super->s_first_data_block; + for (i = 0; i < fs->group_desc_count; i++) { + pctx.group = i; + + ext2fs_reserve_super_and_bgd(fs, i, ctx->block_found_map); + + /* + * Mark the blocks used for the inode table + */ + if (fs->group_desc[i].bg_inode_table) { + for (j = 0, b = fs->group_desc[i].bg_inode_table; + j < fs->inode_blocks_per_group; + j++, b++) { + if (ext2fs_test_block_bitmap(ctx->block_found_map, + b)) { + pctx.blk = b; + if (fix_problem(ctx, + PR_1_ITABLE_CONFLICT, &pctx)) { + ctx->invalid_inode_table_flag[i]++; + ctx->invalid_bitmaps++; + } + } else { + ext2fs_mark_block_bitmap(ctx->block_found_map, + b); + } + } + } + + /* + * Mark block used for the block bitmap + */ + if (fs->group_desc[i].bg_block_bitmap) { + if (ext2fs_test_block_bitmap(ctx->block_found_map, + fs->group_desc[i].bg_block_bitmap)) { + pctx.blk = fs->group_desc[i].bg_block_bitmap; + if (fix_problem(ctx, PR_1_BB_CONFLICT, &pctx)) { + ctx->invalid_block_bitmap_flag[i]++; + ctx->invalid_bitmaps++; + } + } else { + ext2fs_mark_block_bitmap(ctx->block_found_map, + fs->group_desc[i].bg_block_bitmap); + } + + } + /* + * Mark block used for the inode bitmap + */ + if (fs->group_desc[i].bg_inode_bitmap) { + if (ext2fs_test_block_bitmap(ctx->block_found_map, + fs->group_desc[i].bg_inode_bitmap)) { + pctx.blk = fs->group_desc[i].bg_inode_bitmap; + if (fix_problem(ctx, PR_1_IB_CONFLICT, &pctx)) { + ctx->invalid_inode_bitmap_flag[i]++; + ctx->invalid_bitmaps++; + } + } else { + ext2fs_mark_block_bitmap(ctx->block_found_map, + fs->group_desc[i].bg_inode_bitmap); + } + } + block += fs->super->s_blocks_per_group; + } +} + +/* + * Thes subroutines short circuits ext2fs_get_blocks and + * ext2fs_check_directory; we use them since we already have the inode + * structure, so there's no point in letting the ext2fs library read + * the inode again. + */ +static errcode_t pass1_get_blocks(ext2_filsys fs, ext2_ino_t ino, + blk_t *blocks) +{ + e2fsck_t ctx = (e2fsck_t) fs->priv_data; + int i; + + if ((ino != ctx->stashed_ino) || !ctx->stashed_inode) + return EXT2_ET_CALLBACK_NOTHANDLED; + + for (i=0; i < EXT2_N_BLOCKS; i++) + blocks[i] = ctx->stashed_inode->i_block[i]; + return 0; +} + +static errcode_t pass1_read_inode(ext2_filsys fs, ext2_ino_t ino, + struct ext2_inode *inode) +{ + e2fsck_t ctx = (e2fsck_t) fs->priv_data; + + if ((ino != ctx->stashed_ino) || !ctx->stashed_inode) + return EXT2_ET_CALLBACK_NOTHANDLED; + *inode = *ctx->stashed_inode; + return 0; +} + +static errcode_t pass1_write_inode(ext2_filsys fs, ext2_ino_t ino, + struct ext2_inode *inode) +{ + e2fsck_t ctx = (e2fsck_t) fs->priv_data; + + if ((ino == ctx->stashed_ino) && ctx->stashed_inode) + *ctx->stashed_inode = *inode; + return EXT2_ET_CALLBACK_NOTHANDLED; +} + +static errcode_t pass1_check_directory(ext2_filsys fs, ext2_ino_t ino) +{ + e2fsck_t ctx = (e2fsck_t) fs->priv_data; + + if ((ino != ctx->stashed_ino) || !ctx->stashed_inode) + return EXT2_ET_CALLBACK_NOTHANDLED; + + if (!LINUX_S_ISDIR(ctx->stashed_inode->i_mode)) + return EXT2_ET_NO_DIRECTORY; + return 0; +} + +void e2fsck_use_inode_shortcuts(e2fsck_t ctx, int bool) +{ + ext2_filsys fs = ctx->fs; + + if (bool) { + fs->get_blocks = pass1_get_blocks; + fs->check_directory = pass1_check_directory; + fs->read_inode = pass1_read_inode; + fs->write_inode = pass1_write_inode; + ctx->stashed_ino = 0; + } else { + fs->get_blocks = 0; + fs->check_directory = 0; + fs->read_inode = 0; + fs->write_inode = 0; + } +} +/* + * pass1b.c --- Pass #1b of e2fsck + * + * This file contains pass1B, pass1C, and pass1D of e2fsck. They are + * only invoked if pass 1 discovered blocks which are in use by more + * than one inode. + * + * Pass1B scans the data blocks of all the inodes again, generating a + * complete list of duplicate blocks and which inodes have claimed + * them. + * + * Pass1C does a tree-traversal of the filesystem, to determine the + * parent directories of these inodes. This step is necessary so that + * e2fsck can print out the pathnames of affected inodes. + * + * Pass1D is a reconciliation pass. For each inode with duplicate + * blocks, the user is prompted if s/he would like to clone the file + * (so that the file gets a fresh copy of the duplicated blocks) or + * simply to delete the file. + * + * Copyright (C) 1993, 1994, 1995, 1996, 1997 Theodore Ts'o. + * + * %Begin-Header% + * This file may be redistributed under the terms of the GNU Public + * License. + * %End-Header% + * + */ + + +/* Needed for architectures where sizeof(int) != sizeof(void *) */ +#define INT_TO_VOIDPTR(val) ((void *)(intptr_t)(val)) +#define VOIDPTR_TO_INT(ptr) ((int)(intptr_t)(ptr)) + +/* Define an extension to the ext2 library's block count information */ +#define BLOCK_COUNT_EXTATTR (-5) + +struct block_el { + blk_t block; + struct block_el *next; +}; + +struct inode_el { + ext2_ino_t inode; + struct inode_el *next; +}; + +struct dup_block { + int num_bad; + struct inode_el *inode_list; +}; + +/* + * This structure stores information about a particular inode which + * is sharing blocks with other inodes. This information is collected + * to display to the user, so that the user knows what files he or she + * is dealing with, when trying to decide how to resolve the conflict + * of multiply-claimed blocks. + */ +struct dup_inode { + ext2_ino_t dir; + int num_dupblocks; + struct ext2_inode inode; + struct block_el *block_list; +}; + +static int process_pass1b_block(ext2_filsys fs, blk_t *blocknr, + e2_blkcnt_t blockcnt, blk_t ref_blk, + int ref_offset, void *priv_data); +static void delete_file(e2fsck_t ctx, ext2_ino_t ino, + struct dup_inode *dp, char *block_buf); +static int clone_file(e2fsck_t ctx, ext2_ino_t ino, + struct dup_inode *dp, char* block_buf); +static int check_if_fs_block(e2fsck_t ctx, blk_t test_blk); + +static void pass1b(e2fsck_t ctx, char *block_buf); +static void pass1c(e2fsck_t ctx, char *block_buf); +static void pass1d(e2fsck_t ctx, char *block_buf); + +static int dup_inode_count = 0; + +static dict_t blk_dict, ino_dict; + +static ext2fs_inode_bitmap inode_dup_map; + +static int dict_int_cmp(const void *a, const void *b) +{ + intptr_t ia, ib; + + ia = (intptr_t)a; + ib = (intptr_t)b; + + return (ia-ib); +} + +/* + * Add a duplicate block record + */ +static void add_dupe(e2fsck_t ctx, ext2_ino_t ino, blk_t blk, + struct ext2_inode *inode) +{ + dnode_t *n; + struct dup_block *db; + struct dup_inode *di; + struct block_el *blk_el; + struct inode_el *ino_el; + + n = dict_lookup(&blk_dict, INT_TO_VOIDPTR(blk)); + if (n) + db = (struct dup_block *) dnode_get(n); + else { + db = (struct dup_block *) e2fsck_allocate_memory(ctx, + sizeof(struct dup_block), "duplicate block header"); + db->num_bad = 0; + db->inode_list = 0; + dict_alloc_insert(&blk_dict, INT_TO_VOIDPTR(blk), db); + } + ino_el = (struct inode_el *) e2fsck_allocate_memory(ctx, + sizeof(struct inode_el), "inode element"); + ino_el->inode = ino; + ino_el->next = db->inode_list; + db->inode_list = ino_el; + db->num_bad++; + + n = dict_lookup(&ino_dict, INT_TO_VOIDPTR(ino)); + if (n) + di = (struct dup_inode *) dnode_get(n); + else { + di = (struct dup_inode *) e2fsck_allocate_memory(ctx, + sizeof(struct dup_inode), "duplicate inode header"); + di->dir = (ino == EXT2_ROOT_INO) ? EXT2_ROOT_INO : 0 ; + di->num_dupblocks = 0; + di->block_list = 0; + di->inode = *inode; + dict_alloc_insert(&ino_dict, INT_TO_VOIDPTR(ino), di); + } + blk_el = (struct block_el *) e2fsck_allocate_memory(ctx, + sizeof(struct block_el), "block element"); + blk_el->block = blk; + blk_el->next = di->block_list; + di->block_list = blk_el; + di->num_dupblocks++; +} + +/* + * Free a duplicate inode record + */ +static void inode_dnode_free(dnode_t *node, + void *context EXT2FS_ATTR((unused))) +{ + struct dup_inode *di; + struct block_el *p, *next; + + di = (struct dup_inode *) dnode_get(node); + for (p = di->block_list; p; p = next) { + next = p->next; + free(p); + } + free(node); +} + +/* + * Free a duplicate block record + */ +static void block_dnode_free(dnode_t *node, + void *context EXT2FS_ATTR((unused))) +{ + struct dup_block *db; + struct inode_el *p, *next; + + db = (struct dup_block *) dnode_get(node); + for (p = db->inode_list; p; p = next) { + next = p->next; + free(p); + } + free(node); +} + + +/* + * Main procedure for handling duplicate blocks + */ +void e2fsck_pass1_dupblocks(e2fsck_t ctx, char *block_buf) +{ + ext2_filsys fs = ctx->fs; + struct problem_context pctx; + + clear_problem_context(&pctx); + + pctx.errcode = ext2fs_allocate_inode_bitmap(fs, + _("multiply claimed inode map"), &inode_dup_map); + if (pctx.errcode) { + fix_problem(ctx, PR_1B_ALLOCATE_IBITMAP_ERROR, &pctx); + ctx->flags |= E2F_FLAG_ABORT; + return; + } + + dict_init(&ino_dict, DICTCOUNT_T_MAX, dict_int_cmp); + dict_init(&blk_dict, DICTCOUNT_T_MAX, dict_int_cmp); + dict_set_allocator(&ino_dict, NULL, inode_dnode_free, NULL); + dict_set_allocator(&blk_dict, NULL, block_dnode_free, NULL); + + pass1b(ctx, block_buf); + pass1c(ctx, block_buf); + pass1d(ctx, block_buf); + + /* + * Time to free all of the accumulated data structures that we + * don't need anymore. + */ + dict_free_nodes(&ino_dict); + dict_free_nodes(&blk_dict); +} + +/* + * Scan the inodes looking for inodes that contain duplicate blocks. + */ +struct process_block_struct_1b { + e2fsck_t ctx; + ext2_ino_t ino; + int dup_blocks; + struct ext2_inode *inode; + struct problem_context *pctx; +}; + +static void pass1b(e2fsck_t ctx, char *block_buf) +{ + ext2_filsys fs = ctx->fs; + ext2_ino_t ino; + struct ext2_inode inode; + ext2_inode_scan scan; + struct process_block_struct_1b pb; + struct problem_context pctx; + + clear_problem_context(&pctx); + + if (!(ctx->options & E2F_OPT_PREEN)) + fix_problem(ctx, PR_1B_PASS_HEADER, &pctx); + pctx.errcode = ext2fs_open_inode_scan(fs, ctx->inode_buffer_blocks, + &scan); + if (pctx.errcode) { + fix_problem(ctx, PR_1B_ISCAN_ERROR, &pctx); + ctx->flags |= E2F_FLAG_ABORT; + return; + } + ctx->stashed_inode = &inode; + pb.ctx = ctx; + pb.pctx = &pctx; + pctx.str = "pass1b"; + while (1) { + pctx.errcode = ext2fs_get_next_inode(scan, &ino, &inode); + if (pctx.errcode == EXT2_ET_BAD_BLOCK_IN_INODE_TABLE) + continue; + if (pctx.errcode) { + fix_problem(ctx, PR_1B_ISCAN_ERROR, &pctx); + ctx->flags |= E2F_FLAG_ABORT; + return; + } + if (!ino) + break; + pctx.ino = ctx->stashed_ino = ino; + if ((ino != EXT2_BAD_INO) && + !ext2fs_test_inode_bitmap(ctx->inode_used_map, ino)) + continue; + + pb.ino = ino; + pb.dup_blocks = 0; + pb.inode = &inode; + + if (ext2fs_inode_has_valid_blocks(&inode) || + (ino == EXT2_BAD_INO)) + pctx.errcode = ext2fs_block_iterate2(fs, ino, + 0, block_buf, process_pass1b_block, &pb); + if (inode.i_file_acl) + process_pass1b_block(fs, &inode.i_file_acl, + BLOCK_COUNT_EXTATTR, 0, 0, &pb); + if (pb.dup_blocks) { + end_problem_latch(ctx, PR_LATCH_DBLOCK); + if (ino >= EXT2_FIRST_INODE(fs->super) || + ino == EXT2_ROOT_INO) + dup_inode_count++; + } + if (pctx.errcode) + fix_problem(ctx, PR_1B_BLOCK_ITERATE, &pctx); + } + ext2fs_close_inode_scan(scan); + e2fsck_use_inode_shortcuts(ctx, 0); +} + +static int process_pass1b_block(ext2_filsys fs EXT2FS_ATTR((unused)), + blk_t *block_nr, + e2_blkcnt_t blockcnt EXT2FS_ATTR((unused)), + blk_t ref_blk EXT2FS_ATTR((unused)), + int ref_offset EXT2FS_ATTR((unused)), + void *priv_data) +{ + struct process_block_struct_1b *p; + e2fsck_t ctx; + + if (HOLE_BLKADDR(*block_nr)) + return 0; + p = (struct process_block_struct_1b *) priv_data; + ctx = p->ctx; + + if (!ext2fs_test_block_bitmap(ctx->block_dup_map, *block_nr)) + return 0; + + /* OK, this is a duplicate block */ + if (p->ino != EXT2_BAD_INO) { + p->pctx->blk = *block_nr; + fix_problem(ctx, PR_1B_DUP_BLOCK, p->pctx); + } + p->dup_blocks++; + ext2fs_mark_inode_bitmap(inode_dup_map, p->ino); + + add_dupe(ctx, p->ino, *block_nr, p->inode); + + return 0; +} + +/* + * Pass 1c: Scan directories for inodes with duplicate blocks. This + * is used so that we can print pathnames when prompting the user for + * what to do. + */ +struct search_dir_struct { + int count; + ext2_ino_t first_inode; + ext2_ino_t max_inode; +}; + +static int search_dirent_proc(ext2_ino_t dir, int entry, + struct ext2_dir_entry *dirent, + int offset EXT2FS_ATTR((unused)), + int blocksize EXT2FS_ATTR((unused)), + char *buf EXT2FS_ATTR((unused)), + void *priv_data) +{ + struct search_dir_struct *sd; + struct dup_inode *p; + dnode_t *n; + + sd = (struct search_dir_struct *) priv_data; + + if (dirent->inode > sd->max_inode) + /* Should abort this inode, but not everything */ + return 0; + + if ((dirent->inode < sd->first_inode) || (entry < DIRENT_OTHER_FILE) || + !ext2fs_test_inode_bitmap(inode_dup_map, dirent->inode)) + return 0; + + n = dict_lookup(&ino_dict, INT_TO_VOIDPTR(dirent->inode)); + if (!n) + return 0; + p = (struct dup_inode *) dnode_get(n); + p->dir = dir; + sd->count--; + + return(sd->count ? 0 : DIRENT_ABORT); +} + + +static void pass1c(e2fsck_t ctx, char *block_buf) +{ + ext2_filsys fs = ctx->fs; + struct search_dir_struct sd; + struct problem_context pctx; + + clear_problem_context(&pctx); + + if (!(ctx->options & E2F_OPT_PREEN)) + fix_problem(ctx, PR_1C_PASS_HEADER, &pctx); + + /* + * Search through all directories to translate inodes to names + * (by searching for the containing directory for that inode.) + */ + sd.count = dup_inode_count; + sd.first_inode = EXT2_FIRST_INODE(fs->super); + sd.max_inode = fs->super->s_inodes_count; + ext2fs_dblist_dir_iterate(fs->dblist, 0, block_buf, + search_dirent_proc, &sd); +} + +static void pass1d(e2fsck_t ctx, char *block_buf) +{ + ext2_filsys fs = ctx->fs; + struct dup_inode *p, *t; + struct dup_block *q; + ext2_ino_t *shared, ino; + int shared_len; + int i; + int file_ok; + int meta_data = 0; + struct problem_context pctx; + dnode_t *n, *m; + struct block_el *s; + struct inode_el *r; + + clear_problem_context(&pctx); + + if (!(ctx->options & E2F_OPT_PREEN)) + fix_problem(ctx, PR_1D_PASS_HEADER, &pctx); + e2fsck_read_bitmaps(ctx); + + pctx.num = dup_inode_count; /* dict_count(&ino_dict); */ + fix_problem(ctx, PR_1D_NUM_DUP_INODES, &pctx); + shared = (ext2_ino_t *) e2fsck_allocate_memory(ctx, + sizeof(ext2_ino_t) * dict_count(&ino_dict), + "Shared inode list"); + for (n = dict_first(&ino_dict); n; n = dict_next(&ino_dict, n)) { + p = (struct dup_inode *) dnode_get(n); + shared_len = 0; + file_ok = 1; + ino = (ext2_ino_t)VOIDPTR_TO_INT(dnode_getkey(n)); + if (ino == EXT2_BAD_INO) + continue; + + /* + * Find all of the inodes which share blocks with this + * one. First we find all of the duplicate blocks + * belonging to this inode, and then search each block + * get the list of inodes, and merge them together. + */ + for (s = p->block_list; s; s = s->next) { + m = dict_lookup(&blk_dict, INT_TO_VOIDPTR(s->block)); + if (!m) + continue; /* Should never happen... */ + q = (struct dup_block *) dnode_get(m); + if (q->num_bad > 1) + file_ok = 0; + if (check_if_fs_block(ctx, s->block)) { + file_ok = 0; + meta_data = 1; + } + + /* + * Add all inodes used by this block to the + * shared[] --- which is a unique list, so + * if an inode is already in shared[], don't + * add it again. + */ + for (r = q->inode_list; r; r = r->next) { + if (r->inode == ino) + continue; + for (i = 0; i < shared_len; i++) + if (shared[i] == r->inode) + break; + if (i == shared_len) { + shared[shared_len++] = r->inode; + } + } + } + + /* + * Report the inode that we are working on + */ + pctx.inode = &p->inode; + pctx.ino = ino; + pctx.dir = p->dir; + pctx.blkcount = p->num_dupblocks; + pctx.num = meta_data ? shared_len+1 : shared_len; + fix_problem(ctx, PR_1D_DUP_FILE, &pctx); + pctx.blkcount = 0; + pctx.num = 0; + + if (meta_data) + fix_problem(ctx, PR_1D_SHARE_METADATA, &pctx); + + for (i = 0; i < shared_len; i++) { + m = dict_lookup(&ino_dict, INT_TO_VOIDPTR(shared[i])); + if (!m) + continue; /* should never happen */ + t = (struct dup_inode *) dnode_get(m); + /* + * Report the inode that we are sharing with + */ + pctx.inode = &t->inode; + pctx.ino = shared[i]; + pctx.dir = t->dir; + fix_problem(ctx, PR_1D_DUP_FILE_LIST, &pctx); + } + if (file_ok) { + fix_problem(ctx, PR_1D_DUP_BLOCKS_DEALT, &pctx); + continue; + } + if (fix_problem(ctx, PR_1D_CLONE_QUESTION, &pctx)) { + pctx.errcode = clone_file(ctx, ino, p, block_buf); + if (pctx.errcode) + fix_problem(ctx, PR_1D_CLONE_ERROR, &pctx); + else + continue; + } + if (fix_problem(ctx, PR_1D_DELETE_QUESTION, &pctx)) + delete_file(ctx, ino, p, block_buf); + else + ext2fs_unmark_valid(fs); + } + ext2fs_free_mem(&shared); +} + +/* + * Drop the refcount on the dup_block structure, and clear the entry + * in the block_dup_map if appropriate. + */ +static void decrement_badcount(e2fsck_t ctx, blk_t block, struct dup_block *p) +{ + p->num_bad--; + if (p->num_bad <= 0 || + (p->num_bad == 1 && !check_if_fs_block(ctx, block))) + ext2fs_unmark_block_bitmap(ctx->block_dup_map, block); +} + +static int delete_file_block(ext2_filsys fs, + blk_t *block_nr, + e2_blkcnt_t blockcnt EXT2FS_ATTR((unused)), + blk_t ref_block EXT2FS_ATTR((unused)), + int ref_offset EXT2FS_ATTR((unused)), + void *priv_data) +{ + struct process_block_struct_1b *pb; + struct dup_block *p; + dnode_t *n; + e2fsck_t ctx; + + pb = (struct process_block_struct_1b *) priv_data; + ctx = pb->ctx; + + if (HOLE_BLKADDR(*block_nr)) + return 0; + + if (ext2fs_test_block_bitmap(ctx->block_dup_map, *block_nr)) { + n = dict_lookup(&blk_dict, INT_TO_VOIDPTR(*block_nr)); + if (n) { + p = (struct dup_block *) dnode_get(n); + decrement_badcount(ctx, *block_nr, p); + } else + com_err("delete_file_block", 0, + _("internal error; can't find dup_blk for %d\n"), + *block_nr); + } else { + ext2fs_unmark_block_bitmap(ctx->block_found_map, *block_nr); + ext2fs_block_alloc_stats(fs, *block_nr, -1); + } + + return 0; +} + +static void delete_file(e2fsck_t ctx, ext2_ino_t ino, + struct dup_inode *dp, char* block_buf) +{ + ext2_filsys fs = ctx->fs; + struct process_block_struct_1b pb; + struct ext2_inode inode; + struct problem_context pctx; + unsigned int count; + + clear_problem_context(&pctx); + pctx.ino = pb.ino = ino; + pb.dup_blocks = dp->num_dupblocks; + pb.ctx = ctx; + pctx.str = "delete_file"; + + e2fsck_read_inode(ctx, ino, &inode, "delete_file"); + if (ext2fs_inode_has_valid_blocks(&inode)) + pctx.errcode = ext2fs_block_iterate2(fs, ino, 0, block_buf, + delete_file_block, &pb); + if (pctx.errcode) + fix_problem(ctx, PR_1B_BLOCK_ITERATE, &pctx); + ext2fs_unmark_inode_bitmap(ctx->inode_used_map, ino); + ext2fs_unmark_inode_bitmap(ctx->inode_dir_map, ino); + if (ctx->inode_bad_map) + ext2fs_unmark_inode_bitmap(ctx->inode_bad_map, ino); + ext2fs_inode_alloc_stats2(fs, ino, -1, LINUX_S_ISDIR(inode.i_mode)); + + /* Inode may have changed by block_iterate, so reread it */ + e2fsck_read_inode(ctx, ino, &inode, "delete_file"); + inode.i_links_count = 0; + inode.i_dtime = time(0); + if (inode.i_file_acl && + (fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_EXT_ATTR)) { + count = 1; + pctx.errcode = ext2fs_adjust_ea_refcount(fs, inode.i_file_acl, + block_buf, -1, &count); + if (pctx.errcode == EXT2_ET_BAD_EA_BLOCK_NUM) { + pctx.errcode = 0; + count = 1; + } + if (pctx.errcode) { + pctx.blk = inode.i_file_acl; + fix_problem(ctx, PR_1B_ADJ_EA_REFCOUNT, &pctx); + } + /* + * If the count is zero, then arrange to have the + * block deleted. If the block is in the block_dup_map, + * also call delete_file_block since it will take care + * of keeping the accounting straight. + */ + if ((count == 0) || + ext2fs_test_block_bitmap(ctx->block_dup_map, + inode.i_file_acl)) + delete_file_block(fs, &inode.i_file_acl, + BLOCK_COUNT_EXTATTR, 0, 0, &pb); + } + e2fsck_write_inode(ctx, ino, &inode, "delete_file"); +} + +struct clone_struct { + errcode_t errcode; + ext2_ino_t dir; + char *buf; + e2fsck_t ctx; +}; + +static int clone_file_block(ext2_filsys fs, + blk_t *block_nr, + e2_blkcnt_t blockcnt, + blk_t ref_block EXT2FS_ATTR((unused)), + int ref_offset EXT2FS_ATTR((unused)), + void *priv_data) +{ + struct dup_block *p; + blk_t new_block; + errcode_t retval; + struct clone_struct *cs = (struct clone_struct *) priv_data; + dnode_t *n; + e2fsck_t ctx; + + ctx = cs->ctx; + + if (HOLE_BLKADDR(*block_nr)) + return 0; + + if (ext2fs_test_block_bitmap(ctx->block_dup_map, *block_nr)) { + n = dict_lookup(&blk_dict, INT_TO_VOIDPTR(*block_nr)); + if (n) { + p = (struct dup_block *) dnode_get(n); + retval = ext2fs_new_block(fs, 0, ctx->block_found_map, + &new_block); + if (retval) { + cs->errcode = retval; + return BLOCK_ABORT; + } + if (cs->dir && (blockcnt >= 0)) { + retval = ext2fs_set_dir_block(fs->dblist, + cs->dir, new_block, blockcnt); + if (retval) { + cs->errcode = retval; + return BLOCK_ABORT; + } + } +#if 0 + printf("Cloning block %u to %u\n", *block_nr, + new_block); +#endif + retval = io_channel_read_blk(fs->io, *block_nr, 1, + cs->buf); + if (retval) { + cs->errcode = retval; + return BLOCK_ABORT; + } + retval = io_channel_write_blk(fs->io, new_block, 1, + cs->buf); + if (retval) { + cs->errcode = retval; + return BLOCK_ABORT; + } + decrement_badcount(ctx, *block_nr, p); + *block_nr = new_block; + ext2fs_mark_block_bitmap(ctx->block_found_map, + new_block); + ext2fs_mark_block_bitmap(fs->block_map, new_block); + return BLOCK_CHANGED; + } else + com_err("clone_file_block", 0, + _("internal error; can't find dup_blk for %d\n"), + *block_nr); + } + return 0; +} + +static int clone_file(e2fsck_t ctx, ext2_ino_t ino, + struct dup_inode *dp, char* block_buf) +{ + ext2_filsys fs = ctx->fs; + errcode_t retval; + struct clone_struct cs; + struct problem_context pctx; + blk_t blk; + dnode_t *n; + struct inode_el *ino_el; + struct dup_block *db; + struct dup_inode *di; + + clear_problem_context(&pctx); + cs.errcode = 0; + cs.dir = 0; + cs.ctx = ctx; + retval = ext2fs_get_mem(fs->blocksize, &cs.buf); + if (retval) + return retval; + + if (ext2fs_test_inode_bitmap(ctx->inode_dir_map, ino)) + cs.dir = ino; + + pctx.ino = ino; + pctx.str = "clone_file"; + if (ext2fs_inode_has_valid_blocks(&dp->inode)) + pctx.errcode = ext2fs_block_iterate2(fs, ino, 0, block_buf, + clone_file_block, &cs); + ext2fs_mark_bb_dirty(fs); + if (pctx.errcode) { + fix_problem(ctx, PR_1B_BLOCK_ITERATE, &pctx); + retval = pctx.errcode; + goto errout; + } + if (cs.errcode) { + com_err("clone_file", cs.errcode, + _("returned from clone_file_block")); + retval = cs.errcode; + goto errout; + } + /* The inode may have changed on disk, so we have to re-read it */ + e2fsck_read_inode(ctx, ino, &dp->inode, "clone file EA"); + blk = dp->inode.i_file_acl; + if (blk && (clone_file_block(fs, &dp->inode.i_file_acl, + BLOCK_COUNT_EXTATTR, 0, 0, &cs) == + BLOCK_CHANGED)) { + e2fsck_write_inode(ctx, ino, &dp->inode, "clone file EA"); + /* + * If we cloned the EA block, find all other inodes + * which refered to that EA block, and modify + * them to point to the new EA block. + */ + n = dict_lookup(&blk_dict, INT_TO_VOIDPTR(blk)); + db = (struct dup_block *) dnode_get(n); + for (ino_el = db->inode_list; ino_el; ino_el = ino_el->next) { + if (ino_el->inode == ino) + continue; + n = dict_lookup(&ino_dict, INT_TO_VOIDPTR(ino_el->inode)); + di = (struct dup_inode *) dnode_get(n); + if (di->inode.i_file_acl == blk) { + di->inode.i_file_acl = dp->inode.i_file_acl; + e2fsck_write_inode(ctx, ino_el->inode, + &di->inode, "clone file EA"); + decrement_badcount(ctx, blk, db); + } + } + } + retval = 0; +errout: + ext2fs_free_mem(&cs.buf); + return retval; +} + +/* + * This routine returns 1 if a block overlaps with one of the superblocks, + * group descriptors, inode bitmaps, or block bitmaps. + */ +static int check_if_fs_block(e2fsck_t ctx, blk_t test_block) +{ + ext2_filsys fs = ctx->fs; + blk_t block; + dgrp_t i; + + block = fs->super->s_first_data_block; + for (i = 0; i < fs->group_desc_count; i++) { + + /* Check superblocks/block group descriptros */ + if (ext2fs_bg_has_super(fs, i)) { + if (test_block >= block && + (test_block <= block + fs->desc_blocks)) + return 1; + } + + /* Check the inode table */ + if ((fs->group_desc[i].bg_inode_table) && + (test_block >= fs->group_desc[i].bg_inode_table) && + (test_block < (fs->group_desc[i].bg_inode_table + + fs->inode_blocks_per_group))) + return 1; + + /* Check the bitmap blocks */ + if ((test_block == fs->group_desc[i].bg_block_bitmap) || + (test_block == fs->group_desc[i].bg_inode_bitmap)) + return 1; + + block += fs->super->s_blocks_per_group; + } + return 0; +} +/* + * pass2.c --- check directory structure + * + * Copyright (C) 1993, 1994, 1995, 1996, 1997 Theodore Ts'o + * + * %Begin-Header% + * This file may be redistributed under the terms of the GNU Public + * License. + * %End-Header% + * + * Pass 2 of e2fsck iterates through all active directory inodes, and + * applies to following tests to each directory entry in the directory + * blocks in the inodes: + * + * - The length of the directory entry (rec_len) should be at + * least 8 bytes, and no more than the remaining space + * left in the directory block. + * - The length of the name in the directory entry (name_len) + * should be less than (rec_len - 8). + * - The inode number in the directory entry should be within + * legal bounds. + * - The inode number should refer to a in-use inode. + * - The first entry should be '.', and its inode should be + * the inode of the directory. + * - The second entry should be '..'. + * + * To minimize disk seek time, the directory blocks are processed in + * sorted order of block numbers. + * + * Pass 2 also collects the following information: + * - The inode numbers of the subdirectories for each directory. + * + * Pass 2 relies on the following information from previous passes: + * - The directory information collected in pass 1. + * - The inode_used_map bitmap + * - The inode_bad_map bitmap + * - The inode_dir_map bitmap + * + * Pass 2 frees the following data structures + * - The inode_bad_map bitmap + * - The inode_reg_map bitmap + */ + +/* #define DX_DEBUG */ + +/* + * Keeps track of how many times an inode is referenced. + */ +static void deallocate_inode(e2fsck_t ctx, ext2_ino_t ino, char* block_buf); +static int check_dir_block(ext2_filsys fs, + struct ext2_db_entry *dir_blocks_info, + void *priv_data); +static int allocate_dir_block(e2fsck_t ctx, + struct ext2_db_entry *dir_blocks_info, + char *buf, struct problem_context *pctx); +static int update_dir_block(ext2_filsys fs, + blk_t *block_nr, + e2_blkcnt_t blockcnt, + blk_t ref_block, + int ref_offset, + void *priv_data); +static void clear_htree(e2fsck_t ctx, ext2_ino_t ino); +static int htree_depth(struct dx_dir_info *dx_dir, + struct dx_dirblock_info *dx_db); +static EXT2_QSORT_TYPE special_dir_block_cmp(const void *a, const void *b); + +struct check_dir_struct { + char *buf; + struct problem_context pctx; + int count, max; + e2fsck_t ctx; +}; + +void e2fsck_pass2(e2fsck_t ctx) +{ + struct ext2_super_block *sb = ctx->fs->super; + struct problem_context pctx; + ext2_filsys fs = ctx->fs; + char *buf; +#ifdef RESOURCE_TRACK + struct resource_track rtrack; +#endif + struct dir_info *dir; + struct check_dir_struct cd; + struct dx_dir_info *dx_dir; + struct dx_dirblock_info *dx_db, *dx_parent; + int b; + int i, depth; + problem_t code; + int bad_dir; + +#ifdef RESOURCE_TRACK + init_resource_track(&rtrack); +#endif + + clear_problem_context(&cd.pctx); + +#ifdef MTRACE + mtrace_print("Pass 2"); +#endif + + if (!(ctx->options & E2F_OPT_PREEN)) + fix_problem(ctx, PR_2_PASS_HEADER, &cd.pctx); + + cd.pctx.errcode = ext2fs_create_icount2(fs, EXT2_ICOUNT_OPT_INCREMENT, + 0, ctx->inode_link_info, + &ctx->inode_count); + if (cd.pctx.errcode) { + fix_problem(ctx, PR_2_ALLOCATE_ICOUNT, &cd.pctx); + ctx->flags |= E2F_FLAG_ABORT; + return; + } + buf = (char *) e2fsck_allocate_memory(ctx, 2*fs->blocksize, + "directory scan buffer"); + + /* + * Set up the parent pointer for the root directory, if + * present. (If the root directory is not present, we will + * create it in pass 3.) + */ + dir = e2fsck_get_dir_info(ctx, EXT2_ROOT_INO); + if (dir) + dir->parent = EXT2_ROOT_INO; + + cd.buf = buf; + cd.ctx = ctx; + cd.count = 1; + cd.max = ext2fs_dblist_count(fs->dblist); + + if (ctx->progress) + (void) (ctx->progress)(ctx, 2, 0, cd.max); + + if (fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_DIR_INDEX) + ext2fs_dblist_sort(fs->dblist, special_dir_block_cmp); + + cd.pctx.errcode = ext2fs_dblist_iterate(fs->dblist, check_dir_block, + &cd); + if (ctx->flags & E2F_FLAG_SIGNAL_MASK) + return; + if (cd.pctx.errcode) { + fix_problem(ctx, PR_2_DBLIST_ITERATE, &cd.pctx); + ctx->flags |= E2F_FLAG_ABORT; + return; + } + +#ifdef ENABLE_HTREE + for (i=0; (dx_dir = e2fsck_dx_dir_info_iter(ctx, &i)) != 0;) { + if (ctx->flags & E2F_FLAG_SIGNAL_MASK) + return; + if (dx_dir->numblocks == 0) + continue; + clear_problem_context(&pctx); + bad_dir = 0; + pctx.dir = dx_dir->ino; + dx_db = dx_dir->dx_block; + if (dx_db->flags & DX_FLAG_REFERENCED) + dx_db->flags |= DX_FLAG_DUP_REF; + else + dx_db->flags |= DX_FLAG_REFERENCED; + /* + * Find all of the first and last leaf blocks, and + * update their parent's min and max hash values + */ + for (b=0, dx_db = dx_dir->dx_block; + b < dx_dir->numblocks; + b++, dx_db++) { + if ((dx_db->type != DX_DIRBLOCK_LEAF) || + !(dx_db->flags & (DX_FLAG_FIRST | DX_FLAG_LAST))) + continue; + dx_parent = &dx_dir->dx_block[dx_db->parent]; + /* + * XXX Make sure dx_parent->min_hash > dx_db->min_hash + */ + if (dx_db->flags & DX_FLAG_FIRST) + dx_parent->min_hash = dx_db->min_hash; + /* + * XXX Make sure dx_parent->max_hash < dx_db->max_hash + */ + if (dx_db->flags & DX_FLAG_LAST) + dx_parent->max_hash = dx_db->max_hash; + } + + for (b=0, dx_db = dx_dir->dx_block; + b < dx_dir->numblocks; + b++, dx_db++) { + pctx.blkcount = b; + pctx.group = dx_db->parent; + code = 0; + if (!(dx_db->flags & DX_FLAG_FIRST) && + (dx_db->min_hash < dx_db->node_min_hash)) { + pctx.blk = dx_db->min_hash; + pctx.blk2 = dx_db->node_min_hash; + code = PR_2_HTREE_MIN_HASH; + fix_problem(ctx, code, &pctx); + bad_dir++; + } + if (dx_db->type == DX_DIRBLOCK_LEAF) { + depth = htree_depth(dx_dir, dx_db); + if (depth != dx_dir->depth) { + code = PR_2_HTREE_BAD_DEPTH; + fix_problem(ctx, code, &pctx); + bad_dir++; + } + } + /* + * This test doesn't apply for the root block + * at block #0 + */ + if (b && + (dx_db->max_hash > dx_db->node_max_hash)) { + pctx.blk = dx_db->max_hash; + pctx.blk2 = dx_db->node_max_hash; + code = PR_2_HTREE_MAX_HASH; + fix_problem(ctx, code, &pctx); + bad_dir++; + } + if (!(dx_db->flags & DX_FLAG_REFERENCED)) { + code = PR_2_HTREE_NOTREF; + fix_problem(ctx, code, &pctx); + bad_dir++; + } else if (dx_db->flags & DX_FLAG_DUP_REF) { + code = PR_2_HTREE_DUPREF; + fix_problem(ctx, code, &pctx); + bad_dir++; + } + if (code == 0) + continue; + } + if (bad_dir && fix_problem(ctx, PR_2_HTREE_CLEAR, &pctx)) { + clear_htree(ctx, dx_dir->ino); + dx_dir->numblocks = 0; + } + } +#endif + ext2fs_free_mem(&buf); + ext2fs_free_dblist(fs->dblist); + + if (ctx->inode_bad_map) { + ext2fs_free_inode_bitmap(ctx->inode_bad_map); + ctx->inode_bad_map = 0; + } + if (ctx->inode_reg_map) { + ext2fs_free_inode_bitmap(ctx->inode_reg_map); + ctx->inode_reg_map = 0; + } + + clear_problem_context(&pctx); + if (ctx->large_files) { + if (!(sb->s_feature_ro_compat & + EXT2_FEATURE_RO_COMPAT_LARGE_FILE) && + fix_problem(ctx, PR_2_FEATURE_LARGE_FILES, &pctx)) { + sb->s_feature_ro_compat |= + EXT2_FEATURE_RO_COMPAT_LARGE_FILE; + ext2fs_mark_super_dirty(fs); + } + if (sb->s_rev_level == EXT2_GOOD_OLD_REV && + fix_problem(ctx, PR_1_FS_REV_LEVEL, &pctx)) { + ext2fs_update_dynamic_rev(fs); + ext2fs_mark_super_dirty(fs); + } + } else if (!ctx->large_files && + (sb->s_feature_ro_compat & + EXT2_FEATURE_RO_COMPAT_LARGE_FILE)) { + if (fs->flags & EXT2_FLAG_RW) { + sb->s_feature_ro_compat &= + ~EXT2_FEATURE_RO_COMPAT_LARGE_FILE; + ext2fs_mark_super_dirty(fs); + } + } + +#ifdef RESOURCE_TRACK + if (ctx->options & E2F_OPT_TIME2) { + e2fsck_clear_progbar(ctx); + print_resource_track(_("Pass 2"), &rtrack); + } +#endif +} + +#define MAX_DEPTH 32000 +static int htree_depth(struct dx_dir_info *dx_dir, + struct dx_dirblock_info *dx_db) +{ + int depth = 0; + + while (dx_db->type != DX_DIRBLOCK_ROOT && depth < MAX_DEPTH) { + dx_db = &dx_dir->dx_block[dx_db->parent]; + depth++; + } + return depth; +} + +static int dict_de_cmp(const void *a, const void *b) +{ + const struct ext2_dir_entry *de_a, *de_b; + int a_len, b_len; + + de_a = (const struct ext2_dir_entry *) a; + a_len = de_a->name_len & 0xFF; + de_b = (const struct ext2_dir_entry *) b; + b_len = de_b->name_len & 0xFF; + + if (a_len != b_len) + return (a_len - b_len); + + return strncmp(de_a->name, de_b->name, a_len); +} + +/* + * This is special sort function that makes sure that directory blocks + * with a dirblock of zero are sorted to the beginning of the list. + * This guarantees that the root node of the htree directories are + * processed first, so we know what hash version to use. + */ +static EXT2_QSORT_TYPE special_dir_block_cmp(const void *a, const void *b) +{ + const struct ext2_db_entry *db_a = + (const struct ext2_db_entry *) a; + const struct ext2_db_entry *db_b = + (const struct ext2_db_entry *) b; + + if (db_a->blockcnt && !db_b->blockcnt) + return 1; + + if (!db_a->blockcnt && db_b->blockcnt) + return -1; + + if (db_a->blk != db_b->blk) + return (int) (db_a->blk - db_b->blk); + + if (db_a->ino != db_b->ino) + return (int) (db_a->ino - db_b->ino); + + return (int) (db_a->blockcnt - db_b->blockcnt); +} + + +/* + * Make sure the first entry in the directory is '.', and that the + * directory entry is sane. + */ +static int check_dot(e2fsck_t ctx, + struct ext2_dir_entry *dirent, + ext2_ino_t ino, struct problem_context *pctx) +{ + struct ext2_dir_entry *nextdir; + int status = 0; + int created = 0; + int new_len; + int problem = 0; + + if (!dirent->inode) + problem = PR_2_MISSING_DOT; + else if (((dirent->name_len & 0xFF) != 1) || + (dirent->name[0] != '.')) + problem = PR_2_1ST_NOT_DOT; + else if (dirent->name[1] != '\0') + problem = PR_2_DOT_NULL_TERM; + + if (problem) { + if (fix_problem(ctx, problem, pctx)) { + if (dirent->rec_len < 12) + dirent->rec_len = 12; + dirent->inode = ino; + dirent->name_len = 1; + dirent->name[0] = '.'; + dirent->name[1] = '\0'; + status = 1; + created = 1; + } + } + if (dirent->inode != ino) { + if (fix_problem(ctx, PR_2_BAD_INODE_DOT, pctx)) { + dirent->inode = ino; + status = 1; + } + } + if (dirent->rec_len > 12) { + new_len = dirent->rec_len - 12; + if (new_len > 12) { + if (created || + fix_problem(ctx, PR_2_SPLIT_DOT, pctx)) { + nextdir = (struct ext2_dir_entry *) + ((char *) dirent + 12); + dirent->rec_len = 12; + nextdir->rec_len = new_len; + nextdir->inode = 0; + nextdir->name_len = 0; + status = 1; + } + } + } + return status; +} + +/* + * Make sure the second entry in the directory is '..', and that the + * directory entry is sane. We do not check the inode number of '..' + * here; this gets done in pass 3. + */ +static int check_dotdot(e2fsck_t ctx, + struct ext2_dir_entry *dirent, + struct dir_info *dir, struct problem_context *pctx) +{ + int problem = 0; + + if (!dirent->inode) + problem = PR_2_MISSING_DOT_DOT; + else if (((dirent->name_len & 0xFF) != 2) || + (dirent->name[0] != '.') || + (dirent->name[1] != '.')) + problem = PR_2_2ND_NOT_DOT_DOT; + else if (dirent->name[2] != '\0') + problem = PR_2_DOT_DOT_NULL_TERM; + + if (problem) { + if (fix_problem(ctx, problem, pctx)) { + if (dirent->rec_len < 12) + dirent->rec_len = 12; + /* + * Note: we don't have the parent inode just + * yet, so we will fill it in with the root + * inode. This will get fixed in pass 3. + */ + dirent->inode = EXT2_ROOT_INO; + dirent->name_len = 2; + dirent->name[0] = '.'; + dirent->name[1] = '.'; + dirent->name[2] = '\0'; + return 1; + } + return 0; + } + dir->dotdot = dirent->inode; + return 0; +} + +/* + * Check to make sure a directory entry doesn't contain any illegal + * characters. + */ +static int check_name(e2fsck_t ctx, + struct ext2_dir_entry *dirent, + ext2_ino_t dir_ino EXT2FS_ATTR((unused)), + struct problem_context *pctx) +{ + int i; + int fixup = -1; + int ret = 0; + + for ( i = 0; i < (dirent->name_len & 0xFF); i++) { + if (dirent->name[i] == '/' || dirent->name[i] == '\0') { + if (fixup < 0) { + fixup = fix_problem(ctx, PR_2_BAD_NAME, pctx); + } + if (fixup) { + dirent->name[i] = '.'; + ret = 1; + } + } + } + return ret; +} + +/* + * Check the directory filetype (if present) + */ +static _INLINE_ int check_filetype(e2fsck_t ctx, + struct ext2_dir_entry *dirent, + ext2_ino_t dir_ino EXT2FS_ATTR((unused)), + struct problem_context *pctx) +{ + int filetype = dirent->name_len >> 8; + int should_be = EXT2_FT_UNKNOWN; + struct ext2_inode inode; + + if (!(ctx->fs->super->s_feature_incompat & + EXT2_FEATURE_INCOMPAT_FILETYPE)) { + if (filetype == 0 || + !fix_problem(ctx, PR_2_CLEAR_FILETYPE, pctx)) + return 0; + dirent->name_len = dirent->name_len & 0xFF; + return 1; + } + + if (ext2fs_test_inode_bitmap(ctx->inode_dir_map, dirent->inode)) { + should_be = EXT2_FT_DIR; + } else if (ext2fs_test_inode_bitmap(ctx->inode_reg_map, + dirent->inode)) { + should_be = EXT2_FT_REG_FILE; + } else if (ctx->inode_bad_map && + ext2fs_test_inode_bitmap(ctx->inode_bad_map, + dirent->inode)) + should_be = 0; + else { + e2fsck_read_inode(ctx, dirent->inode, &inode, + "check_filetype"); + should_be = ext2_file_type(inode.i_mode); + } + if (filetype == should_be) + return 0; + pctx->num = should_be; + + if (fix_problem(ctx, filetype ? PR_2_BAD_FILETYPE : PR_2_SET_FILETYPE, + pctx) == 0) + return 0; + + dirent->name_len = (dirent->name_len & 0xFF) | should_be << 8; + return 1; +} + +#ifdef ENABLE_HTREE +static void parse_int_node(ext2_filsys fs, + struct ext2_db_entry *db, + struct check_dir_struct *cd, + struct dx_dir_info *dx_dir, + char *block_buf) +{ + struct ext2_dx_root_info *root; + struct ext2_dx_entry *ent; + struct ext2_dx_countlimit *limit; + struct dx_dirblock_info *dx_db; + int i, expect_limit, count; + blk_t blk; + ext2_dirhash_t min_hash = 0xffffffff; + ext2_dirhash_t max_hash = 0; + ext2_dirhash_t hash = 0, prev_hash; + + if (db->blockcnt == 0) { + root = (struct ext2_dx_root_info *) (block_buf + 24); + +#ifdef DX_DEBUG + printf("Root node dump:\n"); + printf("\t Reserved zero: %d\n", root->reserved_zero); + printf("\t Hash Version: %d\n", root->hash_version); + printf("\t Info length: %d\n", root->info_length); + printf("\t Indirect levels: %d\n", root->indirect_levels); + printf("\t Flags: %d\n", root->unused_flags); +#endif + + ent = (struct ext2_dx_entry *) (block_buf + 24 + root->info_length); + } else { + ent = (struct ext2_dx_entry *) (block_buf+8); + } + limit = (struct ext2_dx_countlimit *) ent; + +#ifdef DX_DEBUG + printf("Number of entries (count): %d\n", + ext2fs_le16_to_cpu(limit->count)); + printf("Number of entries (limit): %d\n", + ext2fs_le16_to_cpu(limit->limit)); +#endif + + count = ext2fs_le16_to_cpu(limit->count); + expect_limit = (fs->blocksize - ((char *) ent - block_buf)) / + sizeof(struct ext2_dx_entry); + if (ext2fs_le16_to_cpu(limit->limit) != expect_limit) { + cd->pctx.num = ext2fs_le16_to_cpu(limit->limit); + if (fix_problem(cd->ctx, PR_2_HTREE_BAD_LIMIT, &cd->pctx)) + goto clear_and_exit; + } + if (count > expect_limit) { + cd->pctx.num = count; + if (fix_problem(cd->ctx, PR_2_HTREE_BAD_COUNT, &cd->pctx)) + goto clear_and_exit; + count = expect_limit; + } + + for (i=0; i < count; i++) { + prev_hash = hash; + hash = i ? (ext2fs_le32_to_cpu(ent[i].hash) & ~1) : 0; +#ifdef DX_DEBUG + printf("Entry #%d: Hash 0x%08x, block %d\n", i, + hash, ext2fs_le32_to_cpu(ent[i].block)); +#endif + blk = ext2fs_le32_to_cpu(ent[i].block) & 0x0ffffff; + /* Check to make sure the block is valid */ + if (blk > (blk_t) dx_dir->numblocks) { + cd->pctx.blk = blk; + if (fix_problem(cd->ctx, PR_2_HTREE_BADBLK, + &cd->pctx)) + goto clear_and_exit; + } + if (hash < prev_hash && + fix_problem(cd->ctx, PR_2_HTREE_HASH_ORDER, &cd->pctx)) + goto clear_and_exit; + dx_db = &dx_dir->dx_block[blk]; + if (dx_db->flags & DX_FLAG_REFERENCED) { + dx_db->flags |= DX_FLAG_DUP_REF; + } else { + dx_db->flags |= DX_FLAG_REFERENCED; + dx_db->parent = db->blockcnt; + } + if (hash < min_hash) + min_hash = hash; + if (hash > max_hash) + max_hash = hash; + dx_db->node_min_hash = hash; + if ((i+1) < count) + dx_db->node_max_hash = + ext2fs_le32_to_cpu(ent[i+1].hash) & ~1; + else { + dx_db->node_max_hash = 0xfffffffe; + dx_db->flags |= DX_FLAG_LAST; + } + if (i == 0) + dx_db->flags |= DX_FLAG_FIRST; + } +#ifdef DX_DEBUG + printf("Blockcnt = %d, min hash 0x%08x, max hash 0x%08x\n", + db->blockcnt, min_hash, max_hash); +#endif + dx_db = &dx_dir->dx_block[db->blockcnt]; + dx_db->min_hash = min_hash; + dx_db->max_hash = max_hash; + return; + +clear_and_exit: + clear_htree(cd->ctx, cd->pctx.ino); + dx_dir->numblocks = 0; +} +#endif /* ENABLE_HTREE */ + +/* + * Given a busted directory, try to salvage it somehow. + * + */ +static void salvage_directory(ext2_filsys fs, + struct ext2_dir_entry *dirent, + struct ext2_dir_entry *prev, + unsigned int *offset) +{ + char *cp = (char *) dirent; + int left = fs->blocksize - *offset - dirent->rec_len; + int name_len = dirent->name_len & 0xFF; + + /* + * Special case of directory entry of size 8: copy what's left + * of the directory block up to cover up the invalid hole. + */ + if ((left >= 12) && (dirent->rec_len == 8)) { + memmove(cp, cp+8, left); + memset(cp + left, 0, 8); + return; + } + /* + * If the directory entry overruns the end of the directory + * block, and the name is small enough to fit, then adjust the + * record length. + */ + if ((left < 0) && + (name_len + 8 <= dirent->rec_len + left) && + dirent->inode <= fs->super->s_inodes_count && + strnlen(dirent->name, name_len) == name_len) { + dirent->rec_len += left; + return; + } + /* + * If the directory entry is a multiple of four, so it is + * valid, let the previous directory entry absorb the invalid + * one. + */ + if (prev && dirent->rec_len && (dirent->rec_len % 4) == 0) { + prev->rec_len += dirent->rec_len; + *offset += dirent->rec_len; + return; + } + /* + * Default salvage method --- kill all of the directory + * entries for the rest of the block. We will either try to + * absorb it into the previous directory entry, or create a + * new empty directory entry the rest of the directory block. + */ + if (prev) { + prev->rec_len += fs->blocksize - *offset; + *offset = fs->blocksize; + } else { + dirent->rec_len = fs->blocksize - *offset; + dirent->name_len = 0; + dirent->inode = 0; + } +} + +static int check_dir_block(ext2_filsys fs, + struct ext2_db_entry *db, + void *priv_data) +{ + struct dir_info *subdir, *dir; + struct dx_dir_info *dx_dir; +#ifdef ENABLE_HTREE + struct dx_dirblock_info *dx_db = 0; +#endif /* ENABLE_HTREE */ + struct ext2_dir_entry *dirent, *prev; + ext2_dirhash_t hash; + unsigned int offset = 0; + int dir_modified = 0; + int dot_state; + blk_t block_nr = db->blk; + ext2_ino_t ino = db->ino; + __u16 links; + struct check_dir_struct *cd; + char *buf; + e2fsck_t ctx; + int problem; + struct ext2_dx_root_info *root; + struct ext2_dx_countlimit *limit; + static dict_t de_dict; + struct problem_context pctx; + int dups_found = 0; + + cd = (struct check_dir_struct *) priv_data; + buf = cd->buf; + ctx = cd->ctx; + + if (ctx->flags & E2F_FLAG_SIGNAL_MASK) + return DIRENT_ABORT; + + if (ctx->progress && (ctx->progress)(ctx, 2, cd->count++, cd->max)) + return DIRENT_ABORT; + + /* + * Make sure the inode is still in use (could have been + * deleted in the duplicate/bad blocks pass. + */ + if (!(ext2fs_test_inode_bitmap(ctx->inode_used_map, ino))) + return 0; + + cd->pctx.ino = ino; + cd->pctx.blk = block_nr; + cd->pctx.blkcount = db->blockcnt; + cd->pctx.ino2 = 0; + cd->pctx.dirent = 0; + cd->pctx.num = 0; + + if (db->blk == 0) { + if (allocate_dir_block(ctx, db, buf, &cd->pctx)) + return 0; + block_nr = db->blk; + } + + if (db->blockcnt) + dot_state = 2; + else + dot_state = 0; + + if (ctx->dirs_to_hash && + ext2fs_u32_list_test(ctx->dirs_to_hash, ino)) + dups_found++; + +#if 0 + printf("In process_dir_block block %lu, #%d, inode %lu\n", block_nr, + db->blockcnt, ino); +#endif + + cd->pctx.errcode = ext2fs_read_dir_block(fs, block_nr, buf); + if (cd->pctx.errcode == EXT2_ET_DIR_CORRUPTED) + cd->pctx.errcode = 0; /* We'll handle this ourselves */ + if (cd->pctx.errcode) { + if (!fix_problem(ctx, PR_2_READ_DIRBLOCK, &cd->pctx)) { + ctx->flags |= E2F_FLAG_ABORT; + return DIRENT_ABORT; + } + memset(buf, 0, fs->blocksize); + } +#ifdef ENABLE_HTREE + dx_dir = e2fsck_get_dx_dir_info(ctx, ino); + if (dx_dir && dx_dir->numblocks) { + if (db->blockcnt >= dx_dir->numblocks) { + printf("XXX should never happen!!!\n"); + abort(); + } + dx_db = &dx_dir->dx_block[db->blockcnt]; + dx_db->type = DX_DIRBLOCK_LEAF; + dx_db->phys = block_nr; + dx_db->min_hash = ~0; + dx_db->max_hash = 0; + + dirent = (struct ext2_dir_entry *) buf; + limit = (struct ext2_dx_countlimit *) (buf+8); + if (db->blockcnt == 0) { + root = (struct ext2_dx_root_info *) (buf + 24); + dx_db->type = DX_DIRBLOCK_ROOT; + dx_db->flags |= DX_FLAG_FIRST | DX_FLAG_LAST; + if ((root->reserved_zero || + root->info_length < 8 || + root->indirect_levels > 1) && + fix_problem(ctx, PR_2_HTREE_BAD_ROOT, &cd->pctx)) { + clear_htree(ctx, ino); + dx_dir->numblocks = 0; + dx_db = 0; + } + dx_dir->hashversion = root->hash_version; + dx_dir->depth = root->indirect_levels + 1; + } else if ((dirent->inode == 0) && + (dirent->rec_len == fs->blocksize) && + (dirent->name_len == 0) && + (ext2fs_le16_to_cpu(limit->limit) == + ((fs->blocksize-8) / + sizeof(struct ext2_dx_entry)))) + dx_db->type = DX_DIRBLOCK_NODE; + } +#endif /* ENABLE_HTREE */ + + dict_init(&de_dict, DICTCOUNT_T_MAX, dict_de_cmp); + prev = 0; + do { + problem = 0; + dirent = (struct ext2_dir_entry *) (buf + offset); + cd->pctx.dirent = dirent; + cd->pctx.num = offset; + if (((offset + dirent->rec_len) > fs->blocksize) || + (dirent->rec_len < 12) || + ((dirent->rec_len % 4) != 0) || + (((dirent->name_len & 0xFF)+8) > dirent->rec_len)) { + if (fix_problem(ctx, PR_2_DIR_CORRUPTED, &cd->pctx)) { + salvage_directory(fs, dirent, prev, &offset); + dir_modified++; + continue; + } else + goto abort_free_dict; + } + if ((dirent->name_len & 0xFF) > EXT2_NAME_LEN) { + if (fix_problem(ctx, PR_2_FILENAME_LONG, &cd->pctx)) { + dirent->name_len = EXT2_NAME_LEN; + dir_modified++; + } + } + + if (dot_state == 0) { + if (check_dot(ctx, dirent, ino, &cd->pctx)) + dir_modified++; + } else if (dot_state == 1) { + dir = e2fsck_get_dir_info(ctx, ino); + if (!dir) { + fix_problem(ctx, PR_2_NO_DIRINFO, &cd->pctx); + goto abort_free_dict; + } + if (check_dotdot(ctx, dirent, dir, &cd->pctx)) + dir_modified++; + } else if (dirent->inode == ino) { + problem = PR_2_LINK_DOT; + if (fix_problem(ctx, PR_2_LINK_DOT, &cd->pctx)) { + dirent->inode = 0; + dir_modified++; + goto next; + } + } + if (!dirent->inode) + goto next; + + /* + * Make sure the inode listed is a legal one. + */ + if (((dirent->inode != EXT2_ROOT_INO) && + (dirent->inode < EXT2_FIRST_INODE(fs->super))) || + (dirent->inode > fs->super->s_inodes_count)) { + problem = PR_2_BAD_INO; + } else if (!(ext2fs_test_inode_bitmap(ctx->inode_used_map, + dirent->inode))) { + /* + * If the inode is unused, offer to clear it. + */ + problem = PR_2_UNUSED_INODE; + } else if (ctx->inode_bb_map && + (ext2fs_test_inode_bitmap(ctx->inode_bb_map, + dirent->inode))) { + /* + * If the inode is in a bad block, offer to + * clear it. + */ + problem = PR_2_BB_INODE; + } else if ((dot_state > 1) && + ((dirent->name_len & 0xFF) == 1) && + (dirent->name[0] == '.')) { + /* + * If there's a '.' entry in anything other + * than the first directory entry, it's a + * duplicate entry that should be removed. + */ + problem = PR_2_DUP_DOT; + } else if ((dot_state > 1) && + ((dirent->name_len & 0xFF) == 2) && + (dirent->name[0] == '.') && + (dirent->name[1] == '.')) { + /* + * If there's a '..' entry in anything other + * than the second directory entry, it's a + * duplicate entry that should be removed. + */ + problem = PR_2_DUP_DOT_DOT; + } else if ((dot_state > 1) && + (dirent->inode == EXT2_ROOT_INO)) { + /* + * Don't allow links to the root directory. + * We check this specially to make sure we + * catch this error case even if the root + * directory hasn't been created yet. + */ + problem = PR_2_LINK_ROOT; + } else if ((dot_state > 1) && + (dirent->name_len & 0xFF) == 0) { + /* + * Don't allow zero-length directory names. + */ + problem = PR_2_NULL_NAME; + } + + if (problem) { + if (fix_problem(ctx, problem, &cd->pctx)) { + dirent->inode = 0; + dir_modified++; + goto next; + } else { + ext2fs_unmark_valid(fs); + if (problem == PR_2_BAD_INO) + goto next; + } + } + + /* + * If the inode was marked as having bad fields in + * pass1, process it and offer to fix/clear it. + * (We wait until now so that we can display the + * pathname to the user.) + */ + if (ctx->inode_bad_map && + ext2fs_test_inode_bitmap(ctx->inode_bad_map, + dirent->inode)) { + if (e2fsck_process_bad_inode(ctx, ino, + dirent->inode, + buf + fs->blocksize)) { + dirent->inode = 0; + dir_modified++; + goto next; + } + if (ctx->flags & E2F_FLAG_SIGNAL_MASK) + return DIRENT_ABORT; + } + + if (check_name(ctx, dirent, ino, &cd->pctx)) + dir_modified++; + + if (check_filetype(ctx, dirent, ino, &cd->pctx)) + dir_modified++; + +#ifdef ENABLE_HTREE + if (dx_db) { + ext2fs_dirhash(dx_dir->hashversion, dirent->name, + (dirent->name_len & 0xFF), + fs->super->s_hash_seed, &hash, 0); + if (hash < dx_db->min_hash) + dx_db->min_hash = hash; + if (hash > dx_db->max_hash) + dx_db->max_hash = hash; + } +#endif + + /* + * If this is a directory, then mark its parent in its + * dir_info structure. If the parent field is already + * filled in, then this directory has more than one + * hard link. We assume the first link is correct, + * and ask the user if he/she wants to clear this one. + */ + if ((dot_state > 1) && + (ext2fs_test_inode_bitmap(ctx->inode_dir_map, + dirent->inode))) { + subdir = e2fsck_get_dir_info(ctx, dirent->inode); + if (!subdir) { + cd->pctx.ino = dirent->inode; + fix_problem(ctx, PR_2_NO_DIRINFO, &cd->pctx); + goto abort_free_dict; + } + if (subdir->parent) { + cd->pctx.ino2 = subdir->parent; + if (fix_problem(ctx, PR_2_LINK_DIR, + &cd->pctx)) { + dirent->inode = 0; + dir_modified++; + goto next; + } + cd->pctx.ino2 = 0; + } else + subdir->parent = ino; + } + + if (dups_found) { + ; + } else if (dict_lookup(&de_dict, dirent)) { + clear_problem_context(&pctx); + pctx.ino = ino; + pctx.dirent = dirent; + fix_problem(ctx, PR_2_REPORT_DUP_DIRENT, &pctx); + if (!ctx->dirs_to_hash) + ext2fs_u32_list_create(&ctx->dirs_to_hash, 50); + if (ctx->dirs_to_hash) + ext2fs_u32_list_add(ctx->dirs_to_hash, ino); + dups_found++; + } else + dict_alloc_insert(&de_dict, dirent, dirent); + + ext2fs_icount_increment(ctx->inode_count, dirent->inode, + &links); + if (links > 1) + ctx->fs_links_count++; + ctx->fs_total_count++; + next: + prev = dirent; + offset += dirent->rec_len; + dot_state++; + } while (offset < fs->blocksize); +#if 0 + printf("\n"); +#endif +#ifdef ENABLE_HTREE + if (dx_db) { +#ifdef DX_DEBUG + printf("db_block %d, type %d, min_hash 0x%0x, max_hash 0x%0x\n", + db->blockcnt, dx_db->type, + dx_db->min_hash, dx_db->max_hash); +#endif + cd->pctx.dir = cd->pctx.ino; + if ((dx_db->type == DX_DIRBLOCK_ROOT) || + (dx_db->type == DX_DIRBLOCK_NODE)) + parse_int_node(fs, db, cd, dx_dir, buf); + } +#endif /* ENABLE_HTREE */ + if (offset != fs->blocksize) { + cd->pctx.num = dirent->rec_len - fs->blocksize + offset; + if (fix_problem(ctx, PR_2_FINAL_RECLEN, &cd->pctx)) { + dirent->rec_len = cd->pctx.num; + dir_modified++; + } + } + if (dir_modified) { + cd->pctx.errcode = ext2fs_write_dir_block(fs, block_nr, buf); + if (cd->pctx.errcode) { + if (!fix_problem(ctx, PR_2_WRITE_DIRBLOCK, + &cd->pctx)) + goto abort_free_dict; + } + ext2fs_mark_changed(fs); + } + dict_free_nodes(&de_dict); + return 0; +abort_free_dict: + dict_free_nodes(&de_dict); + ctx->flags |= E2F_FLAG_ABORT; + return DIRENT_ABORT; +} + +/* + * This function is called to deallocate a block, and is an interator + * functioned called by deallocate inode via ext2fs_iterate_block(). + */ +static int deallocate_inode_block(ext2_filsys fs, + blk_t *block_nr, + e2_blkcnt_t blockcnt EXT2FS_ATTR((unused)), + blk_t ref_block EXT2FS_ATTR((unused)), + int ref_offset EXT2FS_ATTR((unused)), + void *priv_data) +{ + e2fsck_t ctx = (e2fsck_t) priv_data; + + if (HOLE_BLKADDR(*block_nr)) + return 0; + if ((*block_nr < fs->super->s_first_data_block) || + (*block_nr >= fs->super->s_blocks_count)) + return 0; + ext2fs_unmark_block_bitmap(ctx->block_found_map, *block_nr); + ext2fs_block_alloc_stats(fs, *block_nr, -1); + return 0; +} + +/* + * This fuction deallocates an inode + */ +static void deallocate_inode(e2fsck_t ctx, ext2_ino_t ino, char* block_buf) +{ + ext2_filsys fs = ctx->fs; + struct ext2_inode inode; + struct problem_context pctx; + __u32 count; + + ext2fs_icount_store(ctx->inode_link_info, ino, 0); + e2fsck_read_inode(ctx, ino, &inode, "deallocate_inode"); + inode.i_links_count = 0; + inode.i_dtime = time(0); + e2fsck_write_inode(ctx, ino, &inode, "deallocate_inode"); + clear_problem_context(&pctx); + pctx.ino = ino; + + /* + * Fix up the bitmaps... + */ + e2fsck_read_bitmaps(ctx); + ext2fs_unmark_inode_bitmap(ctx->inode_used_map, ino); + ext2fs_unmark_inode_bitmap(ctx->inode_dir_map, ino); + if (ctx->inode_bad_map) + ext2fs_unmark_inode_bitmap(ctx->inode_bad_map, ino); + ext2fs_inode_alloc_stats2(fs, ino, -1, LINUX_S_ISDIR(inode.i_mode)); + + if (inode.i_file_acl && + (fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_EXT_ATTR)) { + pctx.errcode = ext2fs_adjust_ea_refcount(fs, inode.i_file_acl, + block_buf, -1, &count); + if (pctx.errcode == EXT2_ET_BAD_EA_BLOCK_NUM) { + pctx.errcode = 0; + count = 1; + } + if (pctx.errcode) { + pctx.blk = inode.i_file_acl; + fix_problem(ctx, PR_2_ADJ_EA_REFCOUNT, &pctx); + ctx->flags |= E2F_FLAG_ABORT; + return; + } + if (count == 0) { + ext2fs_unmark_block_bitmap(ctx->block_found_map, + inode.i_file_acl); + ext2fs_block_alloc_stats(fs, inode.i_file_acl, -1); + } + inode.i_file_acl = 0; + } + + if (!ext2fs_inode_has_valid_blocks(&inode)) + return; + + if (LINUX_S_ISREG(inode.i_mode) && + (inode.i_size_high || inode.i_size & 0x80000000UL)) + ctx->large_files--; + + pctx.errcode = ext2fs_block_iterate2(fs, ino, 0, block_buf, + deallocate_inode_block, ctx); + if (pctx.errcode) { + fix_problem(ctx, PR_2_DEALLOC_INODE, &pctx); + ctx->flags |= E2F_FLAG_ABORT; + return; + } +} + +/* + * This fuction clears the htree flag on an inode + */ +static void clear_htree(e2fsck_t ctx, ext2_ino_t ino) +{ + struct ext2_inode inode; + + e2fsck_read_inode(ctx, ino, &inode, "clear_htree"); + inode.i_flags = inode.i_flags & ~EXT2_INDEX_FL; + e2fsck_write_inode(ctx, ino, &inode, "clear_htree"); + if (ctx->dirs_to_hash) + ext2fs_u32_list_add(ctx->dirs_to_hash, ino); +} + + +static int e2fsck_process_bad_inode(e2fsck_t ctx, ext2_ino_t dir, + ext2_ino_t ino, char *buf) +{ + ext2_filsys fs = ctx->fs; + struct ext2_inode inode; + int inode_modified = 0; + int not_fixed = 0; + unsigned char *frag, *fsize; + struct problem_context pctx; + int problem = 0; + + e2fsck_read_inode(ctx, ino, &inode, "process_bad_inode"); + + clear_problem_context(&pctx); + pctx.ino = ino; + pctx.dir = dir; + pctx.inode = &inode; + + if (inode.i_file_acl && + !(fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_EXT_ATTR) && + fix_problem(ctx, PR_2_FILE_ACL_ZERO, &pctx)) { + inode.i_file_acl = 0; +#ifdef EXT2FS_ENABLE_SWAPFS + /* + * This is a special kludge to deal with long symlinks + * on big endian systems. i_blocks had already been + * decremented earlier in pass 1, but since i_file_acl + * hadn't yet been cleared, ext2fs_read_inode() + * assumed that the file was short symlink and would + * not have byte swapped i_block[0]. Hence, we have + * to byte-swap it here. + */ + if (LINUX_S_ISLNK(inode.i_mode) && + (fs->flags & EXT2_FLAG_SWAP_BYTES) && + (inode.i_blocks == fs->blocksize >> 9)) + inode.i_block[0] = ext2fs_swab32(inode.i_block[0]); +#endif + inode_modified++; + } else + not_fixed++; + + if (!LINUX_S_ISDIR(inode.i_mode) && !LINUX_S_ISREG(inode.i_mode) && + !LINUX_S_ISCHR(inode.i_mode) && !LINUX_S_ISBLK(inode.i_mode) && + !LINUX_S_ISLNK(inode.i_mode) && !LINUX_S_ISFIFO(inode.i_mode) && + !(LINUX_S_ISSOCK(inode.i_mode))) + problem = PR_2_BAD_MODE; + else if (LINUX_S_ISCHR(inode.i_mode) + && !e2fsck_pass1_check_device_inode(fs, &inode)) + problem = PR_2_BAD_CHAR_DEV; + else if (LINUX_S_ISBLK(inode.i_mode) + && !e2fsck_pass1_check_device_inode(fs, &inode)) + problem = PR_2_BAD_BLOCK_DEV; + else if (LINUX_S_ISFIFO(inode.i_mode) + && !e2fsck_pass1_check_device_inode(fs, &inode)) + problem = PR_2_BAD_FIFO; + else if (LINUX_S_ISSOCK(inode.i_mode) + && !e2fsck_pass1_check_device_inode(fs, &inode)) + problem = PR_2_BAD_SOCKET; + else if (LINUX_S_ISLNK(inode.i_mode) + && !e2fsck_pass1_check_symlink(fs, &inode, buf)) { + problem = PR_2_INVALID_SYMLINK; + } + + if (problem) { + if (fix_problem(ctx, problem, &pctx)) { + deallocate_inode(ctx, ino, 0); + if (ctx->flags & E2F_FLAG_SIGNAL_MASK) + return 0; + return 1; + } else + not_fixed++; + problem = 0; + } + + if (inode.i_faddr) { + if (fix_problem(ctx, PR_2_FADDR_ZERO, &pctx)) { + inode.i_faddr = 0; + inode_modified++; + } else + not_fixed++; + } + + switch (fs->super->s_creator_os) { + case EXT2_OS_LINUX: + frag = &inode.osd2.linux2.l_i_frag; + fsize = &inode.osd2.linux2.l_i_fsize; + break; + case EXT2_OS_HURD: + frag = &inode.osd2.hurd2.h_i_frag; + fsize = &inode.osd2.hurd2.h_i_fsize; + break; + case EXT2_OS_MASIX: + frag = &inode.osd2.masix2.m_i_frag; + fsize = &inode.osd2.masix2.m_i_fsize; + break; + default: + frag = fsize = 0; + } + if (frag && *frag) { + pctx.num = *frag; + if (fix_problem(ctx, PR_2_FRAG_ZERO, &pctx)) { + *frag = 0; + inode_modified++; + } else + not_fixed++; + pctx.num = 0; + } + if (fsize && *fsize) { + pctx.num = *fsize; + if (fix_problem(ctx, PR_2_FSIZE_ZERO, &pctx)) { + *fsize = 0; + inode_modified++; + } else + not_fixed++; + pctx.num = 0; + } + + if (inode.i_file_acl && + ((inode.i_file_acl < fs->super->s_first_data_block) || + (inode.i_file_acl >= fs->super->s_blocks_count))) { + if (fix_problem(ctx, PR_2_FILE_ACL_BAD, &pctx)) { + inode.i_file_acl = 0; + inode_modified++; + } else + not_fixed++; + } + if (inode.i_dir_acl && + LINUX_S_ISDIR(inode.i_mode)) { + if (fix_problem(ctx, PR_2_DIR_ACL_ZERO, &pctx)) { + inode.i_dir_acl = 0; + inode_modified++; + } else + not_fixed++; + } + + if (inode_modified) + e2fsck_write_inode(ctx, ino, &inode, "process_bad_inode"); + if (!not_fixed) + ext2fs_unmark_inode_bitmap(ctx->inode_bad_map, ino); + return 0; +} + + +/* + * allocate_dir_block --- this function allocates a new directory + * block for a particular inode; this is done if a directory has + * a "hole" in it, or if a directory has a illegal block number + * that was zeroed out and now needs to be replaced. + */ +static int allocate_dir_block(e2fsck_t ctx, + struct ext2_db_entry *db, + char *buf EXT2FS_ATTR((unused)), + struct problem_context *pctx) +{ + ext2_filsys fs = ctx->fs; + blk_t blk; + char *block; + struct ext2_inode inode; + + if (fix_problem(ctx, PR_2_DIRECTORY_HOLE, pctx) == 0) + return 1; + + /* + * Read the inode and block bitmaps in; we'll be messing with + * them. + */ + e2fsck_read_bitmaps(ctx); + + /* + * First, find a free block + */ + pctx->errcode = ext2fs_new_block(fs, 0, ctx->block_found_map, &blk); + if (pctx->errcode) { + pctx->str = "ext2fs_new_block"; + fix_problem(ctx, PR_2_ALLOC_DIRBOCK, pctx); + return 1; + } + ext2fs_mark_block_bitmap(ctx->block_found_map, blk); + ext2fs_mark_block_bitmap(fs->block_map, blk); + ext2fs_mark_bb_dirty(fs); + + /* + * Now let's create the actual data block for the inode + */ + if (db->blockcnt) + pctx->errcode = ext2fs_new_dir_block(fs, 0, 0, &block); + else + pctx->errcode = ext2fs_new_dir_block(fs, db->ino, + EXT2_ROOT_INO, &block); + + if (pctx->errcode) { + pctx->str = "ext2fs_new_dir_block"; + fix_problem(ctx, PR_2_ALLOC_DIRBOCK, pctx); + return 1; + } + + pctx->errcode = ext2fs_write_dir_block(fs, blk, block); + ext2fs_free_mem(&block); + if (pctx->errcode) { + pctx->str = "ext2fs_write_dir_block"; + fix_problem(ctx, PR_2_ALLOC_DIRBOCK, pctx); + return 1; + } + + /* + * Update the inode block count + */ + e2fsck_read_inode(ctx, db->ino, &inode, "allocate_dir_block"); + inode.i_blocks += fs->blocksize / 512; + if (inode.i_size < (db->blockcnt+1) * fs->blocksize) + inode.i_size = (db->blockcnt+1) * fs->blocksize; + e2fsck_write_inode(ctx, db->ino, &inode, "allocate_dir_block"); + + /* + * Finally, update the block pointers for the inode + */ + db->blk = blk; + pctx->errcode = ext2fs_block_iterate2(fs, db->ino, BLOCK_FLAG_HOLE, + 0, update_dir_block, db); + if (pctx->errcode) { + pctx->str = "ext2fs_block_iterate"; + fix_problem(ctx, PR_2_ALLOC_DIRBOCK, pctx); + return 1; + } + + return 0; +} + +/* + * This is a helper function for allocate_dir_block(). + */ +static int update_dir_block(ext2_filsys fs EXT2FS_ATTR((unused)), + blk_t *block_nr, + e2_blkcnt_t blockcnt, + blk_t ref_block EXT2FS_ATTR((unused)), + int ref_offset EXT2FS_ATTR((unused)), + void *priv_data) +{ + struct ext2_db_entry *db; + + db = (struct ext2_db_entry *) priv_data; + if (db->blockcnt == (int) blockcnt) { + *block_nr = db->blk; + return BLOCK_CHANGED; + } + return 0; +} +/* + * pass3.c -- pass #3 of e2fsck: Check for directory connectivity + * + * Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999 Theodore Ts'o. + * + * %Begin-Header% + * This file may be redistributed under the terms of the GNU Public + * License. + * %End-Header% + * + * Pass #3 assures that all directories are connected to the + * filesystem tree, using the following algorithm: + * + * First, the root directory is checked to make sure it exists; if + * not, e2fsck will offer to create a new one. It is then marked as + * "done". + * + * Then, pass3 interates over all directory inodes; for each directory + * it attempts to trace up the filesystem tree, using dirinfo.parent + * until it reaches a directory which has been marked "done". If it + * can not do so, then the directory must be disconnected, and e2fsck + * will offer to reconnect it to /lost+found. While it is chasing + * parent pointers up the filesystem tree, if pass3 sees a directory + * twice, then it has detected a filesystem loop, and it will again + * offer to reconnect the directory to /lost+found in to break the + * filesystem loop. + * + * Pass 3 also contains the subroutine, e2fsck_reconnect_file() to + * reconnect inodes to /lost+found; this subroutine is also used by + * pass 4. e2fsck_reconnect_file() calls get_lost_and_found(), which + * is responsible for creating /lost+found if it does not exist. + * + * Pass 3 frees the following data structures: + * - The dirinfo directory information cache. + */ + +static void check_root(e2fsck_t ctx); +static int check_directory(e2fsck_t ctx, struct dir_info *dir, + struct problem_context *pctx); +static void fix_dotdot(e2fsck_t ctx, struct dir_info *dir, ext2_ino_t parent); + +static ext2fs_inode_bitmap inode_loop_detect = 0; +static ext2fs_inode_bitmap inode_done_map = 0; + +void e2fsck_pass3(e2fsck_t ctx) +{ + ext2_filsys fs = ctx->fs; + int i; +#ifdef RESOURCE_TRACK + struct resource_track rtrack; +#endif + struct problem_context pctx; + struct dir_info *dir; + unsigned long maxdirs, count; + +#ifdef RESOURCE_TRACK + init_resource_track(&rtrack); +#endif + + clear_problem_context(&pctx); + +#ifdef MTRACE + mtrace_print("Pass 3"); +#endif + + if (!(ctx->options & E2F_OPT_PREEN)) + fix_problem(ctx, PR_3_PASS_HEADER, &pctx); + + /* + * Allocate some bitmaps to do loop detection. + */ + pctx.errcode = ext2fs_allocate_inode_bitmap(fs, _("inode done bitmap"), + &inode_done_map); + if (pctx.errcode) { + pctx.num = 2; + fix_problem(ctx, PR_3_ALLOCATE_IBITMAP_ERROR, &pctx); + ctx->flags |= E2F_FLAG_ABORT; + goto abort_exit; + } +#ifdef RESOURCE_TRACK + if (ctx->options & E2F_OPT_TIME) { + e2fsck_clear_progbar(ctx); + print_resource_track(_("Peak memory"), &ctx->global_rtrack); + } +#endif + + check_root(ctx); + if (ctx->flags & E2F_FLAG_SIGNAL_MASK) + goto abort_exit; + + ext2fs_mark_inode_bitmap(inode_done_map, EXT2_ROOT_INO); + + maxdirs = e2fsck_get_num_dirinfo(ctx); + count = 1; + + if (ctx->progress) + if ((ctx->progress)(ctx, 3, 0, maxdirs)) + goto abort_exit; + + for (i=0; (dir = e2fsck_dir_info_iter(ctx, &i)) != 0;) { + if (ctx->flags & E2F_FLAG_SIGNAL_MASK) + goto abort_exit; + if (ctx->progress && (ctx->progress)(ctx, 3, count++, maxdirs)) + goto abort_exit; + if (ext2fs_test_inode_bitmap(ctx->inode_dir_map, dir->ino)) + if (check_directory(ctx, dir, &pctx)) + goto abort_exit; + } + + /* + * Force the creation of /lost+found if not present + */ + if ((ctx->flags & E2F_OPT_READONLY) == 0) + e2fsck_get_lost_and_found(ctx, 1); + + /* + * If there are any directories that need to be indexed or + * optimized, do it here. + */ + e2fsck_rehash_directories(ctx); + +abort_exit: + e2fsck_free_dir_info(ctx); + if (inode_loop_detect) { + ext2fs_free_inode_bitmap(inode_loop_detect); + inode_loop_detect = 0; + } + if (inode_done_map) { + ext2fs_free_inode_bitmap(inode_done_map); + inode_done_map = 0; + } + +#ifdef RESOURCE_TRACK + if (ctx->options & E2F_OPT_TIME2) { + e2fsck_clear_progbar(ctx); + print_resource_track(_("Pass 3"), &rtrack); + } +#endif +} + +/* + * This makes sure the root inode is present; if not, we ask if the + * user wants us to create it. Not creating it is a fatal error. + */ +static void check_root(e2fsck_t ctx) +{ + ext2_filsys fs = ctx->fs; + blk_t blk; + struct ext2_inode inode; + char * block; + struct problem_context pctx; + + clear_problem_context(&pctx); + + if (ext2fs_test_inode_bitmap(ctx->inode_used_map, EXT2_ROOT_INO)) { + /* + * If the root inode is not a directory, die here. The + * user must have answered 'no' in pass1 when we + * offered to clear it. + */ + if (!(ext2fs_test_inode_bitmap(ctx->inode_dir_map, + EXT2_ROOT_INO))) { + fix_problem(ctx, PR_3_ROOT_NOT_DIR_ABORT, &pctx); + ctx->flags |= E2F_FLAG_ABORT; + } + return; + } + + if (!fix_problem(ctx, PR_3_NO_ROOT_INODE, &pctx)) { + fix_problem(ctx, PR_3_NO_ROOT_INODE_ABORT, &pctx); + ctx->flags |= E2F_FLAG_ABORT; + return; + } + + e2fsck_read_bitmaps(ctx); + + /* + * First, find a free block + */ + pctx.errcode = ext2fs_new_block(fs, 0, ctx->block_found_map, &blk); + if (pctx.errcode) { + pctx.str = "ext2fs_new_block"; + fix_problem(ctx, PR_3_CREATE_ROOT_ERROR, &pctx); + ctx->flags |= E2F_FLAG_ABORT; + return; + } + ext2fs_mark_block_bitmap(ctx->block_found_map, blk); + ext2fs_mark_block_bitmap(fs->block_map, blk); + ext2fs_mark_bb_dirty(fs); + + /* + * Now let's create the actual data block for the inode + */ + pctx.errcode = ext2fs_new_dir_block(fs, EXT2_ROOT_INO, EXT2_ROOT_INO, + &block); + if (pctx.errcode) { + pctx.str = "ext2fs_new_dir_block"; + fix_problem(ctx, PR_3_CREATE_ROOT_ERROR, &pctx); + ctx->flags |= E2F_FLAG_ABORT; + return; + } + + pctx.errcode = ext2fs_write_dir_block(fs, blk, block); + if (pctx.errcode) { + pctx.str = "ext2fs_write_dir_block"; + fix_problem(ctx, PR_3_CREATE_ROOT_ERROR, &pctx); + ctx->flags |= E2F_FLAG_ABORT; + return; + } + ext2fs_free_mem(&block); + + /* + * Set up the inode structure + */ + memset(&inode, 0, sizeof(inode)); + inode.i_mode = 040755; + inode.i_size = fs->blocksize; + inode.i_atime = inode.i_ctime = inode.i_mtime = time(0); + inode.i_links_count = 2; + inode.i_blocks = fs->blocksize / 512; + inode.i_block[0] = blk; + + /* + * Write out the inode. + */ + pctx.errcode = ext2fs_write_new_inode(fs, EXT2_ROOT_INO, &inode); + if (pctx.errcode) { + pctx.str = "ext2fs_write_inode"; + fix_problem(ctx, PR_3_CREATE_ROOT_ERROR, &pctx); + ctx->flags |= E2F_FLAG_ABORT; + return; + } + + /* + * Miscellaneous bookkeeping... + */ + e2fsck_add_dir_info(ctx, EXT2_ROOT_INO, EXT2_ROOT_INO); + ext2fs_icount_store(ctx->inode_count, EXT2_ROOT_INO, 2); + ext2fs_icount_store(ctx->inode_link_info, EXT2_ROOT_INO, 2); + + ext2fs_mark_inode_bitmap(ctx->inode_used_map, EXT2_ROOT_INO); + ext2fs_mark_inode_bitmap(ctx->inode_dir_map, EXT2_ROOT_INO); + ext2fs_mark_inode_bitmap(fs->inode_map, EXT2_ROOT_INO); + ext2fs_mark_ib_dirty(fs); +} + +/* + * This subroutine is responsible for making sure that a particular + * directory is connected to the root; if it isn't we trace it up as + * far as we can go, and then offer to connect the resulting parent to + * the lost+found. We have to do loop detection; if we ever discover + * a loop, we treat that as a disconnected directory and offer to + * reparent it to lost+found. + * + * However, loop detection is expensive, because for very large + * filesystems, the inode_loop_detect bitmap is huge, and clearing it + * is non-trivial. Loops in filesystems are also a rare error case, + * and we shouldn't optimize for error cases. So we try two passes of + * the algorithm. The first time, we ignore loop detection and merely + * increment a counter; if the counter exceeds some extreme threshold, + * then we try again with the loop detection bitmap enabled. + */ +static int check_directory(e2fsck_t ctx, struct dir_info *dir, + struct problem_context *pctx) +{ + ext2_filsys fs = ctx->fs; + struct dir_info *p = dir; + int loop_pass = 0, parent_count = 0; + + if (!p) + return 0; + + while (1) { + /* + * Mark this inode as being "done"; by the time we + * return from this function, the inode we either be + * verified as being connected to the directory tree, + * or we will have offered to reconnect this to + * lost+found. + * + * If it was marked done already, then we've reached a + * parent we've already checked. + */ + if (ext2fs_mark_inode_bitmap(inode_done_map, p->ino)) + break; + + /* + * If this directory doesn't have a parent, or we've + * seen the parent once already, then offer to + * reparent it to lost+found + */ + if (!p->parent || + (loop_pass && + (ext2fs_test_inode_bitmap(inode_loop_detect, + p->parent)))) { + pctx->ino = p->ino; + if (fix_problem(ctx, PR_3_UNCONNECTED_DIR, pctx)) { + if (e2fsck_reconnect_file(ctx, pctx->ino)) + ext2fs_unmark_valid(fs); + else { + p = e2fsck_get_dir_info(ctx, pctx->ino); + p->parent = ctx->lost_and_found; + fix_dotdot(ctx, p, ctx->lost_and_found); + } + } + break; + } + p = e2fsck_get_dir_info(ctx, p->parent); + if (!p) { + fix_problem(ctx, PR_3_NO_DIRINFO, pctx); + return 0; + } + if (loop_pass) { + ext2fs_mark_inode_bitmap(inode_loop_detect, + p->ino); + } else if (parent_count++ > 2048) { + /* + * If we've run into a path depth that's + * greater than 2048, try again with the inode + * loop bitmap turned on and start from the + * top. + */ + loop_pass = 1; + if (inode_loop_detect) + ext2fs_clear_inode_bitmap(inode_loop_detect); + else { + pctx->errcode = ext2fs_allocate_inode_bitmap(fs, _("inode loop detection bitmap"), &inode_loop_detect); + if (pctx->errcode) { + pctx->num = 1; + fix_problem(ctx, + PR_3_ALLOCATE_IBITMAP_ERROR, pctx); + ctx->flags |= E2F_FLAG_ABORT; + return -1; + } + } + p = dir; + } + } + + /* + * Make sure that .. and the parent directory are the same; + * offer to fix it if not. + */ + if (dir->parent != dir->dotdot) { + pctx->ino = dir->ino; + pctx->ino2 = dir->dotdot; + pctx->dir = dir->parent; + if (fix_problem(ctx, PR_3_BAD_DOT_DOT, pctx)) + fix_dotdot(ctx, dir, dir->parent); + } + return 0; +} + +/* + * This routine gets the lost_and_found inode, making it a directory + * if necessary + */ +ext2_ino_t e2fsck_get_lost_and_found(e2fsck_t ctx, int fix) +{ + ext2_filsys fs = ctx->fs; + ext2_ino_t ino; + blk_t blk; + errcode_t retval; + struct ext2_inode inode; + char * block; + static const char name[] = "lost+found"; + struct problem_context pctx; + struct dir_info *dirinfo; + + if (ctx->lost_and_found) + return ctx->lost_and_found; + + clear_problem_context(&pctx); + + retval = ext2fs_lookup(fs, EXT2_ROOT_INO, name, + sizeof(name)-1, 0, &ino); + if (retval && !fix) + return 0; + if (!retval) { + if (ext2fs_test_inode_bitmap(ctx->inode_dir_map, ino)) { + ctx->lost_and_found = ino; + return ino; + } + + /* Lost+found isn't a directory! */ + if (!fix) + return 0; + pctx.ino = ino; + if (!fix_problem(ctx, PR_3_LPF_NOTDIR, &pctx)) + return 0; + + /* OK, unlink the old /lost+found file. */ + pctx.errcode = ext2fs_unlink(fs, EXT2_ROOT_INO, name, ino, 0); + if (pctx.errcode) { + pctx.str = "ext2fs_unlink"; + fix_problem(ctx, PR_3_CREATE_LPF_ERROR, &pctx); + return 0; + } + dirinfo = e2fsck_get_dir_info(ctx, ino); + if (dirinfo) + dirinfo->parent = 0; + e2fsck_adjust_inode_count(ctx, ino, -1); + } else if (retval != EXT2_ET_FILE_NOT_FOUND) { + pctx.errcode = retval; + fix_problem(ctx, PR_3_ERR_FIND_LPF, &pctx); + } + if (!fix_problem(ctx, PR_3_NO_LF_DIR, 0)) + return 0; + + /* + * Read the inode and block bitmaps in; we'll be messing with + * them. + */ + e2fsck_read_bitmaps(ctx); + + /* + * First, find a free block + */ + retval = ext2fs_new_block(fs, 0, ctx->block_found_map, &blk); + if (retval) { + pctx.errcode = retval; + fix_problem(ctx, PR_3_ERR_LPF_NEW_BLOCK, &pctx); + return 0; + } + ext2fs_mark_block_bitmap(ctx->block_found_map, blk); + ext2fs_block_alloc_stats(fs, blk, +1); + + /* + * Next find a free inode. + */ + retval = ext2fs_new_inode(fs, EXT2_ROOT_INO, 040700, + ctx->inode_used_map, &ino); + if (retval) { + pctx.errcode = retval; + fix_problem(ctx, PR_3_ERR_LPF_NEW_INODE, &pctx); + return 0; + } + ext2fs_mark_inode_bitmap(ctx->inode_used_map, ino); + ext2fs_mark_inode_bitmap(ctx->inode_dir_map, ino); + ext2fs_inode_alloc_stats2(fs, ino, +1, 1); + + /* + * Now let's create the actual data block for the inode + */ + retval = ext2fs_new_dir_block(fs, ino, EXT2_ROOT_INO, &block); + if (retval) { + pctx.errcode = retval; + fix_problem(ctx, PR_3_ERR_LPF_NEW_DIR_BLOCK, &pctx); + return 0; + } + + retval = ext2fs_write_dir_block(fs, blk, block); + ext2fs_free_mem(&block); + if (retval) { + pctx.errcode = retval; + fix_problem(ctx, PR_3_ERR_LPF_WRITE_BLOCK, &pctx); + return 0; + } + + /* + * Set up the inode structure + */ + memset(&inode, 0, sizeof(inode)); + inode.i_mode = 040700; + inode.i_size = fs->blocksize; + inode.i_atime = inode.i_ctime = inode.i_mtime = time(0); + inode.i_links_count = 2; + inode.i_blocks = fs->blocksize / 512; + inode.i_block[0] = blk; + + /* + * Next, write out the inode. + */ + pctx.errcode = ext2fs_write_new_inode(fs, ino, &inode); + if (pctx.errcode) { + pctx.str = "ext2fs_write_inode"; + fix_problem(ctx, PR_3_CREATE_LPF_ERROR, &pctx); + return 0; + } + /* + * Finally, create the directory link + */ + pctx.errcode = ext2fs_link(fs, EXT2_ROOT_INO, name, ino, EXT2_FT_DIR); + if (pctx.errcode) { + pctx.str = "ext2fs_link"; + fix_problem(ctx, PR_3_CREATE_LPF_ERROR, &pctx); + return 0; + } + + /* + * Miscellaneous bookkeeping that needs to be kept straight. + */ + e2fsck_add_dir_info(ctx, ino, EXT2_ROOT_INO); + e2fsck_adjust_inode_count(ctx, EXT2_ROOT_INO, 1); + ext2fs_icount_store(ctx->inode_count, ino, 2); + ext2fs_icount_store(ctx->inode_link_info, ino, 2); + ctx->lost_and_found = ino; +#if 0 + printf("/lost+found created; inode #%lu\n", ino); +#endif + return ino; +} + +/* + * This routine will connect a file to lost+found + */ +int e2fsck_reconnect_file(e2fsck_t ctx, ext2_ino_t ino) +{ + ext2_filsys fs = ctx->fs; + errcode_t retval; + char name[80]; + struct problem_context pctx; + struct ext2_inode inode; + int file_type = 0; + + clear_problem_context(&pctx); + pctx.ino = ino; + + if (!ctx->bad_lost_and_found && !ctx->lost_and_found) { + if (e2fsck_get_lost_and_found(ctx, 1) == 0) + ctx->bad_lost_and_found++; + } + if (ctx->bad_lost_and_found) { + fix_problem(ctx, PR_3_NO_LPF, &pctx); + return 1; + } + + sprintf(name, "#%u", ino); + if (ext2fs_read_inode(fs, ino, &inode) == 0) + file_type = ext2_file_type(inode.i_mode); + retval = ext2fs_link(fs, ctx->lost_and_found, name, ino, file_type); + if (retval == EXT2_ET_DIR_NO_SPACE) { + if (!fix_problem(ctx, PR_3_EXPAND_LF_DIR, &pctx)) + return 1; + retval = e2fsck_expand_directory(ctx, ctx->lost_and_found, + 1, 0); + if (retval) { + pctx.errcode = retval; + fix_problem(ctx, PR_3_CANT_EXPAND_LPF, &pctx); + return 1; + } + retval = ext2fs_link(fs, ctx->lost_and_found, name, + ino, file_type); + } + if (retval) { + pctx.errcode = retval; + fix_problem(ctx, PR_3_CANT_RECONNECT, &pctx); + return 1; + } + e2fsck_adjust_inode_count(ctx, ino, 1); + + return 0; +} + +/* + * Utility routine to adjust the inode counts on an inode. + */ +errcode_t e2fsck_adjust_inode_count(e2fsck_t ctx, ext2_ino_t ino, int adj) +{ + ext2_filsys fs = ctx->fs; + errcode_t retval; + struct ext2_inode inode; + + if (!ino) + return 0; + + retval = ext2fs_read_inode(fs, ino, &inode); + if (retval) + return retval; + +#if 0 + printf("Adjusting link count for inode %lu by %d (from %d)\n", ino, adj, + inode.i_links_count); +#endif + + if (adj == 1) { + ext2fs_icount_increment(ctx->inode_count, ino, 0); + if (inode.i_links_count == (__u16) ~0) + return 0; + ext2fs_icount_increment(ctx->inode_link_info, ino, 0); + inode.i_links_count++; + } else if (adj == -1) { + ext2fs_icount_decrement(ctx->inode_count, ino, 0); + if (inode.i_links_count == 0) + return 0; + ext2fs_icount_decrement(ctx->inode_link_info, ino, 0); + inode.i_links_count--; + } + + retval = ext2fs_write_inode(fs, ino, &inode); + if (retval) + return retval; + + return 0; +} + +/* + * Fix parent --- this routine fixes up the parent of a directory. + */ +struct fix_dotdot_struct { + ext2_filsys fs; + ext2_ino_t parent; + int done; + e2fsck_t ctx; +}; + +static int fix_dotdot_proc(struct ext2_dir_entry *dirent, + int offset EXT2FS_ATTR((unused)), + int blocksize EXT2FS_ATTR((unused)), + char *buf EXT2FS_ATTR((unused)), + void *priv_data) +{ + struct fix_dotdot_struct *fp = (struct fix_dotdot_struct *) priv_data; + errcode_t retval; + struct problem_context pctx; + + if ((dirent->name_len & 0xFF) != 2) + return 0; + if (strncmp(dirent->name, "..", 2)) + return 0; + + clear_problem_context(&pctx); + + retval = e2fsck_adjust_inode_count(fp->ctx, dirent->inode, -1); + if (retval) { + pctx.errcode = retval; + fix_problem(fp->ctx, PR_3_ADJUST_INODE, &pctx); + } + retval = e2fsck_adjust_inode_count(fp->ctx, fp->parent, 1); + if (retval) { + pctx.errcode = retval; + fix_problem(fp->ctx, PR_3_ADJUST_INODE, &pctx); + } + dirent->inode = fp->parent; + + fp->done++; + return DIRENT_ABORT | DIRENT_CHANGED; +} + +static void fix_dotdot(e2fsck_t ctx, struct dir_info *dir, ext2_ino_t parent) +{ + ext2_filsys fs = ctx->fs; + errcode_t retval; + struct fix_dotdot_struct fp; + struct problem_context pctx; + + fp.fs = fs; + fp.parent = parent; + fp.done = 0; + fp.ctx = ctx; + +#if 0 + printf("Fixing '..' of inode %lu to be %lu...\n", dir->ino, parent); +#endif + + retval = ext2fs_dir_iterate(fs, dir->ino, DIRENT_FLAG_INCLUDE_EMPTY, + 0, fix_dotdot_proc, &fp); + if (retval || !fp.done) { + clear_problem_context(&pctx); + pctx.ino = dir->ino; + pctx.errcode = retval; + fix_problem(ctx, retval ? PR_3_FIX_PARENT_ERR : + PR_3_FIX_PARENT_NOFIND, &pctx); + ext2fs_unmark_valid(fs); + } + dir->dotdot = parent; + + return; +} + +/* + * These routines are responsible for expanding a /lost+found if it is + * too small. + */ + +struct expand_dir_struct { + int num; + int guaranteed_size; + int newblocks; + int last_block; + errcode_t err; + e2fsck_t ctx; +}; + +static int expand_dir_proc(ext2_filsys fs, + blk_t *blocknr, + e2_blkcnt_t blockcnt, + blk_t ref_block EXT2FS_ATTR((unused)), + int ref_offset EXT2FS_ATTR((unused)), + void *priv_data) +{ + struct expand_dir_struct *es = (struct expand_dir_struct *) priv_data; + blk_t new_blk; + static blk_t last_blk = 0; + char *block; + errcode_t retval; + e2fsck_t ctx; + + ctx = es->ctx; + + if (es->guaranteed_size && blockcnt >= es->guaranteed_size) + return BLOCK_ABORT; + + if (blockcnt > 0) + es->last_block = blockcnt; + if (*blocknr) { + last_blk = *blocknr; + return 0; + } + retval = ext2fs_new_block(fs, last_blk, ctx->block_found_map, + &new_blk); + if (retval) { + es->err = retval; + return BLOCK_ABORT; + } + if (blockcnt > 0) { + retval = ext2fs_new_dir_block(fs, 0, 0, &block); + if (retval) { + es->err = retval; + return BLOCK_ABORT; + } + es->num--; + retval = ext2fs_write_dir_block(fs, new_blk, block); + } else { + retval = ext2fs_get_mem(fs->blocksize, &block); + if (retval) { + es->err = retval; + return BLOCK_ABORT; + } + memset(block, 0, fs->blocksize); + retval = io_channel_write_blk(fs->io, new_blk, 1, block); + } + if (retval) { + es->err = retval; + return BLOCK_ABORT; + } + ext2fs_free_mem(&block); + *blocknr = new_blk; + ext2fs_mark_block_bitmap(ctx->block_found_map, new_blk); + ext2fs_block_alloc_stats(fs, new_blk, +1); + es->newblocks++; + + if (es->num == 0) + return (BLOCK_CHANGED | BLOCK_ABORT); + else + return BLOCK_CHANGED; +} + +errcode_t e2fsck_expand_directory(e2fsck_t ctx, ext2_ino_t dir, + int num, int guaranteed_size) +{ + ext2_filsys fs = ctx->fs; + errcode_t retval; + struct expand_dir_struct es; + struct ext2_inode inode; + + if (!(fs->flags & EXT2_FLAG_RW)) + return EXT2_ET_RO_FILSYS; + + /* + * Read the inode and block bitmaps in; we'll be messing with + * them. + */ + e2fsck_read_bitmaps(ctx); + + retval = ext2fs_check_directory(fs, dir); + if (retval) + return retval; + + es.num = num; + es.guaranteed_size = guaranteed_size; + es.last_block = 0; + es.err = 0; + es.newblocks = 0; + es.ctx = ctx; + + retval = ext2fs_block_iterate2(fs, dir, BLOCK_FLAG_APPEND, + 0, expand_dir_proc, &es); + + if (es.err) + return es.err; + + /* + * Update the size and block count fields in the inode. + */ + retval = ext2fs_read_inode(fs, dir, &inode); + if (retval) + return retval; + + inode.i_size = (es.last_block + 1) * fs->blocksize; + inode.i_blocks += (fs->blocksize / 512) * es.newblocks; + + e2fsck_write_inode(ctx, dir, &inode, "expand_directory"); + + return 0; +} + +/* + * pass4.c -- pass #4 of e2fsck: Check reference counts + * + * Copyright (C) 1993, 1994, 1995, 1996, 1997 Theodore Ts'o. + * + * %Begin-Header% + * This file may be redistributed under the terms of the GNU Public + * License. + * %End-Header% + * + * Pass 4 frees the following data structures: + * - A bitmap of which inodes are in bad blocks. (inode_bb_map) + * - A bitmap of which inodes are imagic inodes. (inode_imagic_map) + */ + +/* + * This routine is called when an inode is not connected to the + * directory tree. + * + * This subroutine returns 1 then the caller shouldn't bother with the + * rest of the pass 4 tests. + */ +static int disconnect_inode(e2fsck_t ctx, ext2_ino_t i) +{ + ext2_filsys fs = ctx->fs; + struct ext2_inode inode; + struct problem_context pctx; + + e2fsck_read_inode(ctx, i, &inode, "pass4: disconnect_inode"); + clear_problem_context(&pctx); + pctx.ino = i; + pctx.inode = &inode; + + /* + * Offer to delete any zero-length files that does not have + * blocks. If there is an EA block, it might have useful + * information, so we won't prompt to delete it, but let it be + * reconnected to lost+found. + */ + if (!inode.i_blocks && (LINUX_S_ISREG(inode.i_mode) || + LINUX_S_ISDIR(inode.i_mode))) { + if (fix_problem(ctx, PR_4_ZERO_LEN_INODE, &pctx)) { + ext2fs_icount_store(ctx->inode_link_info, i, 0); + inode.i_links_count = 0; + inode.i_dtime = time(0); + e2fsck_write_inode(ctx, i, &inode, + "disconnect_inode"); + /* + * Fix up the bitmaps... + */ + e2fsck_read_bitmaps(ctx); + ext2fs_unmark_inode_bitmap(ctx->inode_used_map, i); + ext2fs_unmark_inode_bitmap(ctx->inode_dir_map, i); + ext2fs_inode_alloc_stats2(fs, i, -1, + LINUX_S_ISDIR(inode.i_mode)); + return 0; + } + } + + /* + * Prompt to reconnect. + */ + if (fix_problem(ctx, PR_4_UNATTACHED_INODE, &pctx)) { + if (e2fsck_reconnect_file(ctx, i)) + ext2fs_unmark_valid(fs); + } else { + /* + * If we don't attach the inode, then skip the + * i_links_test since there's no point in trying to + * force i_links_count to zero. + */ + ext2fs_unmark_valid(fs); + return 1; + } + return 0; +} + + +void e2fsck_pass4(e2fsck_t ctx) +{ + ext2_filsys fs = ctx->fs; + ext2_ino_t i; + struct ext2_inode inode; +#ifdef RESOURCE_TRACK + struct resource_track rtrack; +#endif + struct problem_context pctx; + __u16 link_count, link_counted; + char *buf = 0; + int group, maxgroup; + +#ifdef RESOURCE_TRACK + init_resource_track(&rtrack); +#endif + +#ifdef MTRACE + mtrace_print("Pass 4"); +#endif + + clear_problem_context(&pctx); + + if (!(ctx->options & E2F_OPT_PREEN)) + fix_problem(ctx, PR_4_PASS_HEADER, &pctx); + + group = 0; + maxgroup = fs->group_desc_count; + if (ctx->progress) + if ((ctx->progress)(ctx, 4, 0, maxgroup)) + return; + + for (i=1; i <= fs->super->s_inodes_count; i++) { + if (ctx->flags & E2F_FLAG_SIGNAL_MASK) + return; + if ((i % fs->super->s_inodes_per_group) == 0) { + group++; + if (ctx->progress) + if ((ctx->progress)(ctx, 4, group, maxgroup)) + return; + } + if (i == EXT2_BAD_INO || + (i > EXT2_ROOT_INO && i < EXT2_FIRST_INODE(fs->super))) + continue; + if (!(ext2fs_test_inode_bitmap(ctx->inode_used_map, i)) || + (ctx->inode_imagic_map && + ext2fs_test_inode_bitmap(ctx->inode_imagic_map, i)) || + (ctx->inode_bb_map && + ext2fs_test_inode_bitmap(ctx->inode_bb_map, i))) + continue; + ext2fs_icount_fetch(ctx->inode_link_info, i, &link_count); + ext2fs_icount_fetch(ctx->inode_count, i, &link_counted); + if (link_counted == 0) { + if (!buf) + buf = e2fsck_allocate_memory(ctx, + fs->blocksize, "bad_inode buffer"); + if (e2fsck_process_bad_inode(ctx, 0, i, buf)) + continue; + if (disconnect_inode(ctx, i)) + continue; + ext2fs_icount_fetch(ctx->inode_link_info, i, + &link_count); + ext2fs_icount_fetch(ctx->inode_count, i, + &link_counted); + } + if (link_counted != link_count) { + e2fsck_read_inode(ctx, i, &inode, "pass4"); + pctx.ino = i; + pctx.inode = &inode; + if (link_count != inode.i_links_count) { + pctx.num = link_count; + fix_problem(ctx, + PR_4_INCONSISTENT_COUNT, &pctx); + } + pctx.num = link_counted; + if (fix_problem(ctx, PR_4_BAD_REF_COUNT, &pctx)) { + inode.i_links_count = link_counted; + e2fsck_write_inode(ctx, i, &inode, "pass4"); + } + } + } + ext2fs_free_icount(ctx->inode_link_info); ctx->inode_link_info = 0; + ext2fs_free_icount(ctx->inode_count); ctx->inode_count = 0; + ext2fs_free_inode_bitmap(ctx->inode_bb_map); + ctx->inode_bb_map = 0; + ext2fs_free_inode_bitmap(ctx->inode_imagic_map); + ctx->inode_imagic_map = 0; + if (buf) + ext2fs_free_mem(&buf); +#ifdef RESOURCE_TRACK + if (ctx->options & E2F_OPT_TIME2) { + e2fsck_clear_progbar(ctx); + print_resource_track(_("Pass 4"), &rtrack); + } +#endif +} + +/* + * pass5.c --- check block and inode bitmaps against on-disk bitmaps + * + * Copyright (C) 1993, 1994, 1995, 1996, 1997 Theodore Ts'o. + * + * %Begin-Header% + * This file may be redistributed under the terms of the GNU Public + * License. + * %End-Header% + * + */ + +static void check_block_bitmaps(e2fsck_t ctx); +static void check_inode_bitmaps(e2fsck_t ctx); +static void check_inode_end(e2fsck_t ctx); +static void check_block_end(e2fsck_t ctx); + +void e2fsck_pass5(e2fsck_t ctx) +{ +#ifdef RESOURCE_TRACK + struct resource_track rtrack; +#endif + struct problem_context pctx; + +#ifdef MTRACE + mtrace_print("Pass 5"); +#endif + +#ifdef RESOURCE_TRACK + init_resource_track(&rtrack); +#endif + + clear_problem_context(&pctx); + + if (!(ctx->options & E2F_OPT_PREEN)) + fix_problem(ctx, PR_5_PASS_HEADER, &pctx); + + if (ctx->progress) + if ((ctx->progress)(ctx, 5, 0, ctx->fs->group_desc_count*2)) + return; + + e2fsck_read_bitmaps(ctx); + + check_block_bitmaps(ctx); + if (ctx->flags & E2F_FLAG_SIGNAL_MASK) + return; + check_inode_bitmaps(ctx); + if (ctx->flags & E2F_FLAG_SIGNAL_MASK) + return; + check_inode_end(ctx); + if (ctx->flags & E2F_FLAG_SIGNAL_MASK) + return; + check_block_end(ctx); + if (ctx->flags & E2F_FLAG_SIGNAL_MASK) + return; + + ext2fs_free_inode_bitmap(ctx->inode_used_map); + ctx->inode_used_map = 0; + ext2fs_free_inode_bitmap(ctx->inode_dir_map); + ctx->inode_dir_map = 0; + ext2fs_free_block_bitmap(ctx->block_found_map); + ctx->block_found_map = 0; + +#ifdef RESOURCE_TRACK + if (ctx->options & E2F_OPT_TIME2) { + e2fsck_clear_progbar(ctx); + print_resource_track(_("Pass 5"), &rtrack); + } +#endif +} + +#define NO_BLK ((blk_t) -1) + +static void print_bitmap_problem(e2fsck_t ctx, int problem, + struct problem_context *pctx) +{ + switch (problem) { + case PR_5_BLOCK_UNUSED: + if (pctx->blk == pctx->blk2) + pctx->blk2 = 0; + else + problem = PR_5_BLOCK_RANGE_UNUSED; + break; + case PR_5_BLOCK_USED: + if (pctx->blk == pctx->blk2) + pctx->blk2 = 0; + else + problem = PR_5_BLOCK_RANGE_USED; + break; + case PR_5_INODE_UNUSED: + if (pctx->ino == pctx->ino2) + pctx->ino2 = 0; + else + problem = PR_5_INODE_RANGE_UNUSED; + break; + case PR_5_INODE_USED: + if (pctx->ino == pctx->ino2) + pctx->ino2 = 0; + else + problem = PR_5_INODE_RANGE_USED; + break; + } + fix_problem(ctx, problem, pctx); + pctx->blk = pctx->blk2 = NO_BLK; + pctx->ino = pctx->ino2 = 0; +} + +static void check_block_bitmaps(e2fsck_t ctx) +{ + ext2_filsys fs = ctx->fs; + blk_t i; + int *free_array; + int group = 0; + unsigned int blocks = 0; + unsigned int free_blocks = 0; + int group_free = 0; + int actual, bitmap; + struct problem_context pctx; + int problem, save_problem, fixit, had_problem; + errcode_t retval; + + clear_problem_context(&pctx); + free_array = (int *) e2fsck_allocate_memory(ctx, + fs->group_desc_count * sizeof(int), "free block count array"); + + if ((fs->super->s_first_data_block < + ext2fs_get_block_bitmap_start(ctx->block_found_map)) || + (fs->super->s_blocks_count-1 > + ext2fs_get_block_bitmap_end(ctx->block_found_map))) { + pctx.num = 1; + pctx.blk = fs->super->s_first_data_block; + pctx.blk2 = fs->super->s_blocks_count -1; + pctx.ino = ext2fs_get_block_bitmap_start(ctx->block_found_map); + pctx.ino2 = ext2fs_get_block_bitmap_end(ctx->block_found_map); + fix_problem(ctx, PR_5_BMAP_ENDPOINTS, &pctx); + + ctx->flags |= E2F_FLAG_ABORT; /* fatal */ + return; + } + + if ((fs->super->s_first_data_block < + ext2fs_get_block_bitmap_start(fs->block_map)) || + (fs->super->s_blocks_count-1 > + ext2fs_get_block_bitmap_end(fs->block_map))) { + pctx.num = 2; + pctx.blk = fs->super->s_first_data_block; + pctx.blk2 = fs->super->s_blocks_count -1; + pctx.ino = ext2fs_get_block_bitmap_start(fs->block_map); + pctx.ino2 = ext2fs_get_block_bitmap_end(fs->block_map); + fix_problem(ctx, PR_5_BMAP_ENDPOINTS, &pctx); + + ctx->flags |= E2F_FLAG_ABORT; /* fatal */ + return; + } + +redo_counts: + had_problem = 0; + save_problem = 0; + pctx.blk = pctx.blk2 = NO_BLK; + for (i = fs->super->s_first_data_block; + i < fs->super->s_blocks_count; + i++) { + actual = ext2fs_fast_test_block_bitmap(ctx->block_found_map, i); + bitmap = ext2fs_fast_test_block_bitmap(fs->block_map, i); + + if (actual == bitmap) + goto do_counts; + + if (!actual && bitmap) { + /* + * Block not used, but marked in use in the bitmap. + */ + problem = PR_5_BLOCK_UNUSED; + } else { + /* + * Block used, but not marked in use in the bitmap. + */ + problem = PR_5_BLOCK_USED; + } + if (pctx.blk == NO_BLK) { + pctx.blk = pctx.blk2 = i; + save_problem = problem; + } else { + if ((problem == save_problem) && + (pctx.blk2 == i-1)) + pctx.blk2++; + else { + print_bitmap_problem(ctx, save_problem, &pctx); + pctx.blk = pctx.blk2 = i; + save_problem = problem; + } + } + ctx->flags |= E2F_FLAG_PROG_SUPPRESS; + had_problem++; + + do_counts: + if (!bitmap) { + group_free++; + free_blocks++; + } + blocks ++; + if ((blocks == fs->super->s_blocks_per_group) || + (i == fs->super->s_blocks_count-1)) { + free_array[group] = group_free; + group ++; + blocks = 0; + group_free = 0; + if (ctx->progress) + if ((ctx->progress)(ctx, 5, group, + fs->group_desc_count*2)) + return; + } + } + if (pctx.blk != NO_BLK) + print_bitmap_problem(ctx, save_problem, &pctx); + if (had_problem) + fixit = end_problem_latch(ctx, PR_LATCH_BBITMAP); + else + fixit = -1; + ctx->flags &= ~E2F_FLAG_PROG_SUPPRESS; + + if (fixit == 1) { + ext2fs_free_block_bitmap(fs->block_map); + retval = ext2fs_copy_bitmap(ctx->block_found_map, + &fs->block_map); + if (retval) { + clear_problem_context(&pctx); + fix_problem(ctx, PR_5_COPY_BBITMAP_ERROR, &pctx); + ctx->flags |= E2F_FLAG_ABORT; + return; + } + ext2fs_set_bitmap_padding(fs->block_map); + ext2fs_mark_bb_dirty(fs); + + /* Redo the counts */ + blocks = 0; free_blocks = 0; group_free = 0; group = 0; + memset(free_array, 0, fs->group_desc_count * sizeof(int)); + goto redo_counts; + } else if (fixit == 0) + ext2fs_unmark_valid(fs); + + for (i = 0; i < fs->group_desc_count; i++) { + if (free_array[i] != fs->group_desc[i].bg_free_blocks_count) { + pctx.group = i; + pctx.blk = fs->group_desc[i].bg_free_blocks_count; + pctx.blk2 = free_array[i]; + + if (fix_problem(ctx, PR_5_FREE_BLOCK_COUNT_GROUP, + &pctx)) { + fs->group_desc[i].bg_free_blocks_count = + free_array[i]; + ext2fs_mark_super_dirty(fs); + } else + ext2fs_unmark_valid(fs); + } + } + if (free_blocks != fs->super->s_free_blocks_count) { + pctx.group = 0; + pctx.blk = fs->super->s_free_blocks_count; + pctx.blk2 = free_blocks; + + if (fix_problem(ctx, PR_5_FREE_BLOCK_COUNT, &pctx)) { + fs->super->s_free_blocks_count = free_blocks; + ext2fs_mark_super_dirty(fs); + } else + ext2fs_unmark_valid(fs); + } + ext2fs_free_mem(&free_array); +} + +static void check_inode_bitmaps(e2fsck_t ctx) +{ + ext2_filsys fs = ctx->fs; + ext2_ino_t i; + unsigned int free_inodes = 0; + int group_free = 0; + int dirs_count = 0; + int group = 0; + unsigned int inodes = 0; + int *free_array; + int *dir_array; + int actual, bitmap; + errcode_t retval; + struct problem_context pctx; + int problem, save_problem, fixit, had_problem; + + clear_problem_context(&pctx); + free_array = (int *) e2fsck_allocate_memory(ctx, + fs->group_desc_count * sizeof(int), "free inode count array"); + + dir_array = (int *) e2fsck_allocate_memory(ctx, + fs->group_desc_count * sizeof(int), "directory count array"); + + if ((1 < ext2fs_get_inode_bitmap_start(ctx->inode_used_map)) || + (fs->super->s_inodes_count > + ext2fs_get_inode_bitmap_end(ctx->inode_used_map))) { + pctx.num = 3; + pctx.blk = 1; + pctx.blk2 = fs->super->s_inodes_count; + pctx.ino = ext2fs_get_inode_bitmap_start(ctx->inode_used_map); + pctx.ino2 = ext2fs_get_inode_bitmap_end(ctx->inode_used_map); + fix_problem(ctx, PR_5_BMAP_ENDPOINTS, &pctx); + + ctx->flags |= E2F_FLAG_ABORT; /* fatal */ + return; + } + if ((1 < ext2fs_get_inode_bitmap_start(fs->inode_map)) || + (fs->super->s_inodes_count > + ext2fs_get_inode_bitmap_end(fs->inode_map))) { + pctx.num = 4; + pctx.blk = 1; + pctx.blk2 = fs->super->s_inodes_count; + pctx.ino = ext2fs_get_inode_bitmap_start(fs->inode_map); + pctx.ino2 = ext2fs_get_inode_bitmap_end(fs->inode_map); + fix_problem(ctx, PR_5_BMAP_ENDPOINTS, &pctx); + + ctx->flags |= E2F_FLAG_ABORT; /* fatal */ + return; + } + +redo_counts: + had_problem = 0; + save_problem = 0; + pctx.ino = pctx.ino2 = 0; + for (i = 1; i <= fs->super->s_inodes_count; i++) { + actual = ext2fs_fast_test_inode_bitmap(ctx->inode_used_map, i); + bitmap = ext2fs_fast_test_inode_bitmap(fs->inode_map, i); + + if (actual == bitmap) + goto do_counts; + + if (!actual && bitmap) { + /* + * Inode wasn't used, but marked in bitmap + */ + problem = PR_5_INODE_UNUSED; + } else /* if (actual && !bitmap) */ { + /* + * Inode used, but not in bitmap + */ + problem = PR_5_INODE_USED; + } + if (pctx.ino == 0) { + pctx.ino = pctx.ino2 = i; + save_problem = problem; + } else { + if ((problem == save_problem) && + (pctx.ino2 == i-1)) + pctx.ino2++; + else { + print_bitmap_problem(ctx, save_problem, &pctx); + pctx.ino = pctx.ino2 = i; + save_problem = problem; + } + } + ctx->flags |= E2F_FLAG_PROG_SUPPRESS; + had_problem++; + +do_counts: + if (!bitmap) { + group_free++; + free_inodes++; + } else { + if (ext2fs_test_inode_bitmap(ctx->inode_dir_map, i)) + dirs_count++; + } + inodes++; + if ((inodes == fs->super->s_inodes_per_group) || + (i == fs->super->s_inodes_count)) { + free_array[group] = group_free; + dir_array[group] = dirs_count; + group ++; + inodes = 0; + group_free = 0; + dirs_count = 0; + if (ctx->progress) + if ((ctx->progress)(ctx, 5, + group + fs->group_desc_count, + fs->group_desc_count*2)) + return; + } + } + if (pctx.ino) + print_bitmap_problem(ctx, save_problem, &pctx); + + if (had_problem) + fixit = end_problem_latch(ctx, PR_LATCH_IBITMAP); + else + fixit = -1; + ctx->flags &= ~E2F_FLAG_PROG_SUPPRESS; + + if (fixit == 1) { + ext2fs_free_inode_bitmap(fs->inode_map); + retval = ext2fs_copy_bitmap(ctx->inode_used_map, + &fs->inode_map); + if (retval) { + clear_problem_context(&pctx); + fix_problem(ctx, PR_5_COPY_IBITMAP_ERROR, &pctx); + ctx->flags |= E2F_FLAG_ABORT; + return; + } + ext2fs_set_bitmap_padding(fs->inode_map); + ext2fs_mark_ib_dirty(fs); + + /* redo counts */ + inodes = 0; free_inodes = 0; group_free = 0; + dirs_count = 0; group = 0; + memset(free_array, 0, fs->group_desc_count * sizeof(int)); + memset(dir_array, 0, fs->group_desc_count * sizeof(int)); + goto redo_counts; + } else if (fixit == 0) + ext2fs_unmark_valid(fs); + + for (i = 0; i < fs->group_desc_count; i++) { + if (free_array[i] != fs->group_desc[i].bg_free_inodes_count) { + pctx.group = i; + pctx.ino = fs->group_desc[i].bg_free_inodes_count; + pctx.ino2 = free_array[i]; + if (fix_problem(ctx, PR_5_FREE_INODE_COUNT_GROUP, + &pctx)) { + fs->group_desc[i].bg_free_inodes_count = + free_array[i]; + ext2fs_mark_super_dirty(fs); + } else + ext2fs_unmark_valid(fs); + } + if (dir_array[i] != fs->group_desc[i].bg_used_dirs_count) { + pctx.group = i; + pctx.ino = fs->group_desc[i].bg_used_dirs_count; + pctx.ino2 = dir_array[i]; + + if (fix_problem(ctx, PR_5_FREE_DIR_COUNT_GROUP, + &pctx)) { + fs->group_desc[i].bg_used_dirs_count = + dir_array[i]; + ext2fs_mark_super_dirty(fs); + } else + ext2fs_unmark_valid(fs); + } + } + if (free_inodes != fs->super->s_free_inodes_count) { + pctx.group = -1; + pctx.ino = fs->super->s_free_inodes_count; + pctx.ino2 = free_inodes; + + if (fix_problem(ctx, PR_5_FREE_INODE_COUNT, &pctx)) { + fs->super->s_free_inodes_count = free_inodes; + ext2fs_mark_super_dirty(fs); + } else + ext2fs_unmark_valid(fs); + } + ext2fs_free_mem(&free_array); + ext2fs_free_mem(&dir_array); +} + +static void check_inode_end(e2fsck_t ctx) +{ + ext2_filsys fs = ctx->fs; + ext2_ino_t end, save_inodes_count, i; + struct problem_context pctx; + + clear_problem_context(&pctx); + + end = EXT2_INODES_PER_GROUP(fs->super) * fs->group_desc_count; + pctx.errcode = ext2fs_fudge_inode_bitmap_end(fs->inode_map, end, + &save_inodes_count); + if (pctx.errcode) { + pctx.num = 1; + fix_problem(ctx, PR_5_FUDGE_BITMAP_ERROR, &pctx); + ctx->flags |= E2F_FLAG_ABORT; /* fatal */ + return; + } + if (save_inodes_count == end) + return; + + for (i = save_inodes_count + 1; i <= end; i++) { + if (!ext2fs_test_inode_bitmap(fs->inode_map, i)) { + if (fix_problem(ctx, PR_5_INODE_BMAP_PADDING, &pctx)) { + for (i = save_inodes_count + 1; i <= end; i++) + ext2fs_mark_inode_bitmap(fs->inode_map, + i); + ext2fs_mark_ib_dirty(fs); + } else + ext2fs_unmark_valid(fs); + break; + } + } + + pctx.errcode = ext2fs_fudge_inode_bitmap_end(fs->inode_map, + save_inodes_count, 0); + if (pctx.errcode) { + pctx.num = 2; + fix_problem(ctx, PR_5_FUDGE_BITMAP_ERROR, &pctx); + ctx->flags |= E2F_FLAG_ABORT; /* fatal */ + return; + } +} + +static void check_block_end(e2fsck_t ctx) +{ + ext2_filsys fs = ctx->fs; + blk_t end, save_blocks_count, i; + struct problem_context pctx; + + clear_problem_context(&pctx); + + end = fs->block_map->start + + (EXT2_BLOCKS_PER_GROUP(fs->super) * fs->group_desc_count) - 1; + pctx.errcode = ext2fs_fudge_block_bitmap_end(fs->block_map, end, + &save_blocks_count); + if (pctx.errcode) { + pctx.num = 3; + fix_problem(ctx, PR_5_FUDGE_BITMAP_ERROR, &pctx); + ctx->flags |= E2F_FLAG_ABORT; /* fatal */ + return; + } + if (save_blocks_count == end) + return; + + for (i = save_blocks_count + 1; i <= end; i++) { + if (!ext2fs_test_block_bitmap(fs->block_map, i)) { + if (fix_problem(ctx, PR_5_BLOCK_BMAP_PADDING, &pctx)) { + for (i = save_blocks_count + 1; i <= end; i++) + ext2fs_mark_block_bitmap(fs->block_map, + i); + ext2fs_mark_bb_dirty(fs); + } else + ext2fs_unmark_valid(fs); + break; + } + } + + pctx.errcode = ext2fs_fudge_block_bitmap_end(fs->block_map, + save_blocks_count, 0); + if (pctx.errcode) { + pctx.num = 4; + fix_problem(ctx, PR_5_FUDGE_BITMAP_ERROR, &pctx); + ctx->flags |= E2F_FLAG_ABORT; /* fatal */ + return; + } +} + + + +/* + * problem.c --- report filesystem problems to the user + * + * Copyright 1996, 1997 by Theodore Ts'o + * + * %Begin-Header% + * This file may be redistributed under the terms of the GNU Public + * License. + * %End-Header% + */ + +#define PR_PREEN_OK 0x000001 /* Don't need to do preenhalt */ +#define PR_NO_OK 0x000002 /* If user answers no, don't make fs invalid */ +#define PR_NO_DEFAULT 0x000004 /* Default to no */ +#define PR_MSG_ONLY 0x000008 /* Print message only */ + +/* Bit positions 0x000ff0 are reserved for the PR_LATCH flags */ + +#define PR_FATAL 0x001000 /* Fatal error */ +#define PR_AFTER_CODE 0x002000 /* After asking the first question, */ + /* ask another */ +#define PR_PREEN_NOMSG 0x004000 /* Don't print a message if we're preening */ +#define PR_NOCOLLATE 0x008000 /* Don't collate answers for this latch */ +#define PR_NO_NOMSG 0x010000 /* Don't print a message if e2fsck -n */ +#define PR_PREEN_NO 0x020000 /* Use No as an answer if preening */ +#define PR_PREEN_NOHDR 0x040000 /* Don't print the preen header */ + + +#define PROMPT_NONE 0 +#define PROMPT_FIX 1 +#define PROMPT_CLEAR 2 +#define PROMPT_RELOCATE 3 +#define PROMPT_ALLOCATE 4 +#define PROMPT_EXPAND 5 +#define PROMPT_CONNECT 6 +#define PROMPT_CREATE 7 +#define PROMPT_SALVAGE 8 +#define PROMPT_TRUNCATE 9 +#define PROMPT_CLEAR_INODE 10 +#define PROMPT_ABORT 11 +#define PROMPT_SPLIT 12 +#define PROMPT_CONTINUE 13 +#define PROMPT_CLONE 14 +#define PROMPT_DELETE 15 +#define PROMPT_SUPPRESS 16 +#define PROMPT_UNLINK 17 +#define PROMPT_CLEAR_HTREE 18 +#define PROMPT_RECREATE 19 +#define PROMPT_NULL 20 + +struct e2fsck_problem { + problem_t e2p_code; + const char * e2p_description; + char prompt; + int flags; + problem_t second_code; +}; + +struct latch_descr { + int latch_code; + problem_t question; + problem_t end_message; + int flags; +}; + +/* + * These are the prompts which are used to ask the user if they want + * to fix a problem. + */ +static const char *prompt[] = { + N_("(no prompt)"), /* 0 */ + N_("Fix"), /* 1 */ + N_("Clear"), /* 2 */ + N_("Relocate"), /* 3 */ + N_("Allocate"), /* 4 */ + N_("Expand"), /* 5 */ + N_("Connect to /lost+found"), /* 6 */ + N_("Create"), /* 7 */ + N_("Salvage"), /* 8 */ + N_("Truncate"), /* 9 */ + N_("Clear inode"), /* 10 */ + N_("Abort"), /* 11 */ + N_("Split"), /* 12 */ + N_("Continue"), /* 13 */ + N_("Clone duplicate/bad blocks"), /* 14 */ + N_("Delete file"), /* 15 */ + N_("Suppress messages"),/* 16 */ + N_("Unlink"), /* 17 */ + N_("Clear HTree index"),/* 18 */ + N_("Recreate"), /* 19 */ + "", /* 20 */ +}; + +/* + * These messages are printed when we are preen mode and we will be + * automatically fixing the problem. + */ +static const char *preen_msg[] = { + N_("(NONE)"), /* 0 */ + N_("FIXED"), /* 1 */ + N_("CLEARED"), /* 2 */ + N_("RELOCATED"), /* 3 */ + N_("ALLOCATED"), /* 4 */ + N_("EXPANDED"), /* 5 */ + N_("RECONNECTED"), /* 6 */ + N_("CREATED"), /* 7 */ + N_("SALVAGED"), /* 8 */ + N_("TRUNCATED"), /* 9 */ + N_("INODE CLEARED"), /* 10 */ + N_("ABORTED"), /* 11 */ + N_("SPLIT"), /* 12 */ + N_("CONTINUING"), /* 13 */ + N_("DUPLICATE/BAD BLOCKS CLONED"), /* 14 */ + N_("FILE DELETED"), /* 15 */ + N_("SUPPRESSED"), /* 16 */ + N_("UNLINKED"), /* 17 */ + N_("HTREE INDEX CLEARED"),/* 18 */ + N_("WILL RECREATE"), /* 19 */ + "", /* 20 */ +}; + +static const struct e2fsck_problem problem_table[] = { + + /* Pre-Pass 1 errors */ + + /* Block bitmap not in group */ + { PR_0_BB_NOT_GROUP, N_("@b @B for @g %g is not in @g. (@b %b)\n"), + PROMPT_RELOCATE, PR_LATCH_RELOC }, + + /* Inode bitmap not in group */ + { PR_0_IB_NOT_GROUP, N_("@i @B for @g %g is not in @g. (@b %b)\n"), + PROMPT_RELOCATE, PR_LATCH_RELOC }, + + /* Inode table not in group */ + { PR_0_ITABLE_NOT_GROUP, + N_("@i table for @g %g is not in @g. (@b %b)\n" + "WARNING: SEVERE DATA LOSS POSSIBLE.\n"), + PROMPT_RELOCATE, PR_LATCH_RELOC }, + + /* Superblock corrupt */ + { PR_0_SB_CORRUPT, + N_("\nThe @S could not be read or does not describe a correct ext2\n" + "@f. If the @v is valid and it really contains an ext2\n" + "@f (and not swap or ufs or something else), then the @S\n" + "is corrupt, and you might try running e2fsck with an alternate @S:\n" + " e2fsck -b %S <@v>\n\n"), + PROMPT_NONE, PR_FATAL }, + + /* Filesystem size is wrong */ + { PR_0_FS_SIZE_WRONG, + N_("The @f size (according to the @S) is %b @bs\n" + "The physical size of the @v is %c @bs\n" + "Either the @S or the partition table is likely to be corrupt!\n"), + PROMPT_ABORT, 0 }, + + /* Fragments not supported */ + { PR_0_NO_FRAGMENTS, + N_("@S @b_size = %b, fragsize = %c.\n" + "This version of e2fsck does not support fragment sizes different\n" + "from the @b size.\n"), + PROMPT_NONE, PR_FATAL }, + + /* Bad blocks_per_group */ + { PR_0_BLOCKS_PER_GROUP, + N_("@S @bs_per_group = %b, should have been %c\n"), + PROMPT_NONE, PR_AFTER_CODE, PR_0_SB_CORRUPT }, + + /* Bad first_data_block */ + { PR_0_FIRST_DATA_BLOCK, + N_("@S first_data_@b = %b, should have been %c\n"), + PROMPT_NONE, PR_AFTER_CODE, PR_0_SB_CORRUPT }, + + /* Adding UUID to filesystem */ + { PR_0_ADD_UUID, + N_("@f did not have a UUID; generating one.\n\n"), + PROMPT_NONE, 0 }, + + /* Relocate hint */ + { PR_0_RELOCATE_HINT, + N_("Note: if there is several inode or block bitmap blocks\n" + "which require relocation, or one part of the inode table\n" + "which must be moved, you may wish to try running e2fsck\n" + "with the '-b %S' option first. The problem may lie only\n" + "with the primary block group descriptor, and the backup\n" + "block group descriptor may be OK.\n\n"), + PROMPT_NONE, PR_PREEN_OK | PR_NOCOLLATE }, + + /* Miscellaneous superblock corruption */ + { PR_0_MISC_CORRUPT_SUPER, + N_("Corruption found in @S. (%s = %N).\n"), + PROMPT_NONE, PR_AFTER_CODE, PR_0_SB_CORRUPT }, + + /* Error determing physical device size of filesystem */ + { PR_0_GETSIZE_ERROR, + N_("Error determining size of the physical @v: %m\n"), + PROMPT_NONE, PR_FATAL }, + + /* Inode count in superblock is incorrect */ + { PR_0_INODE_COUNT_WRONG, + N_("@i count in @S is %i, should be %j.\n"), + PROMPT_FIX, 0 }, + + { PR_0_HURD_CLEAR_FILETYPE, + N_("The Hurd does not support the filetype feature.\n"), + PROMPT_CLEAR, 0 }, + + /* Journal inode is invalid */ + { PR_0_JOURNAL_BAD_INODE, + N_("@S has a bad ext3 @j (@i %i).\n"), + PROMPT_CLEAR, PR_PREEN_OK }, + + /* The external journal has (unsupported) multiple filesystems */ + { PR_0_JOURNAL_UNSUPP_MULTIFS, + N_("External @j has multiple @f users (unsupported).\n"), + PROMPT_NONE, PR_FATAL }, + + /* Can't find external journal */ + { PR_0_CANT_FIND_JOURNAL, + N_("Can't find external @j\n"), + PROMPT_NONE, PR_FATAL }, + + /* External journal has bad superblock */ + { PR_0_EXT_JOURNAL_BAD_SUPER, + N_("External @j has bad @S\n"), + PROMPT_NONE, PR_FATAL }, + + /* Superblock has a bad journal UUID */ + { PR_0_JOURNAL_BAD_UUID, + N_("External @j does not support this @f\n"), + PROMPT_NONE, PR_FATAL }, + + /* Journal has an unknown superblock type */ + { PR_0_JOURNAL_UNSUPP_SUPER, + N_("Ext3 @j @S is unknown type %N (unsupported).\n" + "It is likely that your copy of e2fsck is old and/or doesn't " + "support this @j format.\n" + "It is also possible the @j @S is corrupt.\n"), + PROMPT_ABORT, PR_NO_OK | PR_AFTER_CODE, PR_0_JOURNAL_BAD_SUPER }, + + /* Journal superblock is corrupt */ + { PR_0_JOURNAL_BAD_SUPER, + N_("Ext3 @j @S is corrupt.\n"), + PROMPT_FIX, PR_PREEN_OK }, + + /* Superblock flag should be cleared */ + { PR_0_JOURNAL_HAS_JOURNAL, + N_("@S doesn't have has_@j flag, but has ext3 @j %s.\n"), + PROMPT_CLEAR, PR_PREEN_OK }, + + /* Superblock flag is incorrect */ + { PR_0_JOURNAL_RECOVER_SET, + N_("@S has ext3 needs_recovery flag set, but no @j.\n"), + PROMPT_CLEAR, PR_PREEN_OK }, + + /* Journal has data, but recovery flag is clear */ + { PR_0_JOURNAL_RECOVERY_CLEAR, + N_("ext3 recovery flag clear, but @j has data.\n"), + PROMPT_NONE, 0 }, + + /* Ask if we should clear the journal */ + { PR_0_JOURNAL_RESET_JOURNAL, + N_("Clear @j"), + PROMPT_NULL, PR_PREEN_NOMSG }, + + /* Ask if we should run the journal anyway */ + { PR_0_JOURNAL_RUN, + N_("Run @j anyway"), + PROMPT_NULL, 0 }, + + /* Run the journal by default */ + { PR_0_JOURNAL_RUN_DEFAULT, + N_("Recovery flag not set in backup @S, so running @j anyway.\n"), + PROMPT_NONE, 0 }, + + /* Clearing orphan inode */ + { PR_0_ORPHAN_CLEAR_INODE, + N_("%s @o @i %i (uid=%Iu, gid=%Ig, mode=%Im, size=%Is)\n"), + PROMPT_NONE, 0 }, + + /* Illegal block found in orphaned inode */ + { PR_0_ORPHAN_ILLEGAL_BLOCK_NUM, + N_("@I @b #%B (%b) found in @o @i %i.\n"), + PROMPT_NONE, 0 }, + + /* Already cleared block found in orphaned inode */ + { PR_0_ORPHAN_ALREADY_CLEARED_BLOCK, + N_("Already cleared @b #%B (%b) found in @o @i %i.\n"), + PROMPT_NONE, 0 }, + + /* Illegal orphan inode in superblock */ + { PR_0_ORPHAN_ILLEGAL_HEAD_INODE, + N_("@I @o @i %i in @S.\n"), + PROMPT_NONE, 0 }, + + /* Illegal inode in orphaned inode list */ + { PR_0_ORPHAN_ILLEGAL_INODE, + N_("@I @i %i in @o @i list.\n"), + PROMPT_NONE, 0 }, + + /* Filesystem revision is 0, but feature flags are set */ + { PR_0_FS_REV_LEVEL, + "@f has feature flag(s) set, but is a revision 0 @f. ", + PROMPT_FIX, PR_PREEN_OK | PR_NO_OK }, + + /* Journal superblock has an unknown read-only feature flag set */ + { PR_0_JOURNAL_UNSUPP_ROCOMPAT, + N_("Ext3 @j @S has an unknown read-only feature flag set.\n"), + PROMPT_ABORT, 0 }, + + /* Journal superblock has an unknown incompatible feature flag set */ + { PR_0_JOURNAL_UNSUPP_INCOMPAT, + N_("Ext3 @j @S has an unknown incompatible feature flag set.\n"), + PROMPT_ABORT, 0 }, + + /* Journal has unsupported version number */ + { PR_0_JOURNAL_UNSUPP_VERSION, + N_("@j version not supported by this e2fsck.\n"), + PROMPT_ABORT, 0 }, + + /* Moving journal to hidden file */ + { PR_0_MOVE_JOURNAL, + N_("Moving @j from /%s to hidden inode.\n\n"), + PROMPT_NONE, 0 }, + + /* Error moving journal to hidden file */ + { PR_0_ERR_MOVE_JOURNAL, + N_("Error moving @j: %m\n\n"), + PROMPT_NONE, 0 }, + + /* Clearing V2 journal superblock */ + { PR_0_CLEAR_V2_JOURNAL, + N_("Found invalid V2 @j @S fields (from V1 journal).\n" + "Clearing fields beyond the V1 @j @S...\n\n"), + PROMPT_NONE, 0 }, + + /* Backup journal inode blocks */ + { PR_0_BACKUP_JNL, + N_("Backing up @j @i @b information.\n\n"), + PROMPT_NONE, 0 }, + + /* Reserved blocks w/o resize_inode */ + { PR_0_NONZERO_RESERVED_GDT_BLOCKS, + N_("@f does not have resize_@i enabled, but s_reserved_gdt_@bs\n" + "is %N; @s zero. "), + PROMPT_FIX, 0 }, + + /* Resize_inode not enabled, but resize inode is non-zero */ + { PR_0_CLEAR_RESIZE_INODE, + N_("Resize_@i not enabled, but the resize inode is non-zero. "), + PROMPT_CLEAR, 0 }, + + /* Resize inode invalid */ + { PR_0_RESIZE_INODE_INVALID, + N_("Resize @i not valid. "), + PROMPT_RECREATE, 0 }, + + /* Pass 1 errors */ + + /* Pass 1: Checking inodes, blocks, and sizes */ + { PR_1_PASS_HEADER, + N_("Pass 1: Checking @is, @bs, and sizes\n"), + PROMPT_NONE, 0 }, + + /* Root directory is not an inode */ + { PR_1_ROOT_NO_DIR, N_("@r is not a @d. "), + PROMPT_CLEAR, 0 }, + + /* Root directory has dtime set */ + { PR_1_ROOT_DTIME, + N_("@r has dtime set (probably due to old mke2fs). "), + PROMPT_FIX, PR_PREEN_OK }, + + /* Reserved inode has bad mode */ + { PR_1_RESERVED_BAD_MODE, + N_("Reserved @i %i %Q has bad mode. "), + PROMPT_CLEAR, PR_PREEN_OK }, + + /* Deleted inode has zero dtime */ + { PR_1_ZERO_DTIME, + N_("@D @i %i has zero dtime. "), + PROMPT_FIX, PR_PREEN_OK }, + + /* Inode in use, but dtime set */ + { PR_1_SET_DTIME, + N_("@i %i is in use, but has dtime set. "), + PROMPT_FIX, PR_PREEN_OK }, + + /* Zero-length directory */ + { PR_1_ZERO_LENGTH_DIR, + N_("@i %i is a @z @d. "), + PROMPT_CLEAR, PR_PREEN_OK }, + + /* Block bitmap conflicts with some other fs block */ + { PR_1_BB_CONFLICT, + N_("@g %g's @b @B at %b @C.\n"), + PROMPT_RELOCATE, 0 }, + + /* Inode bitmap conflicts with some other fs block */ + { PR_1_IB_CONFLICT, + N_("@g %g's @i @B at %b @C.\n"), + PROMPT_RELOCATE, 0 }, + + /* Inode table conflicts with some other fs block */ + { PR_1_ITABLE_CONFLICT, + N_("@g %g's @i table at %b @C.\n"), + PROMPT_RELOCATE, 0 }, + + /* Block bitmap is on a bad block */ + { PR_1_BB_BAD_BLOCK, + N_("@g %g's @b @B (%b) is bad. "), + PROMPT_RELOCATE, 0 }, + + /* Inode bitmap is on a bad block */ + { PR_1_IB_BAD_BLOCK, + N_("@g %g's @i @B (%b) is bad. "), + PROMPT_RELOCATE, 0 }, + + /* Inode has incorrect i_size */ + { PR_1_BAD_I_SIZE, + N_("@i %i, i_size is %Is, @s %N. "), + PROMPT_FIX, PR_PREEN_OK }, + + /* Inode has incorrect i_blocks */ + { PR_1_BAD_I_BLOCKS, + N_("@i %i, i_@bs is %Ib, @s %N. "), + PROMPT_FIX, PR_PREEN_OK }, + + /* Illegal blocknumber in inode */ + { PR_1_ILLEGAL_BLOCK_NUM, + N_("@I @b #%B (%b) in @i %i. "), + PROMPT_CLEAR, PR_LATCH_BLOCK }, + + /* Block number overlaps fs metadata */ + { PR_1_BLOCK_OVERLAPS_METADATA, + N_("@b #%B (%b) overlaps @f metadata in @i %i. "), + PROMPT_CLEAR, PR_LATCH_BLOCK }, + + /* Inode has illegal blocks (latch question) */ + { PR_1_INODE_BLOCK_LATCH, + N_("@i %i has illegal @b(s). "), + PROMPT_CLEAR, 0 }, + + /* Too many bad blocks in inode */ + { PR_1_TOO_MANY_BAD_BLOCKS, + N_("Too many illegal @bs in @i %i.\n"), + PROMPT_CLEAR_INODE, PR_NO_OK }, + + /* Illegal block number in bad block inode */ + { PR_1_BB_ILLEGAL_BLOCK_NUM, + N_("@I @b #%B (%b) in bad @b @i. "), + PROMPT_CLEAR, PR_LATCH_BBLOCK }, + + /* Bad block inode has illegal blocks (latch question) */ + { PR_1_INODE_BBLOCK_LATCH, + N_("Bad @b @i has illegal @b(s). "), + PROMPT_CLEAR, 0 }, + + /* Duplicate or bad blocks in use! */ + { PR_1_DUP_BLOCKS_PREENSTOP, + N_("Duplicate or bad @b in use!\n"), + PROMPT_NONE, 0 }, + + /* Bad block used as bad block indirect block */ + { PR_1_BBINODE_BAD_METABLOCK, + N_("Bad @b %b used as bad @b @i indirect @b. "), + PROMPT_CLEAR, PR_LATCH_BBLOCK }, + + /* Inconsistency can't be fixed prompt */ + { PR_1_BBINODE_BAD_METABLOCK_PROMPT, + N_("\nThe bad @b @i has probably been corrupted. You probably\n" + "should stop now and run ""e2fsck -c"" to scan for bad blocks\n" + "in the @f.\n"), + PROMPT_CONTINUE, PR_PREEN_NOMSG }, + + /* Bad primary block */ + { PR_1_BAD_PRIMARY_BLOCK, + N_("\nIf the @b is really bad, the @f can not be fixed.\n"), + PROMPT_NONE, PR_AFTER_CODE, PR_1_BAD_PRIMARY_BLOCK_PROMPT }, + + /* Bad primary block prompt */ + { PR_1_BAD_PRIMARY_BLOCK_PROMPT, + N_("You can clear the this @b (and hope for the best) from the\n" + "bad @b list and hope that @b is really OK, but there are no\n" + "guarantees.\n\n"), + PROMPT_CLEAR, PR_PREEN_NOMSG }, + + /* Bad primary superblock */ + { PR_1_BAD_PRIMARY_SUPERBLOCK, + N_("The primary @S (%b) is on the bad @b list.\n"), + PROMPT_NONE, PR_AFTER_CODE, PR_1_BAD_PRIMARY_BLOCK }, + + /* Bad primary block group descriptors */ + { PR_1_BAD_PRIMARY_GROUP_DESCRIPTOR, + N_("Block %b in the primary @g descriptors " + "is on the bad @b list\n"), + PROMPT_NONE, PR_AFTER_CODE, PR_1_BAD_PRIMARY_BLOCK }, + + /* Bad superblock in group */ + { PR_1_BAD_SUPERBLOCK, + N_("Warning: Group %g's @S (%b) is bad.\n"), + PROMPT_NONE, PR_PREEN_OK | PR_PREEN_NOMSG }, + + /* Bad block group descriptors in group */ + { PR_1_BAD_GROUP_DESCRIPTORS, + N_("Warning: Group %g's copy of the @g descriptors has a bad " + "@b (%b).\n"), + PROMPT_NONE, PR_PREEN_OK | PR_PREEN_NOMSG }, + + /* Block claimed for no reason */ + { PR_1_PROGERR_CLAIMED_BLOCK, + N_("Programming error? @b #%b claimed for no reason in " + "process_bad_@b.\n"), + PROMPT_NONE, PR_PREEN_OK }, + + /* Error allocating blocks for relocating metadata */ + { PR_1_RELOC_BLOCK_ALLOCATE, + N_("@A %N contiguous @b(s) in @b @g %g for %s: %m\n"), + PROMPT_NONE, PR_PREEN_OK }, + + /* Error allocating block buffer during relocation process */ + { PR_1_RELOC_MEMORY_ALLOCATE, + N_("@A @b buffer for relocating %s\n"), + PROMPT_NONE, PR_PREEN_OK }, + + /* Relocating metadata group information from X to Y */ + { PR_1_RELOC_FROM_TO, + N_("Relocating @g %g's %s from %b to %c...\n"), + PROMPT_NONE, PR_PREEN_OK }, + + /* Relocating metatdata group information to X */ + { PR_1_RELOC_TO, + N_("Relocating @g %g's %s to %c...\n"), /* xgettext:no-c-format */ + PROMPT_NONE, PR_PREEN_OK }, + + /* Block read error during relocation process */ + { PR_1_RELOC_READ_ERR, + N_("Warning: could not read @b %b of %s: %m\n"), + PROMPT_NONE, PR_PREEN_OK }, + + /* Block write error during relocation process */ + { PR_1_RELOC_WRITE_ERR, + N_("Warning: could not write @b %b for %s: %m\n"), + PROMPT_NONE, PR_PREEN_OK }, + + /* Error allocating inode bitmap */ + { PR_1_ALLOCATE_IBITMAP_ERROR, + "@A @i @B (%N): %m\n", + PROMPT_NONE, PR_FATAL }, + + /* Error allocating block bitmap */ + { PR_1_ALLOCATE_BBITMAP_ERROR, + "@A @b @B (%N): %m\n", + PROMPT_NONE, PR_FATAL }, + + /* Error allocating icount structure */ + { PR_1_ALLOCATE_ICOUNT, + N_("@A icount link information: %m\n"), + PROMPT_NONE, PR_FATAL }, + + /* Error allocating dbcount */ + { PR_1_ALLOCATE_DBCOUNT, + N_("@A @d @b array: %m\n"), + PROMPT_NONE, PR_FATAL }, + + /* Error while scanning inodes */ + { PR_1_ISCAN_ERROR, + N_("Error while scanning @is (%i): %m\n"), + PROMPT_NONE, PR_FATAL }, + + /* Error while iterating over blocks */ + { PR_1_BLOCK_ITERATE, + N_("Error while iterating over @bs in @i %i: %m\n"), + PROMPT_NONE, PR_FATAL }, + + /* Error while storing inode count information */ + { PR_1_ICOUNT_STORE, + N_("Error storing @i count information (@i=%i, count=%N): %m\n"), + PROMPT_NONE, PR_FATAL }, + + /* Error while storing directory block information */ + { PR_1_ADD_DBLOCK, + N_("Error storing @d @b information " + "(@i=%i, @b=%b, num=%N): %m\n"), + PROMPT_NONE, PR_FATAL }, + + /* Error while reading inode (for clearing) */ + { PR_1_READ_INODE, + N_("Error reading @i %i: %m\n"), + PROMPT_NONE, PR_FATAL }, + + /* Suppress messages prompt */ + { PR_1_SUPPRESS_MESSAGES, "", PROMPT_SUPPRESS, PR_NO_OK }, + + /* Imagic flag set on an inode when filesystem doesn't support it */ + { PR_1_SET_IMAGIC, + N_("@i %i has imagic flag set. "), + PROMPT_CLEAR, 0 }, + + /* Immutable flag set on a device or socket inode */ + { PR_1_SET_IMMUTABLE, + N_("Special (@v/socket/fifo/symlink) file (@i %i) has immutable\n" + "or append-only flag set. "), + PROMPT_CLEAR, PR_PREEN_OK | PR_PREEN_NO | PR_NO_OK }, + + /* Compression flag set on an inode when filesystem doesn't support it */ + { PR_1_COMPR_SET, + N_("@i %i has @cion flag set on @f without @cion support. "), + PROMPT_CLEAR, 0 }, + + /* Non-zero size for device, fifo or socket inode */ + { PR_1_SET_NONZSIZE, + "Special (@v/socket/fifo) @i %i has non-zero size. ", + PROMPT_FIX, PR_PREEN_OK }, + + /* Filesystem revision is 0, but feature flags are set */ + { PR_1_FS_REV_LEVEL, + "@f has feature flag(s) set, but is a revision 0 @f. ", + PROMPT_FIX, PR_PREEN_OK | PR_NO_OK }, + + /* Journal inode is not in use, but contains data */ + { PR_1_JOURNAL_INODE_NOT_CLEAR, + "@j @i is not in use, but contains data. ", + PROMPT_CLEAR, PR_PREEN_OK }, + + /* Journal has bad mode */ + { PR_1_JOURNAL_BAD_MODE, + N_("@j is not regular file. "), + PROMPT_FIX, PR_PREEN_OK }, + + /* Deal with inodes that were part of orphan linked list */ + { PR_1_LOW_DTIME, + N_("@i %i was part of the orphaned @i list. "), + PROMPT_FIX, PR_LATCH_LOW_DTIME, 0 }, + + /* Deal with inodes that were part of corrupted orphan linked + list (latch question) */ + { PR_1_ORPHAN_LIST_REFUGEES, + N_("@is that were part of a corrupted orphan linked list found. "), + PROMPT_FIX, 0 }, + + /* Error allocating refcount structure */ + { PR_1_ALLOCATE_REFCOUNT, + "@A refcount structure (%N): %m\n", + PROMPT_NONE, PR_FATAL }, + + /* Error reading extended attribute block */ + { PR_1_READ_EA_BLOCK, + N_("Error reading @a @b %b for @i %i. "), + PROMPT_CLEAR, 0 }, + + /* Invalid extended attribute block */ + { PR_1_BAD_EA_BLOCK, + N_("@i %i has a bad @a @b %b. "), + PROMPT_CLEAR, 0 }, + + /* Error reading Extended Attribute block while fixing refcount */ + { PR_1_EXTATTR_READ_ABORT, + N_("Error reading @a @b %b (%m). "), + PROMPT_ABORT, 0 }, + + /* Extended attribute reference count incorrect */ + { PR_1_EXTATTR_REFCOUNT, + N_("@a @b %b has reference count %B, should be %N. "), + PROMPT_FIX, 0 }, + + /* Error writing Extended Attribute block while fixing refcount */ + { PR_1_EXTATTR_WRITE, + N_("Error writing @a @b %b (%m). "), + PROMPT_ABORT, 0 }, + + /* Multiple EA blocks not supported */ + { PR_1_EA_MULTI_BLOCK, + N_("@a @b %b has h_blocks > 1. "), + PROMPT_CLEAR, 0}, + + /* Error allocating EA region allocation structure */ + { PR_1_EA_ALLOC_REGION, + N_("Error allocating @a @b %b. "), + PROMPT_ABORT, 0}, + + /* Error EA allocation collision */ + { PR_1_EA_ALLOC_COLLISION, + N_("@a @b %b is corrupt (allocation collision). "), + PROMPT_CLEAR, 0}, + + /* Bad extended attribute name */ + { PR_1_EA_BAD_NAME, + N_("@a @b %b is corrupt (invalid name). "), + PROMPT_CLEAR, 0}, + + /* Bad extended attribute value */ + { PR_1_EA_BAD_VALUE, + N_("@a @b %b is corrupt (invalid value). "), + PROMPT_CLEAR, 0}, + + /* Inode too big (latch question) */ + { PR_1_INODE_TOOBIG, + N_("@i %i is too big. "), PROMPT_TRUNCATE, 0 }, + + /* Directory too big */ + { PR_1_TOOBIG_DIR, + N_("@b #%B (%b) causes @d to be too big. "), + PROMPT_CLEAR, PR_LATCH_TOOBIG }, + + /* Regular file too big */ + { PR_1_TOOBIG_REG, + N_("@b #%B (%b) causes file to be too big. "), + PROMPT_CLEAR, PR_LATCH_TOOBIG }, + + /* Symlink too big */ + { PR_1_TOOBIG_SYMLINK, + N_("@b #%B (%b) causes symlink to be too big. "), + PROMPT_CLEAR, PR_LATCH_TOOBIG }, + + /* INDEX_FL flag set on a non-HTREE filesystem */ + { PR_1_HTREE_SET, + N_("@i %i has INDEX_FL flag set on @f without htree support.\n"), + PROMPT_CLEAR_HTREE, PR_PREEN_OK }, + + /* INDEX_FL flag set on a non-directory */ + { PR_1_HTREE_NODIR, + N_("@i %i has INDEX_FL flag set but is not a @d.\n"), + PROMPT_CLEAR_HTREE, PR_PREEN_OK }, + + /* Invalid root node in HTREE directory */ + { PR_1_HTREE_BADROOT, + N_("@h %i has an invalid root node.\n"), + PROMPT_CLEAR_HTREE, PR_PREEN_OK }, + + /* Unsupported hash version in HTREE directory */ + { PR_1_HTREE_HASHV, + N_("@h %i has an unsupported hash version (%N)\n"), + PROMPT_CLEAR_HTREE, PR_PREEN_OK }, + + /* Incompatible flag in HTREE root node */ + { PR_1_HTREE_INCOMPAT, + N_("@h %i uses an incompatible htree root node flag.\n"), + PROMPT_CLEAR_HTREE, PR_PREEN_OK }, + + /* HTREE too deep */ + { PR_1_HTREE_DEPTH, + N_("@h %i has a tree depth (%N) which is too big\n"), + PROMPT_CLEAR_HTREE, PR_PREEN_OK }, + + /* Bad block has indirect block that conflicts with filesystem block */ + { PR_1_BB_FS_BLOCK, + N_("Bad @b @i has an indirect @b (%b) that conflicts with\n" + "@f metadata. "), + PROMPT_CLEAR, PR_LATCH_BBLOCK }, + + /* Resize inode failed */ + { PR_1_RESIZE_INODE_CREATE, + N_("Resize @i (re)creation failed: %m."), + PROMPT_ABORT, 0 }, + + /* invalid inode->i_extra_isize */ + { PR_1_EXTRA_ISIZE, + N_("@i %i has a extra size (%IS) which is invalid\n"), + PROMPT_FIX, PR_PREEN_OK }, + + /* invalid ea entry->e_name_len */ + { PR_1_ATTR_NAME_LEN, + N_("@a in @i %i has a namelen (%N) which is invalid\n"), + PROMPT_CLEAR, PR_PREEN_OK }, + + /* invalid ea entry->e_value_size */ + { PR_1_ATTR_VALUE_SIZE, + N_("@a in @i %i has a value size (%N) which is invalid\n"), + PROMPT_CLEAR, PR_PREEN_OK }, + + /* invalid ea entry->e_value_offs */ + { PR_1_ATTR_VALUE_OFFSET, + N_("@a in @i %i has a value offset (%N) which is invalid\n"), + PROMPT_CLEAR, PR_PREEN_OK }, + + /* invalid ea entry->e_value_block */ + { PR_1_ATTR_VALUE_BLOCK, + N_("@a in @i %i has a value block (%N) which is invalid (must be 0)\n"), + PROMPT_CLEAR, PR_PREEN_OK }, + + /* invalid ea entry->e_hash */ + { PR_1_ATTR_HASH, + N_("@a in @i %i has a hash (%N) which is invalid (must be 0)\n"), + PROMPT_CLEAR, PR_PREEN_OK }, + + /* Pass 1b errors */ + + /* Pass 1B: Rescan for duplicate/bad blocks */ + { PR_1B_PASS_HEADER, + N_("Duplicate @bs found... invoking duplicate @b passes.\n" + "Pass 1B: Rescan for duplicate/bad @bs\n"), + PROMPT_NONE, 0 }, + + /* Duplicate/bad block(s) header */ + { PR_1B_DUP_BLOCK_HEADER, + N_("Duplicate/bad @b(s) in @i %i:"), + PROMPT_NONE, 0 }, + + /* Duplicate/bad block(s) in inode */ + { PR_1B_DUP_BLOCK, + " %b", + PROMPT_NONE, PR_LATCH_DBLOCK | PR_PREEN_NOHDR }, + + /* Duplicate/bad block(s) end */ + { PR_1B_DUP_BLOCK_END, + "\n", + PROMPT_NONE, PR_PREEN_NOHDR }, + + /* Error while scanning inodes */ + { PR_1B_ISCAN_ERROR, + N_("Error while scanning inodes (%i): %m\n"), + PROMPT_NONE, PR_FATAL }, + + /* Error allocating inode bitmap */ + { PR_1B_ALLOCATE_IBITMAP_ERROR, + N_("@A @i @B (inode_dup_map): %m\n"), + PROMPT_NONE, PR_FATAL }, + + /* Error while iterating over blocks */ + { PR_1B_BLOCK_ITERATE, + N_("Error while iterating over @bs in @i %i (%s): %m\n"), + PROMPT_NONE, 0 }, + + /* Error adjusting EA refcount */ + { PR_1B_ADJ_EA_REFCOUNT, + N_("Error addjusting refcount for @a @b %b (@i %i): %m\n"), + PROMPT_NONE, 0 }, + + + /* Pass 1C: Scan directories for inodes with dup blocks. */ + { PR_1C_PASS_HEADER, + N_("Pass 1C: Scan directories for @is with dup @bs.\n"), + PROMPT_NONE, 0 }, + + + /* Pass 1D: Reconciling duplicate blocks */ + { PR_1D_PASS_HEADER, + N_("Pass 1D: Reconciling duplicate @bs\n"), + PROMPT_NONE, 0 }, + + /* File has duplicate blocks */ + { PR_1D_DUP_FILE, + N_("File %Q (@i #%i, mod time %IM) \n" + " has %B duplicate @b(s), shared with %N file(s):\n"), + PROMPT_NONE, 0 }, + + /* List of files sharing duplicate blocks */ + { PR_1D_DUP_FILE_LIST, + N_("\t%Q (@i #%i, mod time %IM)\n"), + PROMPT_NONE, 0 }, + + /* File sharing blocks with filesystem metadata */ + { PR_1D_SHARE_METADATA, + N_("\t<@f metadata>\n"), + PROMPT_NONE, 0 }, + + /* Report of how many duplicate/bad inodes */ + { PR_1D_NUM_DUP_INODES, + N_("(There are %N @is containing duplicate/bad @bs.)\n\n"), + PROMPT_NONE, 0 }, + + /* Duplicated blocks already reassigned or cloned. */ + { PR_1D_DUP_BLOCKS_DEALT, + N_("Duplicated @bs already reassigned or cloned.\n\n"), + PROMPT_NONE, 0 }, + + /* Clone duplicate/bad blocks? */ + { PR_1D_CLONE_QUESTION, + "", PROMPT_CLONE, PR_NO_OK }, + + /* Delete file? */ + { PR_1D_DELETE_QUESTION, + "", PROMPT_DELETE, 0 }, + + /* Couldn't clone file (error) */ + { PR_1D_CLONE_ERROR, + N_("Couldn't clone file: %m\n"), PROMPT_NONE, 0 }, + + /* Pass 2 errors */ + + /* Pass 2: Checking directory structure */ + { PR_2_PASS_HEADER, + N_("Pass 2: Checking @d structure\n"), + PROMPT_NONE, 0 }, + + /* Bad inode number for '.' */ + { PR_2_BAD_INODE_DOT, + N_("Bad @i number for '.' in @d @i %i.\n"), + PROMPT_FIX, 0 }, + + /* Directory entry has bad inode number */ + { PR_2_BAD_INO, + N_("@E has bad @i #: %Di.\n"), + PROMPT_CLEAR, 0 }, + + /* Directory entry has deleted or unused inode */ + { PR_2_UNUSED_INODE, + N_("@E has @D/unused @i %Di. "), + PROMPT_CLEAR, PR_PREEN_OK }, + + /* Directry entry is link to '.' */ + { PR_2_LINK_DOT, + N_("@E @L to '.' "), + PROMPT_CLEAR, 0 }, + + /* Directory entry points to inode now located in a bad block */ + { PR_2_BB_INODE, + N_("@E points to @i (%Di) located in a bad @b.\n"), + PROMPT_CLEAR, 0 }, + + /* Directory entry contains a link to a directory */ + { PR_2_LINK_DIR, + N_("@E @L to @d %P (%Di).\n"), + PROMPT_CLEAR, 0 }, + + /* Directory entry contains a link to the root directry */ + { PR_2_LINK_ROOT, + N_("@E @L to the @r.\n"), + PROMPT_CLEAR, 0 }, + + /* Directory entry has illegal characters in its name */ + { PR_2_BAD_NAME, + N_("@E has illegal characters in its name.\n"), + PROMPT_FIX, 0 }, + + /* Missing '.' in directory inode */ + { PR_2_MISSING_DOT, + N_("Missing '.' in @d @i %i.\n"), + PROMPT_FIX, 0 }, + + /* Missing '..' in directory inode */ + { PR_2_MISSING_DOT_DOT, + N_("Missing '..' in @d @i %i.\n"), + PROMPT_FIX, 0 }, + + /* First entry in directory inode doesn't contain '.' */ + { PR_2_1ST_NOT_DOT, + N_("First @e '%Dn' (inode=%Di) in @d @i %i (%p) @s '.'\n"), + PROMPT_FIX, 0 }, + + /* Second entry in directory inode doesn't contain '..' */ + { PR_2_2ND_NOT_DOT_DOT, + N_("Second @e '%Dn' (inode=%Di) in @d @i %i @s '..'\n"), + PROMPT_FIX, 0 }, + + /* i_faddr should be zero */ + { PR_2_FADDR_ZERO, + N_("i_faddr @F %IF, @s zero.\n"), + PROMPT_CLEAR, 0 }, + + /* i_file_acl should be zero */ + { PR_2_FILE_ACL_ZERO, + N_("i_file_acl @F %If, @s zero.\n"), + PROMPT_CLEAR, 0 }, + + /* i_dir_acl should be zero */ + { PR_2_DIR_ACL_ZERO, + N_("i_dir_acl @F %Id, @s zero.\n"), + PROMPT_CLEAR, 0 }, + + /* i_frag should be zero */ + { PR_2_FRAG_ZERO, + N_("i_frag @F %N, @s zero.\n"), + PROMPT_CLEAR, 0 }, + + /* i_fsize should be zero */ + { PR_2_FSIZE_ZERO, + N_("i_fsize @F %N, @s zero.\n"), + PROMPT_CLEAR, 0 }, + + /* inode has bad mode */ + { PR_2_BAD_MODE, + N_("@i %i (%Q) has a bad mode (%Im).\n"), + PROMPT_CLEAR, 0 }, + + /* directory corrupted */ + { PR_2_DIR_CORRUPTED, + N_("@d @i %i, @b %B, offset %N: @d corrupted\n"), + PROMPT_SALVAGE, 0 }, + + /* filename too long */ + { PR_2_FILENAME_LONG, + N_("@d @i %i, @b %B, offset %N: filename too long\n"), + PROMPT_TRUNCATE, 0 }, + + /* Directory inode has a missing block (hole) */ + { PR_2_DIRECTORY_HOLE, + N_("@d @i %i has an unallocated @b #%B. "), + PROMPT_ALLOCATE, 0 }, + + /* '.' is not NULL terminated */ + { PR_2_DOT_NULL_TERM, + N_("'.' @d @e in @d @i %i is not NULL terminated\n"), + PROMPT_FIX, 0 }, + + /* '..' is not NULL terminated */ + { PR_2_DOT_DOT_NULL_TERM, + N_("'..' @d @e in @d @i %i is not NULL terminated\n"), + PROMPT_FIX, 0 }, + + /* Illegal character device inode */ + { PR_2_BAD_CHAR_DEV, + N_("@i %i (%Q) is an @I character @v.\n"), + PROMPT_CLEAR, 0 }, + + /* Illegal block device inode */ + { PR_2_BAD_BLOCK_DEV, + N_("@i %i (%Q) is an @I @b @v.\n"), + PROMPT_CLEAR, 0 }, + + /* Duplicate '.' entry */ + { PR_2_DUP_DOT, + N_("@E is duplicate '.' @e.\n"), + PROMPT_FIX, 0 }, + + /* Duplicate '..' entry */ + { PR_2_DUP_DOT_DOT, + N_("@E is duplicate '..' @e.\n"), + PROMPT_FIX, 0 }, + + /* Internal error: couldn't find dir_info */ + { PR_2_NO_DIRINFO, + N_("Internal error: couldn't find dir_info for %i.\n"), + PROMPT_NONE, PR_FATAL }, + + /* Final rec_len is wrong */ + { PR_2_FINAL_RECLEN, + N_("@E has rec_len of %Dr, should be %N.\n"), + PROMPT_FIX, 0 }, + + /* Error allocating icount structure */ + { PR_2_ALLOCATE_ICOUNT, + N_("@A icount structure: %m\n"), + PROMPT_NONE, PR_FATAL }, + + /* Error iterating over directory blocks */ + { PR_2_DBLIST_ITERATE, + N_("Error iterating over @d @bs: %m\n"), + PROMPT_NONE, PR_FATAL }, + + /* Error reading directory block */ + { PR_2_READ_DIRBLOCK, + N_("Error reading @d @b %b (@i %i): %m\n"), + PROMPT_CONTINUE, 0 }, + + /* Error writing directory block */ + { PR_2_WRITE_DIRBLOCK, + N_("Error writing @d @b %b (@i %i): %m\n"), + PROMPT_CONTINUE, 0 }, + + /* Error allocating new directory block */ + { PR_2_ALLOC_DIRBOCK, + N_("@A new @d @b for @i %i (%s): %m\n"), + PROMPT_NONE, 0 }, + + /* Error deallocating inode */ + { PR_2_DEALLOC_INODE, + N_("Error deallocating @i %i: %m\n"), + PROMPT_NONE, PR_FATAL }, + + /* Directory entry for '.' is big. Split? */ + { PR_2_SPLIT_DOT, + N_("@d @e for '.' is big. "), + PROMPT_SPLIT, PR_NO_OK }, + + /* Illegal FIFO inode */ + { PR_2_BAD_FIFO, + N_("@i %i (%Q) is an @I FIFO.\n"), + PROMPT_CLEAR, 0 }, + + /* Illegal socket inode */ + { PR_2_BAD_SOCKET, + N_("@i %i (%Q) is an @I socket.\n"), + PROMPT_CLEAR, 0 }, + + /* Directory filetype not set */ + { PR_2_SET_FILETYPE, + N_("Setting filetype for @E to %N.\n"), + PROMPT_NONE, PR_PREEN_OK | PR_NO_OK | PR_NO_NOMSG }, + + /* Directory filetype incorrect */ + { PR_2_BAD_FILETYPE, + N_("@E has an incorrect filetype (was %Dt, should be %N).\n"), + PROMPT_FIX, 0 }, + + /* Directory filetype set on filesystem */ + { PR_2_CLEAR_FILETYPE, + N_("@E has filetype set.\n"), + PROMPT_CLEAR, PR_PREEN_OK }, + + /* Directory filename is null */ + { PR_2_NULL_NAME, + N_("@E has a zero-length name.\n"), + PROMPT_CLEAR, 0 }, + + /* Invalid symlink */ + { PR_2_INVALID_SYMLINK, + N_("Symlink %Q (@i #%i) is invalid.\n"), + PROMPT_CLEAR, 0 }, + + /* i_file_acl (extended attribute block) is bad */ + { PR_2_FILE_ACL_BAD, + N_("@a @b @F invalid (%If).\n"), + PROMPT_CLEAR, 0 }, + + /* Filesystem contains large files, but has no such flag in sb */ + { PR_2_FEATURE_LARGE_FILES, + N_("@f contains large files, but lacks LARGE_FILE flag in @S.\n"), + PROMPT_FIX, 0 }, + + /* Node in HTREE directory not referenced */ + { PR_2_HTREE_NOTREF, + N_("@p @h %d: node (%B) not referenced\n"), + PROMPT_NONE, 0 }, + + /* Node in HTREE directory referenced twice */ + { PR_2_HTREE_DUPREF, + N_("@p @h %d: node (%B) referenced twice\n"), + PROMPT_NONE, 0 }, + + /* Node in HTREE directory has bad min hash */ + { PR_2_HTREE_MIN_HASH, + N_("@p @h %d: node (%B) has bad min hash\n"), + PROMPT_NONE, 0 }, + + /* Node in HTREE directory has bad max hash */ + { PR_2_HTREE_MAX_HASH, + N_("@p @h %d: node (%B) has bad max hash\n"), + PROMPT_NONE, 0 }, + + /* Clear invalid HTREE directory */ + { PR_2_HTREE_CLEAR, + N_("Invalid @h %d (%q). "), PROMPT_CLEAR, 0 }, + + /* Bad block in htree interior node */ + { PR_2_HTREE_BADBLK, + N_("@p @h %d (%q): bad @b number %b.\n"), + PROMPT_CLEAR_HTREE, 0 }, + + /* Error adjusting EA refcount */ + { PR_2_ADJ_EA_REFCOUNT, + N_("Error addjusting refcount for @a @b %b (@i %i): %m\n"), + PROMPT_NONE, PR_FATAL }, + + /* Invalid HTREE root node */ + { PR_2_HTREE_BAD_ROOT, + N_("@p @h %d: root node is invalid\n"), + PROMPT_CLEAR_HTREE, PR_PREEN_OK }, + + /* Invalid HTREE limit */ + { PR_2_HTREE_BAD_LIMIT, + N_("@p @h %d: node (%B) has bad limit (%N)\n"), + PROMPT_CLEAR_HTREE, PR_PREEN_OK }, + + /* Invalid HTREE count */ + { PR_2_HTREE_BAD_COUNT, + N_("@p @h %d: node (%B) has bad count (%N)\n"), + PROMPT_CLEAR_HTREE, PR_PREEN_OK }, + + /* HTREE interior node has out-of-order hashes in table */ + { PR_2_HTREE_HASH_ORDER, + N_("@p @h %d: node (%B) has an unordered hash table\n"), + PROMPT_CLEAR_HTREE, PR_PREEN_OK }, + + /* Node in HTREE directory has bad depth */ + { PR_2_HTREE_BAD_DEPTH, + N_("@p @h %d: node (%B) has bad depth\n"), + PROMPT_NONE, 0 }, + + /* Duplicate directory entry found */ + { PR_2_DUPLICATE_DIRENT, + N_("Duplicate @E found. "), + PROMPT_CLEAR, 0 }, + + /* Non-unique filename found */ + { PR_2_NON_UNIQUE_FILE, /* xgettext: no-c-format */ + N_("@E has a non-unique filename.\nRename to %s"), + PROMPT_NULL, 0 }, + + /* Duplicate directory entry found */ + { PR_2_REPORT_DUP_DIRENT, + N_("Duplicate @e '%Dn' found.\n\tMarking %p (%i) to be rebuilt.\n\n"), + PROMPT_NONE, 0 }, + + /* Pass 3 errors */ + + /* Pass 3: Checking directory connectivity */ + { PR_3_PASS_HEADER, + N_("Pass 3: Checking @d connectivity\n"), + PROMPT_NONE, 0 }, + + /* Root inode not allocated */ + { PR_3_NO_ROOT_INODE, + N_("@r not allocated. "), + PROMPT_ALLOCATE, 0 }, + + /* No room in lost+found */ + { PR_3_EXPAND_LF_DIR, + N_("No room in @l @d. "), + PROMPT_EXPAND, 0 }, + + /* Unconnected directory inode */ + { PR_3_UNCONNECTED_DIR, + N_("Unconnected @d @i %i (%p)\n"), + PROMPT_CONNECT, 0 }, + + /* /lost+found not found */ + { PR_3_NO_LF_DIR, + N_("/@l not found. "), + PROMPT_CREATE, PR_PREEN_OK }, + + /* .. entry is incorrect */ + { PR_3_BAD_DOT_DOT, + N_("'..' in %Q (%i) is %P (%j), @s %q (%d).\n"), + PROMPT_FIX, 0 }, + + /* Bad or non-existent /lost+found. Cannot reconnect */ + { PR_3_NO_LPF, + N_("Bad or non-existent /@l. Cannot reconnect.\n"), + PROMPT_NONE, 0 }, + + /* Could not expand /lost+found */ + { PR_3_CANT_EXPAND_LPF, + N_("Could not expand /@l: %m\n"), + PROMPT_NONE, 0 }, + + /* Could not reconnect inode */ + { PR_3_CANT_RECONNECT, + N_("Could not reconnect %i: %m\n"), + PROMPT_NONE, 0 }, + + /* Error while trying to find /lost+found */ + { PR_3_ERR_FIND_LPF, + N_("Error while trying to find /@l: %m\n"), + PROMPT_NONE, 0 }, + + /* Error in ext2fs_new_block while creating /lost+found */ + { PR_3_ERR_LPF_NEW_BLOCK, + N_("ext2fs_new_@b: %m while trying to create /@l @d\n"), + PROMPT_NONE, 0 }, + + /* Error in ext2fs_new_inode while creating /lost+found */ + { PR_3_ERR_LPF_NEW_INODE, + N_("ext2fs_new_@i: %m while trying to create /@l @d\n"), + PROMPT_NONE, 0 }, + + /* Error in ext2fs_new_dir_block while creating /lost+found */ + { PR_3_ERR_LPF_NEW_DIR_BLOCK, + N_("ext2fs_new_dir_@b: %m while creating new @d @b\n"), + PROMPT_NONE, 0 }, + + /* Error while writing directory block for /lost+found */ + { PR_3_ERR_LPF_WRITE_BLOCK, + N_("ext2fs_write_dir_@b: %m while writing the @d @b for /@l\n"), + PROMPT_NONE, 0 }, + + /* Error while adjusting inode count */ + { PR_3_ADJUST_INODE, + N_("Error while adjusting @i count on @i %i\n"), + PROMPT_NONE, 0 }, + + /* Couldn't fix parent directory -- error */ + { PR_3_FIX_PARENT_ERR, + N_("Couldn't fix parent of @i %i: %m\n\n"), + PROMPT_NONE, 0 }, + + /* Couldn't fix parent directory -- couldn't find it */ + { PR_3_FIX_PARENT_NOFIND, + N_("Couldn't fix parent of @i %i: Couldn't find parent @d entry\n\n"), + PROMPT_NONE, 0 }, + + /* Error allocating inode bitmap */ + { PR_3_ALLOCATE_IBITMAP_ERROR, + N_("@A @i @B (%N): %m\n"), + PROMPT_NONE, PR_FATAL }, + + /* Error creating root directory */ + { PR_3_CREATE_ROOT_ERROR, + N_("Error creating root @d (%s): %m\n"), + PROMPT_NONE, PR_FATAL }, + + /* Error creating lost and found directory */ + { PR_3_CREATE_LPF_ERROR, + N_("Error creating /@l @d (%s): %m\n"), + PROMPT_NONE, PR_FATAL }, + + /* Root inode is not directory; aborting */ + { PR_3_ROOT_NOT_DIR_ABORT, + N_("@r is not a @d; aborting.\n"), + PROMPT_NONE, PR_FATAL }, + + /* Cannot proceed without a root inode. */ + { PR_3_NO_ROOT_INODE_ABORT, + N_("Cannot proceed without a @r.\n"), + PROMPT_NONE, PR_FATAL }, + + /* Internal error: couldn't find dir_info */ + { PR_3_NO_DIRINFO, + N_("Internal error: couldn't find dir_info for %i.\n"), + PROMPT_NONE, PR_FATAL }, + + /* Lost+found not a directory */ + { PR_3_LPF_NOTDIR, + N_("/@l is not a @d (ino=%i)\n"), + PROMPT_UNLINK, 0 }, + + /* Pass 3A Directory Optimization */ + + /* Pass 3A: Optimizing directories */ + { PR_3A_PASS_HEADER, + N_("Pass 3A: Optimizing directories\n"), + PROMPT_NONE, PR_PREEN_NOMSG }, + + /* Error iterating over directories */ + { PR_3A_OPTIMIZE_ITER, + N_("Failed to create dirs_to_hash iterator: %m"), + PROMPT_NONE, 0 }, + + /* Error rehash directory */ + { PR_3A_OPTIMIZE_DIR_ERR, + N_("Failed to optimize directory %q (%d): %m"), + PROMPT_NONE, 0 }, + + /* Rehashing dir header */ + { PR_3A_OPTIMIZE_DIR_HEADER, + N_("Optimizing directories: "), + PROMPT_NONE, PR_MSG_ONLY }, + + /* Rehashing directory %d */ + { PR_3A_OPTIMIZE_DIR, + " %d", + PROMPT_NONE, PR_LATCH_OPTIMIZE_DIR | PR_PREEN_NOHDR}, + + /* Rehashing dir end */ + { PR_3A_OPTIMIZE_DIR_END, + "\n", + PROMPT_NONE, PR_PREEN_NOHDR }, + + /* Pass 4 errors */ + + /* Pass 4: Checking reference counts */ + { PR_4_PASS_HEADER, + N_("Pass 4: Checking reference counts\n"), + PROMPT_NONE, 0 }, + + /* Unattached zero-length inode */ + { PR_4_ZERO_LEN_INODE, + "@u @z @i %i. ", + PROMPT_CLEAR, PR_PREEN_OK|PR_NO_OK }, + + /* Unattached inode */ + { PR_4_UNATTACHED_INODE, + "@u @i %i\n", + PROMPT_CONNECT, 0 }, + + /* Inode ref count wrong */ + { PR_4_BAD_REF_COUNT, + N_("@i %i ref count is %Il, @s %N. "), + PROMPT_FIX, PR_PREEN_OK }, + + { PR_4_INCONSISTENT_COUNT, + N_("WARNING: PROGRAMMING BUG IN E2FSCK!\n" + "\tOR SOME BONEHEAD (YOU) IS CHECKING A MOUNTED (LIVE) FILESYSTEM.\n" + "@i_link_info[%i] is %N, @i.i_links_count is %Il. " + "They should be the same!\n"), + PROMPT_NONE, 0 }, + + /* Pass 5 errors */ + + /* Pass 5: Checking group summary information */ + { PR_5_PASS_HEADER, + N_("Pass 5: Checking @g summary information\n"), + PROMPT_NONE, 0 }, + + /* Padding at end of inode bitmap is not set. */ + { PR_5_INODE_BMAP_PADDING, + N_("Padding at end of @i @B is not set. "), + PROMPT_FIX, PR_PREEN_OK }, + + /* Padding at end of block bitmap is not set. */ + { PR_5_BLOCK_BMAP_PADDING, + N_("Padding at end of @b @B is not set. "), + PROMPT_FIX, PR_PREEN_OK }, + + /* Block bitmap differences header */ + { PR_5_BLOCK_BITMAP_HEADER, + N_("@b @B differences: "), + PROMPT_NONE, PR_PREEN_OK | PR_PREEN_NOMSG}, + + /* Block not used, but marked in bitmap */ + { PR_5_BLOCK_UNUSED, + " -%b", + PROMPT_NONE, PR_LATCH_BBITMAP | PR_PREEN_OK | PR_PREEN_NOMSG }, + + /* Block used, but not marked used in bitmap */ + { PR_5_BLOCK_USED, + " +%b", + PROMPT_NONE, PR_LATCH_BBITMAP | PR_PREEN_OK | PR_PREEN_NOMSG }, + + /* Block bitmap differences end */ + { PR_5_BLOCK_BITMAP_END, + "\n", + PROMPT_FIX, PR_PREEN_OK | PR_PREEN_NOMSG }, + + /* Inode bitmap differences header */ + { PR_5_INODE_BITMAP_HEADER, + N_("@i @B differences: "), + PROMPT_NONE, PR_PREEN_OK | PR_PREEN_NOMSG }, + + /* Inode not used, but marked in bitmap */ + { PR_5_INODE_UNUSED, + " -%i", + PROMPT_NONE, PR_LATCH_IBITMAP | PR_PREEN_OK | PR_PREEN_NOMSG }, + + /* Inode used, but not marked used in bitmap */ + { PR_5_INODE_USED, + " +%i", + PROMPT_NONE, PR_LATCH_IBITMAP | PR_PREEN_OK | PR_PREEN_NOMSG }, + + /* Inode bitmap differences end */ + { PR_5_INODE_BITMAP_END, + "\n", + PROMPT_FIX, PR_PREEN_OK | PR_PREEN_NOMSG }, + + /* Free inodes count for group wrong */ + { PR_5_FREE_INODE_COUNT_GROUP, + N_("Free @is count wrong for @g #%g (%i, counted=%j).\n"), + PROMPT_FIX, PR_PREEN_OK | PR_PREEN_NOMSG }, + + /* Directories count for group wrong */ + { PR_5_FREE_DIR_COUNT_GROUP, + N_("Directories count wrong for @g #%g (%i, counted=%j).\n"), + PROMPT_FIX, PR_PREEN_OK | PR_PREEN_NOMSG }, + + /* Free inodes count wrong */ + { PR_5_FREE_INODE_COUNT, + N_("Free @is count wrong (%i, counted=%j).\n"), + PROMPT_FIX, PR_PREEN_OK | PR_PREEN_NOMSG }, + + /* Free blocks count for group wrong */ + { PR_5_FREE_BLOCK_COUNT_GROUP, + N_("Free @bs count wrong for @g #%g (%b, counted=%c).\n"), + PROMPT_FIX, PR_PREEN_OK | PR_PREEN_NOMSG }, + + /* Free blocks count wrong */ + { PR_5_FREE_BLOCK_COUNT, + N_("Free @bs count wrong (%b, counted=%c).\n"), + PROMPT_FIX, PR_PREEN_OK | PR_PREEN_NOMSG }, + + /* Programming error: bitmap endpoints don't match */ + { PR_5_BMAP_ENDPOINTS, + N_("PROGRAMMING ERROR: @f (#%N) @B endpoints (%b, %c) don't " + "match calculated @B endpoints (%i, %j)\n"), + PROMPT_NONE, PR_FATAL }, + + /* Internal error: fudging end of bitmap */ + { PR_5_FUDGE_BITMAP_ERROR, + N_("Internal error: fudging end of bitmap (%N)\n"), + PROMPT_NONE, PR_FATAL }, + + /* Error copying in replacement inode bitmap */ + { PR_5_COPY_IBITMAP_ERROR, + "Error copying in replacement @i @B: %m\n", + PROMPT_NONE, PR_FATAL }, + + /* Error copying in replacement block bitmap */ + { PR_5_COPY_BBITMAP_ERROR, + "Error copying in replacement @b @B: %m\n", + PROMPT_NONE, PR_FATAL }, + + /* Block range not used, but marked in bitmap */ + { PR_5_BLOCK_RANGE_UNUSED, + " -(%b--%c)", + PROMPT_NONE, PR_LATCH_BBITMAP | PR_PREEN_OK | PR_PREEN_NOMSG }, + + /* Block range used, but not marked used in bitmap */ + { PR_5_BLOCK_RANGE_USED, + " +(%b--%c)", + PROMPT_NONE, PR_LATCH_BBITMAP | PR_PREEN_OK | PR_PREEN_NOMSG }, + + /* Inode range not used, but marked in bitmap */ + { PR_5_INODE_RANGE_UNUSED, + " -(%i--%j)", + PROMPT_NONE, PR_LATCH_IBITMAP | PR_PREEN_OK | PR_PREEN_NOMSG }, + + /* Inode range used, but not marked used in bitmap */ + { PR_5_INODE_RANGE_USED, + " +(%i--%j)", + PROMPT_NONE, PR_LATCH_IBITMAP | PR_PREEN_OK | PR_PREEN_NOMSG }, + + { 0 } +}; + +/* + * This is the latch flags register. It allows several problems to be + * "latched" together. This means that the user has to answer but one + * question for the set of problems, and all of the associated + * problems will be either fixed or not fixed. + */ +static struct latch_descr pr_latch_info[] = { + { PR_LATCH_BLOCK, PR_1_INODE_BLOCK_LATCH, 0 }, + { PR_LATCH_BBLOCK, PR_1_INODE_BBLOCK_LATCH, 0 }, + { PR_LATCH_IBITMAP, PR_5_INODE_BITMAP_HEADER, PR_5_INODE_BITMAP_END }, + { PR_LATCH_BBITMAP, PR_5_BLOCK_BITMAP_HEADER, PR_5_BLOCK_BITMAP_END }, + { PR_LATCH_RELOC, PR_0_RELOCATE_HINT, 0 }, + { PR_LATCH_DBLOCK, PR_1B_DUP_BLOCK_HEADER, PR_1B_DUP_BLOCK_END }, + { PR_LATCH_LOW_DTIME, PR_1_ORPHAN_LIST_REFUGEES, 0 }, + { PR_LATCH_TOOBIG, PR_1_INODE_TOOBIG, 0 }, + { PR_LATCH_OPTIMIZE_DIR, PR_3A_OPTIMIZE_DIR_HEADER, PR_3A_OPTIMIZE_DIR_END }, + { -1, 0, 0 }, +}; + +static const struct e2fsck_problem *find_problem(problem_t code) +{ + int i; + + for (i=0; problem_table[i].e2p_code; i++) { + if (problem_table[i].e2p_code == code) + return &problem_table[i]; + } + return 0; +} + +static struct latch_descr *find_latch(int code) +{ + int i; + + for (i=0; pr_latch_info[i].latch_code >= 0; i++) { + if (pr_latch_info[i].latch_code == code) + return &pr_latch_info[i]; + } + return 0; +} + +int end_problem_latch(e2fsck_t ctx, int mask) +{ + struct latch_descr *ldesc; + struct problem_context pctx; + int answer = -1; + + ldesc = find_latch(mask); + if (ldesc->end_message && (ldesc->flags & PRL_LATCHED)) { + clear_problem_context(&pctx); + answer = fix_problem(ctx, ldesc->end_message, &pctx); + } + ldesc->flags &= ~(PRL_VARIABLE); + return answer; +} + +int set_latch_flags(int mask, int setflags, int clearflags) +{ + struct latch_descr *ldesc; + + ldesc = find_latch(mask); + if (!ldesc) + return -1; + ldesc->flags |= setflags; + ldesc->flags &= ~clearflags; + return 0; +} + +void clear_problem_context(struct problem_context *ctx) +{ + memset(ctx, 0, sizeof(struct problem_context)); + ctx->blkcount = -1; + ctx->group = -1; +} + +int fix_problem(e2fsck_t ctx, problem_t code, struct problem_context *pctx) +{ + ext2_filsys fs = ctx->fs; + const struct e2fsck_problem *ptr; + struct latch_descr *ldesc = 0; + const char *message; + int def_yn, answer, ans; + int print_answer = 0; + int suppress = 0; + + ptr = find_problem(code); + if (!ptr) { + printf(_("Unhandled error code (0x%x)!\n"), code); + return 0; + } + def_yn = 1; + if ((ptr->flags & PR_NO_DEFAULT) || + ((ptr->flags & PR_PREEN_NO) && (ctx->options & E2F_OPT_PREEN)) || + (ctx->options & E2F_OPT_NO)) + def_yn= 0; + + /* + * Do special latch processing. This is where we ask the + * latch question, if it exists + */ + if (ptr->flags & PR_LATCH_MASK) { + ldesc = find_latch(ptr->flags & PR_LATCH_MASK); + if (ldesc->question && !(ldesc->flags & PRL_LATCHED)) { + ans = fix_problem(ctx, ldesc->question, pctx); + if (ans == 1) + ldesc->flags |= PRL_YES; + if (ans == 0) + ldesc->flags |= PRL_NO; + ldesc->flags |= PRL_LATCHED; + } + if (ldesc->flags & PRL_SUPPRESS) + suppress++; + } + if ((ptr->flags & PR_PREEN_NOMSG) && + (ctx->options & E2F_OPT_PREEN)) + suppress++; + if ((ptr->flags & PR_NO_NOMSG) && + (ctx->options & E2F_OPT_NO)) + suppress++; + if (!suppress) { + message = ptr->e2p_description; + if ((ctx->options & E2F_OPT_PREEN) && + !(ptr->flags & PR_PREEN_NOHDR)) { + printf("%s: ", ctx->device_name ? + ctx->device_name : ctx->filesystem_name); + } + if (*message) + print_e2fsck_message(ctx, _(message), pctx, 1); + } + if (!(ptr->flags & PR_PREEN_OK) && (ptr->prompt != PROMPT_NONE)) + preenhalt(ctx); + + if (ptr->flags & PR_FATAL) + fatal_error(ctx, 0); + + if (ptr->prompt == PROMPT_NONE) { + if (ptr->flags & PR_NOCOLLATE) + answer = -1; + else + answer = def_yn; + } else { + if (ctx->options & E2F_OPT_PREEN) { + answer = def_yn; + if (!(ptr->flags & PR_PREEN_NOMSG)) + print_answer = 1; + } else if ((ptr->flags & PR_LATCH_MASK) && + (ldesc->flags & (PRL_YES | PRL_NO))) { + if (!suppress) + print_answer = 1; + if (ldesc->flags & PRL_YES) + answer = 1; + else + answer = 0; + } else + answer = ask(ctx, _(prompt[(int) ptr->prompt]), def_yn); + if (!answer && !(ptr->flags & PR_NO_OK)) + ext2fs_unmark_valid(fs); + + if (print_answer) + printf("%s.\n", answer ? + _(preen_msg[(int) ptr->prompt]) : _("IGNORED")); + + } + + if ((ptr->prompt == PROMPT_ABORT) && answer) + fatal_error(ctx, 0); + + if (ptr->flags & PR_AFTER_CODE) + answer = fix_problem(ctx, ptr->second_code, pctx); + + return answer; +} +/* + * linux/fs/recovery.c + * + * Written by Stephen C. Tweedie , 1999 + * + * Copyright 1999-2000 Red Hat Software --- All Rights Reserved + * + * This file is part of the Linux kernel and is made available under + * the terms of the GNU General Public License, version 2, or at your + * option, any later version, incorporated herein by reference. + * + * Journal recovery routines for the generic filesystem journaling code; + * part of the ext2fs journaling system. + */ + +/* + * Maintain information about the progress of the recovery job, so that + * the different passes can carry information between them. + */ +struct recovery_info +{ + tid_t start_transaction; + tid_t end_transaction; + + int nr_replays; + int nr_revokes; + int nr_revoke_hits; +}; + +enum passtype {PASS_SCAN, PASS_REVOKE, PASS_REPLAY}; +static int do_one_pass(journal_t *journal, + struct recovery_info *info, enum passtype pass); +static int scan_revoke_records(journal_t *, struct buffer_head *, + tid_t, struct recovery_info *); + +#ifdef __KERNEL__ + +/* Release readahead buffers after use */ +void journal_brelse_array(struct buffer_head *b[], int n) +{ + while (--n >= 0) + brelse (b[n]); +} + + +/* + * When reading from the journal, we are going through the block device + * layer directly and so there is no readahead being done for us. We + * need to implement any readahead ourselves if we want it to happen at + * all. Recovery is basically one long sequential read, so make sure we + * do the IO in reasonably large chunks. + * + * This is not so critical that we need to be enormously clever about + * the readahead size, though. 128K is a purely arbitrary, good-enough + * fixed value. + */ + +#define MAXBUF 8 +static int do_readahead(journal_t *journal, unsigned int start) +{ + int err; + unsigned int max, nbufs, next; + unsigned long blocknr; + struct buffer_head *bh; + + struct buffer_head * bufs[MAXBUF]; + + /* Do up to 128K of readahead */ + max = start + (128 * 1024 / journal->j_blocksize); + if (max > journal->j_maxlen) + max = journal->j_maxlen; + + /* Do the readahead itself. We'll submit MAXBUF buffer_heads at + * a time to the block device IO layer. */ + + nbufs = 0; + + for (next = start; next < max; next++) { + err = journal_bmap(journal, next, &blocknr); + + if (err) { + printk (KERN_ERR "JBD: bad block at offset %u\n", + next); + goto failed; + } + + bh = __getblk(journal->j_dev, blocknr, journal->j_blocksize); + if (!bh) { + err = -ENOMEM; + goto failed; + } + + if (!buffer_uptodate(bh) && !buffer_locked(bh)) { + bufs[nbufs++] = bh; + if (nbufs == MAXBUF) { + ll_rw_block(READ, nbufs, bufs); + journal_brelse_array(bufs, nbufs); + nbufs = 0; + } + } else + brelse(bh); + } + + if (nbufs) + ll_rw_block(READ, nbufs, bufs); + err = 0; + +failed: + if (nbufs) + journal_brelse_array(bufs, nbufs); + return err; +} + +#endif /* __KERNEL__ */ + + +/* + * Read a block from the journal + */ + +static int jread(struct buffer_head **bhp, journal_t *journal, + unsigned int offset) +{ + int err; + unsigned long blocknr; + struct buffer_head *bh; + + *bhp = NULL; + + J_ASSERT (offset < journal->j_maxlen); + + err = journal_bmap(journal, offset, &blocknr); + + if (err) { + printk (KERN_ERR "JBD: bad block at offset %u\n", + offset); + return err; + } + + bh = __getblk(journal->j_dev, blocknr, journal->j_blocksize); + if (!bh) + return -ENOMEM; + + if (!buffer_uptodate(bh)) { + /* If this is a brand new buffer, start readahead. + Otherwise, we assume we are already reading it. */ + if (!buffer_req(bh)) + do_readahead(journal, offset); + wait_on_buffer(bh); + } + + if (!buffer_uptodate(bh)) { + printk (KERN_ERR "JBD: Failed to read block at offset %u\n", + offset); + brelse(bh); + return -EIO; + } + + *bhp = bh; + return 0; +} + + +/* + * Count the number of in-use tags in a journal descriptor block. + */ + +static int count_tags(struct buffer_head *bh, int size) +{ + char * tagp; + journal_block_tag_t * tag; + int nr = 0; + + tagp = &bh->b_data[sizeof(journal_header_t)]; + + while ((tagp - bh->b_data + sizeof(journal_block_tag_t)) <= size) { + tag = (journal_block_tag_t *) tagp; + + nr++; + tagp += sizeof(journal_block_tag_t); + if (!(tag->t_flags & htonl(JFS_FLAG_SAME_UUID))) + tagp += 16; + + if (tag->t_flags & htonl(JFS_FLAG_LAST_TAG)) + break; + } + + return nr; +} + + +/* Make sure we wrap around the log correctly! */ +#define wrap(journal, var) \ +do { \ + if (var >= (journal)->j_last) \ + var -= ((journal)->j_last - (journal)->j_first); \ +} while (0) + +/** + * int journal_recover(journal_t *journal) - recovers a on-disk journal + * @journal: the journal to recover + * + * The primary function for recovering the log contents when mounting a + * journaled device. + * + * Recovery is done in three passes. In the first pass, we look for the + * end of the log. In the second, we assemble the list of revoke + * blocks. In the third and final pass, we replay any un-revoked blocks + * in the log. + */ +int journal_recover(journal_t *journal) +{ + int err; + journal_superblock_t * sb; + + struct recovery_info info; + + memset(&info, 0, sizeof(info)); + sb = journal->j_superblock; + + /* + * The journal superblock's s_start field (the current log head) + * is always zero if, and only if, the journal was cleanly + * unmounted. + */ + + if (!sb->s_start) { + jbd_debug(1, "No recovery required, last transaction %d\n", + ntohl(sb->s_sequence)); + journal->j_transaction_sequence = ntohl(sb->s_sequence) + 1; + return 0; + } + + err = do_one_pass(journal, &info, PASS_SCAN); + if (!err) + err = do_one_pass(journal, &info, PASS_REVOKE); + if (!err) + err = do_one_pass(journal, &info, PASS_REPLAY); + + jbd_debug(0, "JBD: recovery, exit status %d, " + "recovered transactions %u to %u\n", + err, info.start_transaction, info.end_transaction); + jbd_debug(0, "JBD: Replayed %d and revoked %d/%d blocks\n", + info.nr_replays, info.nr_revoke_hits, info.nr_revokes); + + /* Restart the log at the next transaction ID, thus invalidating + * any existing commit records in the log. */ + journal->j_transaction_sequence = ++info.end_transaction; + + journal_clear_revoke(journal); + sync_blockdev(journal->j_fs_dev); + return err; +} + +static int do_one_pass(journal_t *journal, + struct recovery_info *info, enum passtype pass) +{ + unsigned int first_commit_ID, next_commit_ID; + unsigned long next_log_block; + int err, success = 0; + journal_superblock_t * sb; + journal_header_t * tmp; + struct buffer_head * bh; + unsigned int sequence; + int blocktype; + + /* Precompute the maximum metadata descriptors in a descriptor block */ + int MAX_BLOCKS_PER_DESC; + MAX_BLOCKS_PER_DESC = ((journal->j_blocksize-sizeof(journal_header_t)) + / sizeof(journal_block_tag_t)); + + /* + * First thing is to establish what we expect to find in the log + * (in terms of transaction IDs), and where (in terms of log + * block offsets): query the superblock. + */ + + sb = journal->j_superblock; + next_commit_ID = ntohl(sb->s_sequence); + next_log_block = ntohl(sb->s_start); + + first_commit_ID = next_commit_ID; + if (pass == PASS_SCAN) + info->start_transaction = first_commit_ID; + + jbd_debug(1, "Starting recovery pass %d\n", pass); + + /* + * Now we walk through the log, transaction by transaction, + * making sure that each transaction has a commit block in the + * expected place. Each complete transaction gets replayed back + * into the main filesystem. + */ + + while (1) { + int flags; + char * tagp; + journal_block_tag_t * tag; + struct buffer_head * obh; + struct buffer_head * nbh; + + /* If we already know where to stop the log traversal, + * check right now that we haven't gone past the end of + * the log. */ + + if (pass != PASS_SCAN) + if (tid_geq(next_commit_ID, info->end_transaction)) + break; + + jbd_debug(2, "Scanning for sequence ID %u at %lu/%lu\n", + next_commit_ID, next_log_block, journal->j_last); + + /* Skip over each chunk of the transaction looking + * either the next descriptor block or the final commit + * record. */ + + jbd_debug(3, "JBD: checking block %ld\n", next_log_block); + err = jread(&bh, journal, next_log_block); + if (err) + goto failed; + + next_log_block++; + wrap(journal, next_log_block); + + /* What kind of buffer is it? + * + * If it is a descriptor block, check that it has the + * expected sequence number. Otherwise, we're all done + * here. */ + + tmp = (journal_header_t *)bh->b_data; + + if (tmp->h_magic != htonl(JFS_MAGIC_NUMBER)) { + brelse(bh); + break; + } + + blocktype = ntohl(tmp->h_blocktype); + sequence = ntohl(tmp->h_sequence); + jbd_debug(3, "Found magic %d, sequence %d\n", + blocktype, sequence); + + if (sequence != next_commit_ID) { + brelse(bh); + break; + } + + /* OK, we have a valid descriptor block which matches + * all of the sequence number checks. What are we going + * to do with it? That depends on the pass... */ + + switch(blocktype) { + case JFS_DESCRIPTOR_BLOCK: + /* If it is a valid descriptor block, replay it + * in pass REPLAY; otherwise, just skip over the + * blocks it describes. */ + if (pass != PASS_REPLAY) { + next_log_block += + count_tags(bh, journal->j_blocksize); + wrap(journal, next_log_block); + brelse(bh); + continue; + } + + /* A descriptor block: we can now write all of + * the data blocks. Yay, useful work is finally + * getting done here! */ + + tagp = &bh->b_data[sizeof(journal_header_t)]; + while ((tagp - bh->b_data +sizeof(journal_block_tag_t)) + <= journal->j_blocksize) { + unsigned long io_block; + + tag = (journal_block_tag_t *) tagp; + flags = ntohl(tag->t_flags); + + io_block = next_log_block++; + wrap(journal, next_log_block); + err = jread(&obh, journal, io_block); + if (err) { + /* Recover what we can, but + * report failure at the end. */ + success = err; + printk (KERN_ERR + "JBD: IO error %d recovering " + "block %ld in log\n", + err, io_block); + } else { + unsigned long blocknr; + + J_ASSERT(obh != NULL); + blocknr = ntohl(tag->t_blocknr); + + /* If the block has been + * revoked, then we're all done + * here. */ + if (journal_test_revoke + (journal, blocknr, + next_commit_ID)) { + brelse(obh); + ++info->nr_revoke_hits; + goto skip_write; + } + + /* Find a buffer for the new + * data being restored */ + nbh = __getblk(journal->j_fs_dev, + blocknr, + journal->j_blocksize); + if (nbh == NULL) { + printk(KERN_ERR + "JBD: Out of memory " + "during recovery.\n"); + err = -ENOMEM; + brelse(bh); + brelse(obh); + goto failed; + } + + lock_buffer(nbh); + memcpy(nbh->b_data, obh->b_data, + journal->j_blocksize); + if (flags & JFS_FLAG_ESCAPE) { + *((unsigned int *)bh->b_data) = + htonl(JFS_MAGIC_NUMBER); + } + + BUFFER_TRACE(nbh, "marking dirty"); + set_buffer_uptodate(nbh); + mark_buffer_dirty(nbh); + BUFFER_TRACE(nbh, "marking uptodate"); + ++info->nr_replays; + /* ll_rw_block(WRITE, 1, &nbh); */ + unlock_buffer(nbh); + brelse(obh); + brelse(nbh); + } + + skip_write: + tagp += sizeof(journal_block_tag_t); + if (!(flags & JFS_FLAG_SAME_UUID)) + tagp += 16; + + if (flags & JFS_FLAG_LAST_TAG) + break; + } + + brelse(bh); + continue; + + case JFS_COMMIT_BLOCK: + /* Found an expected commit block: not much to + * do other than move on to the next sequence + * number. */ + brelse(bh); + next_commit_ID++; + continue; + + case JFS_REVOKE_BLOCK: + /* If we aren't in the REVOKE pass, then we can + * just skip over this block. */ + if (pass != PASS_REVOKE) { + brelse(bh); + continue; + } + + err = scan_revoke_records(journal, bh, + next_commit_ID, info); + brelse(bh); + if (err) + goto failed; + continue; + + default: + jbd_debug(3, "Unrecognised magic %d, end of scan.\n", + blocktype); + goto done; + } + } + + done: + /* + * We broke out of the log scan loop: either we came to the + * known end of the log or we found an unexpected block in the + * log. If the latter happened, then we know that the "current" + * transaction marks the end of the valid log. + */ + + if (pass == PASS_SCAN) + info->end_transaction = next_commit_ID; + else { + /* It's really bad news if different passes end up at + * different places (but possible due to IO errors). */ + if (info->end_transaction != next_commit_ID) { + printk (KERN_ERR "JBD: recovery pass %d ended at " + "transaction %u, expected %u\n", + pass, next_commit_ID, info->end_transaction); + if (!success) + success = -EIO; + } + } + + return success; + + failed: + return err; +} + + +/* Scan a revoke record, marking all blocks mentioned as revoked. */ + +static int scan_revoke_records(journal_t *journal, struct buffer_head *bh, + tid_t sequence, struct recovery_info *info) +{ + journal_revoke_header_t *header; + int offset, max; + + header = (journal_revoke_header_t *) bh->b_data; + offset = sizeof(journal_revoke_header_t); + max = ntohl(header->r_count); + + while (offset < max) { + unsigned long blocknr; + int err; + + blocknr = ntohl(* ((unsigned int *) (bh->b_data+offset))); + offset += 4; + err = journal_set_revoke(journal, blocknr, sequence); + if (err) + return err; + ++info->nr_revokes; + } + return 0; +} +/* + * region.c --- code which manages allocations within a region. + * + * Copyright (C) 2001 Theodore Ts'o. + * + * %Begin-Header% + * This file may be redistributed under the terms of the GNU Public + * License. + * %End-Header% + */ + +struct region_el { + region_addr_t start; + region_addr_t end; + struct region_el *next; +}; + +struct region_struct { + region_addr_t min; + region_addr_t max; + struct region_el *allocated; +}; + +region_t region_create(region_addr_t min, region_addr_t max) +{ + region_t region; + + region = malloc(sizeof(struct region_struct)); + if (!region) + return NULL; + memset(region, 0, sizeof(struct region_struct)); + region->min = min; + region->max = max; + return region; +} + +void region_free(region_t region) +{ + struct region_el *r, *next; + + for (r = region->allocated; r; r = next) { + next = r->next; + free(r); + } + memset(region, 0, sizeof(struct region_struct)); + free(region); +} + +int region_allocate(region_t region, region_addr_t start, int n) +{ + struct region_el *r, *new_region, *prev, *next; + region_addr_t end; + + end = start+n; + if ((start < region->min) || (end > region->max)) + return -1; + if (n == 0) + return 1; + + /* + * Search through the linked list. If we find that it + * conflicts witih something that's already allocated, return + * 1; if we can find an existing region which we can grow, do + * so. Otherwise, stop when we find the appropriate place + * insert a new region element into the linked list. + */ + for (r = region->allocated, prev=NULL; r; prev = r, r = r->next) { + if (((start >= r->start) && (start < r->end)) || + ((end > r->start) && (end <= r->end)) || + ((start <= r->start) && (end >= r->end))) + return 1; + if (end == r->start) { + r->start = start; + return 0; + } + if (start == r->end) { + if ((next = r->next)) { + if (end > next->start) + return 1; + if (end == next->start) { + r->end = next->end; + r->next = next->next; + free(next); + return 0; + } + } + r->end = end; + return 0; + } + if (start < r->start) + break; + } + /* + * Insert a new region element structure into the linked list + */ + new_region = malloc(sizeof(struct region_el)); + if (!new_region) + return -1; + new_region->start = start; + new_region->end = start + n; + new_region->next = r; + if (prev) + prev->next = new_region; + else + region->allocated = new_region; + return 0; +} + +/* + * rehash.c --- rebuild hash tree directories + * + * Copyright (C) 2002 Theodore Ts'o + * + * %Begin-Header% + * This file may be redistributed under the terms of the GNU Public + * License. + * %End-Header% + * + * This algorithm is designed for simplicity of implementation and to + * pack the directory as much as possible. It however requires twice + * as much memory as the size of the directory. The maximum size + * directory supported using a 4k blocksize is roughly a gigabyte, and + * so there may very well be problems with machines that don't have + * virtual memory, and obscenely large directories. + * + * An alternate algorithm which is much more disk intensive could be + * written, and probably will need to be written in the future. The + * design goals of such an algorithm are: (a) use (roughly) constant + * amounts of memory, no matter how large the directory, (b) the + * directory must be safe at all times, even if e2fsck is interrupted + * in the middle, (c) we must use minimal amounts of extra disk + * blocks. This pretty much requires an incremental approach, where + * we are reading from one part of the directory, and inserting into + * the front half. So the algorithm will have to keep track of a + * moving block boundary between the new tree and the old tree, and + * files will need to be moved from the old directory and inserted + * into the new tree. If the new directory requires space which isn't + * yet available, blocks from the beginning part of the old directory + * may need to be moved to the end of the directory to make room for + * the new tree: + * + * -------------------------------------------------------- + * | new tree | | old tree | + * -------------------------------------------------------- + * ^ ptr ^ptr + * tail new head old + * + * This is going to be a pain in the tuckus to implement, and will + * require a lot more disk accesses. So I'm going to skip it for now; + * it's only really going to be an issue for really, really big + * filesystems (when we reach the level of tens of millions of files + * in a single directory). It will probably be easier to simply + * require that e2fsck use VM first. + */ + +struct fill_dir_struct { + char *buf; + struct ext2_inode *inode; + int err; + e2fsck_t ctx; + struct hash_entry *harray; + int max_array, num_array; + int dir_size; + int compress; + ino_t parent; +}; + +struct hash_entry { + ext2_dirhash_t hash; + ext2_dirhash_t minor_hash; + struct ext2_dir_entry *dir; +}; + +struct out_dir { + int num; + int max; + char *buf; + ext2_dirhash_t *hashes; +}; + +static int fill_dir_block(ext2_filsys fs, + blk_t *block_nr, + e2_blkcnt_t blockcnt, + blk_t ref_block EXT2FS_ATTR((unused)), + int ref_offset EXT2FS_ATTR((unused)), + void *priv_data) +{ + struct fill_dir_struct *fd = (struct fill_dir_struct *) priv_data; + struct hash_entry *new_array, *ent; + struct ext2_dir_entry *dirent; + char *dir; + unsigned int offset, dir_offset; + + if (blockcnt < 0) + return 0; + + offset = blockcnt * fs->blocksize; + if (offset + fs->blocksize > fd->inode->i_size) { + fd->err = EXT2_ET_DIR_CORRUPTED; + return BLOCK_ABORT; + } + dir = (fd->buf+offset); + if (HOLE_BLKADDR(*block_nr)) { + memset(dir, 0, fs->blocksize); + dirent = (struct ext2_dir_entry *) dir; + dirent->rec_len = fs->blocksize; + } else { + fd->err = ext2fs_read_dir_block(fs, *block_nr, dir); + if (fd->err) + return BLOCK_ABORT; + } + /* While the directory block is "hot", index it. */ + dir_offset = 0; + while (dir_offset < fs->blocksize) { + dirent = (struct ext2_dir_entry *) (dir + dir_offset); + if (((dir_offset + dirent->rec_len) > fs->blocksize) || + (dirent->rec_len < 8) || + ((dirent->rec_len % 4) != 0) || + (((dirent->name_len & 0xFF)+8) > dirent->rec_len)) { + fd->err = EXT2_ET_DIR_CORRUPTED; + return BLOCK_ABORT; + } + dir_offset += dirent->rec_len; + if (dirent->inode == 0) + continue; + if (!fd->compress && ((dirent->name_len&0xFF) == 1) && + (dirent->name[0] == '.')) + continue; + if (!fd->compress && ((dirent->name_len&0xFF) == 2) && + (dirent->name[0] == '.') && (dirent->name[1] == '.')) { + fd->parent = dirent->inode; + continue; + } + if (fd->num_array >= fd->max_array) { + new_array = realloc(fd->harray, + sizeof(struct hash_entry) * (fd->max_array+500)); + if (!new_array) { + fd->err = ENOMEM; + return BLOCK_ABORT; + } + fd->harray = new_array; + fd->max_array += 500; + } + ent = fd->harray + fd->num_array++; + ent->dir = dirent; + fd->dir_size += EXT2_DIR_REC_LEN(dirent->name_len & 0xFF); + if (fd->compress) + ent->hash = ent->minor_hash = 0; + else { + fd->err = ext2fs_dirhash(fs->super->s_def_hash_version, + dirent->name, + dirent->name_len & 0xFF, + fs->super->s_hash_seed, + &ent->hash, &ent->minor_hash); + if (fd->err) + return BLOCK_ABORT; + } + } + + return 0; +} + +/* Used for sorting the hash entry */ +static EXT2_QSORT_TYPE name_cmp(const void *a, const void *b) +{ + const struct hash_entry *he_a = (const struct hash_entry *) a; + const struct hash_entry *he_b = (const struct hash_entry *) b; + int ret; + int min_len; + + min_len = he_a->dir->name_len; + if (min_len > he_b->dir->name_len) + min_len = he_b->dir->name_len; + + ret = strncmp(he_a->dir->name, he_b->dir->name, min_len); + if (ret == 0) { + if (he_a->dir->name_len > he_b->dir->name_len) + ret = 1; + else if (he_a->dir->name_len < he_b->dir->name_len) + ret = -1; + else + ret = he_b->dir->inode - he_a->dir->inode; + } + return ret; +} + +/* Used for sorting the hash entry */ +static EXT2_QSORT_TYPE hash_cmp(const void *a, const void *b) +{ + const struct hash_entry *he_a = (const struct hash_entry *) a; + const struct hash_entry *he_b = (const struct hash_entry *) b; + int ret; + + if (he_a->hash > he_b->hash) + ret = 1; + else if (he_a->hash < he_b->hash) + ret = -1; + else { + if (he_a->minor_hash > he_b->minor_hash) + ret = 1; + else if (he_a->minor_hash < he_b->minor_hash) + ret = -1; + else + ret = name_cmp(a, b); + } + return ret; +} + +static errcode_t alloc_size_dir(ext2_filsys fs, struct out_dir *outdir, + int blocks) +{ + void *new_mem; + + if (outdir->max) { + new_mem = realloc(outdir->buf, blocks * fs->blocksize); + if (!new_mem) + return ENOMEM; + outdir->buf = new_mem; + new_mem = realloc(outdir->hashes, + blocks * sizeof(ext2_dirhash_t)); + if (!new_mem) + return ENOMEM; + outdir->hashes = new_mem; + } else { + outdir->buf = malloc(blocks * fs->blocksize); + outdir->hashes = malloc(blocks * sizeof(ext2_dirhash_t)); + outdir->num = 0; + } + outdir->max = blocks; + return 0; +} + +static void free_out_dir(struct out_dir *outdir) +{ + if (outdir->buf) + free(outdir->buf); + if (outdir->hashes) + free(outdir->hashes); + outdir->max = 0; + outdir->num =0; +} + +static errcode_t get_next_block(ext2_filsys fs, struct out_dir *outdir, + char ** ret) +{ + errcode_t retval; + + if (outdir->num >= outdir->max) { + retval = alloc_size_dir(fs, outdir, outdir->max + 50); + if (retval) + return retval; + } + *ret = outdir->buf + (outdir->num++ * fs->blocksize); + memset(*ret, 0, fs->blocksize); + return 0; +} + +/* + * This function is used to make a unique filename. We do this by + * appending ~0, and then incrementing the number. However, we cannot + * expand the length of the filename beyond the padding available in + * the directory entry. + */ +static void mutate_name(char *str, __u16 *len) +{ + int i; + __u16 l = *len & 0xFF, h = *len & 0xff00; + + /* + * First check to see if it looks the name has been mutated + * already + */ + for (i = l-1; i > 0; i--) { + if (!isdigit(str[i])) + break; + } + if ((i == l-1) || (str[i] != '~')) { + if (((l-1) & 3) < 2) + l += 2; + else + l = (l+3) & ~3; + str[l-2] = '~'; + str[l-1] = '0'; + *len = l | h; + return; + } + for (i = l-1; i >= 0; i--) { + if (isdigit(str[i])) { + if (str[i] == '9') + str[i] = '0'; + else { + str[i]++; + return; + } + continue; + } + if (i == 1) { + if (str[0] == 'z') + str[0] = 'A'; + else if (str[0] == 'Z') { + str[0] = '~'; + str[1] = '0'; + } else + str[0]++; + } else if (i > 0) { + str[i] = '1'; + str[i-1] = '~'; + } else { + if (str[0] == '~') + str[0] = 'a'; + else + str[0]++; + } + break; + } +} + +static int duplicate_search_and_fix(e2fsck_t ctx, ext2_filsys fs, + ext2_ino_t ino, + struct fill_dir_struct *fd) +{ + struct problem_context pctx; + struct hash_entry *ent, *prev; + int i, j; + int fixed = 0; + char new_name[256]; + __u16 new_len; + + clear_problem_context(&pctx); + pctx.ino = ino; + + for (i=1; i < fd->num_array; i++) { + ent = fd->harray + i; + prev = ent - 1; + if (!ent->dir->inode || + ((ent->dir->name_len & 0xFF) != + (prev->dir->name_len & 0xFF)) || + (strncmp(ent->dir->name, prev->dir->name, + ent->dir->name_len & 0xFF))) + continue; + pctx.dirent = ent->dir; + if ((ent->dir->inode == prev->dir->inode) && + fix_problem(ctx, PR_2_DUPLICATE_DIRENT, &pctx)) { + e2fsck_adjust_inode_count(ctx, ent->dir->inode, -1); + ent->dir->inode = 0; + fixed++; + continue; + } + memcpy(new_name, ent->dir->name, ent->dir->name_len & 0xFF); + new_len = ent->dir->name_len; + mutate_name(new_name, &new_len); + for (j=0; j < fd->num_array; j++) { + if ((i==j) || + ((ent->dir->name_len & 0xFF) != + (fd->harray[j].dir->name_len & 0xFF)) || + (strncmp(new_name, fd->harray[j].dir->name, + new_len & 0xFF))) + continue; + mutate_name(new_name, &new_len); + + j = -1; + } + new_name[new_len & 0xFF] = 0; + pctx.str = new_name; + if (fix_problem(ctx, PR_2_NON_UNIQUE_FILE, &pctx)) { + memcpy(ent->dir->name, new_name, new_len & 0xFF); + ent->dir->name_len = new_len; + ext2fs_dirhash(fs->super->s_def_hash_version, + ent->dir->name, + ent->dir->name_len & 0xFF, + fs->super->s_hash_seed, + &ent->hash, &ent->minor_hash); + fixed++; + } + } + return fixed; +} + + +static errcode_t copy_dir_entries(ext2_filsys fs, + struct fill_dir_struct *fd, + struct out_dir *outdir) +{ + errcode_t retval; + char *block_start; + struct hash_entry *ent; + struct ext2_dir_entry *dirent; + int i, rec_len, left; + ext2_dirhash_t prev_hash; + int offset; + + outdir->max = 0; + retval = alloc_size_dir(fs, outdir, + (fd->dir_size / fs->blocksize) + 2); + if (retval) + return retval; + outdir->num = fd->compress ? 0 : 1; + offset = 0; + outdir->hashes[0] = 0; + prev_hash = 1; + if ((retval = get_next_block(fs, outdir, &block_start))) + return retval; + dirent = (struct ext2_dir_entry *) block_start; + left = fs->blocksize; + for (i=0; i < fd->num_array; i++) { + ent = fd->harray + i; + if (ent->dir->inode == 0) + continue; + rec_len = EXT2_DIR_REC_LEN(ent->dir->name_len & 0xFF); + if (rec_len > left) { + if (left) + dirent->rec_len += left; + if ((retval = get_next_block(fs, outdir, + &block_start))) + return retval; + offset = 0; + } + left = fs->blocksize - offset; + dirent = (struct ext2_dir_entry *) (block_start + offset); + if (offset == 0) { + if (ent->hash == prev_hash) + outdir->hashes[outdir->num-1] = ent->hash | 1; + else + outdir->hashes[outdir->num-1] = ent->hash; + } + dirent->inode = ent->dir->inode; + dirent->name_len = ent->dir->name_len; + dirent->rec_len = rec_len; + memcpy(dirent->name, ent->dir->name, dirent->name_len & 0xFF); + offset += rec_len; + left -= rec_len; + if (left < 12) { + dirent->rec_len += left; + offset += left; + left = 0; + } + prev_hash = ent->hash; + } + if (left) + dirent->rec_len += left; + + return 0; +} + + +static struct ext2_dx_root_info *set_root_node(ext2_filsys fs, char *buf, + ext2_ino_t ino, ext2_ino_t parent) +{ + struct ext2_dir_entry *dir; + struct ext2_dx_root_info *root; + struct ext2_dx_countlimit *limits; + int filetype = 0; + + if (fs->super->s_feature_incompat & EXT2_FEATURE_INCOMPAT_FILETYPE) + filetype = EXT2_FT_DIR << 8; + + memset(buf, 0, fs->blocksize); + dir = (struct ext2_dir_entry *) buf; + dir->inode = ino; + dir->name[0] = '.'; + dir->name_len = 1 | filetype; + dir->rec_len = 12; + dir = (struct ext2_dir_entry *) (buf + 12); + dir->inode = parent; + dir->name[0] = '.'; + dir->name[1] = '.'; + dir->name_len = 2 | filetype; + dir->rec_len = fs->blocksize - 12; + + root = (struct ext2_dx_root_info *) (buf+24); + root->reserved_zero = 0; + root->hash_version = fs->super->s_def_hash_version; + root->info_length = 8; + root->indirect_levels = 0; + root->unused_flags = 0; + + limits = (struct ext2_dx_countlimit *) (buf+32); + limits->limit = (fs->blocksize - 32) / sizeof(struct ext2_dx_entry); + limits->count = 0; + + return root; +} + + +static struct ext2_dx_entry *set_int_node(ext2_filsys fs, char *buf) +{ + struct ext2_dir_entry *dir; + struct ext2_dx_countlimit *limits; + + memset(buf, 0, fs->blocksize); + dir = (struct ext2_dir_entry *) buf; + dir->inode = 0; + dir->rec_len = fs->blocksize; + + limits = (struct ext2_dx_countlimit *) (buf+8); + limits->limit = (fs->blocksize - 8) / sizeof(struct ext2_dx_entry); + limits->count = 0; + + return (struct ext2_dx_entry *) limits; +} + +/* + * This function takes the leaf nodes which have been written in + * outdir, and populates the root node and any necessary interior nodes. + */ +static errcode_t calculate_tree(ext2_filsys fs, + struct out_dir *outdir, + ext2_ino_t ino, + ext2_ino_t parent) +{ + struct ext2_dx_root_info *root_info; + struct ext2_dx_entry *root, *dx_ent = 0; + struct ext2_dx_countlimit *root_limit, *limit; + errcode_t retval; + char * block_start; + int i, c1, c2, nblks; + int limit_offset, root_offset; + + root_info = set_root_node(fs, outdir->buf, ino, parent); + root_offset = limit_offset = ((char *) root_info - outdir->buf) + + root_info->info_length; + root_limit = (struct ext2_dx_countlimit *) (outdir->buf + limit_offset); + c1 = root_limit->limit; + nblks = outdir->num; + + /* Write out the pointer blocks */ + if (nblks-1 <= c1) { + /* Just write out the root block, and we're done */ + root = (struct ext2_dx_entry *) (outdir->buf + root_offset); + for (i=1; i < nblks; i++) { + root->block = ext2fs_cpu_to_le32(i); + if (i != 1) + root->hash = + ext2fs_cpu_to_le32(outdir->hashes[i]); + root++; + c1--; + } + } else { + c2 = 0; + limit = 0; + root_info->indirect_levels = 1; + for (i=1; i < nblks; i++) { + if (c1 == 0) + return ENOSPC; + if (c2 == 0) { + if (limit) + limit->limit = limit->count = + ext2fs_cpu_to_le16(limit->limit); + root = (struct ext2_dx_entry *) + (outdir->buf + root_offset); + root->block = ext2fs_cpu_to_le32(outdir->num); + if (i != 1) + root->hash = + ext2fs_cpu_to_le32(outdir->hashes[i]); + if ((retval = get_next_block(fs, outdir, + &block_start))) + return retval; + dx_ent = set_int_node(fs, block_start); + limit = (struct ext2_dx_countlimit *) dx_ent; + c2 = limit->limit; + root_offset += sizeof(struct ext2_dx_entry); + c1--; + } + dx_ent->block = ext2fs_cpu_to_le32(i); + if (c2 != limit->limit) + dx_ent->hash = + ext2fs_cpu_to_le32(outdir->hashes[i]); + dx_ent++; + c2--; + } + limit->count = ext2fs_cpu_to_le16(limit->limit - c2); + limit->limit = ext2fs_cpu_to_le16(limit->limit); + } + root_limit = (struct ext2_dx_countlimit *) (outdir->buf + limit_offset); + root_limit->count = ext2fs_cpu_to_le16(root_limit->limit - c1); + root_limit->limit = ext2fs_cpu_to_le16(root_limit->limit); + + return 0; +} + +struct write_dir_struct { + struct out_dir *outdir; + errcode_t err; + e2fsck_t ctx; + int cleared; +}; + +/* + * Helper function which writes out a directory block. + */ +static int write_dir_block(ext2_filsys fs, + blk_t *block_nr, + e2_blkcnt_t blockcnt, + blk_t ref_block EXT2FS_ATTR((unused)), + int ref_offset EXT2FS_ATTR((unused)), + void *priv_data) +{ + struct write_dir_struct *wd = (struct write_dir_struct *) priv_data; + blk_t blk; + char *dir; + + if (*block_nr == 0) + return 0; + if (blockcnt >= wd->outdir->num) { + e2fsck_read_bitmaps(wd->ctx); + blk = *block_nr; + ext2fs_unmark_block_bitmap(wd->ctx->block_found_map, blk); + ext2fs_block_alloc_stats(fs, blk, -1); + *block_nr = 0; + wd->cleared++; + return BLOCK_CHANGED; + } + if (blockcnt < 0) + return 0; + + dir = wd->outdir->buf + (blockcnt * fs->blocksize); + wd->err = ext2fs_write_dir_block(fs, *block_nr, dir); + if (wd->err) + return BLOCK_ABORT; + return 0; +} + +static errcode_t write_directory(e2fsck_t ctx, ext2_filsys fs, + struct out_dir *outdir, + ext2_ino_t ino, int compress) +{ + struct write_dir_struct wd; + errcode_t retval; + struct ext2_inode inode; + + retval = e2fsck_expand_directory(ctx, ino, -1, outdir->num); + if (retval) + return retval; + + wd.outdir = outdir; + wd.err = 0; + wd.ctx = ctx; + wd.cleared = 0; + + retval = ext2fs_block_iterate2(fs, ino, 0, 0, + write_dir_block, &wd); + if (retval) + return retval; + if (wd.err) + return wd.err; + + e2fsck_read_inode(ctx, ino, &inode, "rehash_dir"); + if (compress) + inode.i_flags &= ~EXT2_INDEX_FL; + else + inode.i_flags |= EXT2_INDEX_FL; + inode.i_size = outdir->num * fs->blocksize; + inode.i_blocks -= (fs->blocksize / 512) * wd.cleared; + e2fsck_write_inode(ctx, ino, &inode, "rehash_dir"); + + return 0; +} + +errcode_t e2fsck_rehash_dir(e2fsck_t ctx, ext2_ino_t ino) +{ + ext2_filsys fs = ctx->fs; + errcode_t retval; + struct ext2_inode inode; + char *dir_buf = 0; + struct fill_dir_struct fd; + struct out_dir outdir; + + outdir.max = outdir.num = 0; + outdir.buf = 0; + outdir.hashes = 0; + e2fsck_read_inode(ctx, ino, &inode, "rehash_dir"); + + retval = ENOMEM; + fd.harray = 0; + dir_buf = malloc(inode.i_size); + if (!dir_buf) + goto errout; + + fd.max_array = inode.i_size / 32; + fd.num_array = 0; + fd.harray = malloc(fd.max_array * sizeof(struct hash_entry)); + if (!fd.harray) + goto errout; + + fd.ctx = ctx; + fd.buf = dir_buf; + fd.inode = &inode; + fd.err = 0; + fd.dir_size = 0; + fd.compress = 0; + if (!(fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_DIR_INDEX) || + (inode.i_size / fs->blocksize) < 2) + fd.compress = 1; + fd.parent = 0; + + /* Read in the entire directory into memory */ + retval = ext2fs_block_iterate2(fs, ino, 0, 0, + fill_dir_block, &fd); + if (fd.err) { + retval = fd.err; + goto errout; + } + +#if 0 + printf("%d entries (%d bytes) found in inode %d\n", + fd.num_array, fd.dir_size, ino); +#endif + + /* Sort the list */ +resort: + if (fd.compress) + qsort(fd.harray+2, fd.num_array-2, + sizeof(struct hash_entry), name_cmp); + else + qsort(fd.harray, fd.num_array, + sizeof(struct hash_entry), hash_cmp); + + /* + * Look for duplicates + */ + if (duplicate_search_and_fix(ctx, fs, ino, &fd)) + goto resort; + + if (ctx->options & E2F_OPT_NO) { + retval = 0; + goto errout; + } + + /* + * Copy the directory entries. In a htree directory these + * will become the leaf nodes. + */ + retval = copy_dir_entries(fs, &fd, &outdir); + if (retval) + goto errout; + + free(dir_buf); dir_buf = 0; + + if (!fd.compress) { + /* Calculate the interior nodes */ + retval = calculate_tree(fs, &outdir, ino, fd.parent); + if (retval) + goto errout; + } + + retval = write_directory(ctx, fs, &outdir, ino, fd.compress); + if (retval) + goto errout; + +errout: + if (dir_buf) + free(dir_buf); + if (fd.harray) + free(fd.harray); + + free_out_dir(&outdir); + return retval; +} + +void e2fsck_rehash_directories(e2fsck_t ctx) +{ + struct problem_context pctx; +#ifdef RESOURCE_TRACK + struct resource_track rtrack; +#endif + struct dir_info *dir; + ext2_u32_iterate iter; + ext2_ino_t ino; + errcode_t retval; + int i, cur, max, all_dirs, dir_index, first = 1; + +#ifdef RESOURCE_TRACK + init_resource_track(&rtrack); +#endif + + all_dirs = ctx->options & E2F_OPT_COMPRESS_DIRS; + + if (!ctx->dirs_to_hash && !all_dirs) + return; + + e2fsck_get_lost_and_found(ctx, 0); + + clear_problem_context(&pctx); + + dir_index = ctx->fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_DIR_INDEX; + cur = 0; + if (all_dirs) { + i = 0; + max = e2fsck_get_num_dirinfo(ctx); + } else { + retval = ext2fs_u32_list_iterate_begin(ctx->dirs_to_hash, + &iter); + if (retval) { + pctx.errcode = retval; + fix_problem(ctx, PR_3A_OPTIMIZE_ITER, &pctx); + return; + } + max = ext2fs_u32_list_count(ctx->dirs_to_hash); + } + while (1) { + if (all_dirs) { + if ((dir = e2fsck_dir_info_iter(ctx, &i)) == 0) + break; + ino = dir->ino; + } else { + if (!ext2fs_u32_list_iterate(iter, &ino)) + break; + } + if (ino == ctx->lost_and_found) + continue; + pctx.dir = ino; + if (first) { + fix_problem(ctx, PR_3A_PASS_HEADER, &pctx); + first = 0; + } +#if 0 + fix_problem(ctx, PR_3A_OPTIMIZE_DIR, &pctx); +#endif + pctx.errcode = e2fsck_rehash_dir(ctx, ino); + if (pctx.errcode) { + end_problem_latch(ctx, PR_LATCH_OPTIMIZE_DIR); + fix_problem(ctx, PR_3A_OPTIMIZE_DIR_ERR, &pctx); + } + if (ctx->progress && !ctx->progress_fd) + e2fsck_simple_progress(ctx, "Rebuilding directory", + 100.0 * (float) (++cur) / (float) max, ino); + } + end_problem_latch(ctx, PR_LATCH_OPTIMIZE_DIR); + if (!all_dirs) + ext2fs_u32_list_iterate_end(iter); + + if (ctx->dirs_to_hash) + ext2fs_u32_list_free(ctx->dirs_to_hash); + ctx->dirs_to_hash = 0; + +#ifdef RESOURCE_TRACK + if (ctx->options & E2F_OPT_TIME2) { + e2fsck_clear_progbar(ctx); + print_resource_track("Pass 3A", &rtrack); + } +#endif +} +/* + * linux/fs/revoke.c + * + * Written by Stephen C. Tweedie , 2000 + * + * Copyright 2000 Red Hat corp --- All Rights Reserved + * + * This file is part of the Linux kernel and is made available under + * the terms of the GNU General Public License, version 2, or at your + * option, any later version, incorporated herein by reference. + * + * Journal revoke routines for the generic filesystem journaling code; + * part of the ext2fs journaling system. + * + * Revoke is the mechanism used to prevent old log records for deleted + * metadata from being replayed on top of newer data using the same + * blocks. The revoke mechanism is used in two separate places: + * + * + Commit: during commit we write the entire list of the current + * transaction's revoked blocks to the journal + * + * + Recovery: during recovery we record the transaction ID of all + * revoked blocks. If there are multiple revoke records in the log + * for a single block, only the last one counts, and if there is a log + * entry for a block beyond the last revoke, then that log entry still + * gets replayed. + * + * We can get interactions between revokes and new log data within a + * single transaction: + * + * Block is revoked and then journaled: + * The desired end result is the journaling of the new block, so we + * cancel the revoke before the transaction commits. + * + * Block is journaled and then revoked: + * The revoke must take precedence over the write of the block, so we + * need either to cancel the journal entry or to write the revoke + * later in the log than the log block. In this case, we choose the + * latter: journaling a block cancels any revoke record for that block + * in the current transaction, so any revoke for that block in the + * transaction must have happened after the block was journaled and so + * the revoke must take precedence. + * + * Block is revoked and then written as data: + * The data write is allowed to succeed, but the revoke is _not_ + * cancelled. We still need to prevent old log records from + * overwriting the new data. We don't even need to clear the revoke + * bit here. + * + * Revoke information on buffers is a tri-state value: + * + * RevokeValid clear: no cached revoke status, need to look it up + * RevokeValid set, Revoked clear: + * buffer has not been revoked, and cancel_revoke + * need do nothing. + * RevokeValid set, Revoked set: + * buffer has been revoked. + */ + +static kmem_cache_t *revoke_record_cache; +static kmem_cache_t *revoke_table_cache; + +/* Each revoke record represents one single revoked block. During + journal replay, this involves recording the transaction ID of the + last transaction to revoke this block. */ + +struct jbd_revoke_record_s +{ + struct list_head hash; + tid_t sequence; /* Used for recovery only */ + unsigned long blocknr; +}; + + +/* The revoke table is just a simple hash table of revoke records. */ +struct jbd_revoke_table_s +{ + /* It is conceivable that we might want a larger hash table + * for recovery. Must be a power of two. */ + int hash_size; + int hash_shift; + struct list_head *hash_table; +}; + + +#ifdef __KERNEL__ +static void write_one_revoke_record(journal_t *, transaction_t *, + struct journal_head **, int *, + struct jbd_revoke_record_s *); +static void flush_descriptor(journal_t *, struct journal_head *, int); +#endif + +/* Utility functions to maintain the revoke table */ + +/* Borrowed from buffer.c: this is a tried and tested block hash function */ +static inline int hash(journal_t *journal, unsigned long block) +{ + struct jbd_revoke_table_s *table = journal->j_revoke; + int hash_shift = table->hash_shift; + + return ((block << (hash_shift - 6)) ^ + (block >> 13) ^ + (block << (hash_shift - 12))) & (table->hash_size - 1); +} + +static int insert_revoke_hash(journal_t *journal, unsigned long blocknr, + tid_t seq) +{ + struct list_head *hash_list; + struct jbd_revoke_record_s *record; + +#ifdef __KERNEL__ +repeat: +#endif + record = kmem_cache_alloc(revoke_record_cache, GFP_NOFS); + if (!record) + goto oom; + + record->sequence = seq; + record->blocknr = blocknr; + hash_list = &journal->j_revoke->hash_table[hash(journal, blocknr)]; + list_add(&record->hash, hash_list); + return 0; + +oom: +#ifdef __KERNEL__ + if (!journal_oom_retry) + return -ENOMEM; + jbd_debug(1, "ENOMEM in " __FUNCTION__ ", retrying.\n"); + current->policy |= SCHED_YIELD; + schedule(); + goto repeat; +#else + return -ENOMEM; +#endif +} + +/* Find a revoke record in the journal's hash table. */ + +static struct jbd_revoke_record_s *find_revoke_record(journal_t *journal, + unsigned long blocknr) +{ + struct list_head *hash_list; + struct jbd_revoke_record_s *record; + + hash_list = &journal->j_revoke->hash_table[hash(journal, blocknr)]; + + record = (struct jbd_revoke_record_s *) hash_list->next; + while (&(record->hash) != hash_list) { + if (record->blocknr == blocknr) + return record; + record = (struct jbd_revoke_record_s *) record->hash.next; + } + return NULL; +} + +int journal_init_revoke_caches(void) +{ + revoke_record_cache = kmem_cache_create("revoke_record", + sizeof(struct jbd_revoke_record_s), + 0, SLAB_HWCACHE_ALIGN, NULL, NULL); + if (revoke_record_cache == 0) + return -ENOMEM; + + revoke_table_cache = kmem_cache_create("revoke_table", + sizeof(struct jbd_revoke_table_s), + 0, 0, NULL, NULL); + if (revoke_table_cache == 0) { + kmem_cache_destroy(revoke_record_cache); + revoke_record_cache = NULL; + return -ENOMEM; + } + return 0; +} + +void journal_destroy_revoke_caches(void) +{ + kmem_cache_destroy(revoke_record_cache); + revoke_record_cache = 0; + kmem_cache_destroy(revoke_table_cache); + revoke_table_cache = 0; +} + +/* Initialise the revoke table for a given journal to a given size. */ + +int journal_init_revoke(journal_t *journal, int hash_size) +{ + int shift, tmp; + + J_ASSERT (journal->j_revoke == NULL); + + journal->j_revoke = kmem_cache_alloc(revoke_table_cache, GFP_KERNEL); + if (!journal->j_revoke) + return -ENOMEM; + + /* Check that the hash_size is a power of two */ + J_ASSERT ((hash_size & (hash_size-1)) == 0); + + journal->j_revoke->hash_size = hash_size; + + shift = 0; + tmp = hash_size; + while((tmp >>= 1UL) != 0UL) + shift++; + journal->j_revoke->hash_shift = shift; + + journal->j_revoke->hash_table = + kmalloc(hash_size * sizeof(struct list_head), GFP_KERNEL); + if (!journal->j_revoke->hash_table) { + kmem_cache_free(revoke_table_cache, journal->j_revoke); + journal->j_revoke = NULL; + return -ENOMEM; + } + + for (tmp = 0; tmp < hash_size; tmp++) + INIT_LIST_HEAD(&journal->j_revoke->hash_table[tmp]); + + return 0; +} + +/* Destoy a journal's revoke table. The table must already be empty! */ + +void journal_destroy_revoke(journal_t *journal) +{ + struct jbd_revoke_table_s *table; + struct list_head *hash_list; + int i; + + table = journal->j_revoke; + if (!table) + return; + + for (i=0; ihash_size; i++) { + hash_list = &table->hash_table[i]; + J_ASSERT (list_empty(hash_list)); + } + + kfree(table->hash_table); + kmem_cache_free(revoke_table_cache, table); + journal->j_revoke = NULL; +} + + +#ifdef __KERNEL__ + +/* + * journal_revoke: revoke a given buffer_head from the journal. This + * prevents the block from being replayed during recovery if we take a + * crash after this current transaction commits. Any subsequent + * metadata writes of the buffer in this transaction cancel the + * revoke. + * + * Note that this call may block --- it is up to the caller to make + * sure that there are no further calls to journal_write_metadata + * before the revoke is complete. In ext3, this implies calling the + * revoke before clearing the block bitmap when we are deleting + * metadata. + * + * Revoke performs a journal_forget on any buffer_head passed in as a + * parameter, but does _not_ forget the buffer_head if the bh was only + * found implicitly. + * + * bh_in may not be a journalled buffer - it may have come off + * the hash tables without an attached journal_head. + * + * If bh_in is non-zero, journal_revoke() will decrement its b_count + * by one. + */ + +int journal_revoke(handle_t *handle, unsigned long blocknr, + struct buffer_head *bh_in) +{ + struct buffer_head *bh = NULL; + journal_t *journal; + kdev_t dev; + int err; + + if (bh_in) + BUFFER_TRACE(bh_in, "enter"); + + journal = handle->h_transaction->t_journal; + if (!journal_set_features(journal, 0, 0, JFS_FEATURE_INCOMPAT_REVOKE)){ + J_ASSERT (!"Cannot set revoke feature!"); + return -EINVAL; + } + + dev = journal->j_fs_dev; + bh = bh_in; + + if (!bh) { + bh = get_hash_table(dev, blocknr, journal->j_blocksize); + if (bh) + BUFFER_TRACE(bh, "found on hash"); + } +#ifdef JBD_EXPENSIVE_CHECKING + else { + struct buffer_head *bh2; + + /* If there is a different buffer_head lying around in + * memory anywhere... */ + bh2 = get_hash_table(dev, blocknr, journal->j_blocksize); + if (bh2) { + /* ... and it has RevokeValid status... */ + if ((bh2 != bh) && + test_bit(BH_RevokeValid, &bh2->b_state)) + /* ...then it better be revoked too, + * since it's illegal to create a revoke + * record against a buffer_head which is + * not marked revoked --- that would + * risk missing a subsequent revoke + * cancel. */ + J_ASSERT_BH(bh2, test_bit(BH_Revoked, & + bh2->b_state)); + __brelse(bh2); + } + } +#endif + + /* We really ought not ever to revoke twice in a row without + first having the revoke cancelled: it's illegal to free a + block twice without allocating it in between! */ + if (bh) { + J_ASSERT_BH(bh, !test_bit(BH_Revoked, &bh->b_state)); + set_bit(BH_Revoked, &bh->b_state); + set_bit(BH_RevokeValid, &bh->b_state); + if (bh_in) { + BUFFER_TRACE(bh_in, "call journal_forget"); + journal_forget(handle, bh_in); + } else { + BUFFER_TRACE(bh, "call brelse"); + __brelse(bh); + } + } + + lock_journal(journal); + jbd_debug(2, "insert revoke for block %lu, bh_in=%p\n", blocknr, bh_in); + err = insert_revoke_hash(journal, blocknr, + handle->h_transaction->t_tid); + unlock_journal(journal); + BUFFER_TRACE(bh_in, "exit"); + return err; +} + +/* + * Cancel an outstanding revoke. For use only internally by the + * journaling code (called from journal_get_write_access). + * + * We trust the BH_Revoked bit on the buffer if the buffer is already + * being journaled: if there is no revoke pending on the buffer, then we + * don't do anything here. + * + * This would break if it were possible for a buffer to be revoked and + * discarded, and then reallocated within the same transaction. In such + * a case we would have lost the revoked bit, but when we arrived here + * the second time we would still have a pending revoke to cancel. So, + * do not trust the Revoked bit on buffers unless RevokeValid is also + * set. + * + * The caller must have the journal locked. + */ +int journal_cancel_revoke(handle_t *handle, struct journal_head *jh) +{ + struct jbd_revoke_record_s *record; + journal_t *journal = handle->h_transaction->t_journal; + int need_cancel; + int did_revoke = 0; /* akpm: debug */ + struct buffer_head *bh = jh2bh(jh); + + jbd_debug(4, "journal_head %p, cancelling revoke\n", jh); + + /* Is the existing Revoke bit valid? If so, we trust it, and + * only perform the full cancel if the revoke bit is set. If + * not, we can't trust the revoke bit, and we need to do the + * full search for a revoke record. */ + if (test_and_set_bit(BH_RevokeValid, &bh->b_state)) + need_cancel = (test_and_clear_bit(BH_Revoked, &bh->b_state)); + else { + need_cancel = 1; + clear_bit(BH_Revoked, &bh->b_state); + } + + if (need_cancel) { + record = find_revoke_record(journal, bh->b_blocknr); + if (record) { + jbd_debug(4, "cancelled existing revoke on " + "blocknr %lu\n", bh->b_blocknr); + list_del(&record->hash); + kmem_cache_free(revoke_record_cache, record); + did_revoke = 1; + } + } + +#ifdef JBD_EXPENSIVE_CHECKING + /* There better not be one left behind by now! */ + record = find_revoke_record(journal, bh->b_blocknr); + J_ASSERT_JH(jh, record == NULL); +#endif + + /* Finally, have we just cleared revoke on an unhashed + * buffer_head? If so, we'd better make sure we clear the + * revoked status on any hashed alias too, otherwise the revoke + * state machine will get very upset later on. */ + if (need_cancel && !bh->b_pprev) { + struct buffer_head *bh2; + bh2 = get_hash_table(bh->b_dev, bh->b_blocknr, bh->b_size); + if (bh2) { + clear_bit(BH_Revoked, &bh2->b_state); + __brelse(bh2); + } + } + + return did_revoke; +} + + +/* + * Write revoke records to the journal for all entries in the current + * revoke hash, deleting the entries as we go. + * + * Called with the journal lock held. + */ + +void journal_write_revoke_records(journal_t *journal, + transaction_t *transaction) +{ + struct journal_head *descriptor; + struct jbd_revoke_record_s *record; + struct jbd_revoke_table_s *revoke; + struct list_head *hash_list; + int i, offset, count; + + descriptor = NULL; + offset = 0; + count = 0; + revoke = journal->j_revoke; + + for (i = 0; i < revoke->hash_size; i++) { + hash_list = &revoke->hash_table[i]; + + while (!list_empty(hash_list)) { + record = (struct jbd_revoke_record_s *) + hash_list->next; + write_one_revoke_record(journal, transaction, + &descriptor, &offset, + record); + count++; + list_del(&record->hash); + kmem_cache_free(revoke_record_cache, record); + } + } + if (descriptor) + flush_descriptor(journal, descriptor, offset); + jbd_debug(1, "Wrote %d revoke records\n", count); +} + +/* + * Write out one revoke record. We need to create a new descriptor + * block if the old one is full or if we have not already created one. + */ + +static void write_one_revoke_record(journal_t *journal, + transaction_t *transaction, + struct journal_head **descriptorp, + int *offsetp, + struct jbd_revoke_record_s *record) +{ + struct journal_head *descriptor; + int offset; + journal_header_t *header; + + /* If we are already aborting, this all becomes a noop. We + still need to go round the loop in + journal_write_revoke_records in order to free all of the + revoke records: only the IO to the journal is omitted. */ + if (is_journal_aborted(journal)) + return; + + descriptor = *descriptorp; + offset = *offsetp; + + /* Make sure we have a descriptor with space left for the record */ + if (descriptor) { + if (offset == journal->j_blocksize) { + flush_descriptor(journal, descriptor, offset); + descriptor = NULL; + } + } + + if (!descriptor) { + descriptor = journal_get_descriptor_buffer(journal); + if (!descriptor) + return; + header = (journal_header_t *) &jh2bh(descriptor)->b_data[0]; + header->h_magic = htonl(JFS_MAGIC_NUMBER); + header->h_blocktype = htonl(JFS_REVOKE_BLOCK); + header->h_sequence = htonl(transaction->t_tid); + + /* Record it so that we can wait for IO completion later */ + JBUFFER_TRACE(descriptor, "file as BJ_LogCtl"); + journal_file_buffer(descriptor, transaction, BJ_LogCtl); + + offset = sizeof(journal_revoke_header_t); + *descriptorp = descriptor; + } + + * ((unsigned int *)(&jh2bh(descriptor)->b_data[offset])) = + htonl(record->blocknr); + offset += 4; + *offsetp = offset; +} + +/* + * Flush a revoke descriptor out to the journal. If we are aborting, + * this is a noop; otherwise we are generating a buffer which needs to + * be waited for during commit, so it has to go onto the appropriate + * journal buffer list. + */ + +static void flush_descriptor(journal_t *journal, + struct journal_head *descriptor, + int offset) +{ + journal_revoke_header_t *header; + + if (is_journal_aborted(journal)) { + JBUFFER_TRACE(descriptor, "brelse"); + __brelse(jh2bh(descriptor)); + return; + } + + header = (journal_revoke_header_t *) jh2bh(descriptor)->b_data; + header->r_count = htonl(offset); + set_bit(BH_JWrite, &jh2bh(descriptor)->b_state); + { + struct buffer_head *bh = jh2bh(descriptor); + BUFFER_TRACE(bh, "write"); + ll_rw_block (WRITE, 1, &bh); + } +} + +#endif + +/* + * Revoke support for recovery. + * + * Recovery needs to be able to: + * + * record all revoke records, including the tid of the latest instance + * of each revoke in the journal + * + * check whether a given block in a given transaction should be replayed + * (ie. has not been revoked by a revoke record in that or a subsequent + * transaction) + * + * empty the revoke table after recovery. + */ + +/* + * First, setting revoke records. We create a new revoke record for + * every block ever revoked in the log as we scan it for recovery, and + * we update the existing records if we find multiple revokes for a + * single block. + */ + +int journal_set_revoke(journal_t *journal, + unsigned long blocknr, + tid_t sequence) +{ + struct jbd_revoke_record_s *record; + + record = find_revoke_record(journal, blocknr); + if (record) { + /* If we have multiple occurences, only record the + * latest sequence number in the hashed record */ + if (tid_gt(sequence, record->sequence)) + record->sequence = sequence; + return 0; + } + return insert_revoke_hash(journal, blocknr, sequence); +} + +/* + * Test revoke records. For a given block referenced in the log, has + * that block been revoked? A revoke record with a given transaction + * sequence number revokes all blocks in that transaction and earlier + * ones, but later transactions still need replayed. + */ + +int journal_test_revoke(journal_t *journal, + unsigned long blocknr, + tid_t sequence) +{ + struct jbd_revoke_record_s *record; + + record = find_revoke_record(journal, blocknr); + if (!record) + return 0; + if (tid_gt(sequence, record->sequence)) + return 0; + return 1; +} + +/* + * Finally, once recovery is over, we need to clear the revoke table so + * that it can be reused by the running filesystem. + */ + +void journal_clear_revoke(journal_t *journal) +{ + int i; + struct list_head *hash_list; + struct jbd_revoke_record_s *record; + struct jbd_revoke_table_s *revoke_var; + + revoke_var = journal->j_revoke; + + for (i = 0; i < revoke_var->hash_size; i++) { + hash_list = &revoke_var->hash_table[i]; + while (!list_empty(hash_list)) { + record = (struct jbd_revoke_record_s*) hash_list->next; + list_del(&record->hash); + kmem_cache_free(revoke_record_cache, record); + } + } +} + +/* + * e2fsck.c - superblock checks + * + * Copyright (C) 1993, 1994, 1995, 1996, 1997 Theodore Ts'o. + * + * %Begin-Header% + * This file may be redistributed under the terms of the GNU Public + * License. + * %End-Header% + */ + +#define MIN_CHECK 1 +#define MAX_CHECK 2 + +static void check_super_value(e2fsck_t ctx, const char *descr, + unsigned long value, int flags, + unsigned long min_val, unsigned long max_val) +{ + struct problem_context pctx; + + if (((flags & MIN_CHECK) && (value < min_val)) || + ((flags & MAX_CHECK) && (value > max_val))) { + clear_problem_context(&pctx); + pctx.num = value; + pctx.str = descr; + fix_problem(ctx, PR_0_MISC_CORRUPT_SUPER, &pctx); + ctx->flags |= E2F_FLAG_ABORT; /* never get here! */ + } +} + +/* + * This routine may get stubbed out in special compilations of the + * e2fsck code.. + */ +#ifndef EXT2_SPECIAL_DEVICE_SIZE +errcode_t e2fsck_get_device_size(e2fsck_t ctx) +{ + return (ext2fs_get_device_size(ctx->filesystem_name, + EXT2_BLOCK_SIZE(ctx->fs->super), + &ctx->num_blocks)); +} +#endif + +/* + * helper function to release an inode + */ +struct process_block_struct { + e2fsck_t ctx; + char *buf; + struct problem_context *pctx; + int truncating; + int truncate_offset; + e2_blkcnt_t truncate_block; + int truncated_blocks; + int abort; + errcode_t errcode; +}; + +static int release_inode_block(ext2_filsys fs, + blk_t *block_nr, + e2_blkcnt_t blockcnt, + blk_t ref_blk EXT2FS_ATTR((unused)), + int ref_offset EXT2FS_ATTR((unused)), + void *priv_data) +{ + struct process_block_struct *pb; + e2fsck_t ctx; + struct problem_context *pctx; + blk_t blk = *block_nr; + int retval = 0; + + pb = (struct process_block_struct *) priv_data; + ctx = pb->ctx; + pctx = pb->pctx; + + pctx->blk = blk; + pctx->blkcount = blockcnt; + + if (HOLE_BLKADDR(blk)) + return 0; + + if ((blk < fs->super->s_first_data_block) || + (blk >= fs->super->s_blocks_count)) { + fix_problem(ctx, PR_0_ORPHAN_ILLEGAL_BLOCK_NUM, pctx); + return_abort: + pb->abort = 1; + return BLOCK_ABORT; + } + + if (!ext2fs_test_block_bitmap(fs->block_map, blk)) { + fix_problem(ctx, PR_0_ORPHAN_ALREADY_CLEARED_BLOCK, pctx); + goto return_abort; + } + + /* + * If we are deleting an orphan, then we leave the fields alone. + * If we are truncating an orphan, then update the inode fields + * and clean up any partial block data. + */ + if (pb->truncating) { + /* + * We only remove indirect blocks if they are + * completely empty. + */ + if (blockcnt < 0) { + int i, limit; + blk_t *bp; + + pb->errcode = io_channel_read_blk(fs->io, blk, 1, + pb->buf); + if (pb->errcode) + goto return_abort; + + limit = fs->blocksize >> 2; + for (i = 0, bp = (blk_t *) pb->buf; + i < limit; i++, bp++) + if (*bp) + return 0; + } + /* + * We don't remove direct blocks until we've reached + * the truncation block. + */ + if (blockcnt >= 0 && blockcnt < pb->truncate_block) + return 0; + /* + * If part of the last block needs truncating, we do + * it here. + */ + if ((blockcnt == pb->truncate_block) && pb->truncate_offset) { + pb->errcode = io_channel_read_blk(fs->io, blk, 1, + pb->buf); + if (pb->errcode) + goto return_abort; + memset(pb->buf + pb->truncate_offset, 0, + fs->blocksize - pb->truncate_offset); + pb->errcode = io_channel_write_blk(fs->io, blk, 1, + pb->buf); + if (pb->errcode) + goto return_abort; + } + pb->truncated_blocks++; + *block_nr = 0; + retval |= BLOCK_CHANGED; + } + + ext2fs_block_alloc_stats(fs, blk, -1); + return retval; +} + +/* + * This function releases an inode. Returns 1 if an inconsistency was + * found. If the inode has a link count, then it is being truncated and + * not deleted. + */ +static int release_inode_blocks(e2fsck_t ctx, ext2_ino_t ino, + struct ext2_inode *inode, char *block_buf, + struct problem_context *pctx) +{ + struct process_block_struct pb; + ext2_filsys fs = ctx->fs; + errcode_t retval; + __u32 count; + + if (!ext2fs_inode_has_valid_blocks(inode)) + return 0; + + pb.buf = block_buf + 3 * ctx->fs->blocksize; + pb.ctx = ctx; + pb.abort = 0; + pb.errcode = 0; + pb.pctx = pctx; + if (inode->i_links_count) { + pb.truncating = 1; + pb.truncate_block = (e2_blkcnt_t) + ((((long long)inode->i_size_high << 32) + + inode->i_size + fs->blocksize - 1) / + fs->blocksize); + pb.truncate_offset = inode->i_size % fs->blocksize; + } else { + pb.truncating = 0; + pb.truncate_block = 0; + pb.truncate_offset = 0; + } + pb.truncated_blocks = 0; + retval = ext2fs_block_iterate2(fs, ino, BLOCK_FLAG_DEPTH_TRAVERSE, + block_buf, release_inode_block, &pb); + if (retval) { + com_err("release_inode_blocks", retval, + _("while calling ext2fs_block_iterate for inode %d"), + ino); + return 1; + } + if (pb.abort) + return 1; + + /* Refresh the inode since ext2fs_block_iterate may have changed it */ + e2fsck_read_inode(ctx, ino, inode, "release_inode_blocks"); + + if (pb.truncated_blocks) + inode->i_blocks -= pb.truncated_blocks * + (fs->blocksize / 512); + + if (inode->i_file_acl) { + retval = ext2fs_adjust_ea_refcount(fs, inode->i_file_acl, + block_buf, -1, &count); + if (retval == EXT2_ET_BAD_EA_BLOCK_NUM) { + retval = 0; + count = 1; + } + if (retval) { + com_err("release_inode_blocks", retval, + _("while calling ext2fs_adjust_ea_refocunt for inode %d"), + ino); + return 1; + } + if (count == 0) + ext2fs_block_alloc_stats(fs, inode->i_file_acl, -1); + inode->i_file_acl = 0; + } + return 0; +} + +/* + * This function releases all of the orphan inodes. It returns 1 if + * it hit some error, and 0 on success. + */ +static int release_orphan_inodes(e2fsck_t ctx) +{ + ext2_filsys fs = ctx->fs; + ext2_ino_t ino, next_ino; + struct ext2_inode inode; + struct problem_context pctx; + char *block_buf; + + if ((ino = fs->super->s_last_orphan) == 0) + return 0; + + /* + * Win or lose, we won't be using the head of the orphan inode + * list again. + */ + fs->super->s_last_orphan = 0; + ext2fs_mark_super_dirty(fs); + + /* + * If the filesystem contains errors, don't run the orphan + * list, since the orphan list can't be trusted; and we're + * going to be running a full e2fsck run anyway... + */ + if (fs->super->s_state & EXT2_ERROR_FS) + return 0; + + if ((ino < EXT2_FIRST_INODE(fs->super)) || + (ino > fs->super->s_inodes_count)) { + clear_problem_context(&pctx); + pctx.ino = ino; + fix_problem(ctx, PR_0_ORPHAN_ILLEGAL_HEAD_INODE, &pctx); + return 1; + } + + block_buf = (char *) e2fsck_allocate_memory(ctx, fs->blocksize * 4, + "block iterate buffer"); + e2fsck_read_bitmaps(ctx); + + while (ino) { + e2fsck_read_inode(ctx, ino, &inode, "release_orphan_inodes"); + clear_problem_context(&pctx); + pctx.ino = ino; + pctx.inode = &inode; + pctx.str = inode.i_links_count ? _("Truncating") : + _("Clearing"); + + fix_problem(ctx, PR_0_ORPHAN_CLEAR_INODE, &pctx); + + next_ino = inode.i_dtime; + if (next_ino && + ((next_ino < EXT2_FIRST_INODE(fs->super)) || + (next_ino > fs->super->s_inodes_count))) { + pctx.ino = next_ino; + fix_problem(ctx, PR_0_ORPHAN_ILLEGAL_INODE, &pctx); + goto return_abort; + } + + if (release_inode_blocks(ctx, ino, &inode, block_buf, &pctx)) + goto return_abort; + + if (!inode.i_links_count) { + ext2fs_inode_alloc_stats2(fs, ino, -1, + LINUX_S_ISDIR(inode.i_mode)); + inode.i_dtime = time(0); + } else { + inode.i_dtime = 0; + } + e2fsck_write_inode(ctx, ino, &inode, "delete_file"); + ino = next_ino; + } + ext2fs_free_mem(&block_buf); + return 0; +return_abort: + ext2fs_free_mem(&block_buf); + return 1; +} + +/* + * Check the resize inode to make sure it is sane. We check both for + * the case where on-line resizing is not enabled (in which case the + * resize inode should be cleared) as well as the case where on-line + * resizing is enabled. + */ +static void check_resize_inode(e2fsck_t ctx) +{ + ext2_filsys fs = ctx->fs; + struct ext2_inode inode; + struct problem_context pctx; + int i, j, gdt_off, ind_off; + blk_t blk, pblk, expect; + __u32 *dind_buf = 0, *ind_buf; + errcode_t retval; + + clear_problem_context(&pctx); + + /* + * If the resize inode feature isn't set, then + * s_reserved_gdt_blocks must be zero. + */ + if (!(fs->super->s_feature_compat & + EXT2_FEATURE_COMPAT_RESIZE_INODE)) { + if (fs->super->s_reserved_gdt_blocks) { + pctx.num = fs->super->s_reserved_gdt_blocks; + if (fix_problem(ctx, PR_0_NONZERO_RESERVED_GDT_BLOCKS, + &pctx)) { + fs->super->s_reserved_gdt_blocks = 0; + ext2fs_mark_super_dirty(fs); + } + } + } + + /* Read the resizde inode */ + pctx.ino = EXT2_RESIZE_INO; + retval = ext2fs_read_inode(fs, EXT2_RESIZE_INO, &inode); + if (retval) { + if (fs->super->s_feature_compat & + EXT2_FEATURE_COMPAT_RESIZE_INODE) + ctx->flags |= E2F_FLAG_RESIZE_INODE; + return; + } + + /* + * If the resize inode feature isn't set, check to make sure + * the resize inode is cleared; then we're done. + */ + if (!(fs->super->s_feature_compat & + EXT2_FEATURE_COMPAT_RESIZE_INODE)) { + for (i=0; i < EXT2_N_BLOCKS; i++) { + if (inode.i_block[i]) + break; + } + if ((i < EXT2_N_BLOCKS) && + fix_problem(ctx, PR_0_CLEAR_RESIZE_INODE, &pctx)) { + memset(&inode, 0, sizeof(inode)); + e2fsck_write_inode(ctx, EXT2_RESIZE_INO, &inode, + "clear_resize"); + } + return; + } + + /* + * The resize inode feature is enabled; check to make sure the + * only block in use is the double indirect block + */ + blk = inode.i_block[EXT2_DIND_BLOCK]; + for (i=0; i < EXT2_N_BLOCKS; i++) { + if (i != EXT2_DIND_BLOCK && inode.i_block[i]) + break; + } + if ((i < EXT2_N_BLOCKS) || !blk || !inode.i_links_count || + !(inode.i_mode & LINUX_S_IFREG) || + (blk < fs->super->s_first_data_block || + blk >= fs->super->s_blocks_count)) { + resize_inode_invalid: + if (fix_problem(ctx, PR_0_RESIZE_INODE_INVALID, &pctx)) { + memset(&inode, 0, sizeof(inode)); + e2fsck_write_inode(ctx, EXT2_RESIZE_INO, &inode, + "clear_resize"); + ctx->flags |= E2F_FLAG_RESIZE_INODE; + } + if (!(ctx->options & E2F_OPT_READONLY)) { + fs->super->s_state &= ~EXT2_VALID_FS; + ext2fs_mark_super_dirty(fs); + } + goto cleanup; + } + dind_buf = (__u32 *) e2fsck_allocate_memory(ctx, fs->blocksize * 2, + "resize dind buffer"); + ind_buf = (__u32 *) ((char *) dind_buf + fs->blocksize); + + retval = ext2fs_read_ind_block(fs, blk, dind_buf); + if (retval) + goto resize_inode_invalid; + + gdt_off = fs->desc_blocks; + pblk = fs->super->s_first_data_block + 1 + fs->desc_blocks; + for (i = 0; i < fs->super->s_reserved_gdt_blocks / 4; + i++, gdt_off++, pblk++) { + gdt_off %= fs->blocksize/4; + if (dind_buf[gdt_off] != pblk) + goto resize_inode_invalid; + retval = ext2fs_read_ind_block(fs, pblk, ind_buf); + if (retval) + goto resize_inode_invalid; + ind_off = 0; + for (j = 1; j < fs->group_desc_count; j++) { + if (!ext2fs_bg_has_super(fs, j)) + continue; + expect = pblk + (j * fs->super->s_blocks_per_group); + if (ind_buf[ind_off] != expect) + goto resize_inode_invalid; + ind_off++; + } + } + +cleanup: + if (dind_buf) + ext2fs_free_mem(&dind_buf); + + } + +void check_super_block(e2fsck_t ctx) +{ + ext2_filsys fs = ctx->fs; + blk_t first_block, last_block; + struct ext2_super_block *sb = fs->super; + struct ext2_group_desc *gd; + blk_t blocks_per_group = fs->super->s_blocks_per_group; + blk_t bpg_max; + int inodes_per_block; + int ipg_max; + int inode_size; + dgrp_t i; + blk_t should_be; + struct problem_context pctx; + __u32 free_blocks = 0, free_inodes = 0; + + inodes_per_block = EXT2_INODES_PER_BLOCK(fs->super); + ipg_max = inodes_per_block * (blocks_per_group - 4); + if (ipg_max > EXT2_MAX_INODES_PER_GROUP(sb)) + ipg_max = EXT2_MAX_INODES_PER_GROUP(sb); + bpg_max = 8 * EXT2_BLOCK_SIZE(sb); + if (bpg_max > EXT2_MAX_BLOCKS_PER_GROUP(sb)) + bpg_max = EXT2_MAX_BLOCKS_PER_GROUP(sb); + + ctx->invalid_inode_bitmap_flag = (int *) e2fsck_allocate_memory(ctx, + sizeof(int) * fs->group_desc_count, "invalid_inode_bitmap"); + ctx->invalid_block_bitmap_flag = (int *) e2fsck_allocate_memory(ctx, + sizeof(int) * fs->group_desc_count, "invalid_block_bitmap"); + ctx->invalid_inode_table_flag = (int *) e2fsck_allocate_memory(ctx, + sizeof(int) * fs->group_desc_count, "invalid_inode_table"); + + clear_problem_context(&pctx); + + /* + * Verify the super block constants... + */ + check_super_value(ctx, "inodes_count", sb->s_inodes_count, + MIN_CHECK, 1, 0); + check_super_value(ctx, "blocks_count", sb->s_blocks_count, + MIN_CHECK, 1, 0); + check_super_value(ctx, "first_data_block", sb->s_first_data_block, + MAX_CHECK, 0, sb->s_blocks_count); + check_super_value(ctx, "log_block_size", sb->s_log_block_size, + MIN_CHECK | MAX_CHECK, 0, + EXT2_MAX_BLOCK_LOG_SIZE - EXT2_MIN_BLOCK_LOG_SIZE); + check_super_value(ctx, "log_frag_size", sb->s_log_frag_size, + MIN_CHECK | MAX_CHECK, 0, sb->s_log_block_size); + check_super_value(ctx, "frags_per_group", sb->s_frags_per_group, + MIN_CHECK | MAX_CHECK, sb->s_blocks_per_group, + bpg_max); + check_super_value(ctx, "blocks_per_group", sb->s_blocks_per_group, + MIN_CHECK | MAX_CHECK, 8, bpg_max); + check_super_value(ctx, "inodes_per_group", sb->s_inodes_per_group, + MIN_CHECK | MAX_CHECK, inodes_per_block, ipg_max); + check_super_value(ctx, "r_blocks_count", sb->s_r_blocks_count, + MAX_CHECK, 0, sb->s_blocks_count / 2); + check_super_value(ctx, "reserved_gdt_blocks", + sb->s_reserved_gdt_blocks, MAX_CHECK, 0, + fs->blocksize/4); + inode_size = EXT2_INODE_SIZE(sb); + check_super_value(ctx, "inode_size", + inode_size, MIN_CHECK | MAX_CHECK, + EXT2_GOOD_OLD_INODE_SIZE, fs->blocksize); + if (inode_size & (inode_size - 1)) { + pctx.num = inode_size; + pctx.str = "inode_size"; + fix_problem(ctx, PR_0_MISC_CORRUPT_SUPER, &pctx); + ctx->flags |= E2F_FLAG_ABORT; /* never get here! */ + return; + } + + if (!ctx->num_blocks) { + pctx.errcode = e2fsck_get_device_size(ctx); + if (pctx.errcode && pctx.errcode != EXT2_ET_UNIMPLEMENTED) { + fix_problem(ctx, PR_0_GETSIZE_ERROR, &pctx); + ctx->flags |= E2F_FLAG_ABORT; + return; + } + if ((pctx.errcode != EXT2_ET_UNIMPLEMENTED) && + (ctx->num_blocks < sb->s_blocks_count)) { + pctx.blk = sb->s_blocks_count; + pctx.blk2 = ctx->num_blocks; + if (fix_problem(ctx, PR_0_FS_SIZE_WRONG, &pctx)) { + ctx->flags |= E2F_FLAG_ABORT; + return; + } + } + } + + if (sb->s_log_block_size != (__u32) sb->s_log_frag_size) { + pctx.blk = EXT2_BLOCK_SIZE(sb); + pctx.blk2 = EXT2_FRAG_SIZE(sb); + fix_problem(ctx, PR_0_NO_FRAGMENTS, &pctx); + ctx->flags |= E2F_FLAG_ABORT; + return; + } + + should_be = sb->s_frags_per_group >> + (sb->s_log_block_size - sb->s_log_frag_size); + if (sb->s_blocks_per_group != should_be) { + pctx.blk = sb->s_blocks_per_group; + pctx.blk2 = should_be; + fix_problem(ctx, PR_0_BLOCKS_PER_GROUP, &pctx); + ctx->flags |= E2F_FLAG_ABORT; + return; + } + + should_be = (sb->s_log_block_size == 0) ? 1 : 0; + if (sb->s_first_data_block != should_be) { + pctx.blk = sb->s_first_data_block; + pctx.blk2 = should_be; + fix_problem(ctx, PR_0_FIRST_DATA_BLOCK, &pctx); + ctx->flags |= E2F_FLAG_ABORT; + return; + } + + should_be = sb->s_inodes_per_group * fs->group_desc_count; + if (sb->s_inodes_count != should_be) { + pctx.ino = sb->s_inodes_count; + pctx.ino2 = should_be; + if (fix_problem(ctx, PR_0_INODE_COUNT_WRONG, &pctx)) { + sb->s_inodes_count = should_be; + ext2fs_mark_super_dirty(fs); + } + } + + /* + * Verify the group descriptors.... + */ + first_block = sb->s_first_data_block; + last_block = first_block + blocks_per_group; + + for (i = 0, gd=fs->group_desc; i < fs->group_desc_count; i++, gd++) { + pctx.group = i; + + if (i == fs->group_desc_count - 1) + last_block = sb->s_blocks_count; + if ((gd->bg_block_bitmap < first_block) || + (gd->bg_block_bitmap >= last_block)) { + pctx.blk = gd->bg_block_bitmap; + if (fix_problem(ctx, PR_0_BB_NOT_GROUP, &pctx)) + gd->bg_block_bitmap = 0; + } + if (gd->bg_block_bitmap == 0) { + ctx->invalid_block_bitmap_flag[i]++; + ctx->invalid_bitmaps++; + } + if ((gd->bg_inode_bitmap < first_block) || + (gd->bg_inode_bitmap >= last_block)) { + pctx.blk = gd->bg_inode_bitmap; + if (fix_problem(ctx, PR_0_IB_NOT_GROUP, &pctx)) + gd->bg_inode_bitmap = 0; + } + if (gd->bg_inode_bitmap == 0) { + ctx->invalid_inode_bitmap_flag[i]++; + ctx->invalid_bitmaps++; + } + if ((gd->bg_inode_table < first_block) || + ((gd->bg_inode_table + + fs->inode_blocks_per_group - 1) >= last_block)) { + pctx.blk = gd->bg_inode_table; + if (fix_problem(ctx, PR_0_ITABLE_NOT_GROUP, &pctx)) + gd->bg_inode_table = 0; + } + if (gd->bg_inode_table == 0) { + ctx->invalid_inode_table_flag[i]++; + ctx->invalid_bitmaps++; + } + free_blocks += gd->bg_free_blocks_count; + free_inodes += gd->bg_free_inodes_count; + first_block += sb->s_blocks_per_group; + last_block += sb->s_blocks_per_group; + + if ((gd->bg_free_blocks_count > sb->s_blocks_per_group) || + (gd->bg_free_inodes_count > sb->s_inodes_per_group) || + (gd->bg_used_dirs_count > sb->s_inodes_per_group)) + ext2fs_unmark_valid(fs); + + } + + /* + * Update the global counts from the block group counts. This + * is needed for an experimental patch which eliminates + * locking the entire filesystem when allocating blocks or + * inodes; if the filesystem is not unmounted cleanly, the + * global counts may not be accurate. + */ + if ((free_blocks != sb->s_free_blocks_count) || + (free_inodes != sb->s_free_inodes_count)) { + if (ctx->options & E2F_OPT_READONLY) + ext2fs_unmark_valid(fs); + else { + sb->s_free_blocks_count = free_blocks; + sb->s_free_inodes_count = free_inodes; + ext2fs_mark_super_dirty(fs); + } + } + + if ((sb->s_free_blocks_count > sb->s_blocks_count) || + (sb->s_free_inodes_count > sb->s_inodes_count)) + ext2fs_unmark_valid(fs); + + + /* + * If we have invalid bitmaps, set the error state of the + * filesystem. + */ + if (ctx->invalid_bitmaps && !(ctx->options & E2F_OPT_READONLY)) { + sb->s_state &= ~EXT2_VALID_FS; + ext2fs_mark_super_dirty(fs); + } + + clear_problem_context(&pctx); + +#ifndef EXT2_SKIP_UUID + /* + * If the UUID field isn't assigned, assign it. + */ + if (!(ctx->options & E2F_OPT_READONLY) && uuid_is_null(sb->s_uuid)) { + if (fix_problem(ctx, PR_0_ADD_UUID, &pctx)) { + uuid_generate(sb->s_uuid); + ext2fs_mark_super_dirty(fs); + fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY; + } + } +#endif + + /* + * For the Hurd, check to see if the filetype option is set, + * since it doesn't support it. + */ + if (!(ctx->options & E2F_OPT_READONLY) && + fs->super->s_creator_os == EXT2_OS_HURD && + (fs->super->s_feature_incompat & + EXT2_FEATURE_INCOMPAT_FILETYPE)) { + if (fix_problem(ctx, PR_0_HURD_CLEAR_FILETYPE, &pctx)) { + fs->super->s_feature_incompat &= + ~EXT2_FEATURE_INCOMPAT_FILETYPE; + ext2fs_mark_super_dirty(fs); + + } + } + + /* + * If we have any of the compatibility flags set, we need to have a + * revision 1 filesystem. Most kernels will not check the flags on + * a rev 0 filesystem and we may have corruption issues because of + * the incompatible changes to the filesystem. + */ + if (!(ctx->options & E2F_OPT_READONLY) && + fs->super->s_rev_level == EXT2_GOOD_OLD_REV && + (fs->super->s_feature_compat || + fs->super->s_feature_ro_compat || + fs->super->s_feature_incompat) && + fix_problem(ctx, PR_0_FS_REV_LEVEL, &pctx)) { + ext2fs_update_dynamic_rev(fs); + ext2fs_mark_super_dirty(fs); + } + + check_resize_inode(ctx); + + /* + * Clean up any orphan inodes, if present. + */ + if (!(ctx->options & E2F_OPT_READONLY) && release_orphan_inodes(ctx)) { + fs->super->s_state &= ~EXT2_VALID_FS; + ext2fs_mark_super_dirty(fs); + } + + /* + * Move the ext3 journal file, if necessary. + */ + e2fsck_move_ext3_journal(ctx); + return; +} +/* + * swapfs.c --- byte-swap an ext2 filesystem + * + * Copyright 1996, 1997 by Theodore Ts'o + * + * %Begin-Header% + * This file may be redistributed under the terms of the GNU Public + * License. + * %End-Header% + * + */ + +#ifdef ENABLE_SWAPFS + +struct swap_block_struct { + ext2_ino_t ino; + int isdir; + errcode_t errcode; + char *dir_buf; + struct ext2_inode *inode; +}; + +/* + * This is a helper function for block_iterate. We mark all of the + * indirect and direct blocks as changed, so that block_iterate will + * write them out. + */ +static int swap_block(ext2_filsys fs, blk_t *block_nr, int blockcnt, + void *priv_data) +{ + errcode_t retval; + + struct swap_block_struct *sb = (struct swap_block_struct *) priv_data; + + if (sb->isdir && (blockcnt >= 0) && *block_nr) { + retval = ext2fs_read_dir_block(fs, *block_nr, sb->dir_buf); + if (retval) { + sb->errcode = retval; + return BLOCK_ABORT; + } + retval = ext2fs_write_dir_block(fs, *block_nr, sb->dir_buf); + if (retval) { + sb->errcode = retval; + return BLOCK_ABORT; + } + } + if (blockcnt >= 0) { + if (blockcnt < EXT2_NDIR_BLOCKS) + return 0; + return BLOCK_CHANGED; + } + if (blockcnt == BLOCK_COUNT_IND) { + if (*block_nr == sb->inode->i_block[EXT2_IND_BLOCK]) + return 0; + return BLOCK_CHANGED; + } + if (blockcnt == BLOCK_COUNT_DIND) { + if (*block_nr == sb->inode->i_block[EXT2_DIND_BLOCK]) + return 0; + return BLOCK_CHANGED; + } + if (blockcnt == BLOCK_COUNT_TIND) { + if (*block_nr == sb->inode->i_block[EXT2_TIND_BLOCK]) + return 0; + return BLOCK_CHANGED; + } + return BLOCK_CHANGED; +} + +/* + * This function is responsible for byte-swapping all of the indirect, + * block pointers. It is also responsible for byte-swapping directories. + */ +static void swap_inode_blocks(e2fsck_t ctx, ext2_ino_t ino, char *block_buf, + struct ext2_inode *inode) +{ + errcode_t retval; + struct swap_block_struct sb; + + sb.ino = ino; + sb.inode = inode; + sb.dir_buf = block_buf + ctx->fs->blocksize*3; + sb.errcode = 0; + sb.isdir = 0; + if (LINUX_S_ISDIR(inode->i_mode)) + sb.isdir = 1; + + retval = ext2fs_block_iterate(ctx->fs, ino, 0, block_buf, + swap_block, &sb); + if (retval) { + com_err("swap_inode_blocks", retval, + _("while calling ext2fs_block_iterate")); + ctx->flags |= E2F_FLAG_ABORT; + return; + } + if (sb.errcode) { + com_err("swap_inode_blocks", sb.errcode, + _("while calling iterator function")); + ctx->flags |= E2F_FLAG_ABORT; + return; + } +} + +static void swap_inodes(e2fsck_t ctx) +{ + ext2_filsys fs = ctx->fs; + dgrp_t group; + unsigned int i; + ext2_ino_t ino = 1; + char *buf, *block_buf; + errcode_t retval; + struct ext2_inode * inode; + + e2fsck_use_inode_shortcuts(ctx, 1); + + retval = ext2fs_get_mem(fs->blocksize * fs->inode_blocks_per_group, + &buf); + if (retval) { + com_err("swap_inodes", retval, + _("while allocating inode buffer")); + ctx->flags |= E2F_FLAG_ABORT; + return; + } + block_buf = (char *) e2fsck_allocate_memory(ctx, fs->blocksize * 4, + "block interate buffer"); + for (group = 0; group < fs->group_desc_count; group++) { + retval = io_channel_read_blk(fs->io, + fs->group_desc[group].bg_inode_table, + fs->inode_blocks_per_group, buf); + if (retval) { + com_err("swap_inodes", retval, + _("while reading inode table (group %d)"), + group); + ctx->flags |= E2F_FLAG_ABORT; + return; + } + inode = (struct ext2_inode *) buf; + for (i=0; i < fs->super->s_inodes_per_group; + i++, ino++, inode++) { + ctx->stashed_ino = ino; + ctx->stashed_inode = inode; + + if (fs->flags & EXT2_FLAG_SWAP_BYTES_READ) + ext2fs_swap_inode(fs, inode, inode, 0); + + /* + * Skip deleted files. + */ + if (inode->i_links_count == 0) + continue; + + if (LINUX_S_ISDIR(inode->i_mode) || + ((inode->i_block[EXT2_IND_BLOCK] || + inode->i_block[EXT2_DIND_BLOCK] || + inode->i_block[EXT2_TIND_BLOCK]) && + ext2fs_inode_has_valid_blocks(inode))) + swap_inode_blocks(ctx, ino, block_buf, inode); + + if (ctx->flags & E2F_FLAG_SIGNAL_MASK) + return; + + if (fs->flags & EXT2_FLAG_SWAP_BYTES_WRITE) + ext2fs_swap_inode(fs, inode, inode, 1); + } + retval = io_channel_write_blk(fs->io, + fs->group_desc[group].bg_inode_table, + fs->inode_blocks_per_group, buf); + if (retval) { + com_err("swap_inodes", retval, + _("while writing inode table (group %d)"), + group); + ctx->flags |= E2F_FLAG_ABORT; + return; + } + } + ext2fs_free_mem(&buf); + ext2fs_free_mem(&block_buf); + e2fsck_use_inode_shortcuts(ctx, 0); + ext2fs_flush_icache(fs); +} + +#if defined(__powerpc__) && defined(EXT2FS_ENABLE_SWAPFS) +/* + * On the PowerPC, the big-endian variant of the ext2 filesystem + * has its bitmaps stored as 32-bit words with bit 0 as the LSB + * of each word. Thus a bitmap with only bit 0 set would be, as + * a string of bytes, 00 00 00 01 00 ... + * To cope with this, we byte-reverse each word of a bitmap if + * we have a big-endian filesystem, that is, if we are *not* + * byte-swapping other word-sized numbers. + */ +#define EXT2_BIG_ENDIAN_BITMAPS +#endif + +#ifdef EXT2_BIG_ENDIAN_BITMAPS +static void ext2fs_swap_bitmap(ext2fs_generic_bitmap bmap) +{ + __u32 *p = (__u32 *) bmap->bitmap; + int n, nbytes = (bmap->end - bmap->start + 7) / 8; + + for (n = nbytes / sizeof(__u32); n > 0; --n, ++p) + *p = ext2fs_swab32(*p); +} +#endif + + +#ifdef ENABLE_SWAPFS +void swap_filesys(e2fsck_t ctx) +{ + ext2_filsys fs = ctx->fs; +#ifdef RESOURCE_TRACK + struct resource_track rtrack; + + init_resource_track(&rtrack); +#endif + + if (!(ctx->options & E2F_OPT_PREEN)) + printf(_("Pass 0: Doing byte-swap of filesystem\n")); + +#ifdef MTRACE + mtrace_print("Byte swap"); +#endif + + if (fs->super->s_mnt_count) { + fprintf(stderr, _("%s: the filesystem must be freshly " + "checked using fsck\n" + "and not mounted before trying to " + "byte-swap it.\n"), ctx->device_name); + ctx->flags |= E2F_FLAG_ABORT; + return; + } + if (fs->flags & EXT2_FLAG_SWAP_BYTES) { + fs->flags &= ~(EXT2_FLAG_SWAP_BYTES| + EXT2_FLAG_SWAP_BYTES_WRITE); + fs->flags |= EXT2_FLAG_SWAP_BYTES_READ; + } else { + fs->flags &= ~EXT2_FLAG_SWAP_BYTES_READ; + fs->flags |= EXT2_FLAG_SWAP_BYTES_WRITE; + } + swap_inodes(ctx); + if (ctx->flags & E2F_FLAG_SIGNAL_MASK) + return; + if (fs->flags & EXT2_FLAG_SWAP_BYTES_WRITE) + fs->flags |= EXT2_FLAG_SWAP_BYTES; + fs->flags &= ~(EXT2_FLAG_SWAP_BYTES_READ| + EXT2_FLAG_SWAP_BYTES_WRITE); + +#ifdef EXT2_BIG_ENDIAN_BITMAPS + e2fsck_read_bitmaps(ctx); + ext2fs_swap_bitmap(fs->inode_map); + ext2fs_swap_bitmap(fs->block_map); + fs->flags |= EXT2_FLAG_BB_DIRTY | EXT2_FLAG_IB_DIRTY; +#endif + fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY; + ext2fs_flush(fs); + fs->flags |= EXT2_FLAG_MASTER_SB_ONLY; + +#ifdef RESOURCE_TRACK + if (ctx->options & E2F_OPT_TIME2) + print_resource_track(_("Byte swap"), &rtrack); +#endif +} +#endif /* ENABLE_SWAPFS */ + +#endif +/* + * util.c --- miscellaneous utilities + * * Copyright (C) 1993, 1994, 1995, 1996, 1997 Theodore Ts'o. * * %Begin-Header% @@ -9,51 +14935,479 @@ * %End-Header% */ -#include -#include -#include -#include -#include -#include -#ifdef HAVE_SIGNAL_H -#include +#ifdef HAVE_CONIO_H +#undef HAVE_TERMIOS_H +#include +#define read_a_char() getch() +#else +#ifdef HAVE_TERMIOS_H +#include #endif -#ifdef HAVE_GETOPT_H -#include +#endif + +#if 0 +void fatal_error(e2fsck_t ctx, const char *msg) +{ + if (msg) + fprintf (stderr, "e2fsck: %s\n", msg); + if (ctx->fs && ctx->fs->io) { + if (ctx->fs->io->magic == EXT2_ET_MAGIC_IO_CHANNEL) + io_channel_flush(ctx->fs->io); + else + fprintf(stderr, "e2fsck: io manager magic bad!\n"); + } + ctx->flags |= E2F_FLAG_ABORT; + if (ctx->flags & E2F_FLAG_SETJMP_OK) + longjmp(ctx->abort_loc, 1); + exit(FSCK_ERROR); +} +#endif + +void *e2fsck_allocate_memory(e2fsck_t ctx, unsigned int size, + const char *description) +{ + void *ret; + char buf[256]; + +#ifdef DEBUG_ALLOCATE_MEMORY + printf("Allocating %d bytes for %s...\n", size, description); +#endif + ret = malloc(size); + if (!ret) { + sprintf(buf, "Can't allocate %s\n", description); + fatal_error(ctx, buf); + } + memset(ret, 0, size); + return ret; +} + +char *string_copy(e2fsck_t ctx EXT2FS_ATTR((unused)), + const char *str, int len) +{ + char *ret; + + if (!str) + return NULL; + if (!len) + len = strlen(str); + ret = malloc(len+1); + if (ret) { + strncpy(ret, str, len); + ret[len] = 0; + } + return ret; +} + +#ifndef HAVE_CONIO_H +static int read_a_char(void) +{ + char c; + int r; + int fail = 0; + + while(1) { + if (e2fsck_global_ctx && + (e2fsck_global_ctx->flags & E2F_FLAG_CANCEL)) { + return 3; + } + r = read(0, &c, 1); + if (r == 1) + return c; + if (fail++ > 100) + break; + } + return EOF; +} +#endif + +int ask_yn(const char * string, int def) +{ + int c; + const char *defstr; + const char *short_yes = _("yY"); + const char *short_no = _("nN"); + +#ifdef HAVE_TERMIOS_H + struct termios termios, tmp; + + tcgetattr (0, &termios); + tmp = termios; + tmp.c_lflag &= ~(ICANON | ECHO); + tmp.c_cc[VMIN] = 1; + tmp.c_cc[VTIME] = 0; + tcsetattr (0, TCSANOW, &tmp); +#endif + + if (def == 1) + defstr = _(_("")); + else if (def == 0) + defstr = _(_("")); + else + defstr = _(" (y/n)"); + printf("%s%s? ", string, defstr); + while (1) { + fflush (stdout); + if ((c = read_a_char()) == EOF) + break; + if (c == 3) { +#ifdef HAVE_TERMIOS_H + tcsetattr (0, TCSANOW, &termios); +#endif + if (e2fsck_global_ctx && + e2fsck_global_ctx->flags & E2F_FLAG_SETJMP_OK) { + puts("\n"); + longjmp(e2fsck_global_ctx->abort_loc, 1); + } + puts(_("cancelled!\n")); + return 0; + } + if (strchr(short_yes, (char) c)) { + def = 1; + break; + } + else if (strchr(short_no, (char) c)) { + def = 0; + break; + } + else if ((c == ' ' || c == '\n') && (def != -1)) + break; + } + if (def) + puts(_("yes\n")); + else + puts (_("no\n")); +#ifdef HAVE_TERMIOS_H + tcsetattr (0, TCSANOW, &termios); +#endif + return def; +} + +int ask (e2fsck_t ctx, const char * string, int def) +{ + if (ctx->options & E2F_OPT_NO) { + printf (_("%s? no\n\n"), string); + return 0; + } + if (ctx->options & E2F_OPT_YES) { + printf (_("%s? yes\n\n"), string); + return 1; + } + if (ctx->options & E2F_OPT_PREEN) { + printf ("%s? %s\n\n", string, def ? _("yes") : _("no")); + return def; + } + return ask_yn(string, def); +} + +void e2fsck_read_bitmaps(e2fsck_t ctx) +{ + ext2_filsys fs = ctx->fs; + errcode_t retval; + + if (ctx->invalid_bitmaps) { + com_err(ctx->program_name, 0, + _("e2fsck_read_bitmaps: illegal bitmap block(s) for %s"), + ctx->device_name); + fatal_error(ctx, 0); + } + + ehandler_operation(_("reading inode and block bitmaps")); + retval = ext2fs_read_bitmaps(fs); + ehandler_operation(0); + if (retval) { + com_err(ctx->program_name, retval, + _("while retrying to read bitmaps for %s"), + ctx->device_name); + fatal_error(ctx, 0); + } +} + +void e2fsck_write_bitmaps(e2fsck_t ctx) +{ + ext2_filsys fs = ctx->fs; + errcode_t retval; + + if (ext2fs_test_bb_dirty(fs)) { + ehandler_operation(_("writing block bitmaps")); + retval = ext2fs_write_block_bitmap(fs); + ehandler_operation(0); + if (retval) { + com_err(ctx->program_name, retval, + _("while retrying to write block bitmaps for %s"), + ctx->device_name); + fatal_error(ctx, 0); + } + } + + if (ext2fs_test_ib_dirty(fs)) { + ehandler_operation(_("writing inode bitmaps")); + retval = ext2fs_write_inode_bitmap(fs); + ehandler_operation(0); + if (retval) { + com_err(ctx->program_name, retval, + _("while retrying to write inode bitmaps for %s"), + ctx->device_name); + fatal_error(ctx, 0); + } + } +} + +void preenhalt(e2fsck_t ctx) +{ + ext2_filsys fs = ctx->fs; + + if (!(ctx->options & E2F_OPT_PREEN)) + return; + fprintf(stderr, _("\n\n%s: UNEXPECTED INCONSISTENCY; " + "RUN fsck MANUALLY.\n\t(i.e., without -a or -p options)\n"), + ctx->device_name); + if (fs != NULL) { + fs->super->s_state |= EXT2_ERROR_FS; + ext2fs_mark_super_dirty(fs); + ext2fs_close(fs); + } + exit(FSCK_UNCORRECTED); +} + +#ifdef RESOURCE_TRACK +void init_resource_track(struct resource_track *track) +{ +#ifdef HAVE_GETRUSAGE + struct rusage r; +#endif + + track->brk_start = sbrk(0); + gettimeofday(&track->time_start, 0); +#ifdef HAVE_GETRUSAGE +#ifdef sun + memset(&r, 0, sizeof(struct rusage)); +#endif + getrusage(RUSAGE_SELF, &r); + track->user_start = r.ru_utime; + track->system_start = r.ru_stime; #else -extern char *optarg; -extern int optind; + track->user_start.tv_sec = track->user_start.tv_usec = 0; + track->system_start.tv_sec = track->system_start.tv_usec = 0; #endif -#include -#ifdef HAVE_ERRNO_H -#include +} + +static _INLINE_ float timeval_subtract(struct timeval *tv1, + struct timeval *tv2) +{ + return ((tv1->tv_sec - tv2->tv_sec) + + ((float) (tv1->tv_usec - tv2->tv_usec)) / 1000000); +} + +void print_resource_track(const char *desc, struct resource_track *track) +{ +#ifdef HAVE_GETRUSAGE + struct rusage r; #endif -#ifdef HAVE_MNTENT_H -#include +#ifdef HAVE_MALLINFO + struct mallinfo malloc_info; #endif -#ifdef HAVE_SYS_IOCTL_H -#include + struct timeval time_end; + + gettimeofday(&time_end, 0); + + if (desc) + printf("%s: ", desc); + +#ifdef HAVE_MALLINFO +#define kbytes(x) (((x) + 1023) / 1024) + + malloc_info = mallinfo(); + printf(_("Memory used: %dk/%dk (%dk/%dk), "), + kbytes(malloc_info.arena), kbytes(malloc_info.hblkhd), + kbytes(malloc_info.uordblks), kbytes(malloc_info.fordblks)); +#else + printf(_("Memory used: %d, "), + (int) (((char *) sbrk(0)) - ((char *) track->brk_start))); #endif -#ifdef HAVE_MALLOC_H -#include +#ifdef HAVE_GETRUSAGE + getrusage(RUSAGE_SELF, &r); + + printf(_("time: %5.2f/%5.2f/%5.2f\n"), + timeval_subtract(&time_end, &track->time_start), + timeval_subtract(&r.ru_utime, &track->user_start), + timeval_subtract(&r.ru_stime, &track->system_start)); +#else + printf(_("elapsed time: %6.3f\n"), + timeval_subtract(&time_end, &track->time_start)); #endif -#ifdef HAVE_SYS_TYPES_H -#include +} +#endif /* RESOURCE_TRACK */ + +void e2fsck_read_inode(e2fsck_t ctx, unsigned long ino, + struct ext2_inode * inode, const char *proc) +{ + int retval; + + retval = ext2fs_read_inode(ctx->fs, ino, inode); + if (retval) { + com_err("ext2fs_read_inode", retval, + _("while reading inode %ld in %s"), ino, proc); + fatal_error(ctx, 0); + } +} + +extern void e2fsck_write_inode_full(e2fsck_t ctx, unsigned long ino, + struct ext2_inode * inode, int bufsize, + const char *proc) +{ + int retval; + + retval = ext2fs_write_inode_full(ctx->fs, ino, inode, bufsize); + if (retval) { + com_err("ext2fs_write_inode", retval, + _("while writing inode %ld in %s"), ino, proc); + fatal_error(ctx, 0); + } +} + +extern void e2fsck_write_inode(e2fsck_t ctx, unsigned long ino, + struct ext2_inode * inode, const char *proc) +{ + int retval; + + retval = ext2fs_write_inode(ctx->fs, ino, inode); + if (retval) { + com_err("ext2fs_write_inode", retval, + _("while writing inode %ld in %s"), ino, proc); + fatal_error(ctx, 0); + } +} + +#ifdef MTRACE +void mtrace_print(char *mesg) +{ + FILE *malloc_get_mallstream(); + FILE *f = malloc_get_mallstream(); + + if (f) + fprintf(f, "============= %s\n", mesg); +} #endif -#ifdef HAVE_DIRENT_H -#include + +blk_t get_backup_sb(e2fsck_t ctx, ext2_filsys fs, const char *name, + io_manager manager) +{ + struct ext2_super_block *sb; + io_channel io = NULL; + void *buf = NULL; + int blocksize; + blk_t superblock, ret_sb = 8193; + + if (fs && fs->super) { + ret_sb = (fs->super->s_blocks_per_group + + fs->super->s_first_data_block); + if (ctx) { + ctx->superblock = ret_sb; + ctx->blocksize = fs->blocksize; + } + return ret_sb; + } + + if (ctx) { + if (ctx->blocksize) { + ret_sb = ctx->blocksize * 8; + if (ctx->blocksize == 1024) + ret_sb++; + ctx->superblock = ret_sb; + return ret_sb; + } + ctx->superblock = ret_sb; + ctx->blocksize = 1024; + } + + if (!name || !manager) + goto cleanup; + + if (manager->open(name, 0, &io) != 0) + goto cleanup; + + if (ext2fs_get_mem(SUPERBLOCK_SIZE, &buf)) + goto cleanup; + sb = (struct ext2_super_block *) buf; + + for (blocksize = EXT2_MIN_BLOCK_SIZE; + blocksize <= EXT2_MAX_BLOCK_SIZE ; blocksize *= 2) { + superblock = blocksize*8; + if (blocksize == 1024) + superblock++; + io_channel_set_blksize(io, blocksize); + if (io_channel_read_blk(io, superblock, + -SUPERBLOCK_SIZE, buf)) + continue; +#ifdef EXT2FS_ENABLE_SWAPFS + if (sb->s_magic == ext2fs_swab16(EXT2_SUPER_MAGIC)) + ext2fs_swap_super(sb); #endif + if (sb->s_magic == EXT2_SUPER_MAGIC) { + ret_sb = superblock; + if (ctx) { + ctx->superblock = superblock; + ctx->blocksize = blocksize; + } + break; + } + } + +cleanup: + if (io) + io_channel_close(io); + if (buf) + ext2fs_free_mem(&buf); + return (ret_sb); +} + +/* + * Given a mode, return the ext2 file type + */ +int ext2_file_type(unsigned int mode) +{ + if (LINUX_S_ISREG(mode)) + return EXT2_FT_REG_FILE; + + if (LINUX_S_ISDIR(mode)) + return EXT2_FT_DIR; + + if (LINUX_S_ISCHR(mode)) + return EXT2_FT_CHRDEV; + + if (LINUX_S_ISBLK(mode)) + return EXT2_FT_BLKDEV; + + if (LINUX_S_ISLNK(mode)) + return EXT2_FT_SYMLINK; + + if (LINUX_S_ISFIFO(mode)) + return EXT2_FT_FIFO; + + if (LINUX_S_ISSOCK(mode)) + return EXT2_FT_SOCK; + + return 0; +} +/* + * unix.c - The unix-specific code for e2fsck + * + * Copyright (C) 1993, 1994, 1995, 1996, 1997 Theodore Ts'o. + * + * %Begin-Header% + * This file may be redistributed under the terms of the GNU Public + * License. + * %End-Header% + */ + -#include "e2fsbb.h" -#include "e2fsck/e2fsck.h" -#include "e2fsck/problem.h" /* Command line options */ static int swapfs; #ifdef ENABLE_SWAPFS static int normalize_swapfs; #endif -static int cflag; /* check disk */ +static int cflag; /* check disk */ static int show_version_only; static int verbose; @@ -61,9 +15415,7 @@ static int replace_bad_blocks; static int keep_bad_blocks; static char *bad_blocks_file; -e2fsck_t e2fsck_global_ctx; /* Try your very best not to use this! */ - -#ifdef __CONFIG_JBD_DEBUG__E2FS /* Enabled by configure --enable-jfs-debug */ +#ifdef __CONFIG_JBD_DEBUG__E2FS /* Enabled by configure --enable-jfs-debug */ int journal_enable_debug = -1; #endif @@ -96,7 +15448,7 @@ static void usage(e2fsck_t ctx) } #endif -static void show_stats(e2fsck_t ctx) +static void show_stats(e2fsck_t ctx) { ext2_filsys fs = ctx->fs; int inodes, inodes_used, blocks, blocks_used; @@ -116,7 +15468,7 @@ static void show_stats(e2fsck_t ctx) frag_percent = (10000 * ctx->fs_fragmented) / inodes_used; frag_percent = (frag_percent + 5) / 10; - + if (!verbose) { printf("%s: %d/%d files (%0d.%d%% non-contiguous), %d/%d blocks\n", ctx->device_name, inodes_used, inodes, @@ -167,8 +15519,8 @@ static void show_stats(e2fsck_t ctx) static void check_mount(e2fsck_t ctx) { - errcode_t retval; - int cont; + errcode_t retval; + int cont; retval = ext2fs_check_if_mounted(ctx->filesystem_name, &ctx->mount_flags); @@ -209,15 +15561,15 @@ static void check_mount(e2fsck_t ctx) static int is_on_batt(void) { - FILE *f; - DIR *d; - char tmp[80], tmp2[80], fname[80]; - unsigned int acflag; - struct dirent* de; + FILE *f; + DIR *d; + char tmp[80], tmp2[80], fname[80]; + unsigned int acflag; + struct dirent* de; f = fopen("/proc/apm", "r"); if (f) { - if (fscanf(f, "%s %s %s %x", tmp, tmp, tmp, &acflag) != 4) + if (fscanf(f, "%s %s %s %x", tmp, tmp, tmp, &acflag) != 4) acflag = 1; fclose(f); return (acflag != 1); @@ -227,7 +15579,7 @@ static int is_on_batt(void) while ((de=readdir(d)) != NULL) { if (!strncmp(".", de->d_name, 1)) continue; - snprintf(fname, 80, "/proc/acpi/ac_adapter/%s/state", + snprintf(fname, 80, "/proc/acpi/ac_adapter/%s/state", de->d_name); f = fopen(fname, "r"); if (!f) @@ -258,11 +15610,11 @@ static void check_if_skip(e2fsck_t ctx) long next_check; int batt = is_on_batt(); time_t now = time(0); - + if ((ctx->options & E2F_OPT_FORCE) || bad_blocks_file || cflag || swapfs) return; - + if ((fs->super->s_state & EXT2_ERROR_FS) || !ext2fs_test_valid(fs)) reason = _(" contains a file system with errors"); @@ -273,15 +15625,15 @@ static void check_if_skip(e2fsck_t ctx) (unsigned) fs->super->s_max_mnt_count)) { reason = _(" has been mounted %u times without being checked"); reason_arg = fs->super->s_mnt_count; - if (batt && (fs->super->s_mnt_count < + if (batt && (fs->super->s_mnt_count < (unsigned) fs->super->s_max_mnt_count*2)) reason = 0; } else if (fs->super->s_checkinterval && - ((now - fs->super->s_lastcheck) >= + ((now - fs->super->s_lastcheck) >= fs->super->s_checkinterval)) { reason = _(" has gone %u days without being checked"); reason_arg = (now - fs->super->s_lastcheck)/(3600*24); - if (batt && ((now - fs->super->s_lastcheck) < + if (batt && ((now - fs->super->s_lastcheck) < fs->super->s_checkinterval*2)) reason = 0; } @@ -299,7 +15651,7 @@ static void check_if_skip(e2fsck_t ctx) next_check = 100000; if (fs->super->s_max_mnt_count > 0) { next_check = fs->super->s_max_mnt_count - fs->super->s_mnt_count; - if (next_check <= 0) + if (next_check <= 0) next_check = 1; } if (fs->super->s_checkinterval && @@ -322,10 +15674,10 @@ static void check_if_skip(e2fsck_t ctx) * For completion notice */ struct percent_tbl { - int max_pass; - int table[32]; + int max_pass; + int table[32]; }; -struct percent_tbl e2fsck_tbl = { +static struct percent_tbl e2fsck_tbl = { 5, { 0, 70, 90, 92, 95, 100 } }; static char bar[128], spaces[128]; @@ -333,8 +15685,8 @@ static char bar[128], spaces[128]; static float calc_percent(struct percent_tbl *tbl, int pass, int curr, int max) { - float percent; - + float percent; + if (pass <= 0) return 0.0; if (pass > tbl->max_pass || max == 0) @@ -348,7 +15700,7 @@ extern void e2fsck_clear_progbar(e2fsck_t ctx) { if (!(ctx->flags & E2F_FLAG_PROG_BAR)) return; - + printf("%s%s\r%s", ctx->start_meta, spaces + (sizeof(spaces) - 80), ctx->stop_meta); fflush(stdout); @@ -359,9 +15711,9 @@ int e2fsck_simple_progress(e2fsck_t ctx, const char *label, float percent, unsigned int dpynum) { static const char spinner[] = "\\|/-"; - int i; - unsigned int tick; - struct timeval tv; + int i; + unsigned int tick; + struct timeval tv; int dpywidth; int fixed_percent; @@ -371,7 +15723,7 @@ int e2fsck_simple_progress(e2fsck_t ctx, const char *label, float percent, /* * Calculate the new progress position. If the * percentage hasn't changed, then we skip out right - * away. + * away. */ fixed_percent = (int) ((10 * percent) + 0.5); if (ctx->progress_last_percent == fixed_percent) @@ -416,7 +15768,7 @@ int e2fsck_simple_progress(e2fsck_t ctx, const char *label, float percent, else fputs(" \r", stdout); fputs(ctx->stop_meta, stdout); - + if (fixed_percent == 1000) e2fsck_clear_progbar(ctx); fflush(stdout); @@ -432,7 +15784,7 @@ static int e2fsck_update_progress(e2fsck_t ctx, int pass, if (pass == 0) return 0; - + if (ctx->progress_fd) { sprintf(buf, "%d %lu %lu\n", pass, cur, max); write(ctx->progress_fd, buf, strlen(buf)); @@ -448,7 +15800,7 @@ static int e2fsck_update_progress(e2fsck_t ctx, int pass, static void reserve_stdio_fds(void) { - int fd; + int fd; while (1) { fd = open("/dev/null", O_RDWR); @@ -464,7 +15816,6 @@ static void reserve_stdio_fds(void) close(fd); } -#ifdef HAVE_SIGNAL_H static void signal_progress_on(int sig EXT2FS_ATTR((unused))) { e2fsck_t ctx = e2fsck_global_ctx; @@ -496,13 +15847,12 @@ static void signal_cancel(int sig EXT2FS_ATTR((unused))) ctx->flags |= E2F_FLAG_CANCEL; } -#endif static void parse_extended_opts(e2fsck_t ctx, const char *opts) { - char *buf, *token, *next, *p, *arg; - int ea_ver; - int extended_usage = 0; + char *buf, *token, *next, *p, *arg; + int ea_ver; + int extended_usage = 0; buf = string_copy(ctx, opts, 0); for (token = buf; token && *token; token = next) { @@ -511,7 +15861,7 @@ static void parse_extended_opts(e2fsck_t ctx, const char *opts) if (p) { *p = 0; next = p+1; - } + } arg = strchr(token, '='); if (arg) { *arg = 0; @@ -542,22 +15892,20 @@ static void parse_extended_opts(e2fsck_t ctx, const char *opts) "\tea_ver=blkid, NULL); - + if (argc && *argv) ctx->program_name = *argv; else @@ -610,7 +15958,7 @@ static errcode_t PRS(int argc, char *argv[], e2fsck_t *ret_ctx) case 'a': if (ctx->options & (E2F_OPT_YES|E2F_OPT_NO)) { conflict_opt: - fatal_error(ctx, + fatal_error(ctx, _("Only one the options -p/-a, -n or -y may be specified.")); } ctx->options |= E2F_OPT_PREEN; @@ -716,17 +16064,17 @@ static errcode_t PRS(int argc, char *argv[], e2fsck_t *ret_ctx) !cflag && !swapfs && !(ctx->options & E2F_OPT_COMPRESS_DIRS)) ctx->options |= E2F_OPT_READONLY; ctx->io_options = strchr(argv[optind], '?'); - if (ctx->io_options) + if (ctx->io_options) *ctx->io_options++ = 0; ctx->filesystem_name = blkid_get_devname(ctx->blkid, argv[optind], 0); if (!ctx->filesystem_name) { - com_err(ctx->program_name, 0, _("Unable to resolve '%s'"), + com_err(ctx->program_name, 0, _("Unable to resolve '%s'"), argv[optind]); fatal_error(ctx, 0); } if (extended_opts) parse_extended_opts(ctx, extended_opts); - + if (flush) { fd = open(ctx->filesystem_name, O_RDONLY, 0); if (fd < 0) { @@ -757,7 +16105,6 @@ static errcode_t PRS(int argc, char *argv[], e2fsck_t *ret_ctx) "not be both used at the same time.\n")); exit(FSCK_USAGE); } -#ifdef HAVE_SIGNAL_H /* * Set up signal action */ @@ -773,7 +16120,6 @@ static errcode_t PRS(int argc, char *argv[], e2fsck_t *ret_ctx) sigaction(SIGUSR1, &sa, 0); sa.sa_handler = signal_progress_off; sigaction(SIGUSR2, &sa, 0); -#endif /* Update our PATH to include /sbin if we need to run badblocks */ if (cflag) { @@ -801,20 +16147,20 @@ static errcode_t PRS(int argc, char *argv[], e2fsck_t *ret_ctx) static const char *my_ver_string = E2FSPROGS_VERSION; static const char *my_ver_date = E2FSPROGS_DATE; - + int e2fsck_main (int argc, char *argv[]) { - errcode_t retval = 0; - int exit_value = FSCK_OK; - ext2_filsys fs = 0; - io_manager io_ptr; + errcode_t retval = 0; + int exit_value = FSCK_OK; + ext2_filsys fs = 0; + io_manager io_ptr; struct ext2_super_block *sb; - const char *lib_ver_date; - int my_ver, lib_ver; - e2fsck_t ctx; + const char *lib_ver_date; + int my_ver, lib_ver; + e2fsck_t ctx; struct problem_context pctx; int flags, run_result; - + clear_problem_context(&pctx); #ifdef MTRACE mtrace(); @@ -835,7 +16181,7 @@ int e2fsck_main (int argc, char *argv[]) "out of date!\n")); show_version_only++; } - + retval = PRS(argc, argv, &ctx); if (retval) { com_err("e2fsck", retval, @@ -843,7 +16189,7 @@ int e2fsck_main (int argc, char *argv[]) exit(FSCK_ERROR); } reserve_stdio_fds(); - + #ifdef RESOURCE_TRACK init_resource_track(&ctx->global_rtrack); #endif @@ -857,9 +16203,9 @@ int e2fsck_main (int argc, char *argv[]) error_message(EXT2_ET_BASE), lib_ver_date); exit(FSCK_OK); } - + check_mount(ctx); - + if (!(ctx->options & E2F_OPT_PREEN) && !(ctx->options & E2F_OPT_NO) && !(ctx->options & E2F_OPT_YES)) { @@ -880,22 +16226,22 @@ restart: flags |= EXT2_FLAG_RW; if (ctx->superblock && ctx->blocksize) { - retval = ext2fs_open2(ctx->filesystem_name, ctx->io_options, + retval = ext2fs_open2(ctx->filesystem_name, ctx->io_options, flags, ctx->superblock, ctx->blocksize, io_ptr, &fs); } else if (ctx->superblock) { int blocksize; for (blocksize = EXT2_MIN_BLOCK_SIZE; blocksize <= EXT2_MAX_BLOCK_SIZE; blocksize *= 2) { - retval = ext2fs_open2(ctx->filesystem_name, + retval = ext2fs_open2(ctx->filesystem_name, ctx->io_options, flags, ctx->superblock, blocksize, io_ptr, &fs); if (!retval) break; } - } else - retval = ext2fs_open2(ctx->filesystem_name, ctx->io_options, + } else + retval = ext2fs_open2(ctx->filesystem_name, ctx->io_options, flags, 0, 0, io_ptr, &fs); if (!ctx->superblock && !(ctx->options & E2F_OPT_PREEN) && !(ctx->flags & E2F_FLAG_SB_SPECIFIED) && @@ -1161,13 +16507,13 @@ restart: } e2fsck_write_bitmaps(ctx); - + ext2fs_close(fs); ctx->fs = NULL; free(ctx->filesystem_name); free(ctx->journal_name); e2fsck_free_context(ctx); - + #ifdef RESOURCE_TRACK if (ctx->options & E2F_OPT_TIME) print_resource_track(NULL, &ctx->global_rtrack); diff --git a/e2fsprogs/e2fsck/badblocks.c b/e2fsprogs/e2fsck/badblocks.c deleted file mode 100644 index 1ab76a091..000000000 --- a/e2fsprogs/e2fsck/badblocks.c +++ /dev/null @@ -1,135 +0,0 @@ -/* - * badblocks.c --- replace/append bad blocks to the bad block inode - * - * Copyright (C) 1993, 1994 Theodore Ts'o. This file may be - * redistributed under the terms of the GNU Public License. - */ - -#include -#ifdef HAVE_ERRNO_H -#include -#endif - -#include "e2fsck.h" - -static int check_bb_inode_blocks(ext2_filsys fs, blk_t *block_nr, int blockcnt, - void *priv_data); - - -static void invalid_block(ext2_filsys fs EXT2FS_ATTR((unused)), blk_t blk) -{ - printf(_("Bad block %u out of range; ignored.\n"), blk); - return; -} - -void read_bad_blocks_file(e2fsck_t ctx, const char *bad_blocks_file, - int replace_bad_blocks) -{ - ext2_filsys fs = ctx->fs; - errcode_t retval; - badblocks_list bb_list = 0; - FILE *f; - char buf[1024]; - - e2fsck_read_bitmaps(ctx); - - /* - * Make sure the bad block inode is sane. If there are any - * illegal blocks, clear them. - */ - retval = ext2fs_block_iterate(fs, EXT2_BAD_INO, 0, 0, - check_bb_inode_blocks, 0); - if (retval) { - com_err("ext2fs_block_iterate", retval, - _("while sanity checking the bad blocks inode")); - goto fatal; - } - - /* - * If we're appending to the bad blocks inode, read in the - * current bad blocks. - */ - if (!replace_bad_blocks) { - retval = ext2fs_read_bb_inode(fs, &bb_list); - if (retval) { - com_err("ext2fs_read_bb_inode", retval, - _("while reading the bad blocks inode")); - goto fatal; - } - } - - /* - * Now read in the bad blocks from the file; if - * bad_blocks_file is null, then try to run the badblocks - * command. - */ - if (bad_blocks_file) { - f = fopen(bad_blocks_file, "r"); - if (!f) { - com_err("read_bad_blocks_file", errno, - _("while trying to open %s"), bad_blocks_file); - goto fatal; - } - } else { - sprintf(buf, "badblocks -b %d %s%s%s %d", fs->blocksize, - (ctx->options & E2F_OPT_PREEN) ? "" : "-s ", - (ctx->options & E2F_OPT_WRITECHECK) ? "-n " : "", - fs->device_name, fs->super->s_blocks_count); - f = popen(buf, "r"); - if (!f) { - com_err("read_bad_blocks_file", errno, - _("while trying popen '%s'"), buf); - goto fatal; - } - } - retval = ext2fs_read_bb_FILE(fs, f, &bb_list, invalid_block); - if (bad_blocks_file) - fclose(f); - else - pclose(f); - if (retval) { - com_err("ext2fs_read_bb_FILE", retval, - _("while reading in list of bad blocks from file")); - goto fatal; - } - - /* - * Finally, update the bad blocks from the bad_block_map - */ - retval = ext2fs_update_bb_inode(fs, bb_list); - if (retval) { - com_err("ext2fs_update_bb_inode", retval, - _("while updating bad block inode")); - goto fatal; - } - - ext2fs_badblocks_list_free(bb_list); - return; - -fatal: - ctx->flags |= E2F_FLAG_ABORT; - return; - -} - -static int check_bb_inode_blocks(ext2_filsys fs, - blk_t *block_nr, - int blockcnt EXT2FS_ATTR((unused)), - void *priv_data EXT2FS_ATTR((unused))) -{ - if (!*block_nr) - return 0; - - /* - * If the block number is outrageous, clear it and ignore it. - */ - if (*block_nr >= fs->super->s_blocks_count || - *block_nr < fs->super->s_first_data_block) { - printf(_("Warning illegal block %u found in bad block inode. Cleared.\n"), *block_nr); - *block_nr = 0; - return BLOCK_CHANGED; - } - - return 0; -} - diff --git a/e2fsprogs/e2fsck/dict.c b/e2fsprogs/e2fsck/dict.c deleted file mode 100644 index b0809a76d..000000000 --- a/e2fsprogs/e2fsck/dict.c +++ /dev/null @@ -1,1529 +0,0 @@ -/* - * Dictionary Abstract Data Type - * Copyright (C) 1997 Kaz Kylheku - * - * Free Software License: - * - * All rights are reserved by the author, with the following exceptions: - * Permission is granted to freely reproduce and distribute this software, - * possibly in exchange for a fee, provided that this copyright notice appears - * intact. Permission is also granted to adapt this software to produce - * derivative works, as long as the modified versions carry this copyright - * notice and additional notices stating that the work has been modified. - * This source code may be translated into executable form and incorporated - * into proprietary software; there is no requirement for such software to - * contain a copyright notice related to this source. - * - * $Id: dict.c,v 1.40.2.7 2000/11/13 01:36:44 kaz Exp $ - * $Name: kazlib_1_20 $ - */ - -#ifdef __GNUC__ -#define EXT2FS_ATTR(x) __attribute__(x) -#else -#define EXT2FS_ATTR(x) -#endif - -#include -#include -#include -#define DICT_IMPLEMENTATION -#include "dict.h" - -#ifndef NDEBUG -# define NDEBUG -#endif - -/* - * These macros provide short convenient names for structure members, - * which are embellished with dict_ prefixes so that they are - * properly confined to the documented namespace. It's legal for a - * program which uses dict to define, for instance, a macro called ``parent''. - * Such a macro would interfere with the dnode_t struct definition. - * In general, highly portable and reusable C modules which expose their - * structures need to confine structure member names to well-defined spaces. - * The resulting identifiers aren't necessarily convenient to use, nor - * readable, in the implementation, however! - */ - -#define left dict_left -#define right dict_right -#define parent dict_parent -#define color dict_color -#define key dict_key -#define data dict_data - -#define nilnode dict_nilnode -#define nodecount dict_nodecount -#define maxcount dict_maxcount -#define compare dict_compare -#define allocnode dict_allocnode -#define freenode dict_freenode -#define context dict_context -#define dupes dict_dupes - -#define dictptr dict_dictptr - -#define dict_root(D) ((D)->nilnode.left) -#define dict_nil(D) (&(D)->nilnode) -#define DICT_DEPTH_MAX 64 - -static dnode_t *dnode_alloc(void *context); -static void dnode_free(dnode_t *node, void *context); - -/* - * Perform a ``left rotation'' adjustment on the tree. The given node P and - * its right child C are rearranged so that the P instead becomes the left - * child of C. The left subtree of C is inherited as the new right subtree - * for P. The ordering of the keys within the tree is thus preserved. - */ - -static void rotate_left(dnode_t *upper) -{ - dnode_t *lower, *lowleft, *upparent; - - lower = upper->right; - upper->right = lowleft = lower->left; - lowleft->parent = upper; - - lower->parent = upparent = upper->parent; - - /* don't need to check for root node here because root->parent is - the sentinel nil node, and root->parent->left points back to root */ - - if (upper == upparent->left) { - upparent->left = lower; - } else { - assert (upper == upparent->right); - upparent->right = lower; - } - - lower->left = upper; - upper->parent = lower; -} - -/* - * This operation is the ``mirror'' image of rotate_left. It is - * the same procedure, but with left and right interchanged. - */ - -static void rotate_right(dnode_t *upper) -{ - dnode_t *lower, *lowright, *upparent; - - lower = upper->left; - upper->left = lowright = lower->right; - lowright->parent = upper; - - lower->parent = upparent = upper->parent; - - if (upper == upparent->right) { - upparent->right = lower; - } else { - assert (upper == upparent->left); - upparent->left = lower; - } - - lower->right = upper; - upper->parent = lower; -} - -/* - * Do a postorder traversal of the tree rooted at the specified - * node and free everything under it. Used by dict_free(). - */ - -static void free_nodes(dict_t *dict, dnode_t *node, dnode_t *nil) -{ - if (node == nil) - return; - free_nodes(dict, node->left, nil); - free_nodes(dict, node->right, nil); - dict->freenode(node, dict->context); -} - -/* - * This procedure performs a verification that the given subtree is a binary - * search tree. It performs an inorder traversal of the tree using the - * dict_next() successor function, verifying that the key of each node is - * strictly lower than that of its successor, if duplicates are not allowed, - * or lower or equal if duplicates are allowed. This function is used for - * debugging purposes. - */ -#ifndef NDEBUG -static int verify_bintree(dict_t *dict) -{ - dnode_t *first, *next; - - first = dict_first(dict); - - if (dict->dupes) { - while (first && (next = dict_next(dict, first))) { - if (dict->compare(first->key, next->key) > 0) - return 0; - first = next; - } - } else { - while (first && (next = dict_next(dict, first))) { - if (dict->compare(first->key, next->key) >= 0) - return 0; - first = next; - } - } - return 1; -} - -/* - * This function recursively verifies that the given binary subtree satisfies - * three of the red black properties. It checks that every red node has only - * black children. It makes sure that each node is either red or black. And it - * checks that every path has the same count of black nodes from root to leaf. - * It returns the blackheight of the given subtree; this allows blackheights to - * be computed recursively and compared for left and right siblings for - * mismatches. It does not check for every nil node being black, because there - * is only one sentinel nil node. The return value of this function is the - * black height of the subtree rooted at the node ``root'', or zero if the - * subtree is not red-black. - */ - -static unsigned int verify_redblack(dnode_t *nil, dnode_t *root) -{ - unsigned height_left, height_right; - - if (root != nil) { - height_left = verify_redblack(nil, root->left); - height_right = verify_redblack(nil, root->right); - if (height_left == 0 || height_right == 0) - return 0; - if (height_left != height_right) - return 0; - if (root->color == dnode_red) { - if (root->left->color != dnode_black) - return 0; - if (root->right->color != dnode_black) - return 0; - return height_left; - } - if (root->color != dnode_black) - return 0; - return height_left + 1; - } - return 1; -} - -/* - * Compute the actual count of nodes by traversing the tree and - * return it. This could be compared against the stored count to - * detect a mismatch. - */ - -static dictcount_t verify_node_count(dnode_t *nil, dnode_t *root) -{ - if (root == nil) - return 0; - else - return 1 + verify_node_count(nil, root->left) - + verify_node_count(nil, root->right); -} -#endif - -/* - * Verify that the tree contains the given node. This is done by - * traversing all of the nodes and comparing their pointers to the - * given pointer. Returns 1 if the node is found, otherwise - * returns zero. It is intended for debugging purposes. - */ - -static int verify_dict_has_node(dnode_t *nil, dnode_t *root, dnode_t *node) -{ - if (root != nil) { - return root == node - || verify_dict_has_node(nil, root->left, node) - || verify_dict_has_node(nil, root->right, node); - } - return 0; -} - - -#ifdef E2FSCK_NOTUSED -/* - * Dynamically allocate and initialize a dictionary object. - */ - -dict_t *dict_create(dictcount_t maxcount, dict_comp_t comp) -{ - dict_t *new = malloc(sizeof *new); - - if (new) { - new->compare = comp; - new->allocnode = dnode_alloc; - new->freenode = dnode_free; - new->context = NULL; - new->nodecount = 0; - new->maxcount = maxcount; - new->nilnode.left = &new->nilnode; - new->nilnode.right = &new->nilnode; - new->nilnode.parent = &new->nilnode; - new->nilnode.color = dnode_black; - new->dupes = 0; - } - return new; -} -#endif /* E2FSCK_NOTUSED */ - -/* - * Select a different set of node allocator routines. - */ - -void dict_set_allocator(dict_t *dict, dnode_alloc_t al, - dnode_free_t fr, void *context) -{ - assert (dict_count(dict) == 0); - assert ((al == NULL && fr == NULL) || (al != NULL && fr != NULL)); - - dict->allocnode = al ? al : dnode_alloc; - dict->freenode = fr ? fr : dnode_free; - dict->context = context; -} - -#ifdef E2FSCK_NOTUSED -/* - * Free a dynamically allocated dictionary object. Removing the nodes - * from the tree before deleting it is required. - */ - -void dict_destroy(dict_t *dict) -{ - assert (dict_isempty(dict)); - free(dict); -} -#endif - -/* - * Free all the nodes in the dictionary by using the dictionary's - * installed free routine. The dictionary is emptied. - */ - -void dict_free_nodes(dict_t *dict) -{ - dnode_t *nil = dict_nil(dict), *root = dict_root(dict); - free_nodes(dict, root, nil); - dict->nodecount = 0; - dict->nilnode.left = &dict->nilnode; - dict->nilnode.right = &dict->nilnode; -} - -#ifdef E2FSCK_NOTUSED -/* - * Obsolescent function, equivalent to dict_free_nodes - */ -void dict_free(dict_t *dict) -{ -#ifdef KAZLIB_OBSOLESCENT_DEBUG - assert ("call to obsolescent function dict_free()" && 0); -#endif - dict_free_nodes(dict); -} -#endif - -/* - * Initialize a user-supplied dictionary object. - */ - -dict_t *dict_init(dict_t *dict, dictcount_t maxcount, dict_comp_t comp) -{ - dict->compare = comp; - dict->allocnode = dnode_alloc; - dict->freenode = dnode_free; - dict->context = NULL; - dict->nodecount = 0; - dict->maxcount = maxcount; - dict->nilnode.left = &dict->nilnode; - dict->nilnode.right = &dict->nilnode; - dict->nilnode.parent = &dict->nilnode; - dict->nilnode.color = dnode_black; - dict->dupes = 0; - return dict; -} - -#ifdef E2FSCK_NOTUSED -/* - * Initialize a dictionary in the likeness of another dictionary - */ - -void dict_init_like(dict_t *dict, const dict_t *template) -{ - dict->compare = template->compare; - dict->allocnode = template->allocnode; - dict->freenode = template->freenode; - dict->context = template->context; - dict->nodecount = 0; - dict->maxcount = template->maxcount; - dict->nilnode.left = &dict->nilnode; - dict->nilnode.right = &dict->nilnode; - dict->nilnode.parent = &dict->nilnode; - dict->nilnode.color = dnode_black; - dict->dupes = template->dupes; - - assert (dict_similar(dict, template)); -} - -/* - * Remove all nodes from the dictionary (without freeing them in any way). - */ - -static void dict_clear(dict_t *dict) -{ - dict->nodecount = 0; - dict->nilnode.left = &dict->nilnode; - dict->nilnode.right = &dict->nilnode; - dict->nilnode.parent = &dict->nilnode; - assert (dict->nilnode.color == dnode_black); -} - - -/* - * Verify the integrity of the dictionary structure. This is provided for - * debugging purposes, and should be placed in assert statements. Just because - * this function succeeds doesn't mean that the tree is not corrupt. Certain - * corruptions in the tree may simply cause undefined behavior. - */ - -int dict_verify(dict_t *dict) -{ -#ifndef NDEBUG - dnode_t *nil = dict_nil(dict), *root = dict_root(dict); - - /* check that the sentinel node and root node are black */ - if (root->color != dnode_black) - return 0; - if (nil->color != dnode_black) - return 0; - if (nil->right != nil) - return 0; - /* nil->left is the root node; check that its parent pointer is nil */ - if (nil->left->parent != nil) - return 0; - /* perform a weak test that the tree is a binary search tree */ - if (!verify_bintree(dict)) - return 0; - /* verify that the tree is a red-black tree */ - if (!verify_redblack(nil, root)) - return 0; - if (verify_node_count(nil, root) != dict_count(dict)) - return 0; -#endif - return 1; -} - -/* - * Determine whether two dictionaries are similar: have the same comparison and - * allocator functions, and same status as to whether duplicates are allowed. - */ - -int dict_similar(const dict_t *left, const dict_t *right) -{ - if (left->compare != right->compare) - return 0; - - if (left->allocnode != right->allocnode) - return 0; - - if (left->freenode != right->freenode) - return 0; - - if (left->context != right->context) - return 0; - - if (left->dupes != right->dupes) - return 0; - - return 1; -} -#endif /* E2FSCK_NOTUSED */ - -/* - * Locate a node in the dictionary having the given key. - * If the node is not found, a null a pointer is returned (rather than - * a pointer that dictionary's nil sentinel node), otherwise a pointer to the - * located node is returned. - */ - -dnode_t *dict_lookup(dict_t *dict, const void *key) -{ - dnode_t *root = dict_root(dict); - dnode_t *nil = dict_nil(dict); - dnode_t *saved; - int result; - - /* simple binary search adapted for trees that contain duplicate keys */ - - while (root != nil) { - result = dict->compare(key, root->key); - if (result < 0) - root = root->left; - else if (result > 0) - root = root->right; - else { - if (!dict->dupes) { /* no duplicates, return match */ - return root; - } else { /* could be dupes, find leftmost one */ - do { - saved = root; - root = root->left; - while (root != nil && dict->compare(key, root->key)) - root = root->right; - } while (root != nil); - return saved; - } - } - } - - return NULL; -} - -#ifdef E2FSCK_NOTUSED -/* - * Look for the node corresponding to the lowest key that is equal to or - * greater than the given key. If there is no such node, return null. - */ - -dnode_t *dict_lower_bound(dict_t *dict, const void *key) -{ - dnode_t *root = dict_root(dict); - dnode_t *nil = dict_nil(dict); - dnode_t *tentative = 0; - - while (root != nil) { - int result = dict->compare(key, root->key); - - if (result > 0) { - root = root->right; - } else if (result < 0) { - tentative = root; - root = root->left; - } else { - if (!dict->dupes) { - return root; - } else { - tentative = root; - root = root->left; - } - } - } - - return tentative; -} - -/* - * Look for the node corresponding to the greatest key that is equal to or - * lower than the given key. If there is no such node, return null. - */ - -dnode_t *dict_upper_bound(dict_t *dict, const void *key) -{ - dnode_t *root = dict_root(dict); - dnode_t *nil = dict_nil(dict); - dnode_t *tentative = 0; - - while (root != nil) { - int result = dict->compare(key, root->key); - - if (result < 0) { - root = root->left; - } else if (result > 0) { - tentative = root; - root = root->right; - } else { - if (!dict->dupes) { - return root; - } else { - tentative = root; - root = root->right; - } - } - } - - return tentative; -} -#endif - -/* - * Insert a node into the dictionary. The node should have been - * initialized with a data field. All other fields are ignored. - * The behavior is undefined if the user attempts to insert into - * a dictionary that is already full (for which the dict_isfull() - * function returns true). - */ - -void dict_insert(dict_t *dict, dnode_t *node, const void *key) -{ - dnode_t *where = dict_root(dict), *nil = dict_nil(dict); - dnode_t *parent = nil, *uncle, *grandpa; - int result = -1; - - node->key = key; - -#ifndef NDEBUG - assert (!dict_isfull(dict)); - assert (!dict_contains(dict, node)); - assert (!dnode_is_in_a_dict(node)); -#endif - - /* basic binary tree insert */ - - while (where != nil) { - parent = where; - result = dict->compare(key, where->key); - /* trap attempts at duplicate key insertion unless it's explicitly allowed */ - assert (dict->dupes || result != 0); - if (result < 0) - where = where->left; - else - where = where->right; - } - - assert (where == nil); - - if (result < 0) - parent->left = node; - else - parent->right = node; - - node->parent = parent; - node->left = nil; - node->right = nil; - - dict->nodecount++; - - /* red black adjustments */ - - node->color = dnode_red; - - while (parent->color == dnode_red) { - grandpa = parent->parent; - if (parent == grandpa->left) { - uncle = grandpa->right; - if (uncle->color == dnode_red) { /* red parent, red uncle */ - parent->color = dnode_black; - uncle->color = dnode_black; - grandpa->color = dnode_red; - node = grandpa; - parent = grandpa->parent; - } else { /* red parent, black uncle */ - if (node == parent->right) { - rotate_left(parent); - parent = node; - assert (grandpa == parent->parent); - /* rotation between parent and child preserves grandpa */ - } - parent->color = dnode_black; - grandpa->color = dnode_red; - rotate_right(grandpa); - break; - } - } else { /* symmetric cases: parent == parent->parent->right */ - uncle = grandpa->left; - if (uncle->color == dnode_red) { - parent->color = dnode_black; - uncle->color = dnode_black; - grandpa->color = dnode_red; - node = grandpa; - parent = grandpa->parent; - } else { - if (node == parent->left) { - rotate_right(parent); - parent = node; - assert (grandpa == parent->parent); - } - parent->color = dnode_black; - grandpa->color = dnode_red; - rotate_left(grandpa); - break; - } - } - } - - dict_root(dict)->color = dnode_black; - -#ifdef E2FSCK_NOTUSED - assert (dict_verify(dict)); -#endif -} - -#ifdef E2FSCK_NOTUSED -/* - * Delete the given node from the dictionary. If the given node does not belong - * to the given dictionary, undefined behavior results. A pointer to the - * deleted node is returned. - */ - -dnode_t *dict_delete(dict_t *dict, dnode_t *delete) -{ - dnode_t *nil = dict_nil(dict), *child, *delparent = delete->parent; - - /* basic deletion */ - - assert (!dict_isempty(dict)); - assert (dict_contains(dict, delete)); - - /* - * If the node being deleted has two children, then we replace it with its - * successor (i.e. the leftmost node in the right subtree.) By doing this, - * we avoid the traditional algorithm under which the successor's key and - * value *only* move to the deleted node and the successor is spliced out - * from the tree. We cannot use this approach because the user may hold - * pointers to the successor, or nodes may be inextricably tied to some - * other structures by way of embedding, etc. So we must splice out the - * node we are given, not some other node, and must not move contents from - * one node to another behind the user's back. - */ - - if (delete->left != nil && delete->right != nil) { - dnode_t *next = dict_next(dict, delete); - dnode_t *nextparent = next->parent; - dnode_color_t nextcolor = next->color; - - assert (next != nil); - assert (next->parent != nil); - assert (next->left == nil); - - /* - * First, splice out the successor from the tree completely, by - * moving up its right child into its place. - */ - - child = next->right; - child->parent = nextparent; - - if (nextparent->left == next) { - nextparent->left = child; - } else { - assert (nextparent->right == next); - nextparent->right = child; - } - - /* - * Now that the successor has been extricated from the tree, install it - * in place of the node that we want deleted. - */ - - next->parent = delparent; - next->left = delete->left; - next->right = delete->right; - next->left->parent = next; - next->right->parent = next; - next->color = delete->color; - delete->color = nextcolor; - - if (delparent->left == delete) { - delparent->left = next; - } else { - assert (delparent->right == delete); - delparent->right = next; - } - - } else { - assert (delete != nil); - assert (delete->left == nil || delete->right == nil); - - child = (delete->left != nil) ? delete->left : delete->right; - - child->parent = delparent = delete->parent; - - if (delete == delparent->left) { - delparent->left = child; - } else { - assert (delete == delparent->right); - delparent->right = child; - } - } - - delete->parent = NULL; - delete->right = NULL; - delete->left = NULL; - - dict->nodecount--; - - assert (verify_bintree(dict)); - - /* red-black adjustments */ - - if (delete->color == dnode_black) { - dnode_t *parent, *sister; - - dict_root(dict)->color = dnode_red; - - while (child->color == dnode_black) { - parent = child->parent; - if (child == parent->left) { - sister = parent->right; - assert (sister != nil); - if (sister->color == dnode_red) { - sister->color = dnode_black; - parent->color = dnode_red; - rotate_left(parent); - sister = parent->right; - assert (sister != nil); - } - if (sister->left->color == dnode_black - && sister->right->color == dnode_black) { - sister->color = dnode_red; - child = parent; - } else { - if (sister->right->color == dnode_black) { - assert (sister->left->color == dnode_red); - sister->left->color = dnode_black; - sister->color = dnode_red; - rotate_right(sister); - sister = parent->right; - assert (sister != nil); - } - sister->color = parent->color; - sister->right->color = dnode_black; - parent->color = dnode_black; - rotate_left(parent); - break; - } - } else { /* symmetric case: child == child->parent->right */ - assert (child == parent->right); - sister = parent->left; - assert (sister != nil); - if (sister->color == dnode_red) { - sister->color = dnode_black; - parent->color = dnode_red; - rotate_right(parent); - sister = parent->left; - assert (sister != nil); - } - if (sister->right->color == dnode_black - && sister->left->color == dnode_black) { - sister->color = dnode_red; - child = parent; - } else { - if (sister->left->color == dnode_black) { - assert (sister->right->color == dnode_red); - sister->right->color = dnode_black; - sister->color = dnode_red; - rotate_left(sister); - sister = parent->left; - assert (sister != nil); - } - sister->color = parent->color; - sister->left->color = dnode_black; - parent->color = dnode_black; - rotate_right(parent); - break; - } - } - } - - child->color = dnode_black; - dict_root(dict)->color = dnode_black; - } - -#ifdef E2FSCK_NOTUSED - assert (dict_verify(dict)); -#endif - - return delete; -} -#endif /* E2FSCK_NOTUSED */ - -/* - * Allocate a node using the dictionary's allocator routine, give it - * the data item. - */ - -int dict_alloc_insert(dict_t *dict, const void *key, void *data) -{ - dnode_t *node = dict->allocnode(dict->context); - - if (node) { - dnode_init(node, data); - dict_insert(dict, node, key); - return 1; - } - return 0; -} - -#ifdef E2FSCK_NOTUSED -void dict_delete_free(dict_t *dict, dnode_t *node) -{ - dict_delete(dict, node); - dict->freenode(node, dict->context); -} -#endif - -/* - * Return the node with the lowest (leftmost) key. If the dictionary is empty - * (that is, dict_isempty(dict) returns 1) a null pointer is returned. - */ - -dnode_t *dict_first(dict_t *dict) -{ - dnode_t *nil = dict_nil(dict), *root = dict_root(dict), *left; - - if (root != nil) - while ((left = root->left) != nil) - root = left; - - return (root == nil) ? NULL : root; -} - -/* - * Return the node with the highest (rightmost) key. If the dictionary is empty - * (that is, dict_isempty(dict) returns 1) a null pointer is returned. - */ - -dnode_t *dict_last(dict_t *dict) -{ - dnode_t *nil = dict_nil(dict), *root = dict_root(dict), *right; - - if (root != nil) - while ((right = root->right) != nil) - root = right; - - return (root == nil) ? NULL : root; -} - -/* - * Return the given node's successor node---the node which has the - * next key in the the left to right ordering. If the node has - * no successor, a null pointer is returned rather than a pointer to - * the nil node. - */ - -dnode_t *dict_next(dict_t *dict, dnode_t *curr) -{ - dnode_t *nil = dict_nil(dict), *parent, *left; - - if (curr->right != nil) { - curr = curr->right; - while ((left = curr->left) != nil) - curr = left; - return curr; - } - - parent = curr->parent; - - while (parent != nil && curr == parent->right) { - curr = parent; - parent = curr->parent; - } - - return (parent == nil) ? NULL : parent; -} - -/* - * Return the given node's predecessor, in the key order. - * The nil sentinel node is returned if there is no predecessor. - */ - -dnode_t *dict_prev(dict_t *dict, dnode_t *curr) -{ - dnode_t *nil = dict_nil(dict), *parent, *right; - - if (curr->left != nil) { - curr = curr->left; - while ((right = curr->right) != nil) - curr = right; - return curr; - } - - parent = curr->parent; - - while (parent != nil && curr == parent->left) { - curr = parent; - parent = curr->parent; - } - - return (parent == nil) ? NULL : parent; -} - -void dict_allow_dupes(dict_t *dict) -{ - dict->dupes = 1; -} - -#undef dict_count -#undef dict_isempty -#undef dict_isfull -#undef dnode_get -#undef dnode_put -#undef dnode_getkey - -dictcount_t dict_count(dict_t *dict) -{ - return dict->nodecount; -} - -int dict_isempty(dict_t *dict) -{ - return dict->nodecount == 0; -} - -int dict_isfull(dict_t *dict) -{ - return dict->nodecount == dict->maxcount; -} - -int dict_contains(dict_t *dict, dnode_t *node) -{ - return verify_dict_has_node(dict_nil(dict), dict_root(dict), node); -} - -static dnode_t *dnode_alloc(void *context EXT2FS_ATTR((unused))) -{ - return malloc(sizeof *dnode_alloc(NULL)); -} - -static void dnode_free(dnode_t *node, void *context EXT2FS_ATTR((unused))) -{ - free(node); -} - -dnode_t *dnode_create(void *data) -{ - dnode_t *new = malloc(sizeof *new); - if (new) { - new->data = data; - new->parent = NULL; - new->left = NULL; - new->right = NULL; - } - return new; -} - -dnode_t *dnode_init(dnode_t *dnode, void *data) -{ - dnode->data = data; - dnode->parent = NULL; - dnode->left = NULL; - dnode->right = NULL; - return dnode; -} - -void dnode_destroy(dnode_t *dnode) -{ -#ifndef NDEBUG - assert (!dnode_is_in_a_dict(dnode)); -#endif - free(dnode); -} - -void *dnode_get(dnode_t *dnode) -{ - return dnode->data; -} - -const void *dnode_getkey(dnode_t *dnode) -{ - return dnode->key; -} - -#ifdef E2FSCK_NOTUSED -void dnode_put(dnode_t *dnode, void *data) -{ - dnode->data = data; -} - -int dnode_is_in_a_dict(dnode_t *dnode) -{ - return (dnode->parent && dnode->left && dnode->right); -} - -void dict_process(dict_t *dict, void *context, dnode_process_t function) -{ - dnode_t *node = dict_first(dict), *next; - - while (node != NULL) { - /* check for callback function deleting */ - /* the next node from under us */ - assert (dict_contains(dict, node)); - next = dict_next(dict, node); - function(dict, node, context); - node = next; - } -} - -static void load_begin_internal(dict_load_t *load, dict_t *dict) -{ - load->dictptr = dict; - load->nilnode.left = &load->nilnode; - load->nilnode.right = &load->nilnode; -} - -void dict_load_begin(dict_load_t *load, dict_t *dict) -{ - assert (dict_isempty(dict)); - load_begin_internal(load, dict); -} - -void dict_load_next(dict_load_t *load, dnode_t *newnode, const void *key) -{ - dict_t *dict = load->dictptr; - dnode_t *nil = &load->nilnode; - -#ifndef NDEBUG - assert (!dnode_is_in_a_dict(newnode)); - assert (dict->nodecount < dict->maxcount); - - if (dict->nodecount > 0) { - if (dict->dupes) - assert (dict->compare(nil->left->key, key) <= 0); - else - assert (dict->compare(nil->left->key, key) < 0); - } -#endif - - newnode->key = key; - nil->right->left = newnode; - nil->right = newnode; - newnode->left = nil; - dict->nodecount++; -} - -void dict_load_end(dict_load_t *load) -{ - dict_t *dict = load->dictptr; - dnode_t *tree[DICT_DEPTH_MAX] = { 0 }; - dnode_t *curr, *dictnil = dict_nil(dict), *loadnil = &load->nilnode, *next; - dnode_t *complete = 0; - dictcount_t fullcount = DICTCOUNT_T_MAX, nodecount = dict->nodecount; - dictcount_t botrowcount; - unsigned baselevel = 0, level = 0, i; - - assert (dnode_red == 0 && dnode_black == 1); - - while (fullcount >= nodecount && fullcount) - fullcount >>= 1; - - botrowcount = nodecount - fullcount; - - for (curr = loadnil->left; curr != loadnil; curr = next) { - next = curr->left; - - if (complete == NULL && botrowcount-- == 0) { - assert (baselevel == 0); - assert (level == 0); - baselevel = level = 1; - complete = tree[0]; - - if (complete != 0) { - tree[0] = 0; - complete->right = dictnil; - while (tree[level] != 0) { - tree[level]->right = complete; - complete->parent = tree[level]; - complete = tree[level]; - tree[level++] = 0; - } - } - } - - if (complete == NULL) { - curr->left = dictnil; - curr->right = dictnil; - curr->color = level % 2; - complete = curr; - - assert (level == baselevel); - while (tree[level] != 0) { - tree[level]->right = complete; - complete->parent = tree[level]; - complete = tree[level]; - tree[level++] = 0; - } - } else { - curr->left = complete; - curr->color = (level + 1) % 2; - complete->parent = curr; - tree[level] = curr; - complete = 0; - level = baselevel; - } - } - - if (complete == NULL) - complete = dictnil; - - for (i = 0; i < DICT_DEPTH_MAX; i++) { - if (tree[i] != 0) { - tree[i]->right = complete; - complete->parent = tree[i]; - complete = tree[i]; - } - } - - dictnil->color = dnode_black; - dictnil->right = dictnil; - complete->parent = dictnil; - complete->color = dnode_black; - dict_root(dict) = complete; - -#ifdef E2FSCK_NOTUSED - assert (dict_verify(dict)); -#endif -} - -void dict_merge(dict_t *dest, dict_t *source) -{ - dict_load_t load; - dnode_t *leftnode = dict_first(dest), *rightnode = dict_first(source); - - assert (dict_similar(dest, source)); - - if (source == dest) - return; - - dest->nodecount = 0; - load_begin_internal(&load, dest); - - for (;;) { - if (leftnode != NULL && rightnode != NULL) { - if (dest->compare(leftnode->key, rightnode->key) < 0) - goto copyleft; - else - goto copyright; - } else if (leftnode != NULL) { - goto copyleft; - } else if (rightnode != NULL) { - goto copyright; - } else { - assert (leftnode == NULL && rightnode == NULL); - break; - } - - copyleft: - { - dnode_t *next = dict_next(dest, leftnode); -#ifndef NDEBUG - leftnode->left = NULL; /* suppress assertion in dict_load_next */ -#endif - dict_load_next(&load, leftnode, leftnode->key); - leftnode = next; - continue; - } - - copyright: - { - dnode_t *next = dict_next(source, rightnode); -#ifndef NDEBUG - rightnode->left = NULL; -#endif - dict_load_next(&load, rightnode, rightnode->key); - rightnode = next; - continue; - } - } - - dict_clear(source); - dict_load_end(&load); -} -#endif /* E2FSCK_NOTUSED */ - -#ifdef KAZLIB_TEST_MAIN - -#include -#include -#include -#include - -typedef char input_t[256]; - -static int tokenize(char *string, ...) -{ - char **tokptr; - va_list arglist; - int tokcount = 0; - - va_start(arglist, string); - tokptr = va_arg(arglist, char **); - while (tokptr) { - while (*string && isspace((unsigned char) *string)) - string++; - if (!*string) - break; - *tokptr = string; - while (*string && !isspace((unsigned char) *string)) - string++; - tokptr = va_arg(arglist, char **); - tokcount++; - if (!*string) - break; - *string++ = 0; - } - va_end(arglist); - - return tokcount; -} - -static int comparef(const void *key1, const void *key2) -{ - return strcmp(key1, key2); -} - -static char *dupstring(char *str) -{ - int sz = strlen(str) + 1; - char *new = malloc(sz); - if (new) - memcpy(new, str, sz); - return new; -} - -static dnode_t *new_node(void *c) -{ - static dnode_t few[5]; - static int count; - - if (count < 5) - return few + count++; - - return NULL; -} - -static void del_node(dnode_t *n, void *c) -{ -} - -static int prompt = 0; - -static void construct(dict_t *d) -{ - input_t in; - int done = 0; - dict_load_t dl; - dnode_t *dn; - char *tok1, *tok2, *val; - const char *key; - char *help = - "p turn prompt on\n" - "q finish construction\n" - "a add new entry\n"; - - if (!dict_isempty(d)) - puts("warning: dictionary not empty!"); - - dict_load_begin(&dl, d); - - while (!done) { - if (prompt) - putchar('>'); - fflush(stdout); - - if (!fgets(in, sizeof(input_t), stdin)) - break; - - switch (in[0]) { - case '?': - puts(help); - break; - case 'p': - prompt = 1; - break; - case 'q': - done = 1; - break; - case 'a': - if (tokenize(in+1, &tok1, &tok2, (char **) 0) != 2) { - puts("what?"); - break; - } - key = dupstring(tok1); - val = dupstring(tok2); - dn = dnode_create(val); - - if (!key || !val || !dn) { - puts("out of memory"); - free((void *) key); - free(val); - if (dn) - dnode_destroy(dn); - } - - dict_load_next(&dl, dn, key); - break; - default: - putchar('?'); - putchar('\n'); - break; - } - } - - dict_load_end(&dl); -} - -int main(void) -{ - input_t in; - dict_t darray[10]; - dict_t *d = &darray[0]; - dnode_t *dn; - int i; - char *tok1, *tok2, *val; - const char *key; - - char *help = - "a add value to dictionary\n" - "d delete value from dictionary\n" - "l lookup value in dictionary\n" - "( lookup lower bound\n" - ") lookup upper bound\n" - "# switch to alternate dictionary (0-9)\n" - "j merge two dictionaries\n" - "f free the whole dictionary\n" - "k allow duplicate keys\n" - "c show number of entries\n" - "t dump whole dictionary in sort order\n" - "m make dictionary out of sorted items\n" - "p turn prompt on\n" - "s switch to non-functioning allocator\n" - "q quit"; - - for (i = 0; i < sizeof darray / sizeof *darray; i++) - dict_init(&darray[i], DICTCOUNT_T_MAX, comparef); - - for (;;) { - if (prompt) - putchar('>'); - fflush(stdout); - - if (!fgets(in, sizeof(input_t), stdin)) - break; - - switch(in[0]) { - case '?': - puts(help); - break; - case 'a': - if (tokenize(in+1, &tok1, &tok2, (char **) 0) != 2) { - puts("what?"); - break; - } - key = dupstring(tok1); - val = dupstring(tok2); - - if (!key || !val) { - puts("out of memory"); - free((void *) key); - free(val); - } - - if (!dict_alloc_insert(d, key, val)) { - puts("dict_alloc_insert failed"); - free((void *) key); - free(val); - break; - } - break; - case 'd': - if (tokenize(in+1, &tok1, (char **) 0) != 1) { - puts("what?"); - break; - } - dn = dict_lookup(d, tok1); - if (!dn) { - puts("dict_lookup failed"); - break; - } - val = dnode_get(dn); - key = dnode_getkey(dn); - dict_delete_free(d, dn); - - free(val); - free((void *) key); - break; - case 'f': - dict_free(d); - break; - case 'l': - case '(': - case ')': - if (tokenize(in+1, &tok1, (char **) 0) != 1) { - puts("what?"); - break; - } - dn = 0; - switch (in[0]) { - case 'l': - dn = dict_lookup(d, tok1); - break; - case '(': - dn = dict_lower_bound(d, tok1); - break; - case ')': - dn = dict_upper_bound(d, tok1); - break; - } - if (!dn) { - puts("lookup failed"); - break; - } - val = dnode_get(dn); - puts(val); - break; - case 'm': - construct(d); - break; - case 'k': - dict_allow_dupes(d); - break; - case 'c': - printf("%lu\n", (unsigned long) dict_count(d)); - break; - case 't': - for (dn = dict_first(d); dn; dn = dict_next(d, dn)) { - printf("%s\t%s\n", (char *) dnode_getkey(dn), - (char *) dnode_get(dn)); - } - break; - case 'q': - exit(0); - break; - case '\0': - break; - case 'p': - prompt = 1; - break; - case 's': - dict_set_allocator(d, new_node, del_node, NULL); - break; - case '#': - if (tokenize(in+1, &tok1, (char **) 0) != 1) { - puts("what?"); - break; - } else { - int dictnum = atoi(tok1); - if (dictnum < 0 || dictnum > 9) { - puts("invalid number"); - break; - } - d = &darray[dictnum]; - } - break; - case 'j': - if (tokenize(in+1, &tok1, &tok2, (char **) 0) != 2) { - puts("what?"); - break; - } else { - int dict1 = atoi(tok1), dict2 = atoi(tok2); - if (dict1 < 0 || dict1 > 9 || dict2 < 0 || dict2 > 9) { - puts("invalid number"); - break; - } - dict_merge(&darray[dict1], &darray[dict2]); - } - break; - default: - putchar('?'); - putchar('\n'); - break; - } - } - - return 0; -} - -#endif diff --git a/e2fsprogs/e2fsck/dict.h b/e2fsprogs/e2fsck/dict.h deleted file mode 100644 index 838079d6c..000000000 --- a/e2fsprogs/e2fsck/dict.h +++ /dev/null @@ -1,144 +0,0 @@ -/* - * Dictionary Abstract Data Type - * Copyright (C) 1997 Kaz Kylheku - * - * Free Software License: - * - * All rights are reserved by the author, with the following exceptions: - * Permission is granted to freely reproduce and distribute this software, - * possibly in exchange for a fee, provided that this copyright notice appears - * intact. Permission is also granted to adapt this software to produce - * derivative works, as long as the modified versions carry this copyright - * notice and additional notices stating that the work has been modified. - * This source code may be translated into executable form and incorporated - * into proprietary software; there is no requirement for such software to - * contain a copyright notice related to this source. - * - * $Id: dict.h,v 1.22.2.6 2000/11/13 01:36:44 kaz Exp $ - * $Name: kazlib_1_20 $ - */ - -#ifndef DICT_H -#define DICT_H - -#include -#ifdef KAZLIB_SIDEEFFECT_DEBUG -#include "sfx.h" -#endif - -/* - * Blurb for inclusion into C++ translation units - */ - -#ifdef __cplusplus -extern "C" { -#endif - -typedef unsigned long dictcount_t; -#define DICTCOUNT_T_MAX ULONG_MAX - -/* - * The dictionary is implemented as a red-black tree - */ - -typedef enum { dnode_red, dnode_black } dnode_color_t; - -typedef struct dnode_t { -#if defined(DICT_IMPLEMENTATION) || !defined(KAZLIB_OPAQUE_DEBUG) - struct dnode_t *dict_left; - struct dnode_t *dict_right; - struct dnode_t *dict_parent; - dnode_color_t dict_color; - const void *dict_key; - void *dict_data; -#else - int dict_dummy; -#endif -} dnode_t; - -typedef int (*dict_comp_t)(const void *, const void *); -typedef dnode_t *(*dnode_alloc_t)(void *); -typedef void (*dnode_free_t)(dnode_t *, void *); - -typedef struct dict_t { -#if defined(DICT_IMPLEMENTATION) || !defined(KAZLIB_OPAQUE_DEBUG) - dnode_t dict_nilnode; - dictcount_t dict_nodecount; - dictcount_t dict_maxcount; - dict_comp_t dict_compare; - dnode_alloc_t dict_allocnode; - dnode_free_t dict_freenode; - void *dict_context; - int dict_dupes; -#else - int dict_dummmy; -#endif -} dict_t; - -typedef void (*dnode_process_t)(dict_t *, dnode_t *, void *); - -typedef struct dict_load_t { -#if defined(DICT_IMPLEMENTATION) || !defined(KAZLIB_OPAQUE_DEBUG) - dict_t *dict_dictptr; - dnode_t dict_nilnode; -#else - int dict_dummmy; -#endif -} dict_load_t; - -extern dict_t *dict_create(dictcount_t, dict_comp_t); -extern void dict_set_allocator(dict_t *, dnode_alloc_t, dnode_free_t, void *); -extern void dict_destroy(dict_t *); -extern void dict_free_nodes(dict_t *); -extern void dict_free(dict_t *); -extern dict_t *dict_init(dict_t *, dictcount_t, dict_comp_t); -extern void dict_init_like(dict_t *, const dict_t *); -extern int dict_verify(dict_t *); -extern int dict_similar(const dict_t *, const dict_t *); -extern dnode_t *dict_lookup(dict_t *, const void *); -extern dnode_t *dict_lower_bound(dict_t *, const void *); -extern dnode_t *dict_upper_bound(dict_t *, const void *); -extern void dict_insert(dict_t *, dnode_t *, const void *); -extern dnode_t *dict_delete(dict_t *, dnode_t *); -extern int dict_alloc_insert(dict_t *, const void *, void *); -extern void dict_delete_free(dict_t *, dnode_t *); -extern dnode_t *dict_first(dict_t *); -extern dnode_t *dict_last(dict_t *); -extern dnode_t *dict_next(dict_t *, dnode_t *); -extern dnode_t *dict_prev(dict_t *, dnode_t *); -extern dictcount_t dict_count(dict_t *); -extern int dict_isempty(dict_t *); -extern int dict_isfull(dict_t *); -extern int dict_contains(dict_t *, dnode_t *); -extern void dict_allow_dupes(dict_t *); -extern int dnode_is_in_a_dict(dnode_t *); -extern dnode_t *dnode_create(void *); -extern dnode_t *dnode_init(dnode_t *, void *); -extern void dnode_destroy(dnode_t *); -extern void *dnode_get(dnode_t *); -extern const void *dnode_getkey(dnode_t *); -extern void dnode_put(dnode_t *, void *); -extern void dict_process(dict_t *, void *, dnode_process_t); -extern void dict_load_begin(dict_load_t *, dict_t *); -extern void dict_load_next(dict_load_t *, dnode_t *, const void *); -extern void dict_load_end(dict_load_t *); -extern void dict_merge(dict_t *, dict_t *); - -#if defined(DICT_IMPLEMENTATION) || !defined(KAZLIB_OPAQUE_DEBUG) -#ifdef KAZLIB_SIDEEFFECT_DEBUG -#define dict_isfull(D) (SFX_CHECK(D)->dict_nodecount == (D)->dict_maxcount) -#else -#define dict_isfull(D) ((D)->dict_nodecount == (D)->dict_maxcount) -#endif -#define dict_count(D) ((D)->dict_nodecount) -#define dict_isempty(D) ((D)->dict_nodecount == 0) -#define dnode_get(N) ((N)->dict_data) -#define dnode_getkey(N) ((N)->dict_key) -#define dnode_put(N, X) ((N)->dict_data = (X)) -#endif - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/e2fsprogs/e2fsck/dirinfo.c b/e2fsprogs/e2fsck/dirinfo.c deleted file mode 100644 index 516c46135..000000000 --- a/e2fsprogs/e2fsck/dirinfo.c +++ /dev/null @@ -1,137 +0,0 @@ -/* - * dirinfo.c --- maintains the directory information table for e2fsck. - * - * Copyright (C) 1993 Theodore Ts'o. This file may be redistributed - * under the terms of the GNU Public License. - */ - -#include "e2fsck.h" - -/* - * This subroutine is called during pass1 to create a directory info - * entry. During pass1, the passed-in parent is 0; it will get filled - * in during pass2. - */ -void e2fsck_add_dir_info(e2fsck_t ctx, ext2_ino_t ino, ext2_ino_t parent) -{ - struct dir_info *dir; - int i, j; - ext2_ino_t num_dirs; - errcode_t retval; - unsigned long old_size; - -#if 0 - printf("add_dir_info for inode %lu...\n", ino); -#endif - if (!ctx->dir_info) { - ctx->dir_info_count = 0; - retval = ext2fs_get_num_dirs(ctx->fs, &num_dirs); - if (retval) - num_dirs = 1024; /* Guess */ - ctx->dir_info_size = num_dirs + 10; - ctx->dir_info = (struct dir_info *) - e2fsck_allocate_memory(ctx, ctx->dir_info_size - * sizeof (struct dir_info), - "directory map"); - } - - if (ctx->dir_info_count >= ctx->dir_info_size) { - old_size = ctx->dir_info_size * sizeof(struct dir_info); - ctx->dir_info_size += 10; - retval = ext2fs_resize_mem(old_size, ctx->dir_info_size * - sizeof(struct dir_info), - &ctx->dir_info); - if (retval) { - ctx->dir_info_size -= 10; - return; - } - } - - /* - * Normally, add_dir_info is called with each inode in - * sequential order; but once in a while (like when pass 3 - * needs to recreate the root directory or lost+found - * directory) it is called out of order. In those cases, we - * need to move the dir_info entries down to make room, since - * the dir_info array needs to be sorted by inode number for - * get_dir_info()'s sake. - */ - if (ctx->dir_info_count && - ctx->dir_info[ctx->dir_info_count-1].ino >= ino) { - for (i = ctx->dir_info_count-1; i > 0; i--) - if (ctx->dir_info[i-1].ino < ino) - break; - dir = &ctx->dir_info[i]; - if (dir->ino != ino) - for (j = ctx->dir_info_count++; j > i; j--) - ctx->dir_info[j] = ctx->dir_info[j-1]; - } else - dir = &ctx->dir_info[ctx->dir_info_count++]; - - dir->ino = ino; - dir->dotdot = parent; - dir->parent = parent; -} - -/* - * get_dir_info() --- given an inode number, try to find the directory - * information entry for it. - */ -struct dir_info *e2fsck_get_dir_info(e2fsck_t ctx, ext2_ino_t ino) -{ - int low, high, mid; - - low = 0; - high = ctx->dir_info_count-1; - if (!ctx->dir_info) - return 0; - if (ino == ctx->dir_info[low].ino) - return &ctx->dir_info[low]; - if (ino == ctx->dir_info[high].ino) - return &ctx->dir_info[high]; - - while (low < high) { - mid = (low+high)/2; - if (mid == low || mid == high) - break; - if (ino == ctx->dir_info[mid].ino) - return &ctx->dir_info[mid]; - if (ino < ctx->dir_info[mid].ino) - high = mid; - else - low = mid; - } - return 0; -} - -/* - * Free the dir_info structure when it isn't needed any more. - */ -void e2fsck_free_dir_info(e2fsck_t ctx) -{ - if (ctx->dir_info) { - ext2fs_free_mem(&ctx->dir_info); - ctx->dir_info = 0; - } - ctx->dir_info_size = 0; - ctx->dir_info_count = 0; -} - -/* - * Return the count of number of directories in the dir_info structure - */ -int e2fsck_get_num_dirinfo(e2fsck_t ctx) -{ - return ctx->dir_info_count; -} - -/* - * A simple interator function - */ -struct dir_info *e2fsck_dir_info_iter(e2fsck_t ctx, int *control) -{ - if (*control >= ctx->dir_info_count) - return 0; - - return(ctx->dir_info + (*control)++); -} diff --git a/e2fsprogs/e2fsck/dx_dirinfo.c b/e2fsprogs/e2fsck/dx_dirinfo.c deleted file mode 100644 index 322f51679..000000000 --- a/e2fsprogs/e2fsck/dx_dirinfo.c +++ /dev/null @@ -1,150 +0,0 @@ -/* - * dirinfo.c --- maintains the directory information table for e2fsck. - * - * Copyright (C) 1993 Theodore Ts'o. This file may be redistributed - * under the terms of the GNU Public License. - */ - -#include "e2fsck.h" -#ifdef ENABLE_HTREE - -/* - * This subroutine is called during pass1 to create a directory info - * entry. During pass1, the passed-in parent is 0; it will get filled - * in during pass2. - */ -void e2fsck_add_dx_dir(e2fsck_t ctx, ext2_ino_t ino, int num_blocks) -{ - struct dx_dir_info *dir; - int i, j; - errcode_t retval; - unsigned long old_size; - -#if 0 - printf("add_dx_dir_info for inode %lu...\n", ino); -#endif - if (!ctx->dx_dir_info) { - ctx->dx_dir_info_count = 0; - ctx->dx_dir_info_size = 100; /* Guess */ - ctx->dx_dir_info = (struct dx_dir_info *) - e2fsck_allocate_memory(ctx, ctx->dx_dir_info_size - * sizeof (struct dx_dir_info), - "directory map"); - } - - if (ctx->dx_dir_info_count >= ctx->dx_dir_info_size) { - old_size = ctx->dx_dir_info_size * sizeof(struct dx_dir_info); - ctx->dx_dir_info_size += 10; - retval = ext2fs_resize_mem(old_size, ctx->dx_dir_info_size * - sizeof(struct dx_dir_info), - &ctx->dx_dir_info); - if (retval) { - ctx->dx_dir_info_size -= 10; - return; - } - } - - /* - * Normally, add_dx_dir_info is called with each inode in - * sequential order; but once in a while (like when pass 3 - * needs to recreate the root directory or lost+found - * directory) it is called out of order. In those cases, we - * need to move the dx_dir_info entries down to make room, since - * the dx_dir_info array needs to be sorted by inode number for - * get_dx_dir_info()'s sake. - */ - if (ctx->dx_dir_info_count && - ctx->dx_dir_info[ctx->dx_dir_info_count-1].ino >= ino) { - for (i = ctx->dx_dir_info_count-1; i > 0; i--) - if (ctx->dx_dir_info[i-1].ino < ino) - break; - dir = &ctx->dx_dir_info[i]; - if (dir->ino != ino) - for (j = ctx->dx_dir_info_count++; j > i; j--) - ctx->dx_dir_info[j] = ctx->dx_dir_info[j-1]; - } else - dir = &ctx->dx_dir_info[ctx->dx_dir_info_count++]; - - dir->ino = ino; - dir->numblocks = num_blocks; - dir->hashversion = 0; - dir->dx_block = e2fsck_allocate_memory(ctx, num_blocks - * sizeof (struct dx_dirblock_info), - "dx_block info array"); - -} - -/* - * get_dx_dir_info() --- given an inode number, try to find the directory - * information entry for it. - */ -struct dx_dir_info *e2fsck_get_dx_dir_info(e2fsck_t ctx, ext2_ino_t ino) -{ - int low, high, mid; - - low = 0; - high = ctx->dx_dir_info_count-1; - if (!ctx->dx_dir_info) - return 0; - if (ino == ctx->dx_dir_info[low].ino) - return &ctx->dx_dir_info[low]; - if (ino == ctx->dx_dir_info[high].ino) - return &ctx->dx_dir_info[high]; - - while (low < high) { - mid = (low+high)/2; - if (mid == low || mid == high) - break; - if (ino == ctx->dx_dir_info[mid].ino) - return &ctx->dx_dir_info[mid]; - if (ino < ctx->dx_dir_info[mid].ino) - high = mid; - else - low = mid; - } - return 0; -} - -/* - * Free the dx_dir_info structure when it isn't needed any more. - */ -void e2fsck_free_dx_dir_info(e2fsck_t ctx) -{ - int i; - struct dx_dir_info *dir; - - if (ctx->dx_dir_info) { - dir = ctx->dx_dir_info; - for (i=0; i < ctx->dx_dir_info_count; i++) { - if (dir->dx_block) { - ext2fs_free_mem(&dir->dx_block); - dir->dx_block = 0; - } - } - ext2fs_free_mem(&ctx->dx_dir_info); - ctx->dx_dir_info = 0; - } - ctx->dx_dir_info_size = 0; - ctx->dx_dir_info_count = 0; -} - -/* - * Return the count of number of directories in the dx_dir_info structure - */ -int e2fsck_get_num_dx_dirinfo(e2fsck_t ctx) -{ - return ctx->dx_dir_info_count; -} - -/* - * A simple interator function - */ -struct dx_dir_info *e2fsck_dx_dir_info_iter(e2fsck_t ctx, int *control) -{ - if (*control >= ctx->dx_dir_info_count) - return 0; - - return(ctx->dx_dir_info + (*control)++); -} - -#endif /* ENABLE_HTREE */ diff --git a/e2fsprogs/e2fsck/e2fsck.c b/e2fsprogs/e2fsck/e2fsck.c deleted file mode 100644 index 2a84c5171..000000000 --- a/e2fsprogs/e2fsck/e2fsck.c +++ /dev/null @@ -1,202 +0,0 @@ -/* - * e2fsck.c - a consistency checker for the new extended file system. - * - * Copyright (C) 1993, 1994, 1995, 1996, 1997 Theodore Ts'o. - * - * %Begin-Header% - * This file may be redistributed under the terms of the GNU Public - * License. - * %End-Header% - */ - -#include - -#include "e2fsck.h" -#include "problem.h" - -/* - * This function allocates an e2fsck context - */ -errcode_t e2fsck_allocate_context(e2fsck_t *ret) -{ - e2fsck_t context; - errcode_t retval; - - retval = ext2fs_get_mem(sizeof(struct e2fsck_struct), &context); - if (retval) - return retval; - - memset(context, 0, sizeof(struct e2fsck_struct)); - - context->process_inode_size = 256; - context->ext_attr_ver = 2; - - *ret = context; - return 0; -} - -/* - * This function resets an e2fsck context; it is called when e2fsck - * needs to be restarted. - */ -errcode_t e2fsck_reset_context(e2fsck_t ctx) -{ - ctx->flags = 0; - ctx->lost_and_found = 0; - ctx->bad_lost_and_found = 0; - if (ctx->inode_used_map) { - ext2fs_free_inode_bitmap(ctx->inode_used_map); - ctx->inode_used_map = 0; - } - if (ctx->inode_dir_map) { - ext2fs_free_inode_bitmap(ctx->inode_dir_map); - ctx->inode_dir_map = 0; - } - if (ctx->inode_reg_map) { - ext2fs_free_inode_bitmap(ctx->inode_reg_map); - ctx->inode_reg_map = 0; - } - if (ctx->block_found_map) { - ext2fs_free_block_bitmap(ctx->block_found_map); - ctx->block_found_map = 0; - } - if (ctx->inode_link_info) { - ext2fs_free_icount(ctx->inode_link_info); - ctx->inode_link_info = 0; - } - if (ctx->journal_io) { - if (ctx->fs && ctx->fs->io != ctx->journal_io) - io_channel_close(ctx->journal_io); - ctx->journal_io = 0; - } - if (ctx->fs && ctx->fs->dblist) { - ext2fs_free_dblist(ctx->fs->dblist); - ctx->fs->dblist = 0; - } - e2fsck_free_dir_info(ctx); -#ifdef ENABLE_HTREE - e2fsck_free_dx_dir_info(ctx); -#endif - if (ctx->refcount) { - ea_refcount_free(ctx->refcount); - ctx->refcount = 0; - } - if (ctx->refcount_extra) { - ea_refcount_free(ctx->refcount_extra); - ctx->refcount_extra = 0; - } - if (ctx->block_dup_map) { - ext2fs_free_block_bitmap(ctx->block_dup_map); - ctx->block_dup_map = 0; - } - if (ctx->block_ea_map) { - ext2fs_free_block_bitmap(ctx->block_ea_map); - ctx->block_ea_map = 0; - } - if (ctx->inode_bb_map) { - ext2fs_free_inode_bitmap(ctx->inode_bb_map); - ctx->inode_bb_map = 0; - } - if (ctx->inode_bad_map) { - ext2fs_free_inode_bitmap(ctx->inode_bad_map); - ctx->inode_bad_map = 0; - } - if (ctx->inode_imagic_map) { - ext2fs_free_inode_bitmap(ctx->inode_imagic_map); - ctx->inode_imagic_map = 0; - } - if (ctx->dirs_to_hash) { - ext2fs_u32_list_free(ctx->dirs_to_hash); - ctx->dirs_to_hash = 0; - } - - /* - * Clear the array of invalid meta-data flags - */ - if (ctx->invalid_inode_bitmap_flag) { - ext2fs_free_mem(&ctx->invalid_inode_bitmap_flag); - ctx->invalid_inode_bitmap_flag = 0; - } - if (ctx->invalid_block_bitmap_flag) { - ext2fs_free_mem(&ctx->invalid_block_bitmap_flag); - ctx->invalid_block_bitmap_flag = 0; - } - if (ctx->invalid_inode_table_flag) { - ext2fs_free_mem(&ctx->invalid_inode_table_flag); - ctx->invalid_inode_table_flag = 0; - } - - /* Clear statistic counters */ - ctx->fs_directory_count = 0; - ctx->fs_regular_count = 0; - ctx->fs_blockdev_count = 0; - ctx->fs_chardev_count = 0; - ctx->fs_links_count = 0; - ctx->fs_symlinks_count = 0; - ctx->fs_fast_symlinks_count = 0; - ctx->fs_fifo_count = 0; - ctx->fs_total_count = 0; - ctx->fs_badblocks_count = 0; - ctx->fs_sockets_count = 0; - ctx->fs_ind_count = 0; - ctx->fs_dind_count = 0; - ctx->fs_tind_count = 0; - ctx->fs_fragmented = 0; - ctx->large_files = 0; - - /* Reset the superblock to the user's requested value */ - ctx->superblock = ctx->use_superblock; - - return 0; -} - -void e2fsck_free_context(e2fsck_t ctx) -{ - if (!ctx) - return; - - e2fsck_reset_context(ctx); - if (ctx->blkid) - blkid_put_cache(ctx->blkid); - - ext2fs_free_mem(&ctx); -} - -/* - * This function runs through the e2fsck passes and calls them all, - * returning restart, abort, or cancel as necessary... - */ -typedef void (*pass_t)(e2fsck_t ctx); - -pass_t e2fsck_passes[] = { - e2fsck_pass1, e2fsck_pass2, e2fsck_pass3, e2fsck_pass4, - e2fsck_pass5, 0 }; - -#define E2F_FLAG_RUN_RETURN (E2F_FLAG_SIGNAL_MASK|E2F_FLAG_RESTART) - -int e2fsck_run(e2fsck_t ctx) -{ - int i; - pass_t e2fsck_pass; - -#ifdef HAVE_SETJMP_H - if (setjmp(ctx->abort_loc)) { - ctx->flags &= ~E2F_FLAG_SETJMP_OK; - return (ctx->flags & E2F_FLAG_RUN_RETURN); - } - ctx->flags |= E2F_FLAG_SETJMP_OK; -#endif - - for (i=0; (e2fsck_pass = e2fsck_passes[i]); i++) { - if (ctx->flags & E2F_FLAG_RUN_RETURN) - break; - e2fsck_pass(ctx); - if (ctx->progress) - (void) (ctx->progress)(ctx, 0, 0, 0); - } - ctx->flags &= ~E2F_FLAG_SETJMP_OK; - - if (ctx->flags & E2F_FLAG_RUN_RETURN) - return (ctx->flags & E2F_FLAG_RUN_RETURN); - return 0; -} diff --git a/e2fsprogs/e2fsck/e2fsck.h b/e2fsprogs/e2fsck/e2fsck.h deleted file mode 100644 index 489903d7c..000000000 --- a/e2fsprogs/e2fsck/e2fsck.h +++ /dev/null @@ -1,446 +0,0 @@ -/* - * e2fsck.h - * - * Copyright (C) 1993, 1994 Theodore Ts'o. This file may be - * redistributed under the terms of the GNU Public License. - * - */ - -#include -#include -#ifdef HAVE_UNISTD_H -#include -#endif -#include -#include -#ifdef HAVE_SYS_TYPES_H -#include -#endif -#ifdef HAVE_SYS_TIME_H -#include -#endif -#ifdef HAVE_SETJMP_H -#include -#endif - -#if EXT2_FLAT_INCLUDES -#include "ext2_fs.h" -#include "ext2fs.h" -#include "blkid.h" -#else -#include "ext2fs/ext2_fs.h" -#include "ext2fs/ext2fs.h" -#include "blkid/blkid.h" -#endif - -/* - * Exit codes used by fsck-type programs - */ -#define FSCK_OK 0 /* No errors */ -#define FSCK_NONDESTRUCT 1 /* File system errors corrected */ -#define FSCK_REBOOT 2 /* System should be rebooted */ -#define FSCK_UNCORRECTED 4 /* File system errors left uncorrected */ -#define FSCK_ERROR 8 /* Operational error */ -#define FSCK_USAGE 16 /* Usage or syntax error */ -#define FSCK_CANCELED 32 /* Aborted with a signal or ^C */ -#define FSCK_LIBRARY 128 /* Shared library error */ - -/* - * The last ext2fs revision level that this version of e2fsck is able to - * support - */ -#define E2FSCK_CURRENT_REV 1 - -/* - * The directory information structure; stores directory information - * collected in earlier passes, to avoid disk i/o in fetching the - * directory information. - */ -struct dir_info { - ext2_ino_t ino; /* Inode number */ - ext2_ino_t dotdot; /* Parent according to '..' */ - ext2_ino_t parent; /* Parent according to treewalk */ -}; - - -/* - * The indexed directory information structure; stores information for - * directories which contain a hash tree index. - */ -struct dx_dir_info { - ext2_ino_t ino; /* Inode number */ - int numblocks; /* number of blocks */ - int hashversion; - short depth; /* depth of tree */ - struct dx_dirblock_info *dx_block; /* Array of size numblocks */ -}; - -#define DX_DIRBLOCK_ROOT 1 -#define DX_DIRBLOCK_LEAF 2 -#define DX_DIRBLOCK_NODE 3 -#define DX_DIRBLOCK_CORRUPT 4 -#define DX_DIRBLOCK_CLEARED 8 - -struct dx_dirblock_info { - int type; - blk_t phys; - int flags; - blk_t parent; - ext2_dirhash_t min_hash; - ext2_dirhash_t max_hash; - ext2_dirhash_t node_min_hash; - ext2_dirhash_t node_max_hash; -}; - -#define DX_FLAG_REFERENCED 1 -#define DX_FLAG_DUP_REF 2 -#define DX_FLAG_FIRST 4 -#define DX_FLAG_LAST 8 - -#ifdef RESOURCE_TRACK -/* - * This structure is used for keeping track of how much resources have - * been used for a particular pass of e2fsck. - */ -struct resource_track { - struct timeval time_start; - struct timeval user_start; - struct timeval system_start; - void *brk_start; -}; -#endif - -/* - * E2fsck options - */ -#define E2F_OPT_READONLY 0x0001 -#define E2F_OPT_PREEN 0x0002 -#define E2F_OPT_YES 0x0004 -#define E2F_OPT_NO 0x0008 -#define E2F_OPT_TIME 0x0010 -#define E2F_OPT_TIME2 0x0020 -#define E2F_OPT_CHECKBLOCKS 0x0040 -#define E2F_OPT_DEBUG 0x0080 -#define E2F_OPT_FORCE 0x0100 -#define E2F_OPT_WRITECHECK 0x0200 -#define E2F_OPT_COMPRESS_DIRS 0x0400 - -/* - * E2fsck flags - */ -#define E2F_FLAG_ABORT 0x0001 /* Abort signaled */ -#define E2F_FLAG_CANCEL 0x0002 /* Cancel signaled */ -#define E2F_FLAG_SIGNAL_MASK 0x0003 -#define E2F_FLAG_RESTART 0x0004 /* Restart signaled */ - -#define E2F_FLAG_SETJMP_OK 0x0010 /* Setjmp valid for abort */ - -#define E2F_FLAG_PROG_BAR 0x0020 /* Progress bar on screen */ -#define E2F_FLAG_PROG_SUPPRESS 0x0040 /* Progress suspended */ -#define E2F_FLAG_JOURNAL_INODE 0x0080 /* Create a new ext3 journal inode */ -#define E2F_FLAG_SB_SPECIFIED 0x0100 /* The superblock was explicitly - * specified by the user */ -#define E2F_FLAG_RESTARTED 0x0200 /* E2fsck has been restarted */ -#define E2F_FLAG_RESIZE_INODE 0x0400 /* Request to recreate resize inode */ - -/* - * Defines for indicating the e2fsck pass number - */ -#define E2F_PASS_1 1 -#define E2F_PASS_2 2 -#define E2F_PASS_3 3 -#define E2F_PASS_4 4 -#define E2F_PASS_5 5 -#define E2F_PASS_1B 6 - -/* - * Define the extended attribute refcount structure - */ -typedef struct ea_refcount *ext2_refcount_t; - -/* - * This is the global e2fsck structure. - */ -typedef struct e2fsck_struct *e2fsck_t; - -struct e2fsck_struct { - ext2_filsys fs; - const char *program_name; - char *filesystem_name; - char *device_name; - char *io_options; - int flags; /* E2fsck internal flags */ - int options; - blk_t use_superblock; /* sb requested by user */ - blk_t superblock; /* sb used to open fs */ - int blocksize; /* blocksize */ - blk_t num_blocks; /* Total number of blocks */ - int mount_flags; - blkid_cache blkid; /* blkid cache */ - -#ifdef HAVE_SETJMP_H - jmp_buf abort_loc; -#endif - unsigned long abort_code; - - int (*progress)(e2fsck_t ctx, int pass, unsigned long cur, - unsigned long max); - - ext2fs_inode_bitmap inode_used_map; /* Inodes which are in use */ - ext2fs_inode_bitmap inode_bad_map; /* Inodes which are bad somehow */ - ext2fs_inode_bitmap inode_dir_map; /* Inodes which are directories */ - ext2fs_inode_bitmap inode_bb_map; /* Inodes which are in bad blocks */ - ext2fs_inode_bitmap inode_imagic_map; /* AFS inodes */ - ext2fs_inode_bitmap inode_reg_map; /* Inodes which are regular files*/ - - ext2fs_block_bitmap block_found_map; /* Blocks which are in use */ - ext2fs_block_bitmap block_dup_map; /* Blks referenced more than once */ - ext2fs_block_bitmap block_ea_map; /* Blocks which are used by EA's */ - - /* - * Inode count arrays - */ - ext2_icount_t inode_count; - ext2_icount_t inode_link_info; - - ext2_refcount_t refcount; - ext2_refcount_t refcount_extra; - - /* - * Array of flags indicating whether an inode bitmap, block - * bitmap, or inode table is invalid - */ - int *invalid_inode_bitmap_flag; - int *invalid_block_bitmap_flag; - int *invalid_inode_table_flag; - int invalid_bitmaps; /* There are invalid bitmaps/itable */ - - /* - * Block buffer - */ - char *block_buf; - - /* - * For pass1_check_directory and pass1_get_blocks - */ - ext2_ino_t stashed_ino; - struct ext2_inode *stashed_inode; - - /* - * Location of the lost and found directory - */ - ext2_ino_t lost_and_found; - int bad_lost_and_found; - - /* - * Directory information - */ - int dir_info_count; - int dir_info_size; - struct dir_info *dir_info; - - /* - * Indexed directory information - */ - int dx_dir_info_count; - int dx_dir_info_size; - struct dx_dir_info *dx_dir_info; - - /* - * Directories to hash - */ - ext2_u32_list dirs_to_hash; - - /* - * Tuning parameters - */ - int process_inode_size; - int inode_buffer_blocks; - - /* - * ext3 journal support - */ - io_channel journal_io; - char *journal_name; - -#ifdef RESOURCE_TRACK - /* - * For timing purposes - */ - struct resource_track global_rtrack; -#endif - - /* - * How we display the progress update (for unix) - */ - int progress_fd; - int progress_pos; - int progress_last_percent; - unsigned int progress_last_time; - int interactive; /* Are we connected directly to a tty? */ - char start_meta[2], stop_meta[2]; - - /* File counts */ - int fs_directory_count; - int fs_regular_count; - int fs_blockdev_count; - int fs_chardev_count; - int fs_links_count; - int fs_symlinks_count; - int fs_fast_symlinks_count; - int fs_fifo_count; - int fs_total_count; - int fs_badblocks_count; - int fs_sockets_count; - int fs_ind_count; - int fs_dind_count; - int fs_tind_count; - int fs_fragmented; - int large_files; - int fs_ext_attr_inodes; - int fs_ext_attr_blocks; - - int ext_attr_ver; - - /* - * For the use of callers of the e2fsck functions; not used by - * e2fsck functions themselves. - */ - void *priv_data; -}; - -/* Used by the region allocation code */ -typedef __u32 region_addr_t; -typedef struct region_struct *region_t; - -#ifndef HAVE_STRNLEN -#define strnlen(str, x) e2fsck_strnlen((str),(x)) -extern int e2fsck_strnlen(const char * s, int count); -#endif - -/* - * Procedure declarations - */ - -extern void e2fsck_pass1(e2fsck_t ctx); -extern void e2fsck_pass1_dupblocks(e2fsck_t ctx, char *block_buf); -extern void e2fsck_pass2(e2fsck_t ctx); -extern void e2fsck_pass3(e2fsck_t ctx); -extern void e2fsck_pass4(e2fsck_t ctx); -extern void e2fsck_pass5(e2fsck_t ctx); - -/* e2fsck.c */ -extern errcode_t e2fsck_allocate_context(e2fsck_t *ret); -extern errcode_t e2fsck_reset_context(e2fsck_t ctx); -extern void e2fsck_free_context(e2fsck_t ctx); -extern int e2fsck_run(e2fsck_t ctx); - - -/* badblock.c */ -extern void read_bad_blocks_file(e2fsck_t ctx, const char *bad_blocks_file, - int replace_bad_blocks); - -/* dirinfo.c */ -extern void e2fsck_add_dir_info(e2fsck_t ctx, ext2_ino_t ino, ext2_ino_t parent); -extern struct dir_info *e2fsck_get_dir_info(e2fsck_t ctx, ext2_ino_t ino); -extern void e2fsck_free_dir_info(e2fsck_t ctx); -extern int e2fsck_get_num_dirinfo(e2fsck_t ctx); -extern struct dir_info *e2fsck_dir_info_iter(e2fsck_t ctx, int *control); - -/* dx_dirinfo.c */ -extern void e2fsck_add_dx_dir(e2fsck_t ctx, ext2_ino_t ino, int num_blocks); -extern struct dx_dir_info *e2fsck_get_dx_dir_info(e2fsck_t ctx, ext2_ino_t ino); -extern void e2fsck_free_dx_dir_info(e2fsck_t ctx); -extern int e2fsck_get_num_dx_dirinfo(e2fsck_t ctx); -extern struct dx_dir_info *e2fsck_dx_dir_info_iter(e2fsck_t ctx, int *control); - -/* ea_refcount.c */ -extern errcode_t ea_refcount_create(int size, ext2_refcount_t *ret); -extern void ea_refcount_free(ext2_refcount_t refcount); -extern errcode_t ea_refcount_fetch(ext2_refcount_t refcount, blk_t blk, - int *ret); -extern errcode_t ea_refcount_increment(ext2_refcount_t refcount, - blk_t blk, int *ret); -extern errcode_t ea_refcount_decrement(ext2_refcount_t refcount, - blk_t blk, int *ret); -extern errcode_t ea_refcount_store(ext2_refcount_t refcount, - blk_t blk, int count); -extern blk_t ext2fs_get_refcount_size(ext2_refcount_t refcount); -extern void ea_refcount_intr_begin(ext2_refcount_t refcount); -extern blk_t ea_refcount_intr_next(ext2_refcount_t refcount, int *ret); - -/* ehandler.c */ -extern const char *ehandler_operation(const char *op); -extern void ehandler_init(io_channel channel); - -/* journal.c */ -extern int e2fsck_check_ext3_journal(e2fsck_t ctx); -extern int e2fsck_run_ext3_journal(e2fsck_t ctx); -extern void e2fsck_move_ext3_journal(e2fsck_t ctx); - -/* pass1.c */ -extern void e2fsck_use_inode_shortcuts(e2fsck_t ctx, int bool); -extern int e2fsck_pass1_check_device_inode(ext2_filsys fs, - struct ext2_inode *inode); -extern int e2fsck_pass1_check_symlink(ext2_filsys fs, - struct ext2_inode *inode, char *buf); - -/* pass2.c */ -extern int e2fsck_process_bad_inode(e2fsck_t ctx, ext2_ino_t dir, - ext2_ino_t ino, char *buf); - -/* pass3.c */ -extern int e2fsck_reconnect_file(e2fsck_t ctx, ext2_ino_t inode); -extern errcode_t e2fsck_expand_directory(e2fsck_t ctx, ext2_ino_t dir, - int num, int gauranteed_size); -extern ext2_ino_t e2fsck_get_lost_and_found(e2fsck_t ctx, int fix); -extern errcode_t e2fsck_adjust_inode_count(e2fsck_t ctx, ext2_ino_t ino, - int adj); - - -/* region.c */ -extern region_t region_create(region_addr_t min, region_addr_t max); -extern void region_free(region_t region); -extern int region_allocate(region_t region, region_addr_t start, int n); - -/* rehash.c */ -errcode_t e2fsck_rehash_dir(e2fsck_t ctx, ext2_ino_t ino); -void e2fsck_rehash_directories(e2fsck_t ctx); - -/* super.c */ -void check_super_block(e2fsck_t ctx); -errcode_t e2fsck_get_device_size(e2fsck_t ctx); - -/* swapfs.c */ -void swap_filesys(e2fsck_t ctx); - -/* util.c */ -extern void *e2fsck_allocate_memory(e2fsck_t ctx, unsigned int size, - const char *description); -extern int ask(e2fsck_t ctx, const char * string, int def); -extern int ask_yn(const char * string, int def); -extern void e2fsck_read_bitmaps(e2fsck_t ctx); -extern void e2fsck_write_bitmaps(e2fsck_t ctx); -extern void preenhalt(e2fsck_t ctx); -extern char *string_copy(e2fsck_t ctx, const char *str, int len); -#ifdef RESOURCE_TRACK -extern void print_resource_track(const char *desc, - struct resource_track *track); -extern void init_resource_track(struct resource_track *track); -#endif -extern int inode_has_valid_blocks(struct ext2_inode *inode); -extern void e2fsck_read_inode(e2fsck_t ctx, unsigned long ino, - struct ext2_inode * inode, const char * proc); -extern void e2fsck_write_inode(e2fsck_t ctx, unsigned long ino, - struct ext2_inode * inode, const char * proc); -#ifdef MTRACE -extern void mtrace_print(char *mesg); -#endif -extern blk_t get_backup_sb(e2fsck_t ctx, ext2_filsys fs, - const char *name, io_manager manager); -extern int ext2_file_type(unsigned int mode); - -/* unix.c */ -extern void e2fsck_clear_progbar(e2fsck_t ctx); -extern int e2fsck_simple_progress(e2fsck_t ctx, const char *label, - float percent, unsigned int dpynum); diff --git a/e2fsprogs/e2fsck/ea_refcount.c b/e2fsprogs/e2fsck/ea_refcount.c deleted file mode 100644 index 6420c7280..000000000 --- a/e2fsprogs/e2fsck/ea_refcount.c +++ /dev/null @@ -1,479 +0,0 @@ -/* - * ea_refcount.c - * - * Copyright (C) 2001 Theodore Ts'o. This file may be - * redistributed under the terms of the GNU Public License. - */ - -#if HAVE_UNISTD_H -#include -#endif -#include -#include - -#include "e2fsck.h" - -/* - * The strategy we use for keeping track of EA refcounts is as - * follows. We keep a sorted array of first EA blocks and its - * reference counts. Once the refcount has dropped to zero, it is - * removed from the array to save memory space. Once the EA block is - * checked, its bit is set in the block_ea_map bitmap. - */ -struct ea_refcount_el { - blk_t ea_blk; - int ea_count; -}; - -struct ea_refcount { - blk_t count; - blk_t size; - blk_t cursor; - struct ea_refcount_el *list; -}; - -void ea_refcount_free(ext2_refcount_t refcount) -{ - if (!refcount) - return; - - if (refcount->list) - ext2fs_free_mem(&refcount->list); - ext2fs_free_mem(&refcount); -} - -errcode_t ea_refcount_create(int size, ext2_refcount_t *ret) -{ - ext2_refcount_t refcount; - errcode_t retval; - size_t bytes; - - retval = ext2fs_get_mem(sizeof(struct ea_refcount), &refcount); - if (retval) - return retval; - memset(refcount, 0, sizeof(struct ea_refcount)); - - if (!size) - size = 500; - refcount->size = size; - bytes = (size_t) (size * sizeof(struct ea_refcount_el)); -#ifdef DEBUG - printf("Refcount allocated %d entries, %d bytes.\n", - refcount->size, bytes); -#endif - retval = ext2fs_get_mem(bytes, &refcount->list); - if (retval) - goto errout; - memset(refcount->list, 0, bytes); - - refcount->count = 0; - refcount->cursor = 0; - - *ret = refcount; - return 0; - -errout: - ea_refcount_free(refcount); - return(retval); -} - -/* - * collapse_refcount() --- go through the refcount array, and get rid - * of any count == zero entries - */ -static void refcount_collapse(ext2_refcount_t refcount) -{ - unsigned int i, j; - struct ea_refcount_el *list; - - list = refcount->list; - for (i = 0, j = 0; i < refcount->count; i++) { - if (list[i].ea_count) { - if (i != j) - list[j] = list[i]; - j++; - } - } -#if defined(DEBUG) || defined(TEST_PROGRAM) - printf("Refcount_collapse: size was %d, now %d\n", - refcount->count, j); -#endif - refcount->count = j; -} - - -/* - * insert_refcount_el() --- Insert a new entry into the sorted list at a - * specified position. - */ -static struct ea_refcount_el *insert_refcount_el(ext2_refcount_t refcount, - blk_t blk, int pos) -{ - struct ea_refcount_el *el; - errcode_t retval; - blk_t new_size = 0; - int num; - - if (refcount->count >= refcount->size) { - new_size = refcount->size + 100; -#ifdef DEBUG - printf("Reallocating refcount %d entries...\n", new_size); -#endif - retval = ext2fs_resize_mem((size_t) refcount->size * - sizeof(struct ea_refcount_el), - (size_t) new_size * - sizeof(struct ea_refcount_el), - &refcount->list); - if (retval) - return 0; - refcount->size = new_size; - } - num = (int) refcount->count - pos; - if (num < 0) - return 0; /* should never happen */ - if (num) { - memmove(&refcount->list[pos+1], &refcount->list[pos], - sizeof(struct ea_refcount_el) * num); - } - refcount->count++; - el = &refcount->list[pos]; - el->ea_count = 0; - el->ea_blk = blk; - return el; -} - - -/* - * get_refcount_el() --- given an block number, try to find refcount - * information in the sorted list. If the create flag is set, - * and we can't find an entry, create one in the sorted list. - */ -static struct ea_refcount_el *get_refcount_el(ext2_refcount_t refcount, - blk_t blk, int create) -{ - float range; - int low, high, mid; - blk_t lowval, highval; - - if (!refcount || !refcount->list) - return 0; -retry: - low = 0; - high = (int) refcount->count-1; - if (create && ((refcount->count == 0) || - (blk > refcount->list[high].ea_blk))) { - if (refcount->count >= refcount->size) - refcount_collapse(refcount); - - return insert_refcount_el(refcount, blk, - (unsigned) refcount->count); - } - if (refcount->count == 0) - return 0; - - if (refcount->cursor >= refcount->count) - refcount->cursor = 0; - if (blk == refcount->list[refcount->cursor].ea_blk) - return &refcount->list[refcount->cursor++]; -#ifdef DEBUG - printf("Non-cursor get_refcount_el: %u\n", blk); -#endif - while (low <= high) { -#if 0 - mid = (low+high)/2; -#else - if (low == high) - mid = low; - else { - /* Interpolate for efficiency */ - lowval = refcount->list[low].ea_blk; - highval = refcount->list[high].ea_blk; - - if (blk < lowval) - range = 0; - else if (blk > highval) - range = 1; - else - range = ((float) (blk - lowval)) / - (highval - lowval); - mid = low + ((int) (range * (high-low))); - } -#endif - if (blk == refcount->list[mid].ea_blk) { - refcount->cursor = mid+1; - return &refcount->list[mid]; - } - if (blk < refcount->list[mid].ea_blk) - high = mid-1; - else - low = mid+1; - } - /* - * If we need to create a new entry, it should be right at - * low (where high will be left at low-1). - */ - if (create) { - if (refcount->count >= refcount->size) { - refcount_collapse(refcount); - if (refcount->count < refcount->size) - goto retry; - } - return insert_refcount_el(refcount, blk, low); - } - return 0; -} - -errcode_t ea_refcount_fetch(ext2_refcount_t refcount, blk_t blk, - int *ret) -{ - struct ea_refcount_el *el; - - el = get_refcount_el(refcount, blk, 0); - if (!el) { - *ret = 0; - return 0; - } - *ret = el->ea_count; - return 0; -} - -errcode_t ea_refcount_increment(ext2_refcount_t refcount, blk_t blk, int *ret) -{ - struct ea_refcount_el *el; - - el = get_refcount_el(refcount, blk, 1); - if (!el) - return EXT2_ET_NO_MEMORY; - el->ea_count++; - - if (ret) - *ret = el->ea_count; - return 0; -} - -errcode_t ea_refcount_decrement(ext2_refcount_t refcount, blk_t blk, int *ret) -{ - struct ea_refcount_el *el; - - el = get_refcount_el(refcount, blk, 0); - if (!el || el->ea_count == 0) - return EXT2_ET_INVALID_ARGUMENT; - - el->ea_count--; - - if (ret) - *ret = el->ea_count; - return 0; -} - -errcode_t ea_refcount_store(ext2_refcount_t refcount, blk_t blk, int count) -{ - struct ea_refcount_el *el; - - /* - * Get the refcount element - */ - el = get_refcount_el(refcount, blk, count ? 1 : 0); - if (!el) - return count ? EXT2_ET_NO_MEMORY : 0; - el->ea_count = count; - return 0; -} - -blk_t ext2fs_get_refcount_size(ext2_refcount_t refcount) -{ - if (!refcount) - return 0; - - return refcount->size; -} - -void ea_refcount_intr_begin(ext2_refcount_t refcount) -{ - refcount->cursor = 0; -} - - -blk_t ea_refcount_intr_next(ext2_refcount_t refcount, - int *ret) -{ - struct ea_refcount_el *list; - - while (1) { - if (refcount->cursor >= refcount->count) - return 0; - list = refcount->list; - if (list[refcount->cursor].ea_count) { - if (ret) - *ret = list[refcount->cursor].ea_count; - return list[refcount->cursor++].ea_blk; - } - refcount->cursor++; - } -} - - -#ifdef TEST_PROGRAM - -errcode_t ea_refcount_validate(ext2_refcount_t refcount, FILE *out) -{ - errcode_t ret = 0; - int i; - const char *bad = "bad refcount"; - - if (refcount->count > refcount->size) { - fprintf(out, "%s: count > size\n", bad); - return EXT2_ET_INVALID_ARGUMENT; - } - for (i=1; i < refcount->count; i++) { - if (refcount->list[i-1].ea_blk >= refcount->list[i].ea_blk) { - fprintf(out, "%s: list[%d].blk=%u, list[%d].blk=%u\n", - bad, i-1, refcount->list[i-1].ea_blk, - i, refcount->list[i].ea_blk); - ret = EXT2_ET_INVALID_ARGUMENT; - } - } - return ret; -} - -#define BCODE_END 0 -#define BCODE_CREATE 1 -#define BCODE_FREE 2 -#define BCODE_STORE 3 -#define BCODE_INCR 4 -#define BCODE_DECR 5 -#define BCODE_FETCH 6 -#define BCODE_VALIDATE 7 -#define BCODE_LIST 8 -#define BCODE_COLLAPSE 9 - -int bcode_program[] = { - BCODE_CREATE, 5, - BCODE_STORE, 3, 3, - BCODE_STORE, 4, 4, - BCODE_STORE, 1, 1, - BCODE_STORE, 8, 8, - BCODE_STORE, 2, 2, - BCODE_STORE, 4, 0, - BCODE_STORE, 2, 0, - BCODE_STORE, 6, 6, - BCODE_VALIDATE, - BCODE_STORE, 4, 4, - BCODE_STORE, 2, 2, - BCODE_FETCH, 1, - BCODE_FETCH, 2, - BCODE_INCR, 3, - BCODE_INCR, 3, - BCODE_DECR, 4, - BCODE_STORE, 4, 4, - BCODE_VALIDATE, - BCODE_STORE, 20, 20, - BCODE_STORE, 40, 40, - BCODE_STORE, 30, 30, - BCODE_STORE, 10, 10, - BCODE_DECR, 30, - BCODE_FETCH, 30, - BCODE_DECR, 2, - BCODE_DECR, 2, - BCODE_COLLAPSE, - BCODE_LIST, - BCODE_VALIDATE, - BCODE_FREE, - BCODE_END -}; - -int main(int argc, char **argv) -{ - int i = 0; - ext2_refcount_t refcount; - int size, arg; - blk_t blk; - errcode_t retval; - - while (1) { - switch (bcode_program[i++]) { - case BCODE_END: - exit(0); - case BCODE_CREATE: - size = bcode_program[i++]; - retval = ea_refcount_create(size, &refcount); - if (retval) { - com_err("ea_refcount_create", - retval, ""); - exit(1); - } else - printf("Creating refcount with size %d\n", - size); - break; - case BCODE_FREE: - ea_refcount_free(refcount); - refcount = 0; - printf("Freeing refcount\n"); - break; - case BCODE_STORE: - blk = (blk_t) bcode_program[i++]; - arg = bcode_program[i++]; - retval = ea_refcount_store(refcount, blk, arg); - printf("Storing blk %u with value %d\n", blk, arg); - if (retval) - com_err("ea_refcount_store", retval, ""); - break; - case BCODE_FETCH: - blk = (blk_t) bcode_program[i++]; - retval = ea_refcount_fetch(refcount, blk, &arg); - if (retval) - com_err("ea_refcount_fetch", retval, ""); - else - printf("bcode_fetch(%u) returns %d\n", - blk, arg); - break; - case BCODE_INCR: - blk = (blk_t) bcode_program[i++]; - retval = ea_refcount_increment(refcount, blk, - &arg); - if (retval) - com_err("ea_refcount_increment", retval, - ""); - else - printf("bcode_increment(%u) returns %d\n", - blk, arg); - break; - case BCODE_DECR: - blk = (blk_t) bcode_program[i++]; - retval = ea_refcount_decrement(refcount, blk, - &arg); - if (retval) - com_err("ea_refcount_decrement", retval, - "while decrementing blk %u", blk); - else - printf("bcode_decrement(%u) returns %d\n", - blk, arg); - break; - case BCODE_VALIDATE: - retval = ea_refcount_validate(refcount, stderr); - if (retval) - com_err("ea_refcount_validate", - retval, ""); - else - printf("Refcount validation OK.\n"); - break; - case BCODE_LIST: - ea_refcount_intr_begin(refcount); - while (1) { - blk = ea_refcount_intr_next(refcount, - &arg); - if (!blk) - break; - printf("\tblk=%u, count=%d\n", blk, - arg); - } - break; - case BCODE_COLLAPSE: - refcount_collapse(refcount); - break; - } - - } -} - -#endif diff --git a/e2fsprogs/e2fsck/ehandler.c b/e2fsprogs/e2fsck/ehandler.c deleted file mode 100644 index 16d6d4fa0..000000000 --- a/e2fsprogs/e2fsck/ehandler.c +++ /dev/null @@ -1,124 +0,0 @@ -/* - * ehandler.c --- handle bad block errors which come up during the - * course of an e2fsck session. - * - * Copyright (C) 1994 Theodore Ts'o. This file may be redistributed - * under the terms of the GNU Public License. - */ - -#include -#include -#include -#include -#include - -#include "e2fsck.h" - -#include -#include - -static const char *operation; - -static errcode_t e2fsck_handle_read_error(io_channel channel, - unsigned long block, - int count, - void *data, - size_t size EXT2FS_ATTR((unused)), - int actual EXT2FS_ATTR((unused)), - errcode_t error) -{ - int i; - char *p; - ext2_filsys fs = (ext2_filsys) channel->app_data; - e2fsck_t ctx; - - ctx = (e2fsck_t) fs->priv_data; - - /* - * If more than one block was read, try reading each block - * separately. We could use the actual bytes read to figure - * out where to start, but we don't bother. - */ - if (count > 1) { - p = (char *) data; - for (i=0; i < count; i++, p += channel->block_size, block++) { - error = io_channel_read_blk(channel, block, - 1, p); - if (error) - return error; - } - return 0; - } - if (operation) - printf(_("Error reading block %lu (%s) while %s. "), block, - error_message(error), operation); - else - printf(_("Error reading block %lu (%s). "), block, - error_message(error)); - preenhalt(ctx); - if (ask(ctx, _("Ignore error"), 1)) { - if (ask(ctx, _("Force rewrite"), 1)) - io_channel_write_blk(channel, block, 1, data); - return 0; - } - - return error; -} - -static errcode_t e2fsck_handle_write_error(io_channel channel, - unsigned long block, - int count, - const void *data, - size_t size EXT2FS_ATTR((unused)), - int actual EXT2FS_ATTR((unused)), - errcode_t error) -{ - int i; - const char *p; - ext2_filsys fs = (ext2_filsys) channel->app_data; - e2fsck_t ctx; - - ctx = (e2fsck_t) fs->priv_data; - - /* - * If more than one block was written, try writing each block - * separately. We could use the actual bytes read to figure - * out where to start, but we don't bother. - */ - if (count > 1) { - p = (const char *) data; - for (i=0; i < count; i++, p += channel->block_size, block++) { - error = io_channel_write_blk(channel, block, - 1, p); - if (error) - return error; - } - return 0; - } - - if (operation) - printf(_("Error writing block %lu (%s) while %s. "), block, - error_message(error), operation); - else - printf(_("Error writing block %lu (%s). "), block, - error_message(error)); - preenhalt(ctx); - if (ask(ctx, _("Ignore error"), 1)) - return 0; - - return error; -} - -const char *ehandler_operation(const char *op) -{ - const char *ret = operation; - - operation = op; - return ret; -} - -void ehandler_init(io_channel channel) -{ - channel->read_error = e2fsck_handle_read_error; - channel->write_error = e2fsck_handle_write_error; -} diff --git a/e2fsprogs/e2fsck/jfs_user.h b/e2fsprogs/e2fsck/jfs_user.h deleted file mode 100644 index c38def3e5..000000000 --- a/e2fsprogs/e2fsck/jfs_user.h +++ /dev/null @@ -1,120 +0,0 @@ -/* - * Compatibility header file for e2fsck which should be included - * instead of linux/jfs.h - * - * Copyright (C) 2000 Stephen C. Tweedie - * - * This file may be redistributed under the terms of the - * GNU General Public License version 2 or at your discretion - * any later version. - */ - -/* - * Pull in the definition of the e2fsck context structure - */ -#include "e2fsck.h" - -struct buffer_head { - char b_data[8192]; - e2fsck_t b_ctx; - io_channel b_io; - int b_size; - blk_t b_blocknr; - int b_dirty; - int b_uptodate; - int b_err; -}; - -struct inode { - e2fsck_t i_ctx; - ext2_ino_t i_ino; - struct ext2_inode i_ext2; -}; - -struct kdev_s { - e2fsck_t k_ctx; - int k_dev; -}; - -#define K_DEV_FS 1 -#define K_DEV_JOURNAL 2 - -typedef struct kdev_s *kdev_t; - -#define lock_buffer(bh) do {} while(0) -#define unlock_buffer(bh) do {} while(0) -#define buffer_req(bh) 1 -#define do_readahead(journal, start) do {} while(0) - -extern e2fsck_t e2fsck_global_ctx; /* Try your very best not to use this! */ - -typedef struct { - int object_length; -} kmem_cache_t; - -#define kmem_cache_alloc(cache,flags) malloc((cache)->object_length) -#define kmem_cache_free(cache,obj) free(obj) -#define kmem_cache_create(name,len,a,b,c,d) do_cache_create(len) -#define kmem_cache_destroy(cache) do_cache_destroy(cache) -#define kmalloc(len,flags) malloc(len) -#define kfree(p) free(p) - -/* - * We use the standard libext2fs portability tricks for inline - * functions. - */ -extern kmem_cache_t * do_cache_create(int len); -extern void do_cache_destroy(kmem_cache_t *cache); - -#if (defined(E2FSCK_INCLUDE_INLINE_FUNCS) || !defined(NO_INLINE_FUNCS)) -#ifdef E2FSCK_INCLUDE_INLINE_FUNCS -#define _INLINE_ extern -#else -#ifdef __GNUC__ -#define _INLINE_ extern __inline__ -#else /* For Watcom C */ -#define _INLINE_ extern inline -#endif -#endif - -_INLINE_ kmem_cache_t * do_cache_create(int len) -{ - kmem_cache_t *new_cache; - new_cache = malloc(sizeof(*new_cache)); - if (new_cache) - new_cache->object_length = len; - return new_cache; -} - -_INLINE_ void do_cache_destroy(kmem_cache_t *cache) -{ - free(cache); -} -#undef _INLINE_ -#endif - -#define __init - -/* - * Now pull in the real linux/jfs.h definitions. - */ -#include - -/* - * Kernel compatibility functions are defined in journal.c - */ -int journal_bmap(journal_t *journal, blk_t block, unsigned long *phys); -struct buffer_head *getblk(kdev_t ctx, blk_t blocknr, int blocksize); -void sync_blockdev(kdev_t kdev); -void ll_rw_block(int rw, int dummy, struct buffer_head *bh[]); -void mark_buffer_dirty(struct buffer_head *bh); -void mark_buffer_uptodate(struct buffer_head *bh, int val); -void brelse(struct buffer_head *bh); -int buffer_uptodate(struct buffer_head *bh); -void wait_on_buffer(struct buffer_head *bh); - -/* - * Define newer 2.5 interfaces - */ -#define __getblk(dev, blocknr, blocksize) getblk(dev, blocknr, blocksize) -#define set_buffer_uptodate(bh) mark_buffer_uptodate(bh, 1) diff --git a/e2fsprogs/e2fsck/journal.c b/e2fsprogs/e2fsck/journal.c deleted file mode 100644 index 14e774d50..000000000 --- a/e2fsprogs/e2fsck/journal.c +++ /dev/null @@ -1,960 +0,0 @@ -/* - * journal.c --- code for handling the "ext3" journal - * - * Copyright (C) 2000 Andreas Dilger - * Copyright (C) 2000 Theodore Ts'o - * - * Parts of the code are based on fs/jfs/journal.c by Stephen C. Tweedie - * Copyright (C) 1999 Red Hat Software - * - * This file may be redistributed under the terms of the - * GNU General Public License version 2 or at your discretion - * any later version. - */ - -#ifdef HAVE_SYS_MOUNT_H -#include -#include -#define MNT_FL (MS_MGC_VAL | MS_RDONLY) -#endif -#ifdef HAVE_SYS_STAT_H -#include -#endif - -#define E2FSCK_INCLUDE_INLINE_FUNCS -#include "jfs_user.h" -#include "problem.h" -#include "uuid/uuid.h" - -#ifdef __CONFIG_JBD_DEBUG__E2FS /* Enabled by configure --enable-jfs-debug */ -static int bh_count = 0; -#endif - -/* - * Define USE_INODE_IO to use the inode_io.c / fileio.c codepaths. - * This creates a larger static binary, and a smaller binary using - * shared libraries. It's also probably slightly less CPU-efficient, - * which is why it's not on by default. But, it's a good way of - * testing the functions in inode_io.c and fileio.c. - */ -#undef USE_INODE_IO - -/* Kernel compatibility functions for handling the journal. These allow us - * to use the recovery.c file virtually unchanged from the kernel, so we - * don't have to do much to keep kernel and user recovery in sync. - */ -int journal_bmap(journal_t *journal, blk_t block, unsigned long *phys) -{ -#ifdef USE_INODE_IO - *phys = block; - return 0; -#else - struct inode *inode = journal->j_inode; - errcode_t retval; - blk_t pblk; - - if (!inode) { - *phys = block; - return 0; - } - - retval= ext2fs_bmap(inode->i_ctx->fs, inode->i_ino, - &inode->i_ext2, NULL, 0, block, &pblk); - *phys = pblk; - return (retval); -#endif -} - -struct buffer_head *getblk(kdev_t kdev, blk_t blocknr, int blocksize) -{ - struct buffer_head *bh; - - bh = e2fsck_allocate_memory(kdev->k_ctx, sizeof(*bh), "block buffer"); - if (!bh) - return NULL; - - jfs_debug(4, "getblk for block %lu (%d bytes)(total %d)\n", - (unsigned long) blocknr, blocksize, ++bh_count); - - bh->b_ctx = kdev->k_ctx; - if (kdev->k_dev == K_DEV_FS) - bh->b_io = kdev->k_ctx->fs->io; - else - bh->b_io = kdev->k_ctx->journal_io; - bh->b_size = blocksize; - bh->b_blocknr = blocknr; - - return bh; -} - -void sync_blockdev(kdev_t kdev) -{ - io_channel io; - - if (kdev->k_dev == K_DEV_FS) - io = kdev->k_ctx->fs->io; - else - io = kdev->k_ctx->journal_io; - - io_channel_flush(io); -} - -void ll_rw_block(int rw, int nr, struct buffer_head *bhp[]) -{ - int retval; - struct buffer_head *bh; - - for (; nr > 0; --nr) { - bh = *bhp++; - if (rw == READ && !bh->b_uptodate) { - jfs_debug(3, "reading block %lu/%p\n", - (unsigned long) bh->b_blocknr, (void *) bh); - retval = io_channel_read_blk(bh->b_io, - bh->b_blocknr, - 1, bh->b_data); - if (retval) { - com_err(bh->b_ctx->device_name, retval, - "while reading block %lu\n", - (unsigned long) bh->b_blocknr); - bh->b_err = retval; - continue; - } - bh->b_uptodate = 1; - } else if (rw == WRITE && bh->b_dirty) { - jfs_debug(3, "writing block %lu/%p\n", - (unsigned long) bh->b_blocknr, (void *) bh); - retval = io_channel_write_blk(bh->b_io, - bh->b_blocknr, - 1, bh->b_data); - if (retval) { - com_err(bh->b_ctx->device_name, retval, - "while writing block %lu\n", - (unsigned long) bh->b_blocknr); - bh->b_err = retval; - continue; - } - bh->b_dirty = 0; - bh->b_uptodate = 1; - } else { - jfs_debug(3, "no-op %s for block %lu\n", - rw == READ ? "read" : "write", - (unsigned long) bh->b_blocknr); - } - } -} - -void mark_buffer_dirty(struct buffer_head *bh) -{ - bh->b_dirty = 1; -} - -static void mark_buffer_clean(struct buffer_head * bh) -{ - bh->b_dirty = 0; -} - -void brelse(struct buffer_head *bh) -{ - if (bh->b_dirty) - ll_rw_block(WRITE, 1, &bh); - jfs_debug(3, "freeing block %lu/%p (total %d)\n", - (unsigned long) bh->b_blocknr, (void *) bh, --bh_count); - ext2fs_free_mem(&bh); -} - -int buffer_uptodate(struct buffer_head *bh) -{ - return bh->b_uptodate; -} - -void mark_buffer_uptodate(struct buffer_head *bh, int val) -{ - bh->b_uptodate = val; -} - -void wait_on_buffer(struct buffer_head *bh) -{ - if (!bh->b_uptodate) - ll_rw_block(READ, 1, &bh); -} - - -static void e2fsck_clear_recover(e2fsck_t ctx, int error) -{ - ctx->fs->super->s_feature_incompat &= ~EXT3_FEATURE_INCOMPAT_RECOVER; - - /* if we had an error doing journal recovery, we need a full fsck */ - if (error) - ctx->fs->super->s_state &= ~EXT2_VALID_FS; - ext2fs_mark_super_dirty(ctx->fs); -} - -static errcode_t e2fsck_get_journal(e2fsck_t ctx, journal_t **ret_journal) -{ - struct ext2_super_block *sb = ctx->fs->super; - struct ext2_super_block jsuper; - struct problem_context pctx; - struct buffer_head *bh; - struct inode *j_inode = NULL; - struct kdev_s *dev_fs = NULL, *dev_journal; - const char *journal_name = 0; - journal_t *journal = NULL; - errcode_t retval = 0; - io_manager io_ptr = 0; - unsigned long start = 0; - blk_t blk; - int ext_journal = 0; - int tried_backup_jnl = 0; - int i; - - clear_problem_context(&pctx); - - journal = e2fsck_allocate_memory(ctx, sizeof(journal_t), "journal"); - if (!journal) { - return EXT2_ET_NO_MEMORY; - } - - dev_fs = e2fsck_allocate_memory(ctx, 2*sizeof(struct kdev_s), "kdev"); - if (!dev_fs) { - retval = EXT2_ET_NO_MEMORY; - goto errout; - } - dev_journal = dev_fs+1; - - dev_fs->k_ctx = dev_journal->k_ctx = ctx; - dev_fs->k_dev = K_DEV_FS; - dev_journal->k_dev = K_DEV_JOURNAL; - - journal->j_dev = dev_journal; - journal->j_fs_dev = dev_fs; - journal->j_inode = NULL; - journal->j_blocksize = ctx->fs->blocksize; - - if (uuid_is_null(sb->s_journal_uuid)) { - if (!sb->s_journal_inum) - return EXT2_ET_BAD_INODE_NUM; - j_inode = e2fsck_allocate_memory(ctx, sizeof(*j_inode), - "journal inode"); - if (!j_inode) { - retval = EXT2_ET_NO_MEMORY; - goto errout; - } - - j_inode->i_ctx = ctx; - j_inode->i_ino = sb->s_journal_inum; - - if ((retval = ext2fs_read_inode(ctx->fs, - sb->s_journal_inum, - &j_inode->i_ext2))) { - try_backup_journal: - if (sb->s_jnl_backup_type != EXT3_JNL_BACKUP_BLOCKS || - tried_backup_jnl) - goto errout; - memset(&j_inode->i_ext2, 0, sizeof(struct ext2_inode)); - memcpy(&j_inode->i_ext2.i_block[0], sb->s_jnl_blocks, - EXT2_N_BLOCKS*4); - j_inode->i_ext2.i_size = sb->s_jnl_blocks[16]; - j_inode->i_ext2.i_links_count = 1; - j_inode->i_ext2.i_mode = LINUX_S_IFREG | 0600; - tried_backup_jnl++; - } - if (!j_inode->i_ext2.i_links_count || - !LINUX_S_ISREG(j_inode->i_ext2.i_mode)) { - retval = EXT2_ET_NO_JOURNAL; - goto try_backup_journal; - } - if (j_inode->i_ext2.i_size / journal->j_blocksize < - JFS_MIN_JOURNAL_BLOCKS) { - retval = EXT2_ET_JOURNAL_TOO_SMALL; - goto try_backup_journal; - } - for (i=0; i < EXT2_N_BLOCKS; i++) { - blk = j_inode->i_ext2.i_block[i]; - if (!blk) { - if (i < EXT2_NDIR_BLOCKS) { - retval = EXT2_ET_JOURNAL_TOO_SMALL; - goto try_backup_journal; - } - continue; - } - if (blk < sb->s_first_data_block || - blk >= sb->s_blocks_count) { - retval = EXT2_ET_BAD_BLOCK_NUM; - goto try_backup_journal; - } - } - journal->j_maxlen = j_inode->i_ext2.i_size / journal->j_blocksize; - -#ifdef USE_INODE_IO - retval = ext2fs_inode_io_intern2(ctx->fs, sb->s_journal_inum, - &j_inode->i_ext2, - &journal_name); - if (retval) - goto errout; - - io_ptr = inode_io_manager; -#else - journal->j_inode = j_inode; - ctx->journal_io = ctx->fs->io; - if ((retval = journal_bmap(journal, 0, &start)) != 0) - goto errout; -#endif - } else { - ext_journal = 1; - if (!ctx->journal_name) { - char uuid[37]; - - uuid_unparse(sb->s_journal_uuid, uuid); - ctx->journal_name = blkid_get_devname(ctx->blkid, - "UUID", uuid); - if (!ctx->journal_name) - ctx->journal_name = blkid_devno_to_devname(sb->s_journal_dev); - } - journal_name = ctx->journal_name; - - if (!journal_name) { - fix_problem(ctx, PR_0_CANT_FIND_JOURNAL, &pctx); - return EXT2_ET_LOAD_EXT_JOURNAL; - } - - jfs_debug(1, "Using journal file %s\n", journal_name); - io_ptr = unix_io_manager; - } - -#if 0 - test_io_backing_manager = io_ptr; - io_ptr = test_io_manager; -#endif -#ifndef USE_INODE_IO - if (ext_journal) -#endif - retval = io_ptr->open(journal_name, IO_FLAG_RW, - &ctx->journal_io); - if (retval) - goto errout; - - io_channel_set_blksize(ctx->journal_io, ctx->fs->blocksize); - - if (ext_journal) { - if (ctx->fs->blocksize == 1024) - start = 1; - bh = getblk(dev_journal, start, ctx->fs->blocksize); - if (!bh) { - retval = EXT2_ET_NO_MEMORY; - goto errout; - } - ll_rw_block(READ, 1, &bh); - if ((retval = bh->b_err) != 0) - goto errout; - memcpy(&jsuper, start ? bh->b_data : bh->b_data + 1024, - sizeof(jsuper)); - brelse(bh); -#ifdef EXT2FS_ENABLE_SWAPFS - if (jsuper.s_magic == ext2fs_swab16(EXT2_SUPER_MAGIC)) - ext2fs_swap_super(&jsuper); -#endif - if (jsuper.s_magic != EXT2_SUPER_MAGIC || - !(jsuper.s_feature_incompat & EXT3_FEATURE_INCOMPAT_JOURNAL_DEV)) { - fix_problem(ctx, PR_0_EXT_JOURNAL_BAD_SUPER, &pctx); - retval = EXT2_ET_LOAD_EXT_JOURNAL; - goto errout; - } - /* Make sure the journal UUID is correct */ - if (memcmp(jsuper.s_uuid, ctx->fs->super->s_journal_uuid, - sizeof(jsuper.s_uuid))) { - fix_problem(ctx, PR_0_JOURNAL_BAD_UUID, &pctx); - retval = EXT2_ET_LOAD_EXT_JOURNAL; - goto errout; - } - - journal->j_maxlen = jsuper.s_blocks_count; - start++; - } - - if (!(bh = getblk(dev_journal, start, journal->j_blocksize))) { - retval = EXT2_ET_NO_MEMORY; - goto errout; - } - - journal->j_sb_buffer = bh; - journal->j_superblock = (journal_superblock_t *)bh->b_data; - -#ifdef USE_INODE_IO - if (j_inode) - ext2fs_free_mem(&j_inode); -#endif - - *ret_journal = journal; - return 0; - -errout: - if (dev_fs) - ext2fs_free_mem(&dev_fs); - if (j_inode) - ext2fs_free_mem(&j_inode); - if (journal) - ext2fs_free_mem(&journal); - return retval; - -} - -static errcode_t e2fsck_journal_fix_bad_inode(e2fsck_t ctx, - struct problem_context *pctx) -{ - struct ext2_super_block *sb = ctx->fs->super; - int recover = ctx->fs->super->s_feature_incompat & - EXT3_FEATURE_INCOMPAT_RECOVER; - int has_journal = ctx->fs->super->s_feature_compat & - EXT3_FEATURE_COMPAT_HAS_JOURNAL; - - if (has_journal || sb->s_journal_inum) { - /* The journal inode is bogus, remove and force full fsck */ - pctx->ino = sb->s_journal_inum; - if (fix_problem(ctx, PR_0_JOURNAL_BAD_INODE, pctx)) { - if (has_journal && sb->s_journal_inum) - printf("*** ext3 journal has been deleted - " - "filesystem is now ext2 only ***\n\n"); - sb->s_feature_compat &= ~EXT3_FEATURE_COMPAT_HAS_JOURNAL; - sb->s_journal_inum = 0; - ctx->flags |= E2F_FLAG_JOURNAL_INODE; /* FIXME: todo */ - e2fsck_clear_recover(ctx, 1); - return 0; - } - return EXT2_ET_BAD_INODE_NUM; - } else if (recover) { - if (fix_problem(ctx, PR_0_JOURNAL_RECOVER_SET, pctx)) { - e2fsck_clear_recover(ctx, 1); - return 0; - } - return EXT2_ET_UNSUPP_FEATURE; - } - return 0; -} - -#define V1_SB_SIZE 0x0024 -static void clear_v2_journal_fields(journal_t *journal) -{ - e2fsck_t ctx = journal->j_dev->k_ctx; - struct problem_context pctx; - - clear_problem_context(&pctx); - - if (!fix_problem(ctx, PR_0_CLEAR_V2_JOURNAL, &pctx)) - return; - - memset(((char *) journal->j_superblock) + V1_SB_SIZE, 0, - ctx->fs->blocksize-V1_SB_SIZE); - mark_buffer_dirty(journal->j_sb_buffer); -} - - -static errcode_t e2fsck_journal_load(journal_t *journal) -{ - e2fsck_t ctx = journal->j_dev->k_ctx; - journal_superblock_t *jsb; - struct buffer_head *jbh = journal->j_sb_buffer; - struct problem_context pctx; - - clear_problem_context(&pctx); - - ll_rw_block(READ, 1, &jbh); - if (jbh->b_err) { - com_err(ctx->device_name, jbh->b_err, - _("reading journal superblock\n")); - return jbh->b_err; - } - - jsb = journal->j_superblock; - /* If we don't even have JFS_MAGIC, we probably have a wrong inode */ - if (jsb->s_header.h_magic != htonl(JFS_MAGIC_NUMBER)) - return e2fsck_journal_fix_bad_inode(ctx, &pctx); - - switch (ntohl(jsb->s_header.h_blocktype)) { - case JFS_SUPERBLOCK_V1: - journal->j_format_version = 1; - if (jsb->s_feature_compat || - jsb->s_feature_incompat || - jsb->s_feature_ro_compat || - jsb->s_nr_users) - clear_v2_journal_fields(journal); - break; - - case JFS_SUPERBLOCK_V2: - journal->j_format_version = 2; - if (ntohl(jsb->s_nr_users) > 1 && - uuid_is_null(ctx->fs->super->s_journal_uuid)) - clear_v2_journal_fields(journal); - if (ntohl(jsb->s_nr_users) > 1) { - fix_problem(ctx, PR_0_JOURNAL_UNSUPP_MULTIFS, &pctx); - return EXT2_ET_JOURNAL_UNSUPP_VERSION; - } - break; - - /* - * These should never appear in a journal super block, so if - * they do, the journal is badly corrupted. - */ - case JFS_DESCRIPTOR_BLOCK: - case JFS_COMMIT_BLOCK: - case JFS_REVOKE_BLOCK: - return EXT2_ET_CORRUPT_SUPERBLOCK; - - /* If we don't understand the superblock major type, but there - * is a magic number, then it is likely to be a new format we - * just don't understand, so leave it alone. */ - default: - return EXT2_ET_JOURNAL_UNSUPP_VERSION; - } - - if (JFS_HAS_INCOMPAT_FEATURE(journal, ~JFS_KNOWN_INCOMPAT_FEATURES)) - return EXT2_ET_UNSUPP_FEATURE; - - if (JFS_HAS_RO_COMPAT_FEATURE(journal, ~JFS_KNOWN_ROCOMPAT_FEATURES)) - return EXT2_ET_RO_UNSUPP_FEATURE; - - /* We have now checked whether we know enough about the journal - * format to be able to proceed safely, so any other checks that - * fail we should attempt to recover from. */ - if (jsb->s_blocksize != htonl(journal->j_blocksize)) { - com_err(ctx->program_name, EXT2_ET_CORRUPT_SUPERBLOCK, - _("%s: no valid journal superblock found\n"), - ctx->device_name); - return EXT2_ET_CORRUPT_SUPERBLOCK; - } - - if (ntohl(jsb->s_maxlen) < journal->j_maxlen) - journal->j_maxlen = ntohl(jsb->s_maxlen); - else if (ntohl(jsb->s_maxlen) > journal->j_maxlen) { - com_err(ctx->program_name, EXT2_ET_CORRUPT_SUPERBLOCK, - _("%s: journal too short\n"), - ctx->device_name); - return EXT2_ET_CORRUPT_SUPERBLOCK; - } - - journal->j_tail_sequence = ntohl(jsb->s_sequence); - journal->j_transaction_sequence = journal->j_tail_sequence; - journal->j_tail = ntohl(jsb->s_start); - journal->j_first = ntohl(jsb->s_first); - journal->j_last = ntohl(jsb->s_maxlen); - - return 0; -} - -static void e2fsck_journal_reset_super(e2fsck_t ctx, journal_superblock_t *jsb, - journal_t *journal) -{ - char *p; - union { - uuid_t uuid; - __u32 val[4]; - } u; - __u32 new_seq = 0; - int i; - - /* Leave a valid existing V1 superblock signature alone. - * Anything unrecognisable we overwrite with a new V2 - * signature. */ - - if (jsb->s_header.h_magic != htonl(JFS_MAGIC_NUMBER) || - jsb->s_header.h_blocktype != htonl(JFS_SUPERBLOCK_V1)) { - jsb->s_header.h_magic = htonl(JFS_MAGIC_NUMBER); - jsb->s_header.h_blocktype = htonl(JFS_SUPERBLOCK_V2); - } - - /* Zero out everything else beyond the superblock header */ - - p = ((char *) jsb) + sizeof(journal_header_t); - memset (p, 0, ctx->fs->blocksize-sizeof(journal_header_t)); - - jsb->s_blocksize = htonl(ctx->fs->blocksize); - jsb->s_maxlen = htonl(journal->j_maxlen); - jsb->s_first = htonl(1); - - /* Initialize the journal sequence number so that there is "no" - * chance we will find old "valid" transactions in the journal. - * This avoids the need to zero the whole journal (slow to do, - * and risky when we are just recovering the filesystem). - */ - uuid_generate(u.uuid); - for (i = 0; i < 4; i ++) - new_seq ^= u.val[i]; - jsb->s_sequence = htonl(new_seq); - - mark_buffer_dirty(journal->j_sb_buffer); - ll_rw_block(WRITE, 1, &journal->j_sb_buffer); -} - -static errcode_t e2fsck_journal_fix_corrupt_super(e2fsck_t ctx, - journal_t *journal, - struct problem_context *pctx) -{ - struct ext2_super_block *sb = ctx->fs->super; - int recover = ctx->fs->super->s_feature_incompat & - EXT3_FEATURE_INCOMPAT_RECOVER; - - if (sb->s_feature_compat & EXT3_FEATURE_COMPAT_HAS_JOURNAL) { - if (fix_problem(ctx, PR_0_JOURNAL_BAD_SUPER, pctx)) { - e2fsck_journal_reset_super(ctx, journal->j_superblock, - journal); - journal->j_transaction_sequence = 1; - e2fsck_clear_recover(ctx, recover); - return 0; - } - return EXT2_ET_CORRUPT_SUPERBLOCK; - } else if (e2fsck_journal_fix_bad_inode(ctx, pctx)) - return EXT2_ET_CORRUPT_SUPERBLOCK; - - return 0; -} - -static void e2fsck_journal_release(e2fsck_t ctx, journal_t *journal, - int reset, int drop) -{ - journal_superblock_t *jsb; - - if (drop) - mark_buffer_clean(journal->j_sb_buffer); - else if (!(ctx->options & E2F_OPT_READONLY)) { - jsb = journal->j_superblock; - jsb->s_sequence = htonl(journal->j_transaction_sequence); - if (reset) - jsb->s_start = 0; /* this marks the journal as empty */ - mark_buffer_dirty(journal->j_sb_buffer); - } - brelse(journal->j_sb_buffer); - - if (ctx->journal_io) { - if (ctx->fs && ctx->fs->io != ctx->journal_io) - io_channel_close(ctx->journal_io); - ctx->journal_io = 0; - } - -#ifndef USE_INODE_IO - if (journal->j_inode) - ext2fs_free_mem(&journal->j_inode); -#endif - if (journal->j_fs_dev) - ext2fs_free_mem(&journal->j_fs_dev); - ext2fs_free_mem(&journal); -} - -/* - * This function makes sure that the superblock fields regarding the - * journal are consistent. - */ -int e2fsck_check_ext3_journal(e2fsck_t ctx) -{ - struct ext2_super_block *sb = ctx->fs->super; - journal_t *journal; - int recover = ctx->fs->super->s_feature_incompat & - EXT3_FEATURE_INCOMPAT_RECOVER; - struct problem_context pctx; - problem_t problem; - int reset = 0, force_fsck = 0; - int retval; - - /* If we don't have any journal features, don't do anything more */ - if (!(sb->s_feature_compat & EXT3_FEATURE_COMPAT_HAS_JOURNAL) && - !recover && sb->s_journal_inum == 0 && sb->s_journal_dev == 0 && - uuid_is_null(sb->s_journal_uuid)) - return 0; - - clear_problem_context(&pctx); - pctx.num = sb->s_journal_inum; - - retval = e2fsck_get_journal(ctx, &journal); - if (retval) { - if ((retval == EXT2_ET_BAD_INODE_NUM) || - (retval == EXT2_ET_BAD_BLOCK_NUM) || - (retval == EXT2_ET_JOURNAL_TOO_SMALL) || - (retval == EXT2_ET_NO_JOURNAL)) - return e2fsck_journal_fix_bad_inode(ctx, &pctx); - return retval; - } - - retval = e2fsck_journal_load(journal); - if (retval) { - if ((retval == EXT2_ET_CORRUPT_SUPERBLOCK) || - ((retval == EXT2_ET_UNSUPP_FEATURE) && - (!fix_problem(ctx, PR_0_JOURNAL_UNSUPP_INCOMPAT, - &pctx))) || - ((retval == EXT2_ET_RO_UNSUPP_FEATURE) && - (!fix_problem(ctx, PR_0_JOURNAL_UNSUPP_ROCOMPAT, - &pctx))) || - ((retval == EXT2_ET_JOURNAL_UNSUPP_VERSION) && - (!fix_problem(ctx, PR_0_JOURNAL_UNSUPP_VERSION, &pctx)))) - retval = e2fsck_journal_fix_corrupt_super(ctx, journal, - &pctx); - e2fsck_journal_release(ctx, journal, 0, 1); - return retval; - } - - /* - * We want to make the flags consistent here. We will not leave with - * needs_recovery set but has_journal clear. We can't get in a loop - * with -y, -n, or -p, only if a user isn't making up their mind. - */ -no_has_journal: - if (!(sb->s_feature_compat & EXT3_FEATURE_COMPAT_HAS_JOURNAL)) { - recover = sb->s_feature_incompat & EXT3_FEATURE_INCOMPAT_RECOVER; - pctx.str = "inode"; - if (fix_problem(ctx, PR_0_JOURNAL_HAS_JOURNAL, &pctx)) { - if (recover && - !fix_problem(ctx, PR_0_JOURNAL_RECOVER_SET, &pctx)) - goto no_has_journal; - /* - * Need a full fsck if we are releasing a - * journal stored on a reserved inode. - */ - force_fsck = recover || - (sb->s_journal_inum < EXT2_FIRST_INODE(sb)); - /* Clear all of the journal fields */ - sb->s_journal_inum = 0; - sb->s_journal_dev = 0; - memset(sb->s_journal_uuid, 0, - sizeof(sb->s_journal_uuid)); - e2fsck_clear_recover(ctx, force_fsck); - } else if (!(ctx->options & E2F_OPT_READONLY)) { - sb->s_feature_compat |= EXT3_FEATURE_COMPAT_HAS_JOURNAL; - ext2fs_mark_super_dirty(ctx->fs); - } - } - - if (sb->s_feature_compat & EXT3_FEATURE_COMPAT_HAS_JOURNAL && - !(sb->s_feature_incompat & EXT3_FEATURE_INCOMPAT_RECOVER) && - journal->j_superblock->s_start != 0) { - /* Print status information */ - fix_problem(ctx, PR_0_JOURNAL_RECOVERY_CLEAR, &pctx); - if (ctx->superblock) - problem = PR_0_JOURNAL_RUN_DEFAULT; - else - problem = PR_0_JOURNAL_RUN; - if (fix_problem(ctx, problem, &pctx)) { - ctx->options |= E2F_OPT_FORCE; - sb->s_feature_incompat |= - EXT3_FEATURE_INCOMPAT_RECOVER; - ext2fs_mark_super_dirty(ctx->fs); - } else if (fix_problem(ctx, - PR_0_JOURNAL_RESET_JOURNAL, &pctx)) { - reset = 1; - sb->s_state &= ~EXT2_VALID_FS; - ext2fs_mark_super_dirty(ctx->fs); - } - /* - * If the user answers no to the above question, we - * ignore the fact that journal apparently has data; - * accidentally replaying over valid data would be far - * worse than skipping a questionable recovery. - * - * XXX should we abort with a fatal error here? What - * will the ext3 kernel code do if a filesystem with - * !NEEDS_RECOVERY but with a non-zero - * journal->j_superblock->s_start is mounted? - */ - } - - e2fsck_journal_release(ctx, journal, reset, 0); - return retval; -} - -static errcode_t recover_ext3_journal(e2fsck_t ctx) -{ - journal_t *journal; - int retval; - - journal_init_revoke_caches(); - retval = e2fsck_get_journal(ctx, &journal); - if (retval) - return retval; - - retval = e2fsck_journal_load(journal); - if (retval) - goto errout; - - retval = journal_init_revoke(journal, 1024); - if (retval) - goto errout; - - retval = -journal_recover(journal); - if (retval) - goto errout; - - if (journal->j_superblock->s_errno) { - ctx->fs->super->s_state |= EXT2_ERROR_FS; - ext2fs_mark_super_dirty(ctx->fs); - journal->j_superblock->s_errno = 0; - mark_buffer_dirty(journal->j_sb_buffer); - } - -errout: - journal_destroy_revoke(journal); - journal_destroy_revoke_caches(); - e2fsck_journal_release(ctx, journal, 1, 0); - return retval; -} - -int e2fsck_run_ext3_journal(e2fsck_t ctx) -{ - io_manager io_ptr = ctx->fs->io->manager; - int blocksize = ctx->fs->blocksize; - errcode_t retval, recover_retval; - - printf(_("%s: recovering journal\n"), ctx->device_name); - if (ctx->options & E2F_OPT_READONLY) { - printf(_("%s: won't do journal recovery while read-only\n"), - ctx->device_name); - return EXT2_ET_FILE_RO; - } - - if (ctx->fs->flags & EXT2_FLAG_DIRTY) - ext2fs_flush(ctx->fs); /* Force out any modifications */ - - recover_retval = recover_ext3_journal(ctx); - - /* - * Reload the filesystem context to get up-to-date data from disk - * because journal recovery will change the filesystem under us. - */ - ext2fs_close(ctx->fs); - retval = ext2fs_open(ctx->filesystem_name, EXT2_FLAG_RW, - ctx->superblock, blocksize, io_ptr, - &ctx->fs); - - if (retval) { - com_err(ctx->program_name, retval, - _("while trying to re-open %s"), - ctx->device_name); - fatal_error(ctx, 0); - } - ctx->fs->priv_data = ctx; - - /* Set the superblock flags */ - e2fsck_clear_recover(ctx, recover_retval); - return recover_retval; -} - -/* - * This function will move the journal inode from a visible file in - * the filesystem directory hierarchy to the reserved inode if necessary. - */ -static const char * const journal_names[] = { - ".journal", "journal", ".journal.dat", "journal.dat", 0 }; - -void e2fsck_move_ext3_journal(e2fsck_t ctx) -{ - struct ext2_super_block *sb = ctx->fs->super; - struct problem_context pctx; - struct ext2_inode inode; - ext2_filsys fs = ctx->fs; - ext2_ino_t ino; - errcode_t retval; - const char * const * cpp; - int group, mount_flags; - - clear_problem_context(&pctx); - - /* - * If the filesystem is opened read-only, or there is no - * journal, then do nothing. - */ - if ((ctx->options & E2F_OPT_READONLY) || - (sb->s_journal_inum == 0) || - !(sb->s_feature_compat & EXT3_FEATURE_COMPAT_HAS_JOURNAL)) - return; - - /* - * Read in the journal inode - */ - if (ext2fs_read_inode(fs, sb->s_journal_inum, &inode) != 0) - return; - - /* - * If it's necessary to backup the journal inode, do so. - */ - if ((sb->s_jnl_backup_type == 0) || - ((sb->s_jnl_backup_type == EXT3_JNL_BACKUP_BLOCKS) && - memcmp(inode.i_block, sb->s_jnl_blocks, EXT2_N_BLOCKS*4))) { - if (fix_problem(ctx, PR_0_BACKUP_JNL, &pctx)) { - memcpy(sb->s_jnl_blocks, inode.i_block, - EXT2_N_BLOCKS*4); - sb->s_jnl_blocks[16] = inode.i_size; - sb->s_jnl_backup_type = EXT3_JNL_BACKUP_BLOCKS; - ext2fs_mark_super_dirty(fs); - fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY; - } - } - - /* - * If the journal is already the hidden inode, then do nothing - */ - if (sb->s_journal_inum == EXT2_JOURNAL_INO) - return; - - /* - * The journal inode had better have only one link and not be readable. - */ - if (inode.i_links_count != 1) - return; - - /* - * If the filesystem is mounted, or we can't tell whether - * or not it's mounted, do nothing. - */ - retval = ext2fs_check_if_mounted(ctx->filesystem_name, &mount_flags); - if (retval || (mount_flags & EXT2_MF_MOUNTED)) - return; - - /* - * If we can't find the name of the journal inode, then do - * nothing. - */ - for (cpp = journal_names; *cpp; cpp++) { - retval = ext2fs_lookup(fs, EXT2_ROOT_INO, *cpp, - strlen(*cpp), 0, &ino); - if ((retval == 0) && (ino == sb->s_journal_inum)) - break; - } - if (*cpp == 0) - return; - - /* We need the inode bitmap to be loaded */ - retval = ext2fs_read_bitmaps(fs); - if (retval) - return; - - pctx.str = *cpp; - if (!fix_problem(ctx, PR_0_MOVE_JOURNAL, &pctx)) - return; - - /* - * OK, we've done all the checks, let's actually move the - * journal inode. Errors at this point mean we need to force - * an ext2 filesystem check. - */ - if ((retval = ext2fs_unlink(fs, EXT2_ROOT_INO, *cpp, ino, 0)) != 0) - goto err_out; - if ((retval = ext2fs_write_inode(fs, EXT2_JOURNAL_INO, &inode)) != 0) - goto err_out; - sb->s_journal_inum = EXT2_JOURNAL_INO; - ext2fs_mark_super_dirty(fs); - fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY; - inode.i_links_count = 0; - inode.i_dtime = time(0); - if ((retval = ext2fs_write_inode(fs, ino, &inode)) != 0) - goto err_out; - - group = ext2fs_group_of_ino(fs, ino); - ext2fs_unmark_inode_bitmap(fs->inode_map, ino); - ext2fs_mark_ib_dirty(fs); - fs->group_desc[group].bg_free_inodes_count++; - fs->super->s_free_inodes_count++; - return; - -err_out: - pctx.errcode = retval; - fix_problem(ctx, PR_0_ERR_MOVE_JOURNAL, &pctx); - fs->super->s_state &= ~EXT2_VALID_FS; - ext2fs_mark_super_dirty(fs); - return; -} - diff --git a/e2fsprogs/e2fsck/message.c b/e2fsprogs/e2fsck/message.c deleted file mode 100644 index b09ae8976..000000000 --- a/e2fsprogs/e2fsck/message.c +++ /dev/null @@ -1,466 +0,0 @@ -/* - * message.c --- print e2fsck messages (with compression) - * - * Copyright 1996, 1997 by Theodore Ts'o - * - * %Begin-Header% - * This file may be redistributed under the terms of the GNU Public - * License. - * %End-Header% - * - * print_e2fsck_message() prints a message to the user, using - * compression techniques and expansions of abbreviations. - * - * The following % expansions are supported: - * - * %b block number - * %B integer - * %c block number - * %Di ->ino inode number - * %Dn ->name string - * %Dr ->rec_len - * %Dl ->name_len - * %Dt ->filetype - * %d inode number - * %g integer - * %i inode number - * %Is -> i_size - * %IS -> i_extra_isize - * %Ib -> i_blocks - * %Il -> i_links_count - * %Im -> i_mode - * %IM -> i_mtime - * %IF -> i_faddr - * %If -> i_file_acl - * %Id -> i_dir_acl - * %Iu -> i_uid - * %Ig -> i_gid - * %j inode number - * %m - * %N - * %p ext2fs_get_pathname of directory - * %P ext2fs_get_pathname of ->ino with as - * the containing directory. (If dirent is NULL - * then return the pathname of directory ) - * %q ext2fs_get_pathname of directory - * %Q ext2fs_get_pathname of directory with as - * the containing directory. - * %s miscellaneous string - * %S backup superblock - * %X hexadecimal format - * - * The following '@' expansions are supported: - * - * @a extended attribute - * @A error allocating - * @b block - * @B bitmap - * @c compress - * @C conflicts with some other fs block - * @D deleted - * @d directory - * @e entry - * @E Entry '%Dn' in %p (%i) - * @f filesystem - * @F for @i %i (%Q) is - * @g group - * @h HTREE directory inode - * @i inode - * @I illegal - * @j journal - * @l lost+found - * @L is a link - * @o orphaned - * @p problem in - * @r root inode - * @s should be - * @S superblock - * @u unattached - * @v device - * @z zero-length - */ - -#include -#include -#include -#include -#include - -#include "e2fsck.h" - -#include "problem.h" - -#ifdef __GNUC__ -#define _INLINE_ __inline__ -#else -#define _INLINE_ -#endif - -/* - * This structure defines the abbreviations used by the text strings - * below. The first character in the string is the index letter. An - * abbreviation of the form '@' is expanded by looking up the index - * letter in the table below. - */ -static const char *abbrevs[] = { - N_("aextended attribute"), - N_("Aerror allocating"), - N_("bblock"), - N_("Bbitmap"), - N_("ccompress"), - N_("Cconflicts with some other fs @b"), - N_("iinode"), - N_("Iillegal"), - N_("jjournal"), - N_("Ddeleted"), - N_("ddirectory"), - N_("eentry"), - N_("E@e '%Dn' in %p (%i)"), - N_("ffilesystem"), - N_("Ffor @i %i (%Q) is"), - N_("ggroup"), - N_("hHTREE @d @i"), - N_("llost+found"), - N_("Lis a link"), - N_("oorphaned"), - N_("pproblem in"), - N_("rroot @i"), - N_("sshould be"), - N_("Ssuper@b"), - N_("uunattached"), - N_("vdevice"), - N_("zzero-length"), - "@@", - 0 - }; - -/* - * Give more user friendly names to the "special" inodes. - */ -#define num_special_inodes 11 -static const char *special_inode_name[] = -{ - N_(""), /* 0 */ - N_(""), /* 1 */ - "/", /* 2 */ - N_(""), /* 3 */ - N_(""), /* 4 */ - N_(""), /* 5 */ - N_(""), /* 6 */ - N_(""), /* 7 */ - N_(""), /* 8 */ - N_(""), /* 9 */ - N_(""), /* 10 */ -}; - -/* - * This function does "safe" printing. It will convert non-printable - * ASCII characters using '^' and M- notation. - */ -static void safe_print(const char *cp, int len) -{ - unsigned char ch; - - if (len < 0) - len = strlen(cp); - - while (len--) { - ch = *cp++; - if (ch > 128) { - fputs("M-", stdout); - ch -= 128; - } - if ((ch < 32) || (ch == 0x7f)) { - fputc('^', stdout); - ch ^= 0x40; /* ^@, ^A, ^B; ^? for DEL */ - } - fputc(ch, stdout); - } -} - - -/* - * This function prints a pathname, using the ext2fs_get_pathname - * function - */ -static void print_pathname(ext2_filsys fs, ext2_ino_t dir, ext2_ino_t ino) -{ - errcode_t retval; - char *path; - - if (!dir && (ino < num_special_inodes)) { - fputs(_(special_inode_name[ino]), stdout); - return; - } - - retval = ext2fs_get_pathname(fs, dir, ino, &path); - if (retval) - fputs("???", stdout); - else { - safe_print(path, -1); - ext2fs_free_mem(&path); - } -} - -/* - * This function handles the '@' expansion. We allow recursive - * expansion; an @ expression can contain further '@' and '%' - * expressions. - */ -static _INLINE_ void expand_at_expression(e2fsck_t ctx, char ch, - struct problem_context *pctx, - int *first) -{ - const char **cpp, *str; - - /* Search for the abbreviation */ - for (cpp = abbrevs; *cpp; cpp++) { - if (ch == *cpp[0]) - break; - } - if (*cpp) { - str = _(*cpp) + 1; - if (*first && islower(*str)) { - *first = 0; - fputc(toupper(*str++), stdout); - } - print_e2fsck_message(ctx, str, pctx, *first); - } else - printf("@%c", ch); -} - -/* - * This function expands '%IX' expressions - */ -static _INLINE_ void expand_inode_expression(char ch, - struct problem_context *ctx) -{ - struct ext2_inode *inode; - struct ext2_inode_large *large_inode; - char * time_str; - time_t t; - int do_gmt = -1; - - if (!ctx || !ctx->inode) - goto no_inode; - - inode = ctx->inode; - large_inode = (struct ext2_inode_large *) inode; - - switch (ch) { - case 's': - if (LINUX_S_ISDIR(inode->i_mode)) - printf("%u", inode->i_size); - else { -#ifdef EXT2_NO_64_TYPE - if (inode->i_size_high) - printf("0x%x%08x", inode->i_size_high, - inode->i_size); - else - printf("%u", inode->i_size); -#else - printf("%llu", (inode->i_size | - ((__u64) inode->i_size_high << 32))); -#endif - } - break; - case 'S': - printf("%u", large_inode->i_extra_isize); - break; - case 'b': - printf("%u", inode->i_blocks); - break; - case 'l': - printf("%d", inode->i_links_count); - break; - case 'm': - printf("0%o", inode->i_mode); - break; - case 'M': - /* The diet libc doesn't respect the TZ environemnt variable */ - if (do_gmt == -1) { - time_str = getenv("TZ"); - if (!time_str) - time_str = ""; - do_gmt = !strcmp(time_str, "GMT"); - } - t = inode->i_mtime; - time_str = asctime(do_gmt ? gmtime(&t) : localtime(&t)); - printf("%.24s", time_str); - break; - case 'F': - printf("%u", inode->i_faddr); - break; - case 'f': - printf("%u", inode->i_file_acl); - break; - case 'd': - printf("%u", (LINUX_S_ISDIR(inode->i_mode) ? - inode->i_dir_acl : 0)); - break; - case 'u': - printf("%d", (inode->i_uid | - (inode->osd2.linux2.l_i_uid_high << 16))); - break; - case 'g': - printf("%d", (inode->i_gid | - (inode->osd2.linux2.l_i_gid_high << 16))); - break; - default: - no_inode: - printf("%%I%c", ch); - break; - } -} - -/* - * This function expands '%dX' expressions - */ -static _INLINE_ void expand_dirent_expression(char ch, - struct problem_context *ctx) -{ - struct ext2_dir_entry *dirent; - int len; - - if (!ctx || !ctx->dirent) - goto no_dirent; - - dirent = ctx->dirent; - - switch (ch) { - case 'i': - printf("%u", dirent->inode); - break; - case 'n': - len = dirent->name_len & 0xFF; - if (len > EXT2_NAME_LEN) - len = EXT2_NAME_LEN; - if (len > dirent->rec_len) - len = dirent->rec_len; - safe_print(dirent->name, len); - break; - case 'r': - printf("%u", dirent->rec_len); - break; - case 'l': - printf("%u", dirent->name_len & 0xFF); - break; - case 't': - printf("%u", dirent->name_len >> 8); - break; - default: - no_dirent: - printf("%%D%c", ch); - break; - } -} - -static _INLINE_ void expand_percent_expression(ext2_filsys fs, char ch, - struct problem_context *ctx) -{ - if (!ctx) - goto no_context; - - switch (ch) { - case '%': - fputc('%', stdout); - break; - case 'b': - printf("%u", ctx->blk); - break; - case 'B': -#ifdef EXT2_NO_64_TYPE - printf("%d", ctx->blkcount); -#else - printf("%lld", ctx->blkcount); -#endif - break; - case 'c': - printf("%u", ctx->blk2); - break; - case 'd': - printf("%u", ctx->dir); - break; - case 'g': - printf("%d", ctx->group); - break; - case 'i': - printf("%u", ctx->ino); - break; - case 'j': - printf("%u", ctx->ino2); - break; - case 'm': - printf("%s", error_message(ctx->errcode)); - break; - case 'N': -#ifdef EXT2_NO_64_TYPE - printf("%u", ctx->num); -#else - printf("%llu", ctx->num); -#endif - break; - case 'p': - print_pathname(fs, ctx->ino, 0); - break; - case 'P': - print_pathname(fs, ctx->ino2, - ctx->dirent ? ctx->dirent->inode : 0); - break; - case 'q': - print_pathname(fs, ctx->dir, 0); - break; - case 'Q': - print_pathname(fs, ctx->dir, ctx->ino); - break; - case 'S': - printf("%d", get_backup_sb(NULL, fs, NULL, NULL)); - break; - case 's': - printf("%s", ctx->str ? ctx->str : "NULL"); - break; - case 'X': -#ifdef EXT2_NO_64_TYPE - printf("0x%x", ctx->num); -#else - printf("0x%llx", ctx->num); -#endif - break; - default: - no_context: - printf("%%%c", ch); - break; - } -} - -void print_e2fsck_message(e2fsck_t ctx, const char *msg, - struct problem_context *pctx, int first) -{ - ext2_filsys fs = ctx->fs; - const char * cp; - int i; - - e2fsck_clear_progbar(ctx); - for (cp = msg; *cp; cp++) { - if (cp[0] == '@') { - cp++; - expand_at_expression(ctx, *cp, pctx, &first); - } else if (cp[0] == '%' && cp[1] == 'I') { - cp += 2; - expand_inode_expression(*cp, pctx); - } else if (cp[0] == '%' && cp[1] == 'D') { - cp += 2; - expand_dirent_expression(*cp, pctx); - } else if ((cp[0] == '%')) { - cp++; - expand_percent_expression(fs, *cp, pctx); - } else { - for (i=0; cp[i]; i++) - if ((cp[i] == '@') || cp[i] == '%') - break; - printf("%.*s", i, cp); - cp += i-1; - } - first = 0; - } -} diff --git a/e2fsprogs/e2fsck/pass1.c b/e2fsprogs/e2fsck/pass1.c deleted file mode 100644 index 8d01cae2b..000000000 --- a/e2fsprogs/e2fsck/pass1.c +++ /dev/null @@ -1,2122 +0,0 @@ -/* - * pass1.c -- pass #1 of e2fsck: sequential scan of the inode table - * - * Copyright (C) 1993, 1994, 1995, 1996, 1997 Theodore Ts'o. - * - * %Begin-Header% - * This file may be redistributed under the terms of the GNU Public - * License. - * %End-Header% - * - * Pass 1 of e2fsck iterates over all the inodes in the filesystems, - * and applies the following tests to each inode: - * - * - The mode field of the inode must be legal. - * - The size and block count fields of the inode are correct. - * - A data block must not be used by another inode - * - * Pass 1 also gathers the collects the following information: - * - * - A bitmap of which inodes are in use. (inode_used_map) - * - A bitmap of which inodes are directories. (inode_dir_map) - * - A bitmap of which inodes are regular files. (inode_reg_map) - * - A bitmap of which inodes have bad fields. (inode_bad_map) - * - A bitmap of which inodes are in bad blocks. (inode_bb_map) - * - A bitmap of which inodes are imagic inodes. (inode_imagic_map) - * - A bitmap of which blocks are in use. (block_found_map) - * - A bitmap of which blocks are in use by two inodes (block_dup_map) - * - The data blocks of the directory inodes. (dir_map) - * - * Pass 1 is designed to stash away enough information so that the - * other passes should not need to read in the inode information - * during the normal course of a filesystem check. (Althogh if an - * inconsistency is detected, other passes may need to read in an - * inode to fix it.) - * - * Note that pass 1B will be invoked if there are any duplicate blocks - * found. - */ - -#define _GNU_SOURCE 1 /* get strnlen() */ -#include -#include -#ifdef HAVE_ERRNO_H -#include -#endif - -#include "e2fsck.h" -#include - -#include "problem.h" - -#ifdef NO_INLINE_FUNCS -#define _INLINE_ -#else -#define _INLINE_ inline -#endif - -static int process_block(ext2_filsys fs, blk_t *blocknr, - e2_blkcnt_t blockcnt, blk_t ref_blk, - int ref_offset, void *priv_data); -static int process_bad_block(ext2_filsys fs, blk_t *block_nr, - e2_blkcnt_t blockcnt, blk_t ref_blk, - int ref_offset, void *priv_data); -static void check_blocks(e2fsck_t ctx, struct problem_context *pctx, - char *block_buf); -static void mark_table_blocks(e2fsck_t ctx); -static void alloc_bb_map(e2fsck_t ctx); -static void alloc_imagic_map(e2fsck_t ctx); -static void mark_inode_bad(e2fsck_t ctx, ino_t ino); -static void handle_fs_bad_blocks(e2fsck_t ctx); -static void process_inodes(e2fsck_t ctx, char *block_buf); -static EXT2_QSORT_TYPE process_inode_cmp(const void *a, const void *b); -static errcode_t scan_callback(ext2_filsys fs, ext2_inode_scan scan, - dgrp_t group, void * priv_data); -static void adjust_extattr_refcount(e2fsck_t ctx, ext2_refcount_t refcount, - char *block_buf, int adjust_sign); -/* static char *describe_illegal_block(ext2_filsys fs, blk_t block); */ - -extern void e2fsck_write_inode_full(e2fsck_t ctx, unsigned long ino, - struct ext2_inode * inode, int bufsize, - const char *proc); - -struct process_block_struct { - ext2_ino_t ino; - unsigned is_dir:1, is_reg:1, clear:1, suppress:1, - fragmented:1, compressed:1, bbcheck:1; - blk_t num_blocks; - blk_t max_blocks; - e2_blkcnt_t last_block; - int num_illegal_blocks; - blk_t previous_block; - struct ext2_inode *inode; - struct problem_context *pctx; - ext2fs_block_bitmap fs_meta_blocks; - e2fsck_t ctx; -}; - -struct process_inode_block { - ext2_ino_t ino; - struct ext2_inode inode; -}; - -struct scan_callback_struct { - e2fsck_t ctx; - char *block_buf; -}; - -/* - * For the inodes to process list. - */ -static struct process_inode_block *inodes_to_process; -static int process_inode_count; - -static __u64 ext2_max_sizes[EXT2_MAX_BLOCK_LOG_SIZE - - EXT2_MIN_BLOCK_LOG_SIZE + 1]; - -/* - * Free all memory allocated by pass1 in preparation for restarting - * things. - */ -static void unwind_pass1(ext2_filsys fs EXT2FS_ATTR((unused))) -{ - ext2fs_free_mem(&inodes_to_process); - inodes_to_process = 0; -} - -/* - * Check to make sure a device inode is real. Returns 1 if the device - * checks out, 0 if not. - * - * Note: this routine is now also used to check FIFO's and Sockets, - * since they have the same requirement; the i_block fields should be - * zero. - */ -int e2fsck_pass1_check_device_inode(ext2_filsys fs, struct ext2_inode *inode) -{ - int i; - - /* - * If i_blocks is non-zero, or the index flag is set, then - * this is a bogus device/fifo/socket - */ - if ((ext2fs_inode_data_blocks(fs, inode) != 0) || - (inode->i_flags & EXT2_INDEX_FL)) - return 0; - - /* - * We should be able to do the test below all the time, but - * because the kernel doesn't forcibly clear the device - * inode's additional i_block fields, there are some rare - * occasions when a legitimate device inode will have non-zero - * additional i_block fields. So for now, we only complain - * when the immutable flag is set, which should never happen - * for devices. (And that's when the problem is caused, since - * you can't set or clear immutable flags for devices.) Once - * the kernel has been fixed we can change this... - */ - if (inode->i_flags & (EXT2_IMMUTABLE_FL | EXT2_APPEND_FL)) { - for (i=4; i < EXT2_N_BLOCKS; i++) - if (inode->i_block[i]) - return 0; - } - return 1; -} - -/* - * Check to make sure a symlink inode is real. Returns 1 if the symlink - * checks out, 0 if not. - */ -int e2fsck_pass1_check_symlink(ext2_filsys fs, struct ext2_inode *inode, - char *buf) -{ - unsigned int len; - int i; - blk_t blocks; - - if ((inode->i_size_high || inode->i_size == 0) || - (inode->i_flags & EXT2_INDEX_FL)) - return 0; - - blocks = ext2fs_inode_data_blocks(fs, inode); - if (blocks) { - if ((inode->i_size >= fs->blocksize) || - (blocks != fs->blocksize >> 9) || - (inode->i_block[0] < fs->super->s_first_data_block) || - (inode->i_block[0] >= fs->super->s_blocks_count)) - return 0; - - for (i = 1; i < EXT2_N_BLOCKS; i++) - if (inode->i_block[i]) - return 0; - - if (io_channel_read_blk(fs->io, inode->i_block[0], 1, buf)) - return 0; - - len = strnlen(buf, fs->blocksize); - if (len == fs->blocksize) - return 0; - } else { - if (inode->i_size >= sizeof(inode->i_block)) - return 0; - - len = strnlen((char *)inode->i_block, sizeof(inode->i_block)); - if (len == sizeof(inode->i_block)) - return 0; - } - if (len != inode->i_size) - return 0; - return 1; -} - -/* - * If the immutable (or append-only) flag is set on the inode, offer - * to clear it. - */ -#define BAD_SPECIAL_FLAGS (EXT2_IMMUTABLE_FL | EXT2_APPEND_FL) -static void check_immutable(e2fsck_t ctx, struct problem_context *pctx) -{ - if (!(pctx->inode->i_flags & BAD_SPECIAL_FLAGS)) - return; - - if (!fix_problem(ctx, PR_1_SET_IMMUTABLE, pctx)) - return; - - pctx->inode->i_flags &= ~BAD_SPECIAL_FLAGS; - e2fsck_write_inode(ctx, pctx->ino, pctx->inode, "pass1"); -} - -/* - * If device, fifo or socket, check size is zero -- if not offer to - * clear it - */ -static void check_size(e2fsck_t ctx, struct problem_context *pctx) -{ - struct ext2_inode *inode = pctx->inode; - - if ((inode->i_size == 0) && (inode->i_size_high == 0)) - return; - - if (!fix_problem(ctx, PR_1_SET_NONZSIZE, pctx)) - return; - - inode->i_size = 0; - inode->i_size_high = 0; - e2fsck_write_inode(ctx, pctx->ino, pctx->inode, "pass1"); -} - -static void check_ea_in_inode(e2fsck_t ctx, struct problem_context *pctx) -{ - struct ext2_super_block *sb = ctx->fs->super; - struct ext2_inode_large *inode; - struct ext2_ext_attr_entry *entry; - char *start, *end; - int storage_size, remain, offs; - int problem = 0; - - inode = (struct ext2_inode_large *) pctx->inode; - storage_size = EXT2_INODE_SIZE(ctx->fs->super) - EXT2_GOOD_OLD_INODE_SIZE - - inode->i_extra_isize; - start = ((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE + - inode->i_extra_isize + sizeof(__u32); - end = (char *) inode + EXT2_INODE_SIZE(ctx->fs->super); - entry = (struct ext2_ext_attr_entry *) start; - - /* scan all entry's headers first */ - - /* take finish entry 0UL into account */ - remain = storage_size - sizeof(__u32); - offs = end - start; - - while (!EXT2_EXT_IS_LAST_ENTRY(entry)) { - - /* header eats this space */ - remain -= sizeof(struct ext2_ext_attr_entry); - - /* is attribute name valid? */ - if (EXT2_EXT_ATTR_SIZE(entry->e_name_len) > remain) { - pctx->num = entry->e_name_len; - problem = PR_1_ATTR_NAME_LEN; - goto fix; - } - - /* attribute len eats this space */ - remain -= EXT2_EXT_ATTR_SIZE(entry->e_name_len); - - /* check value size */ - if (entry->e_value_size == 0 || entry->e_value_size > remain) { - pctx->num = entry->e_value_size; - problem = PR_1_ATTR_VALUE_SIZE; - goto fix; - } - - /* check value placement */ - if (entry->e_value_offs + - EXT2_XATTR_SIZE(entry->e_value_size) != offs) { - printf("(entry->e_value_offs + entry->e_value_size: %d, offs: %d)\n", entry->e_value_offs + entry->e_value_size, offs); - pctx->num = entry->e_value_offs; - problem = PR_1_ATTR_VALUE_OFFSET; - goto fix; - } - - /* e_value_block must be 0 in inode's ea */ - if (entry->e_value_block != 0) { - pctx->num = entry->e_value_block; - problem = PR_1_ATTR_VALUE_BLOCK; - goto fix; - } - - /* e_hash must be 0 in inode's ea */ - if (entry->e_hash != 0) { - pctx->num = entry->e_hash; - problem = PR_1_ATTR_HASH; - goto fix; - } - - remain -= entry->e_value_size; - offs -= EXT2_XATTR_SIZE(entry->e_value_size); - - entry = EXT2_EXT_ATTR_NEXT(entry); - } -fix: - /* - * it seems like a corruption. it's very unlikely we could repair - * EA(s) in automatic fashion -bzzz - */ -#if 0 - problem = PR_1_ATTR_HASH; -#endif - if (problem == 0 || !fix_problem(ctx, problem, pctx)) - return; - - /* simple remove all possible EA(s) */ - *((__u32 *)start) = 0UL; - e2fsck_write_inode_full(ctx, pctx->ino, (struct ext2_inode *)inode, - EXT2_INODE_SIZE(sb), "pass1"); -} - -static void check_inode_extra_space(e2fsck_t ctx, struct problem_context *pctx) -{ - struct ext2_super_block *sb = ctx->fs->super; - struct ext2_inode_large *inode; - __u32 *eamagic; - int min, max; - - inode = (struct ext2_inode_large *) pctx->inode; - if (EXT2_INODE_SIZE(sb) == EXT2_GOOD_OLD_INODE_SIZE) { - /* this isn't large inode. so, nothing to check */ - return; - } - -#if 0 - printf("inode #%u, i_extra_size %d\n", pctx->ino, - inode->i_extra_isize); -#endif - /* i_extra_isize must cover i_extra_isize + i_pad1 at least */ - min = sizeof(inode->i_extra_isize) + sizeof(inode->i_pad1); - max = EXT2_INODE_SIZE(sb) - EXT2_GOOD_OLD_INODE_SIZE; - /* - * For now we will allow i_extra_isize to be 0, but really - * implementations should never allow i_extra_isize to be 0 - */ - if (inode->i_extra_isize && - (inode->i_extra_isize < min || inode->i_extra_isize > max)) { - if (!fix_problem(ctx, PR_1_EXTRA_ISIZE, pctx)) - return; - inode->i_extra_isize = min; - e2fsck_write_inode_full(ctx, pctx->ino, pctx->inode, - EXT2_INODE_SIZE(sb), "pass1"); - return; - } - - eamagic = (__u32 *) (((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE + - inode->i_extra_isize); - if (*eamagic == EXT2_EXT_ATTR_MAGIC) { - /* it seems inode has an extended attribute(s) in body */ - check_ea_in_inode(ctx, pctx); - } -} - -void e2fsck_pass1(e2fsck_t ctx) -{ - int i; - __u64 max_sizes; - ext2_filsys fs = ctx->fs; - ext2_ino_t ino; - struct ext2_inode *inode; - ext2_inode_scan scan; - char *block_buf; -#ifdef RESOURCE_TRACK - struct resource_track rtrack; -#endif - unsigned char frag, fsize; - struct problem_context pctx; - struct scan_callback_struct scan_struct; - struct ext2_super_block *sb = ctx->fs->super; - int imagic_fs; - int busted_fs_time = 0; - int inode_size; - -#ifdef RESOURCE_TRACK - init_resource_track(&rtrack); -#endif - clear_problem_context(&pctx); - - if (!(ctx->options & E2F_OPT_PREEN)) - fix_problem(ctx, PR_1_PASS_HEADER, &pctx); - - if ((fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_DIR_INDEX) && - !(ctx->options & E2F_OPT_NO)) { - if (ext2fs_u32_list_create(&ctx->dirs_to_hash, 50)) - ctx->dirs_to_hash = 0; - } - -#ifdef MTRACE - mtrace_print("Pass 1"); -#endif - -#define EXT2_BPP(bits) (1ULL << ((bits) - 2)) - - for (i = EXT2_MIN_BLOCK_LOG_SIZE; i <= EXT2_MAX_BLOCK_LOG_SIZE; i++) { - max_sizes = EXT2_NDIR_BLOCKS + EXT2_BPP(i); - max_sizes = max_sizes + EXT2_BPP(i) * EXT2_BPP(i); - max_sizes = max_sizes + EXT2_BPP(i) * EXT2_BPP(i) * EXT2_BPP(i); - max_sizes = (max_sizes * (1UL << i)) - 1; - ext2_max_sizes[i - EXT2_MIN_BLOCK_LOG_SIZE] = max_sizes; - } -#undef EXT2_BPP - - imagic_fs = (sb->s_feature_compat & EXT2_FEATURE_COMPAT_IMAGIC_INODES); - - /* - * Allocate bitmaps structures - */ - pctx.errcode = ext2fs_allocate_inode_bitmap(fs, _("in-use inode map"), - &ctx->inode_used_map); - if (pctx.errcode) { - pctx.num = 1; - fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - pctx.errcode = ext2fs_allocate_inode_bitmap(fs, - _("directory inode map"), &ctx->inode_dir_map); - if (pctx.errcode) { - pctx.num = 2; - fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - pctx.errcode = ext2fs_allocate_inode_bitmap(fs, - _("regular file inode map"), &ctx->inode_reg_map); - if (pctx.errcode) { - pctx.num = 6; - fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - pctx.errcode = ext2fs_allocate_block_bitmap(fs, _("in-use block map"), - &ctx->block_found_map); - if (pctx.errcode) { - pctx.num = 1; - fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, &pctx); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - pctx.errcode = ext2fs_create_icount2(fs, 0, 0, 0, - &ctx->inode_link_info); - if (pctx.errcode) { - fix_problem(ctx, PR_1_ALLOCATE_ICOUNT, &pctx); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - inode_size = EXT2_INODE_SIZE(fs->super); - inode = (struct ext2_inode *) - e2fsck_allocate_memory(ctx, inode_size, "scratch inode"); - - inodes_to_process = (struct process_inode_block *) - e2fsck_allocate_memory(ctx, - (ctx->process_inode_size * - sizeof(struct process_inode_block)), - "array of inodes to process"); - process_inode_count = 0; - - pctx.errcode = ext2fs_init_dblist(fs, 0); - if (pctx.errcode) { - fix_problem(ctx, PR_1_ALLOCATE_DBCOUNT, &pctx); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - - /* - * If the last orphan field is set, clear it, since the pass1 - * processing will automatically find and clear the orphans. - * In the future, we may want to try using the last_orphan - * linked list ourselves, but for now, we clear it so that the - * ext3 mount code won't get confused. - */ - if (!(ctx->options & E2F_OPT_READONLY)) { - if (fs->super->s_last_orphan) { - fs->super->s_last_orphan = 0; - ext2fs_mark_super_dirty(fs); - } - } - - mark_table_blocks(ctx); - block_buf = (char *) e2fsck_allocate_memory(ctx, fs->blocksize * 3, - "block interate buffer"); - e2fsck_use_inode_shortcuts(ctx, 1); - ehandler_operation(_("doing inode scan")); - pctx.errcode = ext2fs_open_inode_scan(fs, ctx->inode_buffer_blocks, - &scan); - if (pctx.errcode) { - fix_problem(ctx, PR_1_ISCAN_ERROR, &pctx); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - ext2fs_inode_scan_flags(scan, EXT2_SF_SKIP_MISSING_ITABLE, 0); - ctx->stashed_inode = inode; - scan_struct.ctx = ctx; - scan_struct.block_buf = block_buf; - ext2fs_set_inode_callback(scan, scan_callback, &scan_struct); - if (ctx->progress) - if ((ctx->progress)(ctx, 1, 0, ctx->fs->group_desc_count)) - return; - if (fs->super->s_wtime < fs->super->s_inodes_count) - busted_fs_time = 1; - - while (1) { - pctx.errcode = ext2fs_get_next_inode_full(scan, &ino, - inode, inode_size); - if (ctx->flags & E2F_FLAG_SIGNAL_MASK) - return; - if (pctx.errcode == EXT2_ET_BAD_BLOCK_IN_INODE_TABLE) { - if (!ctx->inode_bb_map) - alloc_bb_map(ctx); - ext2fs_mark_inode_bitmap(ctx->inode_bb_map, ino); - ext2fs_mark_inode_bitmap(ctx->inode_used_map, ino); - continue; - } - if (pctx.errcode) { - fix_problem(ctx, PR_1_ISCAN_ERROR, &pctx); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - if (!ino) - break; - pctx.ino = ino; - pctx.inode = inode; - ctx->stashed_ino = ino; - if (inode->i_links_count) { - pctx.errcode = ext2fs_icount_store(ctx->inode_link_info, - ino, inode->i_links_count); - if (pctx.errcode) { - pctx.num = inode->i_links_count; - fix_problem(ctx, PR_1_ICOUNT_STORE, &pctx); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - } - if (ino == EXT2_BAD_INO) { - struct process_block_struct pb; - - pctx.errcode = ext2fs_copy_bitmap(ctx->block_found_map, - &pb.fs_meta_blocks); - if (pctx.errcode) { - pctx.num = 4; - fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, &pctx); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - pb.ino = EXT2_BAD_INO; - pb.num_blocks = pb.last_block = 0; - pb.num_illegal_blocks = 0; - pb.suppress = 0; pb.clear = 0; pb.is_dir = 0; - pb.is_reg = 0; pb.fragmented = 0; pb.bbcheck = 0; - pb.inode = inode; - pb.pctx = &pctx; - pb.ctx = ctx; - pctx.errcode = ext2fs_block_iterate2(fs, ino, 0, - block_buf, process_bad_block, &pb); - ext2fs_free_block_bitmap(pb.fs_meta_blocks); - if (pctx.errcode) { - fix_problem(ctx, PR_1_BLOCK_ITERATE, &pctx); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - if (pb.bbcheck) - if (!fix_problem(ctx, PR_1_BBINODE_BAD_METABLOCK_PROMPT, &pctx)) { - ctx->flags |= E2F_FLAG_ABORT; - return; - } - ext2fs_mark_inode_bitmap(ctx->inode_used_map, ino); - clear_problem_context(&pctx); - continue; - } else if (ino == EXT2_ROOT_INO) { - /* - * Make sure the root inode is a directory; if - * not, offer to clear it. It will be - * regnerated in pass #3. - */ - if (!LINUX_S_ISDIR(inode->i_mode)) { - if (fix_problem(ctx, PR_1_ROOT_NO_DIR, &pctx)) { - inode->i_dtime = time(0); - inode->i_links_count = 0; - ext2fs_icount_store(ctx->inode_link_info, - ino, 0); - e2fsck_write_inode(ctx, ino, inode, - "pass1"); - } - - } - /* - * If dtime is set, offer to clear it. mke2fs - * version 0.2b created filesystems with the - * dtime field set for the root and lost+found - * directories. We won't worry about - * /lost+found, since that can be regenerated - * easily. But we will fix the root directory - * as a special case. - */ - if (inode->i_dtime && inode->i_links_count) { - if (fix_problem(ctx, PR_1_ROOT_DTIME, &pctx)) { - inode->i_dtime = 0; - e2fsck_write_inode(ctx, ino, inode, - "pass1"); - } - } - } else if (ino == EXT2_JOURNAL_INO) { - ext2fs_mark_inode_bitmap(ctx->inode_used_map, ino); - if (fs->super->s_journal_inum == EXT2_JOURNAL_INO) { - if (!LINUX_S_ISREG(inode->i_mode) && - fix_problem(ctx, PR_1_JOURNAL_BAD_MODE, - &pctx)) { - inode->i_mode = LINUX_S_IFREG; - e2fsck_write_inode(ctx, ino, inode, - "pass1"); - } - check_blocks(ctx, &pctx, block_buf); - continue; - } - if ((inode->i_links_count || inode->i_blocks || - inode->i_blocks || inode->i_block[0]) && - fix_problem(ctx, PR_1_JOURNAL_INODE_NOT_CLEAR, - &pctx)) { - memset(inode, 0, inode_size); - ext2fs_icount_store(ctx->inode_link_info, - ino, 0); - e2fsck_write_inode_full(ctx, ino, inode, - inode_size, "pass1"); - } - } else if (ino < EXT2_FIRST_INODE(fs->super)) { - int problem = 0; - - ext2fs_mark_inode_bitmap(ctx->inode_used_map, ino); - if (ino == EXT2_BOOT_LOADER_INO) { - if (LINUX_S_ISDIR(inode->i_mode)) - problem = PR_1_RESERVED_BAD_MODE; - } else if (ino == EXT2_RESIZE_INO) { - if (inode->i_mode && - !LINUX_S_ISREG(inode->i_mode)) - problem = PR_1_RESERVED_BAD_MODE; - } else { - if (inode->i_mode != 0) - problem = PR_1_RESERVED_BAD_MODE; - } - if (problem) { - if (fix_problem(ctx, problem, &pctx)) { - inode->i_mode = 0; - e2fsck_write_inode(ctx, ino, inode, - "pass1"); - } - } - check_blocks(ctx, &pctx, block_buf); - continue; - } - /* - * Check for inodes who might have been part of the - * orphaned list linked list. They should have gotten - * dealt with by now, unless the list had somehow been - * corrupted. - * - * FIXME: In the future, inodes which are still in use - * (and which are therefore) pending truncation should - * be handled specially. Right now we just clear the - * dtime field, and the normal e2fsck handling of - * inodes where i_size and the inode blocks are - * inconsistent is to fix i_size, instead of releasing - * the extra blocks. This won't catch the inodes that - * was at the end of the orphan list, but it's better - * than nothing. The right answer is that there - * shouldn't be any bugs in the orphan list handling. :-) - */ - if (inode->i_dtime && !busted_fs_time && - inode->i_dtime < ctx->fs->super->s_inodes_count) { - if (fix_problem(ctx, PR_1_LOW_DTIME, &pctx)) { - inode->i_dtime = inode->i_links_count ? - 0 : time(0); - e2fsck_write_inode(ctx, ino, inode, - "pass1"); - } - } - - /* - * This code assumes that deleted inodes have - * i_links_count set to 0. - */ - if (!inode->i_links_count) { - if (!inode->i_dtime && inode->i_mode) { - if (fix_problem(ctx, - PR_1_ZERO_DTIME, &pctx)) { - inode->i_dtime = time(0); - e2fsck_write_inode(ctx, ino, inode, - "pass1"); - } - } - continue; - } - /* - * n.b. 0.3c ext2fs code didn't clear i_links_count for - * deleted files. Oops. - * - * Since all new ext2 implementations get this right, - * we now assume that the case of non-zero - * i_links_count and non-zero dtime means that we - * should keep the file, not delete it. - * - */ - if (inode->i_dtime) { - if (fix_problem(ctx, PR_1_SET_DTIME, &pctx)) { - inode->i_dtime = 0; - e2fsck_write_inode(ctx, ino, inode, "pass1"); - } - } - - ext2fs_mark_inode_bitmap(ctx->inode_used_map, ino); - switch (fs->super->s_creator_os) { - case EXT2_OS_LINUX: - frag = inode->osd2.linux2.l_i_frag; - fsize = inode->osd2.linux2.l_i_fsize; - break; - case EXT2_OS_HURD: - frag = inode->osd2.hurd2.h_i_frag; - fsize = inode->osd2.hurd2.h_i_fsize; - break; - case EXT2_OS_MASIX: - frag = inode->osd2.masix2.m_i_frag; - fsize = inode->osd2.masix2.m_i_fsize; - break; - default: - frag = fsize = 0; - } - - if (inode->i_faddr || frag || fsize || - (LINUX_S_ISDIR(inode->i_mode) && inode->i_dir_acl)) - mark_inode_bad(ctx, ino); - if (inode->i_flags & EXT2_IMAGIC_FL) { - if (imagic_fs) { - if (!ctx->inode_imagic_map) - alloc_imagic_map(ctx); - ext2fs_mark_inode_bitmap(ctx->inode_imagic_map, - ino); - } else { - if (fix_problem(ctx, PR_1_SET_IMAGIC, &pctx)) { - inode->i_flags &= ~EXT2_IMAGIC_FL; - e2fsck_write_inode(ctx, ino, - inode, "pass1"); - } - } - } - - check_inode_extra_space(ctx, &pctx); - - if (LINUX_S_ISDIR(inode->i_mode)) { - ext2fs_mark_inode_bitmap(ctx->inode_dir_map, ino); - e2fsck_add_dir_info(ctx, ino, 0); - ctx->fs_directory_count++; - } else if (LINUX_S_ISREG (inode->i_mode)) { - ext2fs_mark_inode_bitmap(ctx->inode_reg_map, ino); - ctx->fs_regular_count++; - } else if (LINUX_S_ISCHR (inode->i_mode) && - e2fsck_pass1_check_device_inode(fs, inode)) { - check_immutable(ctx, &pctx); - check_size(ctx, &pctx); - ctx->fs_chardev_count++; - } else if (LINUX_S_ISBLK (inode->i_mode) && - e2fsck_pass1_check_device_inode(fs, inode)) { - check_immutable(ctx, &pctx); - check_size(ctx, &pctx); - ctx->fs_blockdev_count++; - } else if (LINUX_S_ISLNK (inode->i_mode) && - e2fsck_pass1_check_symlink(fs, inode, block_buf)) { - check_immutable(ctx, &pctx); - ctx->fs_symlinks_count++; - if (ext2fs_inode_data_blocks(fs, inode) == 0) { - ctx->fs_fast_symlinks_count++; - check_blocks(ctx, &pctx, block_buf); - continue; - } - } - else if (LINUX_S_ISFIFO (inode->i_mode) && - e2fsck_pass1_check_device_inode(fs, inode)) { - check_immutable(ctx, &pctx); - check_size(ctx, &pctx); - ctx->fs_fifo_count++; - } else if ((LINUX_S_ISSOCK (inode->i_mode)) && - e2fsck_pass1_check_device_inode(fs, inode)) { - check_immutable(ctx, &pctx); - check_size(ctx, &pctx); - ctx->fs_sockets_count++; - } else - mark_inode_bad(ctx, ino); - if (inode->i_block[EXT2_IND_BLOCK]) - ctx->fs_ind_count++; - if (inode->i_block[EXT2_DIND_BLOCK]) - ctx->fs_dind_count++; - if (inode->i_block[EXT2_TIND_BLOCK]) - ctx->fs_tind_count++; - if (inode->i_block[EXT2_IND_BLOCK] || - inode->i_block[EXT2_DIND_BLOCK] || - inode->i_block[EXT2_TIND_BLOCK] || - inode->i_file_acl) { - inodes_to_process[process_inode_count].ino = ino; - inodes_to_process[process_inode_count].inode = *inode; - process_inode_count++; - } else - check_blocks(ctx, &pctx, block_buf); - - if (ctx->flags & E2F_FLAG_SIGNAL_MASK) - return; - - if (process_inode_count >= ctx->process_inode_size) { - process_inodes(ctx, block_buf); - - if (ctx->flags & E2F_FLAG_SIGNAL_MASK) - return; - } - } - process_inodes(ctx, block_buf); - ext2fs_close_inode_scan(scan); - ehandler_operation(0); - - /* - * If any extended attribute blocks' reference counts need to - * be adjusted, either up (ctx->refcount_extra), or down - * (ctx->refcount), then fix them. - */ - if (ctx->refcount) { - adjust_extattr_refcount(ctx, ctx->refcount, block_buf, -1); - ea_refcount_free(ctx->refcount); - ctx->refcount = 0; - } - if (ctx->refcount_extra) { - adjust_extattr_refcount(ctx, ctx->refcount_extra, - block_buf, +1); - ea_refcount_free(ctx->refcount_extra); - ctx->refcount_extra = 0; - } - - if (ctx->invalid_bitmaps) - handle_fs_bad_blocks(ctx); - - /* We don't need the block_ea_map any more */ - if (ctx->block_ea_map) { - ext2fs_free_block_bitmap(ctx->block_ea_map); - ctx->block_ea_map = 0; - } - - if (ctx->flags & E2F_FLAG_RESIZE_INODE) { - ext2fs_block_bitmap save_bmap; - - save_bmap = fs->block_map; - fs->block_map = ctx->block_found_map; - clear_problem_context(&pctx); - pctx.errcode = ext2fs_create_resize_inode(fs); - if (pctx.errcode) { - fix_problem(ctx, PR_1_RESIZE_INODE_CREATE, &pctx); - /* Should never get here */ - ctx->flags |= E2F_FLAG_ABORT; - return; - } - fs->block_map = save_bmap; - ctx->flags &= ~E2F_FLAG_RESIZE_INODE; - } - - if (ctx->flags & E2F_FLAG_RESTART) { - /* - * Only the master copy of the superblock and block - * group descriptors are going to be written during a - * restart, so set the superblock to be used to be the - * master superblock. - */ - ctx->use_superblock = 0; - unwind_pass1(fs); - goto endit; - } - - if (ctx->block_dup_map) { - if (ctx->options & E2F_OPT_PREEN) { - clear_problem_context(&pctx); - fix_problem(ctx, PR_1_DUP_BLOCKS_PREENSTOP, &pctx); - } - e2fsck_pass1_dupblocks(ctx, block_buf); - } - ext2fs_free_mem(&inodes_to_process); -endit: - e2fsck_use_inode_shortcuts(ctx, 0); - - ext2fs_free_mem(&block_buf); - ext2fs_free_mem(&inode); - -#ifdef RESOURCE_TRACK - if (ctx->options & E2F_OPT_TIME2) { - e2fsck_clear_progbar(ctx); - print_resource_track(_("Pass 1"), &rtrack); - } -#endif -} - -/* - * When the inode_scan routines call this callback at the end of the - * glock group, call process_inodes. - */ -static errcode_t scan_callback(ext2_filsys fs, - ext2_inode_scan scan EXT2FS_ATTR((unused)), - dgrp_t group, void * priv_data) -{ - struct scan_callback_struct *scan_struct; - e2fsck_t ctx; - - scan_struct = (struct scan_callback_struct *) priv_data; - ctx = scan_struct->ctx; - - process_inodes((e2fsck_t) fs->priv_data, scan_struct->block_buf); - - if (ctx->progress) - if ((ctx->progress)(ctx, 1, group+1, - ctx->fs->group_desc_count)) - return EXT2_ET_CANCEL_REQUESTED; - - return 0; -} - -/* - * Process the inodes in the "inodes to process" list. - */ -static void process_inodes(e2fsck_t ctx, char *block_buf) -{ - int i; - struct ext2_inode *old_stashed_inode; - ext2_ino_t old_stashed_ino; - const char *old_operation; - char buf[80]; - struct problem_context pctx; - -#if 0 - printf("begin process_inodes: "); -#endif - if (process_inode_count == 0) - return; - old_operation = ehandler_operation(0); - old_stashed_inode = ctx->stashed_inode; - old_stashed_ino = ctx->stashed_ino; - qsort(inodes_to_process, process_inode_count, - sizeof(struct process_inode_block), process_inode_cmp); - clear_problem_context(&pctx); - for (i=0; i < process_inode_count; i++) { - pctx.inode = ctx->stashed_inode = &inodes_to_process[i].inode; - pctx.ino = ctx->stashed_ino = inodes_to_process[i].ino; - -#if 0 - printf("%u ", pctx.ino); -#endif - sprintf(buf, _("reading indirect blocks of inode %u"), - pctx.ino); - ehandler_operation(buf); - check_blocks(ctx, &pctx, block_buf); - if (ctx->flags & E2F_FLAG_SIGNAL_MASK) - break; - } - ctx->stashed_inode = old_stashed_inode; - ctx->stashed_ino = old_stashed_ino; - process_inode_count = 0; -#if 0 - printf("end process inodes\n"); -#endif - ehandler_operation(old_operation); -} - -static EXT2_QSORT_TYPE process_inode_cmp(const void *a, const void *b) -{ - const struct process_inode_block *ib_a = - (const struct process_inode_block *) a; - const struct process_inode_block *ib_b = - (const struct process_inode_block *) b; - int ret; - - ret = (ib_a->inode.i_block[EXT2_IND_BLOCK] - - ib_b->inode.i_block[EXT2_IND_BLOCK]); - if (ret == 0) - ret = ib_a->inode.i_file_acl - ib_b->inode.i_file_acl; - return ret; -} - -/* - * Mark an inode as being bad in some what - */ -static void mark_inode_bad(e2fsck_t ctx, ino_t ino) -{ - struct problem_context pctx; - - if (!ctx->inode_bad_map) { - clear_problem_context(&pctx); - - pctx.errcode = ext2fs_allocate_inode_bitmap(ctx->fs, - _("bad inode map"), &ctx->inode_bad_map); - if (pctx.errcode) { - pctx.num = 3; - fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx); - /* Should never get here */ - ctx->flags |= E2F_FLAG_ABORT; - return; - } - } - ext2fs_mark_inode_bitmap(ctx->inode_bad_map, ino); -} - - -/* - * This procedure will allocate the inode "bb" (badblock) map table - */ -static void alloc_bb_map(e2fsck_t ctx) -{ - struct problem_context pctx; - - clear_problem_context(&pctx); - pctx.errcode = ext2fs_allocate_inode_bitmap(ctx->fs, - _("inode in bad block map"), - &ctx->inode_bb_map); - if (pctx.errcode) { - pctx.num = 4; - fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx); - /* Should never get here */ - ctx->flags |= E2F_FLAG_ABORT; - return; - } -} - -/* - * This procedure will allocate the inode imagic table - */ -static void alloc_imagic_map(e2fsck_t ctx) -{ - struct problem_context pctx; - - clear_problem_context(&pctx); - pctx.errcode = ext2fs_allocate_inode_bitmap(ctx->fs, - _("imagic inode map"), - &ctx->inode_imagic_map); - if (pctx.errcode) { - pctx.num = 5; - fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx); - /* Should never get here */ - ctx->flags |= E2F_FLAG_ABORT; - return; - } -} - -/* - * Marks a block as in use, setting the dup_map if it's been set - * already. Called by process_block and process_bad_block. - * - * WARNING: Assumes checks have already been done to make sure block - * is valid. This is true in both process_block and process_bad_block. - */ -static _INLINE_ void mark_block_used(e2fsck_t ctx, blk_t block) -{ - struct problem_context pctx; - - clear_problem_context(&pctx); - - if (ext2fs_fast_test_block_bitmap(ctx->block_found_map, block)) { - if (!ctx->block_dup_map) { - pctx.errcode = ext2fs_allocate_block_bitmap(ctx->fs, - _("multiply claimed block map"), - &ctx->block_dup_map); - if (pctx.errcode) { - pctx.num = 3; - fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, - &pctx); - /* Should never get here */ - ctx->flags |= E2F_FLAG_ABORT; - return; - } - } - ext2fs_fast_mark_block_bitmap(ctx->block_dup_map, block); - } else { - ext2fs_fast_mark_block_bitmap(ctx->block_found_map, block); - } -} - -/* - * Adjust the extended attribute block's reference counts at the end - * of pass 1, either by subtracting out references for EA blocks that - * are still referenced in ctx->refcount, or by adding references for - * EA blocks that had extra references as accounted for in - * ctx->refcount_extra. - */ -static void adjust_extattr_refcount(e2fsck_t ctx, ext2_refcount_t refcount, - char *block_buf, int adjust_sign) -{ - struct ext2_ext_attr_header *header; - struct problem_context pctx; - ext2_filsys fs = ctx->fs; - blk_t blk; - __u32 should_be; - int count; - - clear_problem_context(&pctx); - - ea_refcount_intr_begin(refcount); - while (1) { - if ((blk = ea_refcount_intr_next(refcount, &count)) == 0) - break; - pctx.blk = blk; - pctx.errcode = ext2fs_read_ext_attr(fs, blk, block_buf); - if (pctx.errcode) { - fix_problem(ctx, PR_1_EXTATTR_READ_ABORT, &pctx); - return; - } - header = (struct ext2_ext_attr_header *) block_buf; - pctx.blkcount = header->h_refcount; - should_be = header->h_refcount + adjust_sign * count; - pctx.num = should_be; - if (fix_problem(ctx, PR_1_EXTATTR_REFCOUNT, &pctx)) { - header->h_refcount = should_be; - pctx.errcode = ext2fs_write_ext_attr(fs, blk, - block_buf); - if (pctx.errcode) { - fix_problem(ctx, PR_1_EXTATTR_WRITE, &pctx); - continue; - } - } - } -} - -/* - * Handle processing the extended attribute blocks - */ -static int check_ext_attr(e2fsck_t ctx, struct problem_context *pctx, - char *block_buf) -{ - ext2_filsys fs = ctx->fs; - ext2_ino_t ino = pctx->ino; - struct ext2_inode *inode = pctx->inode; - blk_t blk; - char * end; - struct ext2_ext_attr_header *header; - struct ext2_ext_attr_entry *entry; - int count; - region_t region; - - blk = inode->i_file_acl; - if (blk == 0) - return 0; - - /* - * If the Extended attribute flag isn't set, then a non-zero - * file acl means that the inode is corrupted. - * - * Or if the extended attribute block is an invalid block, - * then the inode is also corrupted. - */ - if (!(fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_EXT_ATTR) || - (blk < fs->super->s_first_data_block) || - (blk >= fs->super->s_blocks_count)) { - mark_inode_bad(ctx, ino); - return 0; - } - - /* If ea bitmap hasn't been allocated, create it */ - if (!ctx->block_ea_map) { - pctx->errcode = ext2fs_allocate_block_bitmap(fs, - _("ext attr block map"), - &ctx->block_ea_map); - if (pctx->errcode) { - pctx->num = 2; - fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, pctx); - ctx->flags |= E2F_FLAG_ABORT; - return 0; - } - } - - /* Create the EA refcount structure if necessary */ - if (!ctx->refcount) { - pctx->errcode = ea_refcount_create(0, &ctx->refcount); - if (pctx->errcode) { - pctx->num = 1; - fix_problem(ctx, PR_1_ALLOCATE_REFCOUNT, pctx); - ctx->flags |= E2F_FLAG_ABORT; - return 0; - } - } - -#if 0 - /* Debugging text */ - printf("Inode %u has EA block %u\n", ino, blk); -#endif - - /* Have we seen this EA block before? */ - if (ext2fs_fast_test_block_bitmap(ctx->block_ea_map, blk)) { - if (ea_refcount_decrement(ctx->refcount, blk, 0) == 0) - return 1; - /* Ooops, this EA was referenced more than it stated */ - if (!ctx->refcount_extra) { - pctx->errcode = ea_refcount_create(0, - &ctx->refcount_extra); - if (pctx->errcode) { - pctx->num = 2; - fix_problem(ctx, PR_1_ALLOCATE_REFCOUNT, pctx); - ctx->flags |= E2F_FLAG_ABORT; - return 0; - } - } - ea_refcount_increment(ctx->refcount_extra, blk, 0); - return 1; - } - - /* - * OK, we haven't seen this EA block yet. So we need to - * validate it - */ - pctx->blk = blk; - pctx->errcode = ext2fs_read_ext_attr(fs, blk, block_buf); - if (pctx->errcode && fix_problem(ctx, PR_1_READ_EA_BLOCK, pctx)) - goto clear_extattr; - header = (struct ext2_ext_attr_header *) block_buf; - pctx->blk = inode->i_file_acl; - if (((ctx->ext_attr_ver == 1) && - (header->h_magic != EXT2_EXT_ATTR_MAGIC_v1)) || - ((ctx->ext_attr_ver == 2) && - (header->h_magic != EXT2_EXT_ATTR_MAGIC))) { - if (fix_problem(ctx, PR_1_BAD_EA_BLOCK, pctx)) - goto clear_extattr; - } - - if (header->h_blocks != 1) { - if (fix_problem(ctx, PR_1_EA_MULTI_BLOCK, pctx)) - goto clear_extattr; - } - - region = region_create(0, fs->blocksize); - if (!region) { - fix_problem(ctx, PR_1_EA_ALLOC_REGION, pctx); - ctx->flags |= E2F_FLAG_ABORT; - return 0; - } - if (region_allocate(region, 0, sizeof(struct ext2_ext_attr_header))) { - if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, pctx)) - goto clear_extattr; - } - - entry = (struct ext2_ext_attr_entry *)(header+1); - end = block_buf + fs->blocksize; - while ((char *)entry < end && *(__u32 *)entry) { - if (region_allocate(region, (char *)entry - (char *)header, - EXT2_EXT_ATTR_LEN(entry->e_name_len))) { - if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, pctx)) - goto clear_extattr; - } - if ((ctx->ext_attr_ver == 1 && - (entry->e_name_len == 0 || entry->e_name_index != 0)) || - (ctx->ext_attr_ver == 2 && - entry->e_name_index == 0)) { - if (fix_problem(ctx, PR_1_EA_BAD_NAME, pctx)) - goto clear_extattr; - } - if (entry->e_value_block != 0) { - if (fix_problem(ctx, PR_1_EA_BAD_VALUE, pctx)) - goto clear_extattr; - } - if (entry->e_value_size && - region_allocate(region, entry->e_value_offs, - EXT2_EXT_ATTR_SIZE(entry->e_value_size))) { - if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, pctx)) - goto clear_extattr; - } - entry = EXT2_EXT_ATTR_NEXT(entry); - } - if (region_allocate(region, (char *)entry - (char *)header, 4)) { - if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, pctx)) - goto clear_extattr; - } - region_free(region); - - count = header->h_refcount - 1; - if (count) - ea_refcount_store(ctx->refcount, blk, count); - mark_block_used(ctx, blk); - ext2fs_fast_mark_block_bitmap(ctx->block_ea_map, blk); - - return 1; - -clear_extattr: - inode->i_file_acl = 0; - e2fsck_write_inode(ctx, ino, inode, "check_ext_attr"); - return 0; -} - -/* Returns 1 if bad htree, 0 if OK */ -static int handle_htree(e2fsck_t ctx, struct problem_context *pctx, - ext2_ino_t ino EXT2FS_ATTR((unused)), - struct ext2_inode *inode, - char *block_buf) -{ - struct ext2_dx_root_info *root; - ext2_filsys fs = ctx->fs; - errcode_t retval; - blk_t blk; - - if ((!LINUX_S_ISDIR(inode->i_mode) && - fix_problem(ctx, PR_1_HTREE_NODIR, pctx)) || - (!(fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_DIR_INDEX) && - fix_problem(ctx, PR_1_HTREE_SET, pctx))) - return 1; - - blk = inode->i_block[0]; - if (((blk == 0) || - (blk < fs->super->s_first_data_block) || - (blk >= fs->super->s_blocks_count)) && - fix_problem(ctx, PR_1_HTREE_BADROOT, pctx)) - return 1; - - retval = io_channel_read_blk(fs->io, blk, 1, block_buf); - if (retval && fix_problem(ctx, PR_1_HTREE_BADROOT, pctx)) - return 1; - - /* XXX should check that beginning matches a directory */ - root = (struct ext2_dx_root_info *) (block_buf + 24); - - if ((root->reserved_zero || root->info_length < 8) && - fix_problem(ctx, PR_1_HTREE_BADROOT, pctx)) - return 1; - - pctx->num = root->hash_version; - if ((root->hash_version != EXT2_HASH_LEGACY) && - (root->hash_version != EXT2_HASH_HALF_MD4) && - (root->hash_version != EXT2_HASH_TEA) && - fix_problem(ctx, PR_1_HTREE_HASHV, pctx)) - return 1; - - if ((root->unused_flags & EXT2_HASH_FLAG_INCOMPAT) && - fix_problem(ctx, PR_1_HTREE_INCOMPAT, pctx)) - return 1; - - pctx->num = root->indirect_levels; - if ((root->indirect_levels > 1) && - fix_problem(ctx, PR_1_HTREE_DEPTH, pctx)) - return 1; - - return 0; -} - -/* - * This subroutine is called on each inode to account for all of the - * blocks used by that inode. - */ -static void check_blocks(e2fsck_t ctx, struct problem_context *pctx, - char *block_buf) -{ - ext2_filsys fs = ctx->fs; - struct process_block_struct pb; - ext2_ino_t ino = pctx->ino; - struct ext2_inode *inode = pctx->inode; - int bad_size = 0; - int dirty_inode = 0; - __u64 size; - - pb.ino = ino; - pb.num_blocks = 0; - pb.last_block = -1; - pb.num_illegal_blocks = 0; - pb.suppress = 0; pb.clear = 0; - pb.fragmented = 0; - pb.compressed = 0; - pb.previous_block = 0; - pb.is_dir = LINUX_S_ISDIR(inode->i_mode); - pb.is_reg = LINUX_S_ISREG(inode->i_mode); - pb.max_blocks = 1 << (31 - fs->super->s_log_block_size); - pb.inode = inode; - pb.pctx = pctx; - pb.ctx = ctx; - pctx->ino = ino; - pctx->errcode = 0; - - if (inode->i_flags & EXT2_COMPRBLK_FL) { - if (fs->super->s_feature_incompat & - EXT2_FEATURE_INCOMPAT_COMPRESSION) - pb.compressed = 1; - else { - if (fix_problem(ctx, PR_1_COMPR_SET, pctx)) { - inode->i_flags &= ~EXT2_COMPRBLK_FL; - dirty_inode++; - } - } - } - - if (inode->i_file_acl && check_ext_attr(ctx, pctx, block_buf)) - pb.num_blocks++; - - if (ext2fs_inode_has_valid_blocks(inode)) - pctx->errcode = ext2fs_block_iterate2(fs, ino, - pb.is_dir ? BLOCK_FLAG_HOLE : 0, - block_buf, process_block, &pb); - end_problem_latch(ctx, PR_LATCH_BLOCK); - end_problem_latch(ctx, PR_LATCH_TOOBIG); - if (ctx->flags & E2F_FLAG_SIGNAL_MASK) - goto out; - if (pctx->errcode) - fix_problem(ctx, PR_1_BLOCK_ITERATE, pctx); - - if (pb.fragmented && pb.num_blocks < fs->super->s_blocks_per_group) - ctx->fs_fragmented++; - - if (pb.clear) { - inode->i_links_count = 0; - ext2fs_icount_store(ctx->inode_link_info, ino, 0); - inode->i_dtime = time(0); - dirty_inode++; - ext2fs_unmark_inode_bitmap(ctx->inode_dir_map, ino); - ext2fs_unmark_inode_bitmap(ctx->inode_reg_map, ino); - ext2fs_unmark_inode_bitmap(ctx->inode_used_map, ino); - /* - * The inode was probably partially accounted for - * before processing was aborted, so we need to - * restart the pass 1 scan. - */ - ctx->flags |= E2F_FLAG_RESTART; - goto out; - } - - if (inode->i_flags & EXT2_INDEX_FL) { - if (handle_htree(ctx, pctx, ino, inode, block_buf)) { - inode->i_flags &= ~EXT2_INDEX_FL; - dirty_inode++; - } else { -#ifdef ENABLE_HTREE - e2fsck_add_dx_dir(ctx, ino, pb.last_block+1); -#endif - } - } - if (ctx->dirs_to_hash && pb.is_dir && - !(inode->i_flags & EXT2_INDEX_FL) && - ((inode->i_size / fs->blocksize) >= 3)) - ext2fs_u32_list_add(ctx->dirs_to_hash, ino); - - if (!pb.num_blocks && pb.is_dir) { - if (fix_problem(ctx, PR_1_ZERO_LENGTH_DIR, pctx)) { - inode->i_links_count = 0; - ext2fs_icount_store(ctx->inode_link_info, ino, 0); - inode->i_dtime = time(0); - dirty_inode++; - ext2fs_unmark_inode_bitmap(ctx->inode_dir_map, ino); - ext2fs_unmark_inode_bitmap(ctx->inode_reg_map, ino); - ext2fs_unmark_inode_bitmap(ctx->inode_used_map, ino); - ctx->fs_directory_count--; - goto out; - } - } - - pb.num_blocks *= (fs->blocksize / 512); -#if 0 - printf("inode %u, i_size = %lu, last_block = %lld, i_blocks=%lu, num_blocks = %lu\n", - ino, inode->i_size, pb.last_block, inode->i_blocks, - pb.num_blocks); -#endif - if (pb.is_dir) { - int nblock = inode->i_size >> EXT2_BLOCK_SIZE_BITS(fs->super); - if (nblock > (pb.last_block + 1)) - bad_size = 1; - else if (nblock < (pb.last_block + 1)) { - if (((pb.last_block + 1) - nblock) > - fs->super->s_prealloc_dir_blocks) - bad_size = 2; - } - } else { - size = EXT2_I_SIZE(inode); - if ((pb.last_block >= 0) && - (size < (__u64) pb.last_block * fs->blocksize)) - bad_size = 3; - else if (size > ext2_max_sizes[fs->super->s_log_block_size]) - bad_size = 4; - } - /* i_size for symlinks is checked elsewhere */ - if (bad_size && !LINUX_S_ISLNK(inode->i_mode)) { - pctx->num = (pb.last_block+1) * fs->blocksize; - if (fix_problem(ctx, PR_1_BAD_I_SIZE, pctx)) { - inode->i_size = pctx->num; - if (!LINUX_S_ISDIR(inode->i_mode)) - inode->i_size_high = pctx->num >> 32; - dirty_inode++; - } - pctx->num = 0; - } - if (LINUX_S_ISREG(inode->i_mode) && - (inode->i_size_high || inode->i_size & 0x80000000UL)) - ctx->large_files++; - if (pb.num_blocks != inode->i_blocks) { - pctx->num = pb.num_blocks; - if (fix_problem(ctx, PR_1_BAD_I_BLOCKS, pctx)) { - inode->i_blocks = pb.num_blocks; - dirty_inode++; - } - pctx->num = 0; - } -out: - if (dirty_inode) - e2fsck_write_inode(ctx, ino, inode, "check_blocks"); -} - -#if 0 -/* - * Helper function called by process block when an illegal block is - * found. It returns a description about why the block is illegal - */ -static char *describe_illegal_block(ext2_filsys fs, blk_t block) -{ - blk_t super; - int i; - static char problem[80]; - - super = fs->super->s_first_data_block; - strcpy(problem, "PROGRAMMING ERROR: Unknown reason for illegal block"); - if (block < super) { - sprintf(problem, "< FIRSTBLOCK (%u)", super); - return(problem); - } else if (block >= fs->super->s_blocks_count) { - sprintf(problem, "> BLOCKS (%u)", fs->super->s_blocks_count); - return(problem); - } - for (i = 0; i < fs->group_desc_count; i++) { - if (block == super) { - sprintf(problem, "is the superblock in group %d", i); - break; - } - if (block > super && - block <= (super + fs->desc_blocks)) { - sprintf(problem, "is in the group descriptors " - "of group %d", i); - break; - } - if (block == fs->group_desc[i].bg_block_bitmap) { - sprintf(problem, "is the block bitmap of group %d", i); - break; - } - if (block == fs->group_desc[i].bg_inode_bitmap) { - sprintf(problem, "is the inode bitmap of group %d", i); - break; - } - if (block >= fs->group_desc[i].bg_inode_table && - (block < fs->group_desc[i].bg_inode_table - + fs->inode_blocks_per_group)) { - sprintf(problem, "is in the inode table of group %d", - i); - break; - } - super += fs->super->s_blocks_per_group; - } - return(problem); -} -#endif - -/* - * This is a helper function for check_blocks(). - */ -static int process_block(ext2_filsys fs, - blk_t *block_nr, - e2_blkcnt_t blockcnt, - blk_t ref_block EXT2FS_ATTR((unused)), - int ref_offset EXT2FS_ATTR((unused)), - void *priv_data) -{ - struct process_block_struct *p; - struct problem_context *pctx; - blk_t blk = *block_nr; - int ret_code = 0; - int problem = 0; - e2fsck_t ctx; - - p = (struct process_block_struct *) priv_data; - pctx = p->pctx; - ctx = p->ctx; - - if (p->compressed && (blk == EXT2FS_COMPRESSED_BLKADDR)) { - /* todo: Check that the comprblk_fl is high, that the - blkaddr pattern looks right (all non-holes up to - first EXT2FS_COMPRESSED_BLKADDR, then all - EXT2FS_COMPRESSED_BLKADDR up to end of cluster), - that the feature_incompat bit is high, and that the - inode is a regular file. If we're doing a "full - check" (a concept introduced to e2fsck by e2compr, - meaning that we look at data blocks as well as - metadata) then call some library routine that - checks the compressed data. I'll have to think - about this, because one particularly important - problem to be able to fix is to recalculate the - cluster size if necessary. I think that perhaps - we'd better do most/all e2compr-specific checks - separately, after the non-e2compr checks. If not - doing a full check, it may be useful to test that - the personality is linux; e.g. if it isn't then - perhaps this really is just an illegal block. */ - return 0; - } - - if (blk == 0) { - if (p->is_dir == 0) { - /* - * Should never happen, since only directories - * get called with BLOCK_FLAG_HOLE - */ -#if DEBUG_E2FSCK - printf("process_block() called with blk == 0, " - "blockcnt=%d, inode %lu???\n", - blockcnt, p->ino); -#endif - return 0; - } - if (blockcnt < 0) - return 0; - if (blockcnt * fs->blocksize < p->inode->i_size) { -#if 0 - printf("Missing block (#%d) in directory inode %lu!\n", - blockcnt, p->ino); -#endif - goto mark_dir; - } - return 0; - } - -#if 0 - printf("Process_block, inode %lu, block %u, #%d\n", p->ino, blk, - blockcnt); -#endif - - /* - * Simplistic fragmentation check. We merely require that the - * file be contiguous. (Which can never be true for really - * big files that are greater than a block group.) - */ - if (!HOLE_BLKADDR(p->previous_block)) { - if (p->previous_block+1 != blk) - p->fragmented = 1; - } - p->previous_block = blk; - - if (p->is_dir && blockcnt > (1 << (21 - fs->super->s_log_block_size))) - problem = PR_1_TOOBIG_DIR; - if (p->is_reg && p->num_blocks+1 >= p->max_blocks) - problem = PR_1_TOOBIG_REG; - if (!p->is_dir && !p->is_reg && blockcnt > 0) - problem = PR_1_TOOBIG_SYMLINK; - - if (blk < fs->super->s_first_data_block || - blk >= fs->super->s_blocks_count) - problem = PR_1_ILLEGAL_BLOCK_NUM; - - if (problem) { - p->num_illegal_blocks++; - if (!p->suppress && (p->num_illegal_blocks % 12) == 0) { - if (fix_problem(ctx, PR_1_TOO_MANY_BAD_BLOCKS, pctx)) { - p->clear = 1; - return BLOCK_ABORT; - } - if (fix_problem(ctx, PR_1_SUPPRESS_MESSAGES, pctx)) { - p->suppress = 1; - set_latch_flags(PR_LATCH_BLOCK, - PRL_SUPPRESS, 0); - } - } - pctx->blk = blk; - pctx->blkcount = blockcnt; - if (fix_problem(ctx, problem, pctx)) { - blk = *block_nr = 0; - ret_code = BLOCK_CHANGED; - goto mark_dir; - } else - return 0; - } - - if (p->ino == EXT2_RESIZE_INO) { - /* - * The resize inode has already be sanity checked - * during pass #0 (the superblock checks). All we - * have to do is mark the double indirect block as - * being in use; all of the other blocks are handled - * by mark_table_blocks()). - */ - if (blockcnt == BLOCK_COUNT_DIND) - mark_block_used(ctx, blk); - } else - mark_block_used(ctx, blk); - p->num_blocks++; - if (blockcnt >= 0) - p->last_block = blockcnt; -mark_dir: - if (p->is_dir && (blockcnt >= 0)) { - pctx->errcode = ext2fs_add_dir_block(fs->dblist, p->ino, - blk, blockcnt); - if (pctx->errcode) { - pctx->blk = blk; - pctx->num = blockcnt; - fix_problem(ctx, PR_1_ADD_DBLOCK, pctx); - /* Should never get here */ - ctx->flags |= E2F_FLAG_ABORT; - return BLOCK_ABORT; - } - } - return ret_code; -} - -static int process_bad_block(ext2_filsys fs, - blk_t *block_nr, - e2_blkcnt_t blockcnt, - blk_t ref_block EXT2FS_ATTR((unused)), - int ref_offset EXT2FS_ATTR((unused)), - void *priv_data) -{ - struct process_block_struct *p; - blk_t blk = *block_nr; - blk_t first_block; - dgrp_t i; - struct problem_context *pctx; - e2fsck_t ctx; - - /* - * Note: This function processes blocks for the bad blocks - * inode, which is never compressed. So we don't use HOLE_BLKADDR(). - */ - - if (!blk) - return 0; - - p = (struct process_block_struct *) priv_data; - ctx = p->ctx; - pctx = p->pctx; - - pctx->ino = EXT2_BAD_INO; - pctx->blk = blk; - pctx->blkcount = blockcnt; - - if ((blk < fs->super->s_first_data_block) || - (blk >= fs->super->s_blocks_count)) { - if (fix_problem(ctx, PR_1_BB_ILLEGAL_BLOCK_NUM, pctx)) { - *block_nr = 0; - return BLOCK_CHANGED; - } else - return 0; - } - - if (blockcnt < 0) { - if (ext2fs_test_block_bitmap(p->fs_meta_blocks, blk)) { - p->bbcheck = 1; - if (fix_problem(ctx, PR_1_BB_FS_BLOCK, pctx)) { - *block_nr = 0; - return BLOCK_CHANGED; - } - } else if (ext2fs_test_block_bitmap(ctx->block_found_map, - blk)) { - p->bbcheck = 1; - if (fix_problem(ctx, PR_1_BBINODE_BAD_METABLOCK, - pctx)) { - *block_nr = 0; - return BLOCK_CHANGED; - } - if (ctx->flags & E2F_FLAG_SIGNAL_MASK) - return BLOCK_ABORT; - } else - mark_block_used(ctx, blk); - return 0; - } -#if 0 - printf ("DEBUG: Marking %u as bad.\n", blk); -#endif - ctx->fs_badblocks_count++; - /* - * If the block is not used, then mark it as used and return. - * If it is already marked as found, this must mean that - * there's an overlap between the filesystem table blocks - * (bitmaps and inode table) and the bad block list. - */ - if (!ext2fs_test_block_bitmap(ctx->block_found_map, blk)) { - ext2fs_mark_block_bitmap(ctx->block_found_map, blk); - return 0; - } - /* - * Try to find the where the filesystem block was used... - */ - first_block = fs->super->s_first_data_block; - - for (i = 0; i < fs->group_desc_count; i++ ) { - pctx->group = i; - pctx->blk = blk; - if (!ext2fs_bg_has_super(fs, i)) - goto skip_super; - if (blk == first_block) { - if (i == 0) { - if (fix_problem(ctx, - PR_1_BAD_PRIMARY_SUPERBLOCK, - pctx)) { - *block_nr = 0; - return BLOCK_CHANGED; - } - return 0; - } - fix_problem(ctx, PR_1_BAD_SUPERBLOCK, pctx); - return 0; - } - if ((blk > first_block) && - (blk <= first_block + fs->desc_blocks)) { - if (i == 0) { - pctx->blk = *block_nr; - if (fix_problem(ctx, - PR_1_BAD_PRIMARY_GROUP_DESCRIPTOR, pctx)) { - *block_nr = 0; - return BLOCK_CHANGED; - } - return 0; - } - fix_problem(ctx, PR_1_BAD_GROUP_DESCRIPTORS, pctx); - return 0; - } - skip_super: - if (blk == fs->group_desc[i].bg_block_bitmap) { - if (fix_problem(ctx, PR_1_BB_BAD_BLOCK, pctx)) { - ctx->invalid_block_bitmap_flag[i]++; - ctx->invalid_bitmaps++; - } - return 0; - } - if (blk == fs->group_desc[i].bg_inode_bitmap) { - if (fix_problem(ctx, PR_1_IB_BAD_BLOCK, pctx)) { - ctx->invalid_inode_bitmap_flag[i]++; - ctx->invalid_bitmaps++; - } - return 0; - } - if ((blk >= fs->group_desc[i].bg_inode_table) && - (blk < (fs->group_desc[i].bg_inode_table + - fs->inode_blocks_per_group))) { - /* - * If there are bad blocks in the inode table, - * the inode scan code will try to do - * something reasonable automatically. - */ - return 0; - } - first_block += fs->super->s_blocks_per_group; - } - /* - * If we've gotten to this point, then the only - * possibility is that the bad block inode meta data - * is using a bad block. - */ - if ((blk == p->inode->i_block[EXT2_IND_BLOCK]) || - (blk == p->inode->i_block[EXT2_DIND_BLOCK]) || - (blk == p->inode->i_block[EXT2_TIND_BLOCK])) { - p->bbcheck = 1; - if (fix_problem(ctx, PR_1_BBINODE_BAD_METABLOCK, pctx)) { - *block_nr = 0; - return BLOCK_CHANGED; - } - if (ctx->flags & E2F_FLAG_SIGNAL_MASK) - return BLOCK_ABORT; - return 0; - } - - pctx->group = -1; - - /* Warn user that the block wasn't claimed */ - fix_problem(ctx, PR_1_PROGERR_CLAIMED_BLOCK, pctx); - - return 0; -} - -static void new_table_block(e2fsck_t ctx, blk_t first_block, int group, - const char *name, int num, blk_t *new_block) -{ - ext2_filsys fs = ctx->fs; - blk_t old_block = *new_block; - int i; - char *buf; - struct problem_context pctx; - - clear_problem_context(&pctx); - - pctx.group = group; - pctx.blk = old_block; - pctx.str = name; - - pctx.errcode = ext2fs_get_free_blocks(fs, first_block, - first_block + fs->super->s_blocks_per_group, - num, ctx->block_found_map, new_block); - if (pctx.errcode) { - pctx.num = num; - fix_problem(ctx, PR_1_RELOC_BLOCK_ALLOCATE, &pctx); - ext2fs_unmark_valid(fs); - return; - } - pctx.errcode = ext2fs_get_mem(fs->blocksize, &buf); - if (pctx.errcode) { - fix_problem(ctx, PR_1_RELOC_MEMORY_ALLOCATE, &pctx); - ext2fs_unmark_valid(fs); - return; - } - ext2fs_mark_super_dirty(fs); - fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY; - pctx.blk2 = *new_block; - fix_problem(ctx, (old_block ? PR_1_RELOC_FROM_TO : - PR_1_RELOC_TO), &pctx); - pctx.blk2 = 0; - for (i = 0; i < num; i++) { - pctx.blk = i; - ext2fs_mark_block_bitmap(ctx->block_found_map, (*new_block)+i); - if (old_block) { - pctx.errcode = io_channel_read_blk(fs->io, - old_block + i, 1, buf); - if (pctx.errcode) - fix_problem(ctx, PR_1_RELOC_READ_ERR, &pctx); - } else - memset(buf, 0, fs->blocksize); - - pctx.blk = (*new_block) + i; - pctx.errcode = io_channel_write_blk(fs->io, pctx.blk, - 1, buf); - if (pctx.errcode) - fix_problem(ctx, PR_1_RELOC_WRITE_ERR, &pctx); - } - ext2fs_free_mem(&buf); -} - -/* - * This routine gets called at the end of pass 1 if bad blocks are - * detected in the superblock, group descriptors, inode_bitmaps, or - * block bitmaps. At this point, all of the blocks have been mapped - * out, so we can try to allocate new block(s) to replace the bad - * blocks. - */ -static void handle_fs_bad_blocks(e2fsck_t ctx) -{ - ext2_filsys fs = ctx->fs; - dgrp_t i; - int first_block = fs->super->s_first_data_block; - - for (i = 0; i < fs->group_desc_count; i++) { - if (ctx->invalid_block_bitmap_flag[i]) { - new_table_block(ctx, first_block, i, _("block bitmap"), - 1, &fs->group_desc[i].bg_block_bitmap); - } - if (ctx->invalid_inode_bitmap_flag[i]) { - new_table_block(ctx, first_block, i, _("inode bitmap"), - 1, &fs->group_desc[i].bg_inode_bitmap); - } - if (ctx->invalid_inode_table_flag[i]) { - new_table_block(ctx, first_block, i, _("inode table"), - fs->inode_blocks_per_group, - &fs->group_desc[i].bg_inode_table); - ctx->flags |= E2F_FLAG_RESTART; - } - first_block += fs->super->s_blocks_per_group; - } - ctx->invalid_bitmaps = 0; -} - -/* - * This routine marks all blocks which are used by the superblock, - * group descriptors, inode bitmaps, and block bitmaps. - */ -static void mark_table_blocks(e2fsck_t ctx) -{ - ext2_filsys fs = ctx->fs; - blk_t block, b; - dgrp_t i; - int j; - struct problem_context pctx; - - clear_problem_context(&pctx); - - block = fs->super->s_first_data_block; - for (i = 0; i < fs->group_desc_count; i++) { - pctx.group = i; - - ext2fs_reserve_super_and_bgd(fs, i, ctx->block_found_map); - - /* - * Mark the blocks used for the inode table - */ - if (fs->group_desc[i].bg_inode_table) { - for (j = 0, b = fs->group_desc[i].bg_inode_table; - j < fs->inode_blocks_per_group; - j++, b++) { - if (ext2fs_test_block_bitmap(ctx->block_found_map, - b)) { - pctx.blk = b; - if (fix_problem(ctx, - PR_1_ITABLE_CONFLICT, &pctx)) { - ctx->invalid_inode_table_flag[i]++; - ctx->invalid_bitmaps++; - } - } else { - ext2fs_mark_block_bitmap(ctx->block_found_map, - b); - } - } - } - - /* - * Mark block used for the block bitmap - */ - if (fs->group_desc[i].bg_block_bitmap) { - if (ext2fs_test_block_bitmap(ctx->block_found_map, - fs->group_desc[i].bg_block_bitmap)) { - pctx.blk = fs->group_desc[i].bg_block_bitmap; - if (fix_problem(ctx, PR_1_BB_CONFLICT, &pctx)) { - ctx->invalid_block_bitmap_flag[i]++; - ctx->invalid_bitmaps++; - } - } else { - ext2fs_mark_block_bitmap(ctx->block_found_map, - fs->group_desc[i].bg_block_bitmap); - } - - } - /* - * Mark block used for the inode bitmap - */ - if (fs->group_desc[i].bg_inode_bitmap) { - if (ext2fs_test_block_bitmap(ctx->block_found_map, - fs->group_desc[i].bg_inode_bitmap)) { - pctx.blk = fs->group_desc[i].bg_inode_bitmap; - if (fix_problem(ctx, PR_1_IB_CONFLICT, &pctx)) { - ctx->invalid_inode_bitmap_flag[i]++; - ctx->invalid_bitmaps++; - } - } else { - ext2fs_mark_block_bitmap(ctx->block_found_map, - fs->group_desc[i].bg_inode_bitmap); - } - } - block += fs->super->s_blocks_per_group; - } -} - -/* - * Thes subroutines short circuits ext2fs_get_blocks and - * ext2fs_check_directory; we use them since we already have the inode - * structure, so there's no point in letting the ext2fs library read - * the inode again. - */ -static errcode_t pass1_get_blocks(ext2_filsys fs, ext2_ino_t ino, - blk_t *blocks) -{ - e2fsck_t ctx = (e2fsck_t) fs->priv_data; - int i; - - if ((ino != ctx->stashed_ino) || !ctx->stashed_inode) - return EXT2_ET_CALLBACK_NOTHANDLED; - - for (i=0; i < EXT2_N_BLOCKS; i++) - blocks[i] = ctx->stashed_inode->i_block[i]; - return 0; -} - -static errcode_t pass1_read_inode(ext2_filsys fs, ext2_ino_t ino, - struct ext2_inode *inode) -{ - e2fsck_t ctx = (e2fsck_t) fs->priv_data; - - if ((ino != ctx->stashed_ino) || !ctx->stashed_inode) - return EXT2_ET_CALLBACK_NOTHANDLED; - *inode = *ctx->stashed_inode; - return 0; -} - -static errcode_t pass1_write_inode(ext2_filsys fs, ext2_ino_t ino, - struct ext2_inode *inode) -{ - e2fsck_t ctx = (e2fsck_t) fs->priv_data; - - if ((ino == ctx->stashed_ino) && ctx->stashed_inode) - *ctx->stashed_inode = *inode; - return EXT2_ET_CALLBACK_NOTHANDLED; -} - -static errcode_t pass1_check_directory(ext2_filsys fs, ext2_ino_t ino) -{ - e2fsck_t ctx = (e2fsck_t) fs->priv_data; - - if ((ino != ctx->stashed_ino) || !ctx->stashed_inode) - return EXT2_ET_CALLBACK_NOTHANDLED; - - if (!LINUX_S_ISDIR(ctx->stashed_inode->i_mode)) - return EXT2_ET_NO_DIRECTORY; - return 0; -} - -void e2fsck_use_inode_shortcuts(e2fsck_t ctx, int bool) -{ - ext2_filsys fs = ctx->fs; - - if (bool) { - fs->get_blocks = pass1_get_blocks; - fs->check_directory = pass1_check_directory; - fs->read_inode = pass1_read_inode; - fs->write_inode = pass1_write_inode; - ctx->stashed_ino = 0; - } else { - fs->get_blocks = 0; - fs->check_directory = 0; - fs->read_inode = 0; - fs->write_inode = 0; - } -} diff --git a/e2fsprogs/e2fsck/pass1b.c b/e2fsprogs/e2fsck/pass1b.c deleted file mode 100644 index ff63807b7..000000000 --- a/e2fsprogs/e2fsck/pass1b.c +++ /dev/null @@ -1,805 +0,0 @@ -/* - * pass1b.c --- Pass #1b of e2fsck - * - * This file contains pass1B, pass1C, and pass1D of e2fsck. They are - * only invoked if pass 1 discovered blocks which are in use by more - * than one inode. - * - * Pass1B scans the data blocks of all the inodes again, generating a - * complete list of duplicate blocks and which inodes have claimed - * them. - * - * Pass1C does a tree-traversal of the filesystem, to determine the - * parent directories of these inodes. This step is necessary so that - * e2fsck can print out the pathnames of affected inodes. - * - * Pass1D is a reconciliation pass. For each inode with duplicate - * blocks, the user is prompted if s/he would like to clone the file - * (so that the file gets a fresh copy of the duplicated blocks) or - * simply to delete the file. - * - * Copyright (C) 1993, 1994, 1995, 1996, 1997 Theodore Ts'o. - * - * %Begin-Header% - * This file may be redistributed under the terms of the GNU Public - * License. - * %End-Header% - * - */ - -#include -#ifdef HAVE_ERRNO_H -#include -#endif - -#ifdef HAVE_INTTYPES_H -#include -#endif - -/* Needed for architectures where sizeof(int) != sizeof(void *) */ -#define INT_TO_VOIDPTR(val) ((void *)(intptr_t)(val)) -#define VOIDPTR_TO_INT(ptr) ((int)(intptr_t)(ptr)) - -#include "e2fsck.h" - -#include "problem.h" -#include "dict.h" - -/* Define an extension to the ext2 library's block count information */ -#define BLOCK_COUNT_EXTATTR (-5) - -struct block_el { - blk_t block; - struct block_el *next; -}; - -struct inode_el { - ext2_ino_t inode; - struct inode_el *next; -}; - -struct dup_block { - int num_bad; - struct inode_el *inode_list; -}; - -/* - * This structure stores information about a particular inode which - * is sharing blocks with other inodes. This information is collected - * to display to the user, so that the user knows what files he or she - * is dealing with, when trying to decide how to resolve the conflict - * of multiply-claimed blocks. - */ -struct dup_inode { - ext2_ino_t dir; - int num_dupblocks; - struct ext2_inode inode; - struct block_el *block_list; -}; - -static int process_pass1b_block(ext2_filsys fs, blk_t *blocknr, - e2_blkcnt_t blockcnt, blk_t ref_blk, - int ref_offset, void *priv_data); -static void delete_file(e2fsck_t ctx, ext2_ino_t ino, - struct dup_inode *dp, char *block_buf); -static int clone_file(e2fsck_t ctx, ext2_ino_t ino, - struct dup_inode *dp, char* block_buf); -static int check_if_fs_block(e2fsck_t ctx, blk_t test_blk); - -static void pass1b(e2fsck_t ctx, char *block_buf); -static void pass1c(e2fsck_t ctx, char *block_buf); -static void pass1d(e2fsck_t ctx, char *block_buf); - -static int dup_inode_count = 0; - -static dict_t blk_dict, ino_dict; - -static ext2fs_inode_bitmap inode_dup_map; - -static int dict_int_cmp(const void *a, const void *b) -{ - intptr_t ia, ib; - - ia = (intptr_t)a; - ib = (intptr_t)b; - - return (ia-ib); -} - -/* - * Add a duplicate block record - */ -static void add_dupe(e2fsck_t ctx, ext2_ino_t ino, blk_t blk, - struct ext2_inode *inode) -{ - dnode_t *n; - struct dup_block *db; - struct dup_inode *di; - struct block_el *blk_el; - struct inode_el *ino_el; - - n = dict_lookup(&blk_dict, INT_TO_VOIDPTR(blk)); - if (n) - db = (struct dup_block *) dnode_get(n); - else { - db = (struct dup_block *) e2fsck_allocate_memory(ctx, - sizeof(struct dup_block), "duplicate block header"); - db->num_bad = 0; - db->inode_list = 0; - dict_alloc_insert(&blk_dict, INT_TO_VOIDPTR(blk), db); - } - ino_el = (struct inode_el *) e2fsck_allocate_memory(ctx, - sizeof(struct inode_el), "inode element"); - ino_el->inode = ino; - ino_el->next = db->inode_list; - db->inode_list = ino_el; - db->num_bad++; - - n = dict_lookup(&ino_dict, INT_TO_VOIDPTR(ino)); - if (n) - di = (struct dup_inode *) dnode_get(n); - else { - di = (struct dup_inode *) e2fsck_allocate_memory(ctx, - sizeof(struct dup_inode), "duplicate inode header"); - di->dir = (ino == EXT2_ROOT_INO) ? EXT2_ROOT_INO : 0 ; - di->num_dupblocks = 0; - di->block_list = 0; - di->inode = *inode; - dict_alloc_insert(&ino_dict, INT_TO_VOIDPTR(ino), di); - } - blk_el = (struct block_el *) e2fsck_allocate_memory(ctx, - sizeof(struct block_el), "block element"); - blk_el->block = blk; - blk_el->next = di->block_list; - di->block_list = blk_el; - di->num_dupblocks++; -} - -/* - * Free a duplicate inode record - */ -static void inode_dnode_free(dnode_t *node, - void *context EXT2FS_ATTR((unused))) -{ - struct dup_inode *di; - struct block_el *p, *next; - - di = (struct dup_inode *) dnode_get(node); - for (p = di->block_list; p; p = next) { - next = p->next; - free(p); - } - free(node); -} - -/* - * Free a duplicate block record - */ -static void block_dnode_free(dnode_t *node, - void *context EXT2FS_ATTR((unused))) -{ - struct dup_block *db; - struct inode_el *p, *next; - - db = (struct dup_block *) dnode_get(node); - for (p = db->inode_list; p; p = next) { - next = p->next; - free(p); - } - free(node); -} - - -/* - * Main procedure for handling duplicate blocks - */ -void e2fsck_pass1_dupblocks(e2fsck_t ctx, char *block_buf) -{ - ext2_filsys fs = ctx->fs; - struct problem_context pctx; - - clear_problem_context(&pctx); - - pctx.errcode = ext2fs_allocate_inode_bitmap(fs, - _("multiply claimed inode map"), &inode_dup_map); - if (pctx.errcode) { - fix_problem(ctx, PR_1B_ALLOCATE_IBITMAP_ERROR, &pctx); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - - dict_init(&ino_dict, DICTCOUNT_T_MAX, dict_int_cmp); - dict_init(&blk_dict, DICTCOUNT_T_MAX, dict_int_cmp); - dict_set_allocator(&ino_dict, NULL, inode_dnode_free, NULL); - dict_set_allocator(&blk_dict, NULL, block_dnode_free, NULL); - - pass1b(ctx, block_buf); - pass1c(ctx, block_buf); - pass1d(ctx, block_buf); - - /* - * Time to free all of the accumulated data structures that we - * don't need anymore. - */ - dict_free_nodes(&ino_dict); - dict_free_nodes(&blk_dict); -} - -/* - * Scan the inodes looking for inodes that contain duplicate blocks. - */ -struct process_block_struct { - e2fsck_t ctx; - ext2_ino_t ino; - int dup_blocks; - struct ext2_inode *inode; - struct problem_context *pctx; -}; - -static void pass1b(e2fsck_t ctx, char *block_buf) -{ - ext2_filsys fs = ctx->fs; - ext2_ino_t ino; - struct ext2_inode inode; - ext2_inode_scan scan; - struct process_block_struct pb; - struct problem_context pctx; - - clear_problem_context(&pctx); - - if (!(ctx->options & E2F_OPT_PREEN)) - fix_problem(ctx, PR_1B_PASS_HEADER, &pctx); - pctx.errcode = ext2fs_open_inode_scan(fs, ctx->inode_buffer_blocks, - &scan); - if (pctx.errcode) { - fix_problem(ctx, PR_1B_ISCAN_ERROR, &pctx); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - ctx->stashed_inode = &inode; - pb.ctx = ctx; - pb.pctx = &pctx; - pctx.str = "pass1b"; - while (1) { - pctx.errcode = ext2fs_get_next_inode(scan, &ino, &inode); - if (pctx.errcode == EXT2_ET_BAD_BLOCK_IN_INODE_TABLE) - continue; - if (pctx.errcode) { - fix_problem(ctx, PR_1B_ISCAN_ERROR, &pctx); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - if (!ino) - break; - pctx.ino = ctx->stashed_ino = ino; - if ((ino != EXT2_BAD_INO) && - !ext2fs_test_inode_bitmap(ctx->inode_used_map, ino)) - continue; - - pb.ino = ino; - pb.dup_blocks = 0; - pb.inode = &inode; - - if (ext2fs_inode_has_valid_blocks(&inode) || - (ino == EXT2_BAD_INO)) - pctx.errcode = ext2fs_block_iterate2(fs, ino, - 0, block_buf, process_pass1b_block, &pb); - if (inode.i_file_acl) - process_pass1b_block(fs, &inode.i_file_acl, - BLOCK_COUNT_EXTATTR, 0, 0, &pb); - if (pb.dup_blocks) { - end_problem_latch(ctx, PR_LATCH_DBLOCK); - if (ino >= EXT2_FIRST_INODE(fs->super) || - ino == EXT2_ROOT_INO) - dup_inode_count++; - } - if (pctx.errcode) - fix_problem(ctx, PR_1B_BLOCK_ITERATE, &pctx); - } - ext2fs_close_inode_scan(scan); - e2fsck_use_inode_shortcuts(ctx, 0); -} - -static int process_pass1b_block(ext2_filsys fs EXT2FS_ATTR((unused)), - blk_t *block_nr, - e2_blkcnt_t blockcnt EXT2FS_ATTR((unused)), - blk_t ref_blk EXT2FS_ATTR((unused)), - int ref_offset EXT2FS_ATTR((unused)), - void *priv_data) -{ - struct process_block_struct *p; - e2fsck_t ctx; - - if (HOLE_BLKADDR(*block_nr)) - return 0; - p = (struct process_block_struct *) priv_data; - ctx = p->ctx; - - if (!ext2fs_test_block_bitmap(ctx->block_dup_map, *block_nr)) - return 0; - - /* OK, this is a duplicate block */ - if (p->ino != EXT2_BAD_INO) { - p->pctx->blk = *block_nr; - fix_problem(ctx, PR_1B_DUP_BLOCK, p->pctx); - } - p->dup_blocks++; - ext2fs_mark_inode_bitmap(inode_dup_map, p->ino); - - add_dupe(ctx, p->ino, *block_nr, p->inode); - - return 0; -} - -/* - * Pass 1c: Scan directories for inodes with duplicate blocks. This - * is used so that we can print pathnames when prompting the user for - * what to do. - */ -struct search_dir_struct { - int count; - ext2_ino_t first_inode; - ext2_ino_t max_inode; -}; - -static int search_dirent_proc(ext2_ino_t dir, int entry, - struct ext2_dir_entry *dirent, - int offset EXT2FS_ATTR((unused)), - int blocksize EXT2FS_ATTR((unused)), - char *buf EXT2FS_ATTR((unused)), - void *priv_data) -{ - struct search_dir_struct *sd; - struct dup_inode *p; - dnode_t *n; - - sd = (struct search_dir_struct *) priv_data; - - if (dirent->inode > sd->max_inode) - /* Should abort this inode, but not everything */ - return 0; - - if ((dirent->inode < sd->first_inode) || (entry < DIRENT_OTHER_FILE) || - !ext2fs_test_inode_bitmap(inode_dup_map, dirent->inode)) - return 0; - - n = dict_lookup(&ino_dict, INT_TO_VOIDPTR(dirent->inode)); - if (!n) - return 0; - p = (struct dup_inode *) dnode_get(n); - p->dir = dir; - sd->count--; - - return(sd->count ? 0 : DIRENT_ABORT); -} - - -static void pass1c(e2fsck_t ctx, char *block_buf) -{ - ext2_filsys fs = ctx->fs; - struct search_dir_struct sd; - struct problem_context pctx; - - clear_problem_context(&pctx); - - if (!(ctx->options & E2F_OPT_PREEN)) - fix_problem(ctx, PR_1C_PASS_HEADER, &pctx); - - /* - * Search through all directories to translate inodes to names - * (by searching for the containing directory for that inode.) - */ - sd.count = dup_inode_count; - sd.first_inode = EXT2_FIRST_INODE(fs->super); - sd.max_inode = fs->super->s_inodes_count; - ext2fs_dblist_dir_iterate(fs->dblist, 0, block_buf, - search_dirent_proc, &sd); -} - -static void pass1d(e2fsck_t ctx, char *block_buf) -{ - ext2_filsys fs = ctx->fs; - struct dup_inode *p, *t; - struct dup_block *q; - ext2_ino_t *shared, ino; - int shared_len; - int i; - int file_ok; - int meta_data = 0; - struct problem_context pctx; - dnode_t *n, *m; - struct block_el *s; - struct inode_el *r; - - clear_problem_context(&pctx); - - if (!(ctx->options & E2F_OPT_PREEN)) - fix_problem(ctx, PR_1D_PASS_HEADER, &pctx); - e2fsck_read_bitmaps(ctx); - - pctx.num = dup_inode_count; /* dict_count(&ino_dict); */ - fix_problem(ctx, PR_1D_NUM_DUP_INODES, &pctx); - shared = (ext2_ino_t *) e2fsck_allocate_memory(ctx, - sizeof(ext2_ino_t) * dict_count(&ino_dict), - "Shared inode list"); - for (n = dict_first(&ino_dict); n; n = dict_next(&ino_dict, n)) { - p = (struct dup_inode *) dnode_get(n); - shared_len = 0; - file_ok = 1; - ino = (ext2_ino_t)VOIDPTR_TO_INT(dnode_getkey(n)); - if (ino == EXT2_BAD_INO) - continue; - - /* - * Find all of the inodes which share blocks with this - * one. First we find all of the duplicate blocks - * belonging to this inode, and then search each block - * get the list of inodes, and merge them together. - */ - for (s = p->block_list; s; s = s->next) { - m = dict_lookup(&blk_dict, INT_TO_VOIDPTR(s->block)); - if (!m) - continue; /* Should never happen... */ - q = (struct dup_block *) dnode_get(m); - if (q->num_bad > 1) - file_ok = 0; - if (check_if_fs_block(ctx, s->block)) { - file_ok = 0; - meta_data = 1; - } - - /* - * Add all inodes used by this block to the - * shared[] --- which is a unique list, so - * if an inode is already in shared[], don't - * add it again. - */ - for (r = q->inode_list; r; r = r->next) { - if (r->inode == ino) - continue; - for (i = 0; i < shared_len; i++) - if (shared[i] == r->inode) - break; - if (i == shared_len) { - shared[shared_len++] = r->inode; - } - } - } - - /* - * Report the inode that we are working on - */ - pctx.inode = &p->inode; - pctx.ino = ino; - pctx.dir = p->dir; - pctx.blkcount = p->num_dupblocks; - pctx.num = meta_data ? shared_len+1 : shared_len; - fix_problem(ctx, PR_1D_DUP_FILE, &pctx); - pctx.blkcount = 0; - pctx.num = 0; - - if (meta_data) - fix_problem(ctx, PR_1D_SHARE_METADATA, &pctx); - - for (i = 0; i < shared_len; i++) { - m = dict_lookup(&ino_dict, INT_TO_VOIDPTR(shared[i])); - if (!m) - continue; /* should never happen */ - t = (struct dup_inode *) dnode_get(m); - /* - * Report the inode that we are sharing with - */ - pctx.inode = &t->inode; - pctx.ino = shared[i]; - pctx.dir = t->dir; - fix_problem(ctx, PR_1D_DUP_FILE_LIST, &pctx); - } - if (file_ok) { - fix_problem(ctx, PR_1D_DUP_BLOCKS_DEALT, &pctx); - continue; - } - if (fix_problem(ctx, PR_1D_CLONE_QUESTION, &pctx)) { - pctx.errcode = clone_file(ctx, ino, p, block_buf); - if (pctx.errcode) - fix_problem(ctx, PR_1D_CLONE_ERROR, &pctx); - else - continue; - } - if (fix_problem(ctx, PR_1D_DELETE_QUESTION, &pctx)) - delete_file(ctx, ino, p, block_buf); - else - ext2fs_unmark_valid(fs); - } - ext2fs_free_mem(&shared); -} - -/* - * Drop the refcount on the dup_block structure, and clear the entry - * in the block_dup_map if appropriate. - */ -static void decrement_badcount(e2fsck_t ctx, blk_t block, struct dup_block *p) -{ - p->num_bad--; - if (p->num_bad <= 0 || - (p->num_bad == 1 && !check_if_fs_block(ctx, block))) - ext2fs_unmark_block_bitmap(ctx->block_dup_map, block); -} - -static int delete_file_block(ext2_filsys fs, - blk_t *block_nr, - e2_blkcnt_t blockcnt EXT2FS_ATTR((unused)), - blk_t ref_block EXT2FS_ATTR((unused)), - int ref_offset EXT2FS_ATTR((unused)), - void *priv_data) -{ - struct process_block_struct *pb; - struct dup_block *p; - dnode_t *n; - e2fsck_t ctx; - - pb = (struct process_block_struct *) priv_data; - ctx = pb->ctx; - - if (HOLE_BLKADDR(*block_nr)) - return 0; - - if (ext2fs_test_block_bitmap(ctx->block_dup_map, *block_nr)) { - n = dict_lookup(&blk_dict, INT_TO_VOIDPTR(*block_nr)); - if (n) { - p = (struct dup_block *) dnode_get(n); - decrement_badcount(ctx, *block_nr, p); - } else - com_err("delete_file_block", 0, - _("internal error; can't find dup_blk for %d\n"), - *block_nr); - } else { - ext2fs_unmark_block_bitmap(ctx->block_found_map, *block_nr); - ext2fs_block_alloc_stats(fs, *block_nr, -1); - } - - return 0; -} - -static void delete_file(e2fsck_t ctx, ext2_ino_t ino, - struct dup_inode *dp, char* block_buf) -{ - ext2_filsys fs = ctx->fs; - struct process_block_struct pb; - struct ext2_inode inode; - struct problem_context pctx; - unsigned int count; - - clear_problem_context(&pctx); - pctx.ino = pb.ino = ino; - pb.dup_blocks = dp->num_dupblocks; - pb.ctx = ctx; - pctx.str = "delete_file"; - - e2fsck_read_inode(ctx, ino, &inode, "delete_file"); - if (ext2fs_inode_has_valid_blocks(&inode)) - pctx.errcode = ext2fs_block_iterate2(fs, ino, 0, block_buf, - delete_file_block, &pb); - if (pctx.errcode) - fix_problem(ctx, PR_1B_BLOCK_ITERATE, &pctx); - ext2fs_unmark_inode_bitmap(ctx->inode_used_map, ino); - ext2fs_unmark_inode_bitmap(ctx->inode_dir_map, ino); - if (ctx->inode_bad_map) - ext2fs_unmark_inode_bitmap(ctx->inode_bad_map, ino); - ext2fs_inode_alloc_stats2(fs, ino, -1, LINUX_S_ISDIR(inode.i_mode)); - - /* Inode may have changed by block_iterate, so reread it */ - e2fsck_read_inode(ctx, ino, &inode, "delete_file"); - inode.i_links_count = 0; - inode.i_dtime = time(0); - if (inode.i_file_acl && - (fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_EXT_ATTR)) { - count = 1; - pctx.errcode = ext2fs_adjust_ea_refcount(fs, inode.i_file_acl, - block_buf, -1, &count); - if (pctx.errcode == EXT2_ET_BAD_EA_BLOCK_NUM) { - pctx.errcode = 0; - count = 1; - } - if (pctx.errcode) { - pctx.blk = inode.i_file_acl; - fix_problem(ctx, PR_1B_ADJ_EA_REFCOUNT, &pctx); - } - /* - * If the count is zero, then arrange to have the - * block deleted. If the block is in the block_dup_map, - * also call delete_file_block since it will take care - * of keeping the accounting straight. - */ - if ((count == 0) || - ext2fs_test_block_bitmap(ctx->block_dup_map, - inode.i_file_acl)) - delete_file_block(fs, &inode.i_file_acl, - BLOCK_COUNT_EXTATTR, 0, 0, &pb); - } - e2fsck_write_inode(ctx, ino, &inode, "delete_file"); -} - -struct clone_struct { - errcode_t errcode; - ext2_ino_t dir; - char *buf; - e2fsck_t ctx; -}; - -static int clone_file_block(ext2_filsys fs, - blk_t *block_nr, - e2_blkcnt_t blockcnt, - blk_t ref_block EXT2FS_ATTR((unused)), - int ref_offset EXT2FS_ATTR((unused)), - void *priv_data) -{ - struct dup_block *p; - blk_t new_block; - errcode_t retval; - struct clone_struct *cs = (struct clone_struct *) priv_data; - dnode_t *n; - e2fsck_t ctx; - - ctx = cs->ctx; - - if (HOLE_BLKADDR(*block_nr)) - return 0; - - if (ext2fs_test_block_bitmap(ctx->block_dup_map, *block_nr)) { - n = dict_lookup(&blk_dict, INT_TO_VOIDPTR(*block_nr)); - if (n) { - p = (struct dup_block *) dnode_get(n); - retval = ext2fs_new_block(fs, 0, ctx->block_found_map, - &new_block); - if (retval) { - cs->errcode = retval; - return BLOCK_ABORT; - } - if (cs->dir && (blockcnt >= 0)) { - retval = ext2fs_set_dir_block(fs->dblist, - cs->dir, new_block, blockcnt); - if (retval) { - cs->errcode = retval; - return BLOCK_ABORT; - } - } -#if 0 - printf("Cloning block %u to %u\n", *block_nr, - new_block); -#endif - retval = io_channel_read_blk(fs->io, *block_nr, 1, - cs->buf); - if (retval) { - cs->errcode = retval; - return BLOCK_ABORT; - } - retval = io_channel_write_blk(fs->io, new_block, 1, - cs->buf); - if (retval) { - cs->errcode = retval; - return BLOCK_ABORT; - } - decrement_badcount(ctx, *block_nr, p); - *block_nr = new_block; - ext2fs_mark_block_bitmap(ctx->block_found_map, - new_block); - ext2fs_mark_block_bitmap(fs->block_map, new_block); - return BLOCK_CHANGED; - } else - com_err("clone_file_block", 0, - _("internal error; can't find dup_blk for %d\n"), - *block_nr); - } - return 0; -} - -static int clone_file(e2fsck_t ctx, ext2_ino_t ino, - struct dup_inode *dp, char* block_buf) -{ - ext2_filsys fs = ctx->fs; - errcode_t retval; - struct clone_struct cs; - struct problem_context pctx; - blk_t blk; - dnode_t *n; - struct inode_el *ino_el; - struct dup_block *db; - struct dup_inode *di; - - clear_problem_context(&pctx); - cs.errcode = 0; - cs.dir = 0; - cs.ctx = ctx; - retval = ext2fs_get_mem(fs->blocksize, &cs.buf); - if (retval) - return retval; - - if (ext2fs_test_inode_bitmap(ctx->inode_dir_map, ino)) - cs.dir = ino; - - pctx.ino = ino; - pctx.str = "clone_file"; - if (ext2fs_inode_has_valid_blocks(&dp->inode)) - pctx.errcode = ext2fs_block_iterate2(fs, ino, 0, block_buf, - clone_file_block, &cs); - ext2fs_mark_bb_dirty(fs); - if (pctx.errcode) { - fix_problem(ctx, PR_1B_BLOCK_ITERATE, &pctx); - retval = pctx.errcode; - goto errout; - } - if (cs.errcode) { - com_err("clone_file", cs.errcode, - _("returned from clone_file_block")); - retval = cs.errcode; - goto errout; - } - /* The inode may have changed on disk, so we have to re-read it */ - e2fsck_read_inode(ctx, ino, &dp->inode, "clone file EA"); - blk = dp->inode.i_file_acl; - if (blk && (clone_file_block(fs, &dp->inode.i_file_acl, - BLOCK_COUNT_EXTATTR, 0, 0, &cs) == - BLOCK_CHANGED)) { - e2fsck_write_inode(ctx, ino, &dp->inode, "clone file EA"); - /* - * If we cloned the EA block, find all other inodes - * which refered to that EA block, and modify - * them to point to the new EA block. - */ - n = dict_lookup(&blk_dict, INT_TO_VOIDPTR(blk)); - db = (struct dup_block *) dnode_get(n); - for (ino_el = db->inode_list; ino_el; ino_el = ino_el->next) { - if (ino_el->inode == ino) - continue; - n = dict_lookup(&ino_dict, INT_TO_VOIDPTR(ino_el->inode)); - di = (struct dup_inode *) dnode_get(n); - if (di->inode.i_file_acl == blk) { - di->inode.i_file_acl = dp->inode.i_file_acl; - e2fsck_write_inode(ctx, ino_el->inode, - &di->inode, "clone file EA"); - decrement_badcount(ctx, blk, db); - } - } - } - retval = 0; -errout: - ext2fs_free_mem(&cs.buf); - return retval; -} - -/* - * This routine returns 1 if a block overlaps with one of the superblocks, - * group descriptors, inode bitmaps, or block bitmaps. - */ -static int check_if_fs_block(e2fsck_t ctx, blk_t test_block) -{ - ext2_filsys fs = ctx->fs; - blk_t block; - dgrp_t i; - - block = fs->super->s_first_data_block; - for (i = 0; i < fs->group_desc_count; i++) { - - /* Check superblocks/block group descriptros */ - if (ext2fs_bg_has_super(fs, i)) { - if (test_block >= block && - (test_block <= block + fs->desc_blocks)) - return 1; - } - - /* Check the inode table */ - if ((fs->group_desc[i].bg_inode_table) && - (test_block >= fs->group_desc[i].bg_inode_table) && - (test_block < (fs->group_desc[i].bg_inode_table + - fs->inode_blocks_per_group))) - return 1; - - /* Check the bitmap blocks */ - if ((test_block == fs->group_desc[i].bg_block_bitmap) || - (test_block == fs->group_desc[i].bg_inode_bitmap)) - return 1; - - block += fs->super->s_blocks_per_group; - } - return 0; -} diff --git a/e2fsprogs/e2fsck/pass2.c b/e2fsprogs/e2fsck/pass2.c deleted file mode 100644 index 69599fffc..000000000 --- a/e2fsprogs/e2fsck/pass2.c +++ /dev/null @@ -1,1414 +0,0 @@ -/* - * pass2.c --- check directory structure - * - * Copyright (C) 1993, 1994, 1995, 1996, 1997 Theodore Ts'o - * - * %Begin-Header% - * This file may be redistributed under the terms of the GNU Public - * License. - * %End-Header% - * - * Pass 2 of e2fsck iterates through all active directory inodes, and - * applies to following tests to each directory entry in the directory - * blocks in the inodes: - * - * - The length of the directory entry (rec_len) should be at - * least 8 bytes, and no more than the remaining space - * left in the directory block. - * - The length of the name in the directory entry (name_len) - * should be less than (rec_len - 8). - * - The inode number in the directory entry should be within - * legal bounds. - * - The inode number should refer to a in-use inode. - * - The first entry should be '.', and its inode should be - * the inode of the directory. - * - The second entry should be '..'. - * - * To minimize disk seek time, the directory blocks are processed in - * sorted order of block numbers. - * - * Pass 2 also collects the following information: - * - The inode numbers of the subdirectories for each directory. - * - * Pass 2 relies on the following information from previous passes: - * - The directory information collected in pass 1. - * - The inode_used_map bitmap - * - The inode_bad_map bitmap - * - The inode_dir_map bitmap - * - * Pass 2 frees the following data structures - * - The inode_bad_map bitmap - * - The inode_reg_map bitmap - */ - -#define _GNU_SOURCE 1 /* get strnlen() */ -#include - -#include "e2fsck.h" -#include "problem.h" -#include "dict.h" - -#ifdef NO_INLINE_FUNCS -#define _INLINE_ -#else -#define _INLINE_ inline -#endif - -/* #define DX_DEBUG */ - -/* - * Keeps track of how many times an inode is referenced. - */ -static void deallocate_inode(e2fsck_t ctx, ext2_ino_t ino, char* block_buf); -static int check_dir_block(ext2_filsys fs, - struct ext2_db_entry *dir_blocks_info, - void *priv_data); -static int allocate_dir_block(e2fsck_t ctx, - struct ext2_db_entry *dir_blocks_info, - char *buf, struct problem_context *pctx); -static int update_dir_block(ext2_filsys fs, - blk_t *block_nr, - e2_blkcnt_t blockcnt, - blk_t ref_block, - int ref_offset, - void *priv_data); -static void clear_htree(e2fsck_t ctx, ext2_ino_t ino); -static int htree_depth(struct dx_dir_info *dx_dir, - struct dx_dirblock_info *dx_db); -static EXT2_QSORT_TYPE special_dir_block_cmp(const void *a, const void *b); - -struct check_dir_struct { - char *buf; - struct problem_context pctx; - int count, max; - e2fsck_t ctx; -}; - -void e2fsck_pass2(e2fsck_t ctx) -{ - struct ext2_super_block *sb = ctx->fs->super; - struct problem_context pctx; - ext2_filsys fs = ctx->fs; - char *buf; -#ifdef RESOURCE_TRACK - struct resource_track rtrack; -#endif - struct dir_info *dir; - struct check_dir_struct cd; - struct dx_dir_info *dx_dir; - struct dx_dirblock_info *dx_db, *dx_parent; - int b; - int i, depth; - problem_t code; - int bad_dir; - -#ifdef RESOURCE_TRACK - init_resource_track(&rtrack); -#endif - - clear_problem_context(&cd.pctx); - -#ifdef MTRACE - mtrace_print("Pass 2"); -#endif - - if (!(ctx->options & E2F_OPT_PREEN)) - fix_problem(ctx, PR_2_PASS_HEADER, &cd.pctx); - - cd.pctx.errcode = ext2fs_create_icount2(fs, EXT2_ICOUNT_OPT_INCREMENT, - 0, ctx->inode_link_info, - &ctx->inode_count); - if (cd.pctx.errcode) { - fix_problem(ctx, PR_2_ALLOCATE_ICOUNT, &cd.pctx); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - buf = (char *) e2fsck_allocate_memory(ctx, 2*fs->blocksize, - "directory scan buffer"); - - /* - * Set up the parent pointer for the root directory, if - * present. (If the root directory is not present, we will - * create it in pass 3.) - */ - dir = e2fsck_get_dir_info(ctx, EXT2_ROOT_INO); - if (dir) - dir->parent = EXT2_ROOT_INO; - - cd.buf = buf; - cd.ctx = ctx; - cd.count = 1; - cd.max = ext2fs_dblist_count(fs->dblist); - - if (ctx->progress) - (void) (ctx->progress)(ctx, 2, 0, cd.max); - - if (fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_DIR_INDEX) - ext2fs_dblist_sort(fs->dblist, special_dir_block_cmp); - - cd.pctx.errcode = ext2fs_dblist_iterate(fs->dblist, check_dir_block, - &cd); - if (ctx->flags & E2F_FLAG_SIGNAL_MASK) - return; - if (cd.pctx.errcode) { - fix_problem(ctx, PR_2_DBLIST_ITERATE, &cd.pctx); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - -#ifdef ENABLE_HTREE - for (i=0; (dx_dir = e2fsck_dx_dir_info_iter(ctx, &i)) != 0;) { - if (ctx->flags & E2F_FLAG_SIGNAL_MASK) - return; - if (dx_dir->numblocks == 0) - continue; - clear_problem_context(&pctx); - bad_dir = 0; - pctx.dir = dx_dir->ino; - dx_db = dx_dir->dx_block; - if (dx_db->flags & DX_FLAG_REFERENCED) - dx_db->flags |= DX_FLAG_DUP_REF; - else - dx_db->flags |= DX_FLAG_REFERENCED; - /* - * Find all of the first and last leaf blocks, and - * update their parent's min and max hash values - */ - for (b=0, dx_db = dx_dir->dx_block; - b < dx_dir->numblocks; - b++, dx_db++) { - if ((dx_db->type != DX_DIRBLOCK_LEAF) || - !(dx_db->flags & (DX_FLAG_FIRST | DX_FLAG_LAST))) - continue; - dx_parent = &dx_dir->dx_block[dx_db->parent]; - /* - * XXX Make sure dx_parent->min_hash > dx_db->min_hash - */ - if (dx_db->flags & DX_FLAG_FIRST) - dx_parent->min_hash = dx_db->min_hash; - /* - * XXX Make sure dx_parent->max_hash < dx_db->max_hash - */ - if (dx_db->flags & DX_FLAG_LAST) - dx_parent->max_hash = dx_db->max_hash; - } - - for (b=0, dx_db = dx_dir->dx_block; - b < dx_dir->numblocks; - b++, dx_db++) { - pctx.blkcount = b; - pctx.group = dx_db->parent; - code = 0; - if (!(dx_db->flags & DX_FLAG_FIRST) && - (dx_db->min_hash < dx_db->node_min_hash)) { - pctx.blk = dx_db->min_hash; - pctx.blk2 = dx_db->node_min_hash; - code = PR_2_HTREE_MIN_HASH; - fix_problem(ctx, code, &pctx); - bad_dir++; - } - if (dx_db->type == DX_DIRBLOCK_LEAF) { - depth = htree_depth(dx_dir, dx_db); - if (depth != dx_dir->depth) { - code = PR_2_HTREE_BAD_DEPTH; - fix_problem(ctx, code, &pctx); - bad_dir++; - } - } - /* - * This test doesn't apply for the root block - * at block #0 - */ - if (b && - (dx_db->max_hash > dx_db->node_max_hash)) { - pctx.blk = dx_db->max_hash; - pctx.blk2 = dx_db->node_max_hash; - code = PR_2_HTREE_MAX_HASH; - fix_problem(ctx, code, &pctx); - bad_dir++; - } - if (!(dx_db->flags & DX_FLAG_REFERENCED)) { - code = PR_2_HTREE_NOTREF; - fix_problem(ctx, code, &pctx); - bad_dir++; - } else if (dx_db->flags & DX_FLAG_DUP_REF) { - code = PR_2_HTREE_DUPREF; - fix_problem(ctx, code, &pctx); - bad_dir++; - } - if (code == 0) - continue; - } - if (bad_dir && fix_problem(ctx, PR_2_HTREE_CLEAR, &pctx)) { - clear_htree(ctx, dx_dir->ino); - dx_dir->numblocks = 0; - } - } -#endif - ext2fs_free_mem(&buf); - ext2fs_free_dblist(fs->dblist); - - if (ctx->inode_bad_map) { - ext2fs_free_inode_bitmap(ctx->inode_bad_map); - ctx->inode_bad_map = 0; - } - if (ctx->inode_reg_map) { - ext2fs_free_inode_bitmap(ctx->inode_reg_map); - ctx->inode_reg_map = 0; - } - - clear_problem_context(&pctx); - if (ctx->large_files) { - if (!(sb->s_feature_ro_compat & - EXT2_FEATURE_RO_COMPAT_LARGE_FILE) && - fix_problem(ctx, PR_2_FEATURE_LARGE_FILES, &pctx)) { - sb->s_feature_ro_compat |= - EXT2_FEATURE_RO_COMPAT_LARGE_FILE; - ext2fs_mark_super_dirty(fs); - } - if (sb->s_rev_level == EXT2_GOOD_OLD_REV && - fix_problem(ctx, PR_1_FS_REV_LEVEL, &pctx)) { - ext2fs_update_dynamic_rev(fs); - ext2fs_mark_super_dirty(fs); - } - } else if (!ctx->large_files && - (sb->s_feature_ro_compat & - EXT2_FEATURE_RO_COMPAT_LARGE_FILE)) { - if (fs->flags & EXT2_FLAG_RW) { - sb->s_feature_ro_compat &= - ~EXT2_FEATURE_RO_COMPAT_LARGE_FILE; - ext2fs_mark_super_dirty(fs); - } - } - -#ifdef RESOURCE_TRACK - if (ctx->options & E2F_OPT_TIME2) { - e2fsck_clear_progbar(ctx); - print_resource_track(_("Pass 2"), &rtrack); - } -#endif -} - -#define MAX_DEPTH 32000 -static int htree_depth(struct dx_dir_info *dx_dir, - struct dx_dirblock_info *dx_db) -{ - int depth = 0; - - while (dx_db->type != DX_DIRBLOCK_ROOT && depth < MAX_DEPTH) { - dx_db = &dx_dir->dx_block[dx_db->parent]; - depth++; - } - return depth; -} - -static int dict_de_cmp(const void *a, const void *b) -{ - const struct ext2_dir_entry *de_a, *de_b; - int a_len, b_len; - - de_a = (const struct ext2_dir_entry *) a; - a_len = de_a->name_len & 0xFF; - de_b = (const struct ext2_dir_entry *) b; - b_len = de_b->name_len & 0xFF; - - if (a_len != b_len) - return (a_len - b_len); - - return strncmp(de_a->name, de_b->name, a_len); -} - -/* - * This is special sort function that makes sure that directory blocks - * with a dirblock of zero are sorted to the beginning of the list. - * This guarantees that the root node of the htree directories are - * processed first, so we know what hash version to use. - */ -static EXT2_QSORT_TYPE special_dir_block_cmp(const void *a, const void *b) -{ - const struct ext2_db_entry *db_a = - (const struct ext2_db_entry *) a; - const struct ext2_db_entry *db_b = - (const struct ext2_db_entry *) b; - - if (db_a->blockcnt && !db_b->blockcnt) - return 1; - - if (!db_a->blockcnt && db_b->blockcnt) - return -1; - - if (db_a->blk != db_b->blk) - return (int) (db_a->blk - db_b->blk); - - if (db_a->ino != db_b->ino) - return (int) (db_a->ino - db_b->ino); - - return (int) (db_a->blockcnt - db_b->blockcnt); -} - - -/* - * Make sure the first entry in the directory is '.', and that the - * directory entry is sane. - */ -static int check_dot(e2fsck_t ctx, - struct ext2_dir_entry *dirent, - ext2_ino_t ino, struct problem_context *pctx) -{ - struct ext2_dir_entry *nextdir; - int status = 0; - int created = 0; - int new_len; - int problem = 0; - - if (!dirent->inode) - problem = PR_2_MISSING_DOT; - else if (((dirent->name_len & 0xFF) != 1) || - (dirent->name[0] != '.')) - problem = PR_2_1ST_NOT_DOT; - else if (dirent->name[1] != '\0') - problem = PR_2_DOT_NULL_TERM; - - if (problem) { - if (fix_problem(ctx, problem, pctx)) { - if (dirent->rec_len < 12) - dirent->rec_len = 12; - dirent->inode = ino; - dirent->name_len = 1; - dirent->name[0] = '.'; - dirent->name[1] = '\0'; - status = 1; - created = 1; - } - } - if (dirent->inode != ino) { - if (fix_problem(ctx, PR_2_BAD_INODE_DOT, pctx)) { - dirent->inode = ino; - status = 1; - } - } - if (dirent->rec_len > 12) { - new_len = dirent->rec_len - 12; - if (new_len > 12) { - if (created || - fix_problem(ctx, PR_2_SPLIT_DOT, pctx)) { - nextdir = (struct ext2_dir_entry *) - ((char *) dirent + 12); - dirent->rec_len = 12; - nextdir->rec_len = new_len; - nextdir->inode = 0; - nextdir->name_len = 0; - status = 1; - } - } - } - return status; -} - -/* - * Make sure the second entry in the directory is '..', and that the - * directory entry is sane. We do not check the inode number of '..' - * here; this gets done in pass 3. - */ -static int check_dotdot(e2fsck_t ctx, - struct ext2_dir_entry *dirent, - struct dir_info *dir, struct problem_context *pctx) -{ - int problem = 0; - - if (!dirent->inode) - problem = PR_2_MISSING_DOT_DOT; - else if (((dirent->name_len & 0xFF) != 2) || - (dirent->name[0] != '.') || - (dirent->name[1] != '.')) - problem = PR_2_2ND_NOT_DOT_DOT; - else if (dirent->name[2] != '\0') - problem = PR_2_DOT_DOT_NULL_TERM; - - if (problem) { - if (fix_problem(ctx, problem, pctx)) { - if (dirent->rec_len < 12) - dirent->rec_len = 12; - /* - * Note: we don't have the parent inode just - * yet, so we will fill it in with the root - * inode. This will get fixed in pass 3. - */ - dirent->inode = EXT2_ROOT_INO; - dirent->name_len = 2; - dirent->name[0] = '.'; - dirent->name[1] = '.'; - dirent->name[2] = '\0'; - return 1; - } - return 0; - } - dir->dotdot = dirent->inode; - return 0; -} - -/* - * Check to make sure a directory entry doesn't contain any illegal - * characters. - */ -static int check_name(e2fsck_t ctx, - struct ext2_dir_entry *dirent, - ext2_ino_t dir_ino EXT2FS_ATTR((unused)), - struct problem_context *pctx) -{ - int i; - int fixup = -1; - int ret = 0; - - for ( i = 0; i < (dirent->name_len & 0xFF); i++) { - if (dirent->name[i] == '/' || dirent->name[i] == '\0') { - if (fixup < 0) { - fixup = fix_problem(ctx, PR_2_BAD_NAME, pctx); - } - if (fixup) { - dirent->name[i] = '.'; - ret = 1; - } - } - } - return ret; -} - -/* - * Check the directory filetype (if present) - */ -static _INLINE_ int check_filetype(e2fsck_t ctx, - struct ext2_dir_entry *dirent, - ext2_ino_t dir_ino EXT2FS_ATTR((unused)), - struct problem_context *pctx) -{ - int filetype = dirent->name_len >> 8; - int should_be = EXT2_FT_UNKNOWN; - struct ext2_inode inode; - - if (!(ctx->fs->super->s_feature_incompat & - EXT2_FEATURE_INCOMPAT_FILETYPE)) { - if (filetype == 0 || - !fix_problem(ctx, PR_2_CLEAR_FILETYPE, pctx)) - return 0; - dirent->name_len = dirent->name_len & 0xFF; - return 1; - } - - if (ext2fs_test_inode_bitmap(ctx->inode_dir_map, dirent->inode)) { - should_be = EXT2_FT_DIR; - } else if (ext2fs_test_inode_bitmap(ctx->inode_reg_map, - dirent->inode)) { - should_be = EXT2_FT_REG_FILE; - } else if (ctx->inode_bad_map && - ext2fs_test_inode_bitmap(ctx->inode_bad_map, - dirent->inode)) - should_be = 0; - else { - e2fsck_read_inode(ctx, dirent->inode, &inode, - "check_filetype"); - should_be = ext2_file_type(inode.i_mode); - } - if (filetype == should_be) - return 0; - pctx->num = should_be; - - if (fix_problem(ctx, filetype ? PR_2_BAD_FILETYPE : PR_2_SET_FILETYPE, - pctx) == 0) - return 0; - - dirent->name_len = (dirent->name_len & 0xFF) | should_be << 8; - return 1; -} - -#ifdef ENABLE_HTREE -static void parse_int_node(ext2_filsys fs, - struct ext2_db_entry *db, - struct check_dir_struct *cd, - struct dx_dir_info *dx_dir, - char *block_buf) -{ - struct ext2_dx_root_info *root; - struct ext2_dx_entry *ent; - struct ext2_dx_countlimit *limit; - struct dx_dirblock_info *dx_db; - int i, expect_limit, count; - blk_t blk; - ext2_dirhash_t min_hash = 0xffffffff; - ext2_dirhash_t max_hash = 0; - ext2_dirhash_t hash = 0, prev_hash; - - if (db->blockcnt == 0) { - root = (struct ext2_dx_root_info *) (block_buf + 24); - -#ifdef DX_DEBUG - printf("Root node dump:\n"); - printf("\t Reserved zero: %d\n", root->reserved_zero); - printf("\t Hash Version: %d\n", root->hash_version); - printf("\t Info length: %d\n", root->info_length); - printf("\t Indirect levels: %d\n", root->indirect_levels); - printf("\t Flags: %d\n", root->unused_flags); -#endif - - ent = (struct ext2_dx_entry *) (block_buf + 24 + root->info_length); - } else { - ent = (struct ext2_dx_entry *) (block_buf+8); - } - limit = (struct ext2_dx_countlimit *) ent; - -#ifdef DX_DEBUG - printf("Number of entries (count): %d\n", - ext2fs_le16_to_cpu(limit->count)); - printf("Number of entries (limit): %d\n", - ext2fs_le16_to_cpu(limit->limit)); -#endif - - count = ext2fs_le16_to_cpu(limit->count); - expect_limit = (fs->blocksize - ((char *) ent - block_buf)) / - sizeof(struct ext2_dx_entry); - if (ext2fs_le16_to_cpu(limit->limit) != expect_limit) { - cd->pctx.num = ext2fs_le16_to_cpu(limit->limit); - if (fix_problem(cd->ctx, PR_2_HTREE_BAD_LIMIT, &cd->pctx)) - goto clear_and_exit; - } - if (count > expect_limit) { - cd->pctx.num = count; - if (fix_problem(cd->ctx, PR_2_HTREE_BAD_COUNT, &cd->pctx)) - goto clear_and_exit; - count = expect_limit; - } - - for (i=0; i < count; i++) { - prev_hash = hash; - hash = i ? (ext2fs_le32_to_cpu(ent[i].hash) & ~1) : 0; -#ifdef DX_DEBUG - printf("Entry #%d: Hash 0x%08x, block %d\n", i, - hash, ext2fs_le32_to_cpu(ent[i].block)); -#endif - blk = ext2fs_le32_to_cpu(ent[i].block) & 0x0ffffff; - /* Check to make sure the block is valid */ - if (blk > (blk_t) dx_dir->numblocks) { - cd->pctx.blk = blk; - if (fix_problem(cd->ctx, PR_2_HTREE_BADBLK, - &cd->pctx)) - goto clear_and_exit; - } - if (hash < prev_hash && - fix_problem(cd->ctx, PR_2_HTREE_HASH_ORDER, &cd->pctx)) - goto clear_and_exit; - dx_db = &dx_dir->dx_block[blk]; - if (dx_db->flags & DX_FLAG_REFERENCED) { - dx_db->flags |= DX_FLAG_DUP_REF; - } else { - dx_db->flags |= DX_FLAG_REFERENCED; - dx_db->parent = db->blockcnt; - } - if (hash < min_hash) - min_hash = hash; - if (hash > max_hash) - max_hash = hash; - dx_db->node_min_hash = hash; - if ((i+1) < count) - dx_db->node_max_hash = - ext2fs_le32_to_cpu(ent[i+1].hash) & ~1; - else { - dx_db->node_max_hash = 0xfffffffe; - dx_db->flags |= DX_FLAG_LAST; - } - if (i == 0) - dx_db->flags |= DX_FLAG_FIRST; - } -#ifdef DX_DEBUG - printf("Blockcnt = %d, min hash 0x%08x, max hash 0x%08x\n", - db->blockcnt, min_hash, max_hash); -#endif - dx_db = &dx_dir->dx_block[db->blockcnt]; - dx_db->min_hash = min_hash; - dx_db->max_hash = max_hash; - return; - -clear_and_exit: - clear_htree(cd->ctx, cd->pctx.ino); - dx_dir->numblocks = 0; -} -#endif /* ENABLE_HTREE */ - -/* - * Given a busted directory, try to salvage it somehow. - * - */ -static void salvage_directory(ext2_filsys fs, - struct ext2_dir_entry *dirent, - struct ext2_dir_entry *prev, - unsigned int *offset) -{ - char *cp = (char *) dirent; - int left = fs->blocksize - *offset - dirent->rec_len; - int name_len = dirent->name_len & 0xFF; - - /* - * Special case of directory entry of size 8: copy what's left - * of the directory block up to cover up the invalid hole. - */ - if ((left >= 12) && (dirent->rec_len == 8)) { - memmove(cp, cp+8, left); - memset(cp + left, 0, 8); - return; - } - /* - * If the directory entry overruns the end of the directory - * block, and the name is small enough to fit, then adjust the - * record length. - */ - if ((left < 0) && - (name_len + 8 <= dirent->rec_len + left) && - dirent->inode <= fs->super->s_inodes_count && - strnlen(dirent->name, name_len) == name_len) { - dirent->rec_len += left; - return; - } - /* - * If the directory entry is a multiple of four, so it is - * valid, let the previous directory entry absorb the invalid - * one. - */ - if (prev && dirent->rec_len && (dirent->rec_len % 4) == 0) { - prev->rec_len += dirent->rec_len; - *offset += dirent->rec_len; - return; - } - /* - * Default salvage method --- kill all of the directory - * entries for the rest of the block. We will either try to - * absorb it into the previous directory entry, or create a - * new empty directory entry the rest of the directory block. - */ - if (prev) { - prev->rec_len += fs->blocksize - *offset; - *offset = fs->blocksize; - } else { - dirent->rec_len = fs->blocksize - *offset; - dirent->name_len = 0; - dirent->inode = 0; - } -} - -static int check_dir_block(ext2_filsys fs, - struct ext2_db_entry *db, - void *priv_data) -{ - struct dir_info *subdir, *dir; - struct dx_dir_info *dx_dir; -#ifdef ENABLE_HTREE - struct dx_dirblock_info *dx_db = 0; -#endif /* ENABLE_HTREE */ - struct ext2_dir_entry *dirent, *prev; - ext2_dirhash_t hash; - unsigned int offset = 0; - int dir_modified = 0; - int dot_state; - blk_t block_nr = db->blk; - ext2_ino_t ino = db->ino; - __u16 links; - struct check_dir_struct *cd; - char *buf; - e2fsck_t ctx; - int problem; - struct ext2_dx_root_info *root; - struct ext2_dx_countlimit *limit; - static dict_t de_dict; - struct problem_context pctx; - int dups_found = 0; - - cd = (struct check_dir_struct *) priv_data; - buf = cd->buf; - ctx = cd->ctx; - - if (ctx->flags & E2F_FLAG_SIGNAL_MASK) - return DIRENT_ABORT; - - if (ctx->progress && (ctx->progress)(ctx, 2, cd->count++, cd->max)) - return DIRENT_ABORT; - - /* - * Make sure the inode is still in use (could have been - * deleted in the duplicate/bad blocks pass. - */ - if (!(ext2fs_test_inode_bitmap(ctx->inode_used_map, ino))) - return 0; - - cd->pctx.ino = ino; - cd->pctx.blk = block_nr; - cd->pctx.blkcount = db->blockcnt; - cd->pctx.ino2 = 0; - cd->pctx.dirent = 0; - cd->pctx.num = 0; - - if (db->blk == 0) { - if (allocate_dir_block(ctx, db, buf, &cd->pctx)) - return 0; - block_nr = db->blk; - } - - if (db->blockcnt) - dot_state = 2; - else - dot_state = 0; - - if (ctx->dirs_to_hash && - ext2fs_u32_list_test(ctx->dirs_to_hash, ino)) - dups_found++; - -#if 0 - printf("In process_dir_block block %lu, #%d, inode %lu\n", block_nr, - db->blockcnt, ino); -#endif - - cd->pctx.errcode = ext2fs_read_dir_block(fs, block_nr, buf); - if (cd->pctx.errcode == EXT2_ET_DIR_CORRUPTED) - cd->pctx.errcode = 0; /* We'll handle this ourselves */ - if (cd->pctx.errcode) { - if (!fix_problem(ctx, PR_2_READ_DIRBLOCK, &cd->pctx)) { - ctx->flags |= E2F_FLAG_ABORT; - return DIRENT_ABORT; - } - memset(buf, 0, fs->blocksize); - } -#ifdef ENABLE_HTREE - dx_dir = e2fsck_get_dx_dir_info(ctx, ino); - if (dx_dir && dx_dir->numblocks) { - if (db->blockcnt >= dx_dir->numblocks) { - printf("XXX should never happen!!!\n"); - abort(); - } - dx_db = &dx_dir->dx_block[db->blockcnt]; - dx_db->type = DX_DIRBLOCK_LEAF; - dx_db->phys = block_nr; - dx_db->min_hash = ~0; - dx_db->max_hash = 0; - - dirent = (struct ext2_dir_entry *) buf; - limit = (struct ext2_dx_countlimit *) (buf+8); - if (db->blockcnt == 0) { - root = (struct ext2_dx_root_info *) (buf + 24); - dx_db->type = DX_DIRBLOCK_ROOT; - dx_db->flags |= DX_FLAG_FIRST | DX_FLAG_LAST; - if ((root->reserved_zero || - root->info_length < 8 || - root->indirect_levels > 1) && - fix_problem(ctx, PR_2_HTREE_BAD_ROOT, &cd->pctx)) { - clear_htree(ctx, ino); - dx_dir->numblocks = 0; - dx_db = 0; - } - dx_dir->hashversion = root->hash_version; - dx_dir->depth = root->indirect_levels + 1; - } else if ((dirent->inode == 0) && - (dirent->rec_len == fs->blocksize) && - (dirent->name_len == 0) && - (ext2fs_le16_to_cpu(limit->limit) == - ((fs->blocksize-8) / - sizeof(struct ext2_dx_entry)))) - dx_db->type = DX_DIRBLOCK_NODE; - } -#endif /* ENABLE_HTREE */ - - dict_init(&de_dict, DICTCOUNT_T_MAX, dict_de_cmp); - prev = 0; - do { - problem = 0; - dirent = (struct ext2_dir_entry *) (buf + offset); - cd->pctx.dirent = dirent; - cd->pctx.num = offset; - if (((offset + dirent->rec_len) > fs->blocksize) || - (dirent->rec_len < 12) || - ((dirent->rec_len % 4) != 0) || - (((dirent->name_len & 0xFF)+8) > dirent->rec_len)) { - if (fix_problem(ctx, PR_2_DIR_CORRUPTED, &cd->pctx)) { - salvage_directory(fs, dirent, prev, &offset); - dir_modified++; - continue; - } else - goto abort_free_dict; - } - if ((dirent->name_len & 0xFF) > EXT2_NAME_LEN) { - if (fix_problem(ctx, PR_2_FILENAME_LONG, &cd->pctx)) { - dirent->name_len = EXT2_NAME_LEN; - dir_modified++; - } - } - - if (dot_state == 0) { - if (check_dot(ctx, dirent, ino, &cd->pctx)) - dir_modified++; - } else if (dot_state == 1) { - dir = e2fsck_get_dir_info(ctx, ino); - if (!dir) { - fix_problem(ctx, PR_2_NO_DIRINFO, &cd->pctx); - goto abort_free_dict; - } - if (check_dotdot(ctx, dirent, dir, &cd->pctx)) - dir_modified++; - } else if (dirent->inode == ino) { - problem = PR_2_LINK_DOT; - if (fix_problem(ctx, PR_2_LINK_DOT, &cd->pctx)) { - dirent->inode = 0; - dir_modified++; - goto next; - } - } - if (!dirent->inode) - goto next; - - /* - * Make sure the inode listed is a legal one. - */ - if (((dirent->inode != EXT2_ROOT_INO) && - (dirent->inode < EXT2_FIRST_INODE(fs->super))) || - (dirent->inode > fs->super->s_inodes_count)) { - problem = PR_2_BAD_INO; - } else if (!(ext2fs_test_inode_bitmap(ctx->inode_used_map, - dirent->inode))) { - /* - * If the inode is unused, offer to clear it. - */ - problem = PR_2_UNUSED_INODE; - } else if (ctx->inode_bb_map && - (ext2fs_test_inode_bitmap(ctx->inode_bb_map, - dirent->inode))) { - /* - * If the inode is in a bad block, offer to - * clear it. - */ - problem = PR_2_BB_INODE; - } else if ((dot_state > 1) && - ((dirent->name_len & 0xFF) == 1) && - (dirent->name[0] == '.')) { - /* - * If there's a '.' entry in anything other - * than the first directory entry, it's a - * duplicate entry that should be removed. - */ - problem = PR_2_DUP_DOT; - } else if ((dot_state > 1) && - ((dirent->name_len & 0xFF) == 2) && - (dirent->name[0] == '.') && - (dirent->name[1] == '.')) { - /* - * If there's a '..' entry in anything other - * than the second directory entry, it's a - * duplicate entry that should be removed. - */ - problem = PR_2_DUP_DOT_DOT; - } else if ((dot_state > 1) && - (dirent->inode == EXT2_ROOT_INO)) { - /* - * Don't allow links to the root directory. - * We check this specially to make sure we - * catch this error case even if the root - * directory hasn't been created yet. - */ - problem = PR_2_LINK_ROOT; - } else if ((dot_state > 1) && - (dirent->name_len & 0xFF) == 0) { - /* - * Don't allow zero-length directory names. - */ - problem = PR_2_NULL_NAME; - } - - if (problem) { - if (fix_problem(ctx, problem, &cd->pctx)) { - dirent->inode = 0; - dir_modified++; - goto next; - } else { - ext2fs_unmark_valid(fs); - if (problem == PR_2_BAD_INO) - goto next; - } - } - - /* - * If the inode was marked as having bad fields in - * pass1, process it and offer to fix/clear it. - * (We wait until now so that we can display the - * pathname to the user.) - */ - if (ctx->inode_bad_map && - ext2fs_test_inode_bitmap(ctx->inode_bad_map, - dirent->inode)) { - if (e2fsck_process_bad_inode(ctx, ino, - dirent->inode, - buf + fs->blocksize)) { - dirent->inode = 0; - dir_modified++; - goto next; - } - if (ctx->flags & E2F_FLAG_SIGNAL_MASK) - return DIRENT_ABORT; - } - - if (check_name(ctx, dirent, ino, &cd->pctx)) - dir_modified++; - - if (check_filetype(ctx, dirent, ino, &cd->pctx)) - dir_modified++; - -#ifdef ENABLE_HTREE - if (dx_db) { - ext2fs_dirhash(dx_dir->hashversion, dirent->name, - (dirent->name_len & 0xFF), - fs->super->s_hash_seed, &hash, 0); - if (hash < dx_db->min_hash) - dx_db->min_hash = hash; - if (hash > dx_db->max_hash) - dx_db->max_hash = hash; - } -#endif - - /* - * If this is a directory, then mark its parent in its - * dir_info structure. If the parent field is already - * filled in, then this directory has more than one - * hard link. We assume the first link is correct, - * and ask the user if he/she wants to clear this one. - */ - if ((dot_state > 1) && - (ext2fs_test_inode_bitmap(ctx->inode_dir_map, - dirent->inode))) { - subdir = e2fsck_get_dir_info(ctx, dirent->inode); - if (!subdir) { - cd->pctx.ino = dirent->inode; - fix_problem(ctx, PR_2_NO_DIRINFO, &cd->pctx); - goto abort_free_dict; - } - if (subdir->parent) { - cd->pctx.ino2 = subdir->parent; - if (fix_problem(ctx, PR_2_LINK_DIR, - &cd->pctx)) { - dirent->inode = 0; - dir_modified++; - goto next; - } - cd->pctx.ino2 = 0; - } else - subdir->parent = ino; - } - - if (dups_found) { - ; - } else if (dict_lookup(&de_dict, dirent)) { - clear_problem_context(&pctx); - pctx.ino = ino; - pctx.dirent = dirent; - fix_problem(ctx, PR_2_REPORT_DUP_DIRENT, &pctx); - if (!ctx->dirs_to_hash) - ext2fs_u32_list_create(&ctx->dirs_to_hash, 50); - if (ctx->dirs_to_hash) - ext2fs_u32_list_add(ctx->dirs_to_hash, ino); - dups_found++; - } else - dict_alloc_insert(&de_dict, dirent, dirent); - - ext2fs_icount_increment(ctx->inode_count, dirent->inode, - &links); - if (links > 1) - ctx->fs_links_count++; - ctx->fs_total_count++; - next: - prev = dirent; - offset += dirent->rec_len; - dot_state++; - } while (offset < fs->blocksize); -#if 0 - printf("\n"); -#endif -#ifdef ENABLE_HTREE - if (dx_db) { -#ifdef DX_DEBUG - printf("db_block %d, type %d, min_hash 0x%0x, max_hash 0x%0x\n", - db->blockcnt, dx_db->type, - dx_db->min_hash, dx_db->max_hash); -#endif - cd->pctx.dir = cd->pctx.ino; - if ((dx_db->type == DX_DIRBLOCK_ROOT) || - (dx_db->type == DX_DIRBLOCK_NODE)) - parse_int_node(fs, db, cd, dx_dir, buf); - } -#endif /* ENABLE_HTREE */ - if (offset != fs->blocksize) { - cd->pctx.num = dirent->rec_len - fs->blocksize + offset; - if (fix_problem(ctx, PR_2_FINAL_RECLEN, &cd->pctx)) { - dirent->rec_len = cd->pctx.num; - dir_modified++; - } - } - if (dir_modified) { - cd->pctx.errcode = ext2fs_write_dir_block(fs, block_nr, buf); - if (cd->pctx.errcode) { - if (!fix_problem(ctx, PR_2_WRITE_DIRBLOCK, - &cd->pctx)) - goto abort_free_dict; - } - ext2fs_mark_changed(fs); - } - dict_free_nodes(&de_dict); - return 0; -abort_free_dict: - dict_free_nodes(&de_dict); - ctx->flags |= E2F_FLAG_ABORT; - return DIRENT_ABORT; -} - -/* - * This function is called to deallocate a block, and is an interator - * functioned called by deallocate inode via ext2fs_iterate_block(). - */ -static int deallocate_inode_block(ext2_filsys fs, - blk_t *block_nr, - e2_blkcnt_t blockcnt EXT2FS_ATTR((unused)), - blk_t ref_block EXT2FS_ATTR((unused)), - int ref_offset EXT2FS_ATTR((unused)), - void *priv_data) -{ - e2fsck_t ctx = (e2fsck_t) priv_data; - - if (HOLE_BLKADDR(*block_nr)) - return 0; - if ((*block_nr < fs->super->s_first_data_block) || - (*block_nr >= fs->super->s_blocks_count)) - return 0; - ext2fs_unmark_block_bitmap(ctx->block_found_map, *block_nr); - ext2fs_block_alloc_stats(fs, *block_nr, -1); - return 0; -} - -/* - * This fuction deallocates an inode - */ -static void deallocate_inode(e2fsck_t ctx, ext2_ino_t ino, char* block_buf) -{ - ext2_filsys fs = ctx->fs; - struct ext2_inode inode; - struct problem_context pctx; - __u32 count; - - ext2fs_icount_store(ctx->inode_link_info, ino, 0); - e2fsck_read_inode(ctx, ino, &inode, "deallocate_inode"); - inode.i_links_count = 0; - inode.i_dtime = time(0); - e2fsck_write_inode(ctx, ino, &inode, "deallocate_inode"); - clear_problem_context(&pctx); - pctx.ino = ino; - - /* - * Fix up the bitmaps... - */ - e2fsck_read_bitmaps(ctx); - ext2fs_unmark_inode_bitmap(ctx->inode_used_map, ino); - ext2fs_unmark_inode_bitmap(ctx->inode_dir_map, ino); - if (ctx->inode_bad_map) - ext2fs_unmark_inode_bitmap(ctx->inode_bad_map, ino); - ext2fs_inode_alloc_stats2(fs, ino, -1, LINUX_S_ISDIR(inode.i_mode)); - - if (inode.i_file_acl && - (fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_EXT_ATTR)) { - pctx.errcode = ext2fs_adjust_ea_refcount(fs, inode.i_file_acl, - block_buf, -1, &count); - if (pctx.errcode == EXT2_ET_BAD_EA_BLOCK_NUM) { - pctx.errcode = 0; - count = 1; - } - if (pctx.errcode) { - pctx.blk = inode.i_file_acl; - fix_problem(ctx, PR_2_ADJ_EA_REFCOUNT, &pctx); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - if (count == 0) { - ext2fs_unmark_block_bitmap(ctx->block_found_map, - inode.i_file_acl); - ext2fs_block_alloc_stats(fs, inode.i_file_acl, -1); - } - inode.i_file_acl = 0; - } - - if (!ext2fs_inode_has_valid_blocks(&inode)) - return; - - if (LINUX_S_ISREG(inode.i_mode) && - (inode.i_size_high || inode.i_size & 0x80000000UL)) - ctx->large_files--; - - pctx.errcode = ext2fs_block_iterate2(fs, ino, 0, block_buf, - deallocate_inode_block, ctx); - if (pctx.errcode) { - fix_problem(ctx, PR_2_DEALLOC_INODE, &pctx); - ctx->flags |= E2F_FLAG_ABORT; - return; - } -} - -/* - * This fuction clears the htree flag on an inode - */ -static void clear_htree(e2fsck_t ctx, ext2_ino_t ino) -{ - struct ext2_inode inode; - - e2fsck_read_inode(ctx, ino, &inode, "clear_htree"); - inode.i_flags = inode.i_flags & ~EXT2_INDEX_FL; - e2fsck_write_inode(ctx, ino, &inode, "clear_htree"); - if (ctx->dirs_to_hash) - ext2fs_u32_list_add(ctx->dirs_to_hash, ino); -} - - -extern int e2fsck_process_bad_inode(e2fsck_t ctx, ext2_ino_t dir, - ext2_ino_t ino, char *buf) -{ - ext2_filsys fs = ctx->fs; - struct ext2_inode inode; - int inode_modified = 0; - int not_fixed = 0; - unsigned char *frag, *fsize; - struct problem_context pctx; - int problem = 0; - - e2fsck_read_inode(ctx, ino, &inode, "process_bad_inode"); - - clear_problem_context(&pctx); - pctx.ino = ino; - pctx.dir = dir; - pctx.inode = &inode; - - if (inode.i_file_acl && - !(fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_EXT_ATTR) && - fix_problem(ctx, PR_2_FILE_ACL_ZERO, &pctx)) { - inode.i_file_acl = 0; -#ifdef EXT2FS_ENABLE_SWAPFS - /* - * This is a special kludge to deal with long symlinks - * on big endian systems. i_blocks had already been - * decremented earlier in pass 1, but since i_file_acl - * hadn't yet been cleared, ext2fs_read_inode() - * assumed that the file was short symlink and would - * not have byte swapped i_block[0]. Hence, we have - * to byte-swap it here. - */ - if (LINUX_S_ISLNK(inode.i_mode) && - (fs->flags & EXT2_FLAG_SWAP_BYTES) && - (inode.i_blocks == fs->blocksize >> 9)) - inode.i_block[0] = ext2fs_swab32(inode.i_block[0]); -#endif - inode_modified++; - } else - not_fixed++; - - if (!LINUX_S_ISDIR(inode.i_mode) && !LINUX_S_ISREG(inode.i_mode) && - !LINUX_S_ISCHR(inode.i_mode) && !LINUX_S_ISBLK(inode.i_mode) && - !LINUX_S_ISLNK(inode.i_mode) && !LINUX_S_ISFIFO(inode.i_mode) && - !(LINUX_S_ISSOCK(inode.i_mode))) - problem = PR_2_BAD_MODE; - else if (LINUX_S_ISCHR(inode.i_mode) - && !e2fsck_pass1_check_device_inode(fs, &inode)) - problem = PR_2_BAD_CHAR_DEV; - else if (LINUX_S_ISBLK(inode.i_mode) - && !e2fsck_pass1_check_device_inode(fs, &inode)) - problem = PR_2_BAD_BLOCK_DEV; - else if (LINUX_S_ISFIFO(inode.i_mode) - && !e2fsck_pass1_check_device_inode(fs, &inode)) - problem = PR_2_BAD_FIFO; - else if (LINUX_S_ISSOCK(inode.i_mode) - && !e2fsck_pass1_check_device_inode(fs, &inode)) - problem = PR_2_BAD_SOCKET; - else if (LINUX_S_ISLNK(inode.i_mode) - && !e2fsck_pass1_check_symlink(fs, &inode, buf)) { - problem = PR_2_INVALID_SYMLINK; - } - - if (problem) { - if (fix_problem(ctx, problem, &pctx)) { - deallocate_inode(ctx, ino, 0); - if (ctx->flags & E2F_FLAG_SIGNAL_MASK) - return 0; - return 1; - } else - not_fixed++; - problem = 0; - } - - if (inode.i_faddr) { - if (fix_problem(ctx, PR_2_FADDR_ZERO, &pctx)) { - inode.i_faddr = 0; - inode_modified++; - } else - not_fixed++; - } - - switch (fs->super->s_creator_os) { - case EXT2_OS_LINUX: - frag = &inode.osd2.linux2.l_i_frag; - fsize = &inode.osd2.linux2.l_i_fsize; - break; - case EXT2_OS_HURD: - frag = &inode.osd2.hurd2.h_i_frag; - fsize = &inode.osd2.hurd2.h_i_fsize; - break; - case EXT2_OS_MASIX: - frag = &inode.osd2.masix2.m_i_frag; - fsize = &inode.osd2.masix2.m_i_fsize; - break; - default: - frag = fsize = 0; - } - if (frag && *frag) { - pctx.num = *frag; - if (fix_problem(ctx, PR_2_FRAG_ZERO, &pctx)) { - *frag = 0; - inode_modified++; - } else - not_fixed++; - pctx.num = 0; - } - if (fsize && *fsize) { - pctx.num = *fsize; - if (fix_problem(ctx, PR_2_FSIZE_ZERO, &pctx)) { - *fsize = 0; - inode_modified++; - } else - not_fixed++; - pctx.num = 0; - } - - if (inode.i_file_acl && - ((inode.i_file_acl < fs->super->s_first_data_block) || - (inode.i_file_acl >= fs->super->s_blocks_count))) { - if (fix_problem(ctx, PR_2_FILE_ACL_BAD, &pctx)) { - inode.i_file_acl = 0; - inode_modified++; - } else - not_fixed++; - } - if (inode.i_dir_acl && - LINUX_S_ISDIR(inode.i_mode)) { - if (fix_problem(ctx, PR_2_DIR_ACL_ZERO, &pctx)) { - inode.i_dir_acl = 0; - inode_modified++; - } else - not_fixed++; - } - - if (inode_modified) - e2fsck_write_inode(ctx, ino, &inode, "process_bad_inode"); - if (!not_fixed) - ext2fs_unmark_inode_bitmap(ctx->inode_bad_map, ino); - return 0; -} - - -/* - * allocate_dir_block --- this function allocates a new directory - * block for a particular inode; this is done if a directory has - * a "hole" in it, or if a directory has a illegal block number - * that was zeroed out and now needs to be replaced. - */ -static int allocate_dir_block(e2fsck_t ctx, - struct ext2_db_entry *db, - char *buf EXT2FS_ATTR((unused)), - struct problem_context *pctx) -{ - ext2_filsys fs = ctx->fs; - blk_t blk; - char *block; - struct ext2_inode inode; - - if (fix_problem(ctx, PR_2_DIRECTORY_HOLE, pctx) == 0) - return 1; - - /* - * Read the inode and block bitmaps in; we'll be messing with - * them. - */ - e2fsck_read_bitmaps(ctx); - - /* - * First, find a free block - */ - pctx->errcode = ext2fs_new_block(fs, 0, ctx->block_found_map, &blk); - if (pctx->errcode) { - pctx->str = "ext2fs_new_block"; - fix_problem(ctx, PR_2_ALLOC_DIRBOCK, pctx); - return 1; - } - ext2fs_mark_block_bitmap(ctx->block_found_map, blk); - ext2fs_mark_block_bitmap(fs->block_map, blk); - ext2fs_mark_bb_dirty(fs); - - /* - * Now let's create the actual data block for the inode - */ - if (db->blockcnt) - pctx->errcode = ext2fs_new_dir_block(fs, 0, 0, &block); - else - pctx->errcode = ext2fs_new_dir_block(fs, db->ino, - EXT2_ROOT_INO, &block); - - if (pctx->errcode) { - pctx->str = "ext2fs_new_dir_block"; - fix_problem(ctx, PR_2_ALLOC_DIRBOCK, pctx); - return 1; - } - - pctx->errcode = ext2fs_write_dir_block(fs, blk, block); - ext2fs_free_mem(&block); - if (pctx->errcode) { - pctx->str = "ext2fs_write_dir_block"; - fix_problem(ctx, PR_2_ALLOC_DIRBOCK, pctx); - return 1; - } - - /* - * Update the inode block count - */ - e2fsck_read_inode(ctx, db->ino, &inode, "allocate_dir_block"); - inode.i_blocks += fs->blocksize / 512; - if (inode.i_size < (db->blockcnt+1) * fs->blocksize) - inode.i_size = (db->blockcnt+1) * fs->blocksize; - e2fsck_write_inode(ctx, db->ino, &inode, "allocate_dir_block"); - - /* - * Finally, update the block pointers for the inode - */ - db->blk = blk; - pctx->errcode = ext2fs_block_iterate2(fs, db->ino, BLOCK_FLAG_HOLE, - 0, update_dir_block, db); - if (pctx->errcode) { - pctx->str = "ext2fs_block_iterate"; - fix_problem(ctx, PR_2_ALLOC_DIRBOCK, pctx); - return 1; - } - - return 0; -} - -/* - * This is a helper function for allocate_dir_block(). - */ -static int update_dir_block(ext2_filsys fs EXT2FS_ATTR((unused)), - blk_t *block_nr, - e2_blkcnt_t blockcnt, - blk_t ref_block EXT2FS_ATTR((unused)), - int ref_offset EXT2FS_ATTR((unused)), - void *priv_data) -{ - struct ext2_db_entry *db; - - db = (struct ext2_db_entry *) priv_data; - if (db->blockcnt == (int) blockcnt) { - *block_nr = db->blk; - return BLOCK_CHANGED; - } - return 0; -} diff --git a/e2fsprogs/e2fsck/pass3.c b/e2fsprogs/e2fsck/pass3.c deleted file mode 100644 index a92c8904c..000000000 --- a/e2fsprogs/e2fsck/pass3.c +++ /dev/null @@ -1,804 +0,0 @@ -/* - * pass3.c -- pass #3 of e2fsck: Check for directory connectivity - * - * Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999 Theodore Ts'o. - * - * %Begin-Header% - * This file may be redistributed under the terms of the GNU Public - * License. - * %End-Header% - * - * Pass #3 assures that all directories are connected to the - * filesystem tree, using the following algorithm: - * - * First, the root directory is checked to make sure it exists; if - * not, e2fsck will offer to create a new one. It is then marked as - * "done". - * - * Then, pass3 interates over all directory inodes; for each directory - * it attempts to trace up the filesystem tree, using dirinfo.parent - * until it reaches a directory which has been marked "done". If it - * can not do so, then the directory must be disconnected, and e2fsck - * will offer to reconnect it to /lost+found. While it is chasing - * parent pointers up the filesystem tree, if pass3 sees a directory - * twice, then it has detected a filesystem loop, and it will again - * offer to reconnect the directory to /lost+found in to break the - * filesystem loop. - * - * Pass 3 also contains the subroutine, e2fsck_reconnect_file() to - * reconnect inodes to /lost+found; this subroutine is also used by - * pass 4. e2fsck_reconnect_file() calls get_lost_and_found(), which - * is responsible for creating /lost+found if it does not exist. - * - * Pass 3 frees the following data structures: - * - The dirinfo directory information cache. - */ - -#ifdef HAVE_ERRNO_H -#include -#endif - -#include "e2fsck.h" -#include "problem.h" - -static void check_root(e2fsck_t ctx); -static int check_directory(e2fsck_t ctx, struct dir_info *dir, - struct problem_context *pctx); -static void fix_dotdot(e2fsck_t ctx, struct dir_info *dir, ext2_ino_t parent); - -static ext2fs_inode_bitmap inode_loop_detect = 0; -static ext2fs_inode_bitmap inode_done_map = 0; - -void e2fsck_pass3(e2fsck_t ctx) -{ - ext2_filsys fs = ctx->fs; - int i; -#ifdef RESOURCE_TRACK - struct resource_track rtrack; -#endif - struct problem_context pctx; - struct dir_info *dir; - unsigned long maxdirs, count; - -#ifdef RESOURCE_TRACK - init_resource_track(&rtrack); -#endif - - clear_problem_context(&pctx); - -#ifdef MTRACE - mtrace_print("Pass 3"); -#endif - - if (!(ctx->options & E2F_OPT_PREEN)) - fix_problem(ctx, PR_3_PASS_HEADER, &pctx); - - /* - * Allocate some bitmaps to do loop detection. - */ - pctx.errcode = ext2fs_allocate_inode_bitmap(fs, _("inode done bitmap"), - &inode_done_map); - if (pctx.errcode) { - pctx.num = 2; - fix_problem(ctx, PR_3_ALLOCATE_IBITMAP_ERROR, &pctx); - ctx->flags |= E2F_FLAG_ABORT; - goto abort_exit; - } -#ifdef RESOURCE_TRACK - if (ctx->options & E2F_OPT_TIME) { - e2fsck_clear_progbar(ctx); - print_resource_track(_("Peak memory"), &ctx->global_rtrack); - } -#endif - - check_root(ctx); - if (ctx->flags & E2F_FLAG_SIGNAL_MASK) - goto abort_exit; - - ext2fs_mark_inode_bitmap(inode_done_map, EXT2_ROOT_INO); - - maxdirs = e2fsck_get_num_dirinfo(ctx); - count = 1; - - if (ctx->progress) - if ((ctx->progress)(ctx, 3, 0, maxdirs)) - goto abort_exit; - - for (i=0; (dir = e2fsck_dir_info_iter(ctx, &i)) != 0;) { - if (ctx->flags & E2F_FLAG_SIGNAL_MASK) - goto abort_exit; - if (ctx->progress && (ctx->progress)(ctx, 3, count++, maxdirs)) - goto abort_exit; - if (ext2fs_test_inode_bitmap(ctx->inode_dir_map, dir->ino)) - if (check_directory(ctx, dir, &pctx)) - goto abort_exit; - } - - /* - * Force the creation of /lost+found if not present - */ - if ((ctx->flags & E2F_OPT_READONLY) == 0) - e2fsck_get_lost_and_found(ctx, 1); - - /* - * If there are any directories that need to be indexed or - * optimized, do it here. - */ - e2fsck_rehash_directories(ctx); - -abort_exit: - e2fsck_free_dir_info(ctx); - if (inode_loop_detect) { - ext2fs_free_inode_bitmap(inode_loop_detect); - inode_loop_detect = 0; - } - if (inode_done_map) { - ext2fs_free_inode_bitmap(inode_done_map); - inode_done_map = 0; - } - -#ifdef RESOURCE_TRACK - if (ctx->options & E2F_OPT_TIME2) { - e2fsck_clear_progbar(ctx); - print_resource_track(_("Pass 3"), &rtrack); - } -#endif -} - -/* - * This makes sure the root inode is present; if not, we ask if the - * user wants us to create it. Not creating it is a fatal error. - */ -static void check_root(e2fsck_t ctx) -{ - ext2_filsys fs = ctx->fs; - blk_t blk; - struct ext2_inode inode; - char * block; - struct problem_context pctx; - - clear_problem_context(&pctx); - - if (ext2fs_test_inode_bitmap(ctx->inode_used_map, EXT2_ROOT_INO)) { - /* - * If the root inode is not a directory, die here. The - * user must have answered 'no' in pass1 when we - * offered to clear it. - */ - if (!(ext2fs_test_inode_bitmap(ctx->inode_dir_map, - EXT2_ROOT_INO))) { - fix_problem(ctx, PR_3_ROOT_NOT_DIR_ABORT, &pctx); - ctx->flags |= E2F_FLAG_ABORT; - } - return; - } - - if (!fix_problem(ctx, PR_3_NO_ROOT_INODE, &pctx)) { - fix_problem(ctx, PR_3_NO_ROOT_INODE_ABORT, &pctx); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - - e2fsck_read_bitmaps(ctx); - - /* - * First, find a free block - */ - pctx.errcode = ext2fs_new_block(fs, 0, ctx->block_found_map, &blk); - if (pctx.errcode) { - pctx.str = "ext2fs_new_block"; - fix_problem(ctx, PR_3_CREATE_ROOT_ERROR, &pctx); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - ext2fs_mark_block_bitmap(ctx->block_found_map, blk); - ext2fs_mark_block_bitmap(fs->block_map, blk); - ext2fs_mark_bb_dirty(fs); - - /* - * Now let's create the actual data block for the inode - */ - pctx.errcode = ext2fs_new_dir_block(fs, EXT2_ROOT_INO, EXT2_ROOT_INO, - &block); - if (pctx.errcode) { - pctx.str = "ext2fs_new_dir_block"; - fix_problem(ctx, PR_3_CREATE_ROOT_ERROR, &pctx); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - - pctx.errcode = ext2fs_write_dir_block(fs, blk, block); - if (pctx.errcode) { - pctx.str = "ext2fs_write_dir_block"; - fix_problem(ctx, PR_3_CREATE_ROOT_ERROR, &pctx); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - ext2fs_free_mem(&block); - - /* - * Set up the inode structure - */ - memset(&inode, 0, sizeof(inode)); - inode.i_mode = 040755; - inode.i_size = fs->blocksize; - inode.i_atime = inode.i_ctime = inode.i_mtime = time(0); - inode.i_links_count = 2; - inode.i_blocks = fs->blocksize / 512; - inode.i_block[0] = blk; - - /* - * Write out the inode. - */ - pctx.errcode = ext2fs_write_new_inode(fs, EXT2_ROOT_INO, &inode); - if (pctx.errcode) { - pctx.str = "ext2fs_write_inode"; - fix_problem(ctx, PR_3_CREATE_ROOT_ERROR, &pctx); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - - /* - * Miscellaneous bookkeeping... - */ - e2fsck_add_dir_info(ctx, EXT2_ROOT_INO, EXT2_ROOT_INO); - ext2fs_icount_store(ctx->inode_count, EXT2_ROOT_INO, 2); - ext2fs_icount_store(ctx->inode_link_info, EXT2_ROOT_INO, 2); - - ext2fs_mark_inode_bitmap(ctx->inode_used_map, EXT2_ROOT_INO); - ext2fs_mark_inode_bitmap(ctx->inode_dir_map, EXT2_ROOT_INO); - ext2fs_mark_inode_bitmap(fs->inode_map, EXT2_ROOT_INO); - ext2fs_mark_ib_dirty(fs); -} - -/* - * This subroutine is responsible for making sure that a particular - * directory is connected to the root; if it isn't we trace it up as - * far as we can go, and then offer to connect the resulting parent to - * the lost+found. We have to do loop detection; if we ever discover - * a loop, we treat that as a disconnected directory and offer to - * reparent it to lost+found. - * - * However, loop detection is expensive, because for very large - * filesystems, the inode_loop_detect bitmap is huge, and clearing it - * is non-trivial. Loops in filesystems are also a rare error case, - * and we shouldn't optimize for error cases. So we try two passes of - * the algorithm. The first time, we ignore loop detection and merely - * increment a counter; if the counter exceeds some extreme threshold, - * then we try again with the loop detection bitmap enabled. - */ -static int check_directory(e2fsck_t ctx, struct dir_info *dir, - struct problem_context *pctx) -{ - ext2_filsys fs = ctx->fs; - struct dir_info *p = dir; - int loop_pass = 0, parent_count = 0; - - if (!p) - return 0; - - while (1) { - /* - * Mark this inode as being "done"; by the time we - * return from this function, the inode we either be - * verified as being connected to the directory tree, - * or we will have offered to reconnect this to - * lost+found. - * - * If it was marked done already, then we've reached a - * parent we've already checked. - */ - if (ext2fs_mark_inode_bitmap(inode_done_map, p->ino)) - break; - - /* - * If this directory doesn't have a parent, or we've - * seen the parent once already, then offer to - * reparent it to lost+found - */ - if (!p->parent || - (loop_pass && - (ext2fs_test_inode_bitmap(inode_loop_detect, - p->parent)))) { - pctx->ino = p->ino; - if (fix_problem(ctx, PR_3_UNCONNECTED_DIR, pctx)) { - if (e2fsck_reconnect_file(ctx, pctx->ino)) - ext2fs_unmark_valid(fs); - else { - p = e2fsck_get_dir_info(ctx, pctx->ino); - p->parent = ctx->lost_and_found; - fix_dotdot(ctx, p, ctx->lost_and_found); - } - } - break; - } - p = e2fsck_get_dir_info(ctx, p->parent); - if (!p) { - fix_problem(ctx, PR_3_NO_DIRINFO, pctx); - return 0; - } - if (loop_pass) { - ext2fs_mark_inode_bitmap(inode_loop_detect, - p->ino); - } else if (parent_count++ > 2048) { - /* - * If we've run into a path depth that's - * greater than 2048, try again with the inode - * loop bitmap turned on and start from the - * top. - */ - loop_pass = 1; - if (inode_loop_detect) - ext2fs_clear_inode_bitmap(inode_loop_detect); - else { - pctx->errcode = ext2fs_allocate_inode_bitmap(fs, _("inode loop detection bitmap"), &inode_loop_detect); - if (pctx->errcode) { - pctx->num = 1; - fix_problem(ctx, - PR_3_ALLOCATE_IBITMAP_ERROR, pctx); - ctx->flags |= E2F_FLAG_ABORT; - return -1; - } - } - p = dir; - } - } - - /* - * Make sure that .. and the parent directory are the same; - * offer to fix it if not. - */ - if (dir->parent != dir->dotdot) { - pctx->ino = dir->ino; - pctx->ino2 = dir->dotdot; - pctx->dir = dir->parent; - if (fix_problem(ctx, PR_3_BAD_DOT_DOT, pctx)) - fix_dotdot(ctx, dir, dir->parent); - } - return 0; -} - -/* - * This routine gets the lost_and_found inode, making it a directory - * if necessary - */ -ext2_ino_t e2fsck_get_lost_and_found(e2fsck_t ctx, int fix) -{ - ext2_filsys fs = ctx->fs; - ext2_ino_t ino; - blk_t blk; - errcode_t retval; - struct ext2_inode inode; - char * block; - static const char name[] = "lost+found"; - struct problem_context pctx; - struct dir_info *dirinfo; - - if (ctx->lost_and_found) - return ctx->lost_and_found; - - clear_problem_context(&pctx); - - retval = ext2fs_lookup(fs, EXT2_ROOT_INO, name, - sizeof(name)-1, 0, &ino); - if (retval && !fix) - return 0; - if (!retval) { - if (ext2fs_test_inode_bitmap(ctx->inode_dir_map, ino)) { - ctx->lost_and_found = ino; - return ino; - } - - /* Lost+found isn't a directory! */ - if (!fix) - return 0; - pctx.ino = ino; - if (!fix_problem(ctx, PR_3_LPF_NOTDIR, &pctx)) - return 0; - - /* OK, unlink the old /lost+found file. */ - pctx.errcode = ext2fs_unlink(fs, EXT2_ROOT_INO, name, ino, 0); - if (pctx.errcode) { - pctx.str = "ext2fs_unlink"; - fix_problem(ctx, PR_3_CREATE_LPF_ERROR, &pctx); - return 0; - } - dirinfo = e2fsck_get_dir_info(ctx, ino); - if (dirinfo) - dirinfo->parent = 0; - e2fsck_adjust_inode_count(ctx, ino, -1); - } else if (retval != EXT2_ET_FILE_NOT_FOUND) { - pctx.errcode = retval; - fix_problem(ctx, PR_3_ERR_FIND_LPF, &pctx); - } - if (!fix_problem(ctx, PR_3_NO_LF_DIR, 0)) - return 0; - - /* - * Read the inode and block bitmaps in; we'll be messing with - * them. - */ - e2fsck_read_bitmaps(ctx); - - /* - * First, find a free block - */ - retval = ext2fs_new_block(fs, 0, ctx->block_found_map, &blk); - if (retval) { - pctx.errcode = retval; - fix_problem(ctx, PR_3_ERR_LPF_NEW_BLOCK, &pctx); - return 0; - } - ext2fs_mark_block_bitmap(ctx->block_found_map, blk); - ext2fs_block_alloc_stats(fs, blk, +1); - - /* - * Next find a free inode. - */ - retval = ext2fs_new_inode(fs, EXT2_ROOT_INO, 040700, - ctx->inode_used_map, &ino); - if (retval) { - pctx.errcode = retval; - fix_problem(ctx, PR_3_ERR_LPF_NEW_INODE, &pctx); - return 0; - } - ext2fs_mark_inode_bitmap(ctx->inode_used_map, ino); - ext2fs_mark_inode_bitmap(ctx->inode_dir_map, ino); - ext2fs_inode_alloc_stats2(fs, ino, +1, 1); - - /* - * Now let's create the actual data block for the inode - */ - retval = ext2fs_new_dir_block(fs, ino, EXT2_ROOT_INO, &block); - if (retval) { - pctx.errcode = retval; - fix_problem(ctx, PR_3_ERR_LPF_NEW_DIR_BLOCK, &pctx); - return 0; - } - - retval = ext2fs_write_dir_block(fs, blk, block); - ext2fs_free_mem(&block); - if (retval) { - pctx.errcode = retval; - fix_problem(ctx, PR_3_ERR_LPF_WRITE_BLOCK, &pctx); - return 0; - } - - /* - * Set up the inode structure - */ - memset(&inode, 0, sizeof(inode)); - inode.i_mode = 040700; - inode.i_size = fs->blocksize; - inode.i_atime = inode.i_ctime = inode.i_mtime = time(0); - inode.i_links_count = 2; - inode.i_blocks = fs->blocksize / 512; - inode.i_block[0] = blk; - - /* - * Next, write out the inode. - */ - pctx.errcode = ext2fs_write_new_inode(fs, ino, &inode); - if (pctx.errcode) { - pctx.str = "ext2fs_write_inode"; - fix_problem(ctx, PR_3_CREATE_LPF_ERROR, &pctx); - return 0; - } - /* - * Finally, create the directory link - */ - pctx.errcode = ext2fs_link(fs, EXT2_ROOT_INO, name, ino, EXT2_FT_DIR); - if (pctx.errcode) { - pctx.str = "ext2fs_link"; - fix_problem(ctx, PR_3_CREATE_LPF_ERROR, &pctx); - return 0; - } - - /* - * Miscellaneous bookkeeping that needs to be kept straight. - */ - e2fsck_add_dir_info(ctx, ino, EXT2_ROOT_INO); - e2fsck_adjust_inode_count(ctx, EXT2_ROOT_INO, 1); - ext2fs_icount_store(ctx->inode_count, ino, 2); - ext2fs_icount_store(ctx->inode_link_info, ino, 2); - ctx->lost_and_found = ino; -#if 0 - printf("/lost+found created; inode #%lu\n", ino); -#endif - return ino; -} - -/* - * This routine will connect a file to lost+found - */ -int e2fsck_reconnect_file(e2fsck_t ctx, ext2_ino_t ino) -{ - ext2_filsys fs = ctx->fs; - errcode_t retval; - char name[80]; - struct problem_context pctx; - struct ext2_inode inode; - int file_type = 0; - - clear_problem_context(&pctx); - pctx.ino = ino; - - if (!ctx->bad_lost_and_found && !ctx->lost_and_found) { - if (e2fsck_get_lost_and_found(ctx, 1) == 0) - ctx->bad_lost_and_found++; - } - if (ctx->bad_lost_and_found) { - fix_problem(ctx, PR_3_NO_LPF, &pctx); - return 1; - } - - sprintf(name, "#%u", ino); - if (ext2fs_read_inode(fs, ino, &inode) == 0) - file_type = ext2_file_type(inode.i_mode); - retval = ext2fs_link(fs, ctx->lost_and_found, name, ino, file_type); - if (retval == EXT2_ET_DIR_NO_SPACE) { - if (!fix_problem(ctx, PR_3_EXPAND_LF_DIR, &pctx)) - return 1; - retval = e2fsck_expand_directory(ctx, ctx->lost_and_found, - 1, 0); - if (retval) { - pctx.errcode = retval; - fix_problem(ctx, PR_3_CANT_EXPAND_LPF, &pctx); - return 1; - } - retval = ext2fs_link(fs, ctx->lost_and_found, name, - ino, file_type); - } - if (retval) { - pctx.errcode = retval; - fix_problem(ctx, PR_3_CANT_RECONNECT, &pctx); - return 1; - } - e2fsck_adjust_inode_count(ctx, ino, 1); - - return 0; -} - -/* - * Utility routine to adjust the inode counts on an inode. - */ -errcode_t e2fsck_adjust_inode_count(e2fsck_t ctx, ext2_ino_t ino, int adj) -{ - ext2_filsys fs = ctx->fs; - errcode_t retval; - struct ext2_inode inode; - - if (!ino) - return 0; - - retval = ext2fs_read_inode(fs, ino, &inode); - if (retval) - return retval; - -#if 0 - printf("Adjusting link count for inode %lu by %d (from %d)\n", ino, adj, - inode.i_links_count); -#endif - - if (adj == 1) { - ext2fs_icount_increment(ctx->inode_count, ino, 0); - if (inode.i_links_count == (__u16) ~0) - return 0; - ext2fs_icount_increment(ctx->inode_link_info, ino, 0); - inode.i_links_count++; - } else if (adj == -1) { - ext2fs_icount_decrement(ctx->inode_count, ino, 0); - if (inode.i_links_count == 0) - return 0; - ext2fs_icount_decrement(ctx->inode_link_info, ino, 0); - inode.i_links_count--; - } - - retval = ext2fs_write_inode(fs, ino, &inode); - if (retval) - return retval; - - return 0; -} - -/* - * Fix parent --- this routine fixes up the parent of a directory. - */ -struct fix_dotdot_struct { - ext2_filsys fs; - ext2_ino_t parent; - int done; - e2fsck_t ctx; -}; - -static int fix_dotdot_proc(struct ext2_dir_entry *dirent, - int offset EXT2FS_ATTR((unused)), - int blocksize EXT2FS_ATTR((unused)), - char *buf EXT2FS_ATTR((unused)), - void *priv_data) -{ - struct fix_dotdot_struct *fp = (struct fix_dotdot_struct *) priv_data; - errcode_t retval; - struct problem_context pctx; - - if ((dirent->name_len & 0xFF) != 2) - return 0; - if (strncmp(dirent->name, "..", 2)) - return 0; - - clear_problem_context(&pctx); - - retval = e2fsck_adjust_inode_count(fp->ctx, dirent->inode, -1); - if (retval) { - pctx.errcode = retval; - fix_problem(fp->ctx, PR_3_ADJUST_INODE, &pctx); - } - retval = e2fsck_adjust_inode_count(fp->ctx, fp->parent, 1); - if (retval) { - pctx.errcode = retval; - fix_problem(fp->ctx, PR_3_ADJUST_INODE, &pctx); - } - dirent->inode = fp->parent; - - fp->done++; - return DIRENT_ABORT | DIRENT_CHANGED; -} - -static void fix_dotdot(e2fsck_t ctx, struct dir_info *dir, ext2_ino_t parent) -{ - ext2_filsys fs = ctx->fs; - errcode_t retval; - struct fix_dotdot_struct fp; - struct problem_context pctx; - - fp.fs = fs; - fp.parent = parent; - fp.done = 0; - fp.ctx = ctx; - -#if 0 - printf("Fixing '..' of inode %lu to be %lu...\n", dir->ino, parent); -#endif - - retval = ext2fs_dir_iterate(fs, dir->ino, DIRENT_FLAG_INCLUDE_EMPTY, - 0, fix_dotdot_proc, &fp); - if (retval || !fp.done) { - clear_problem_context(&pctx); - pctx.ino = dir->ino; - pctx.errcode = retval; - fix_problem(ctx, retval ? PR_3_FIX_PARENT_ERR : - PR_3_FIX_PARENT_NOFIND, &pctx); - ext2fs_unmark_valid(fs); - } - dir->dotdot = parent; - - return; -} - -/* - * These routines are responsible for expanding a /lost+found if it is - * too small. - */ - -struct expand_dir_struct { - int num; - int guaranteed_size; - int newblocks; - int last_block; - errcode_t err; - e2fsck_t ctx; -}; - -static int expand_dir_proc(ext2_filsys fs, - blk_t *blocknr, - e2_blkcnt_t blockcnt, - blk_t ref_block EXT2FS_ATTR((unused)), - int ref_offset EXT2FS_ATTR((unused)), - void *priv_data) -{ - struct expand_dir_struct *es = (struct expand_dir_struct *) priv_data; - blk_t new_blk; - static blk_t last_blk = 0; - char *block; - errcode_t retval; - e2fsck_t ctx; - - ctx = es->ctx; - - if (es->guaranteed_size && blockcnt >= es->guaranteed_size) - return BLOCK_ABORT; - - if (blockcnt > 0) - es->last_block = blockcnt; - if (*blocknr) { - last_blk = *blocknr; - return 0; - } - retval = ext2fs_new_block(fs, last_blk, ctx->block_found_map, - &new_blk); - if (retval) { - es->err = retval; - return BLOCK_ABORT; - } - if (blockcnt > 0) { - retval = ext2fs_new_dir_block(fs, 0, 0, &block); - if (retval) { - es->err = retval; - return BLOCK_ABORT; - } - es->num--; - retval = ext2fs_write_dir_block(fs, new_blk, block); - } else { - retval = ext2fs_get_mem(fs->blocksize, &block); - if (retval) { - es->err = retval; - return BLOCK_ABORT; - } - memset(block, 0, fs->blocksize); - retval = io_channel_write_blk(fs->io, new_blk, 1, block); - } - if (retval) { - es->err = retval; - return BLOCK_ABORT; - } - ext2fs_free_mem(&block); - *blocknr = new_blk; - ext2fs_mark_block_bitmap(ctx->block_found_map, new_blk); - ext2fs_block_alloc_stats(fs, new_blk, +1); - es->newblocks++; - - if (es->num == 0) - return (BLOCK_CHANGED | BLOCK_ABORT); - else - return BLOCK_CHANGED; -} - -errcode_t e2fsck_expand_directory(e2fsck_t ctx, ext2_ino_t dir, - int num, int guaranteed_size) -{ - ext2_filsys fs = ctx->fs; - errcode_t retval; - struct expand_dir_struct es; - struct ext2_inode inode; - - if (!(fs->flags & EXT2_FLAG_RW)) - return EXT2_ET_RO_FILSYS; - - /* - * Read the inode and block bitmaps in; we'll be messing with - * them. - */ - e2fsck_read_bitmaps(ctx); - - retval = ext2fs_check_directory(fs, dir); - if (retval) - return retval; - - es.num = num; - es.guaranteed_size = guaranteed_size; - es.last_block = 0; - es.err = 0; - es.newblocks = 0; - es.ctx = ctx; - - retval = ext2fs_block_iterate2(fs, dir, BLOCK_FLAG_APPEND, - 0, expand_dir_proc, &es); - - if (es.err) - return es.err; - - /* - * Update the size and block count fields in the inode. - */ - retval = ext2fs_read_inode(fs, dir, &inode); - if (retval) - return retval; - - inode.i_size = (es.last_block + 1) * fs->blocksize; - inode.i_blocks += (fs->blocksize / 512) * es.newblocks; - - e2fsck_write_inode(ctx, dir, &inode, "expand_directory"); - - return 0; -} - diff --git a/e2fsprogs/e2fsck/pass4.c b/e2fsprogs/e2fsck/pass4.c deleted file mode 100644 index a9e49f178..000000000 --- a/e2fsprogs/e2fsck/pass4.c +++ /dev/null @@ -1,178 +0,0 @@ -/* - * pass4.c -- pass #4 of e2fsck: Check reference counts - * - * Copyright (C) 1993, 1994, 1995, 1996, 1997 Theodore Ts'o. - * - * %Begin-Header% - * This file may be redistributed under the terms of the GNU Public - * License. - * %End-Header% - * - * Pass 4 frees the following data structures: - * - A bitmap of which inodes are in bad blocks. (inode_bb_map) - * - A bitmap of which inodes are imagic inodes. (inode_imagic_map) - */ - -#include "e2fsck.h" -#include "problem.h" - -/* - * This routine is called when an inode is not connected to the - * directory tree. - * - * This subroutine returns 1 then the caller shouldn't bother with the - * rest of the pass 4 tests. - */ -static int disconnect_inode(e2fsck_t ctx, ext2_ino_t i) -{ - ext2_filsys fs = ctx->fs; - struct ext2_inode inode; - struct problem_context pctx; - - e2fsck_read_inode(ctx, i, &inode, "pass4: disconnect_inode"); - clear_problem_context(&pctx); - pctx.ino = i; - pctx.inode = &inode; - - /* - * Offer to delete any zero-length files that does not have - * blocks. If there is an EA block, it might have useful - * information, so we won't prompt to delete it, but let it be - * reconnected to lost+found. - */ - if (!inode.i_blocks && (LINUX_S_ISREG(inode.i_mode) || - LINUX_S_ISDIR(inode.i_mode))) { - if (fix_problem(ctx, PR_4_ZERO_LEN_INODE, &pctx)) { - ext2fs_icount_store(ctx->inode_link_info, i, 0); - inode.i_links_count = 0; - inode.i_dtime = time(0); - e2fsck_write_inode(ctx, i, &inode, - "disconnect_inode"); - /* - * Fix up the bitmaps... - */ - e2fsck_read_bitmaps(ctx); - ext2fs_unmark_inode_bitmap(ctx->inode_used_map, i); - ext2fs_unmark_inode_bitmap(ctx->inode_dir_map, i); - ext2fs_inode_alloc_stats2(fs, i, -1, - LINUX_S_ISDIR(inode.i_mode)); - return 0; - } - } - - /* - * Prompt to reconnect. - */ - if (fix_problem(ctx, PR_4_UNATTACHED_INODE, &pctx)) { - if (e2fsck_reconnect_file(ctx, i)) - ext2fs_unmark_valid(fs); - } else { - /* - * If we don't attach the inode, then skip the - * i_links_test since there's no point in trying to - * force i_links_count to zero. - */ - ext2fs_unmark_valid(fs); - return 1; - } - return 0; -} - - -void e2fsck_pass4(e2fsck_t ctx) -{ - ext2_filsys fs = ctx->fs; - ext2_ino_t i; - struct ext2_inode inode; -#ifdef RESOURCE_TRACK - struct resource_track rtrack; -#endif - struct problem_context pctx; - __u16 link_count, link_counted; - char *buf = 0; - int group, maxgroup; - -#ifdef RESOURCE_TRACK - init_resource_track(&rtrack); -#endif - -#ifdef MTRACE - mtrace_print("Pass 4"); -#endif - - clear_problem_context(&pctx); - - if (!(ctx->options & E2F_OPT_PREEN)) - fix_problem(ctx, PR_4_PASS_HEADER, &pctx); - - group = 0; - maxgroup = fs->group_desc_count; - if (ctx->progress) - if ((ctx->progress)(ctx, 4, 0, maxgroup)) - return; - - for (i=1; i <= fs->super->s_inodes_count; i++) { - if (ctx->flags & E2F_FLAG_SIGNAL_MASK) - return; - if ((i % fs->super->s_inodes_per_group) == 0) { - group++; - if (ctx->progress) - if ((ctx->progress)(ctx, 4, group, maxgroup)) - return; - } - if (i == EXT2_BAD_INO || - (i > EXT2_ROOT_INO && i < EXT2_FIRST_INODE(fs->super))) - continue; - if (!(ext2fs_test_inode_bitmap(ctx->inode_used_map, i)) || - (ctx->inode_imagic_map && - ext2fs_test_inode_bitmap(ctx->inode_imagic_map, i)) || - (ctx->inode_bb_map && - ext2fs_test_inode_bitmap(ctx->inode_bb_map, i))) - continue; - ext2fs_icount_fetch(ctx->inode_link_info, i, &link_count); - ext2fs_icount_fetch(ctx->inode_count, i, &link_counted); - if (link_counted == 0) { - if (!buf) - buf = e2fsck_allocate_memory(ctx, - fs->blocksize, "bad_inode buffer"); - if (e2fsck_process_bad_inode(ctx, 0, i, buf)) - continue; - if (disconnect_inode(ctx, i)) - continue; - ext2fs_icount_fetch(ctx->inode_link_info, i, - &link_count); - ext2fs_icount_fetch(ctx->inode_count, i, - &link_counted); - } - if (link_counted != link_count) { - e2fsck_read_inode(ctx, i, &inode, "pass4"); - pctx.ino = i; - pctx.inode = &inode; - if (link_count != inode.i_links_count) { - pctx.num = link_count; - fix_problem(ctx, - PR_4_INCONSISTENT_COUNT, &pctx); - } - pctx.num = link_counted; - if (fix_problem(ctx, PR_4_BAD_REF_COUNT, &pctx)) { - inode.i_links_count = link_counted; - e2fsck_write_inode(ctx, i, &inode, "pass4"); - } - } - } - ext2fs_free_icount(ctx->inode_link_info); ctx->inode_link_info = 0; - ext2fs_free_icount(ctx->inode_count); ctx->inode_count = 0; - ext2fs_free_inode_bitmap(ctx->inode_bb_map); - ctx->inode_bb_map = 0; - ext2fs_free_inode_bitmap(ctx->inode_imagic_map); - ctx->inode_imagic_map = 0; - if (buf) - ext2fs_free_mem(&buf); -#ifdef RESOURCE_TRACK - if (ctx->options & E2F_OPT_TIME2) { - e2fsck_clear_progbar(ctx); - print_resource_track(_("Pass 4"), &rtrack); - } -#endif -} - diff --git a/e2fsprogs/e2fsck/pass5.c b/e2fsprogs/e2fsck/pass5.c deleted file mode 100644 index e708fa41d..000000000 --- a/e2fsprogs/e2fsck/pass5.c +++ /dev/null @@ -1,547 +0,0 @@ -/* - * pass5.c --- check block and inode bitmaps against on-disk bitmaps - * - * Copyright (C) 1993, 1994, 1995, 1996, 1997 Theodore Ts'o. - * - * %Begin-Header% - * This file may be redistributed under the terms of the GNU Public - * License. - * %End-Header% - * - */ - -#include "e2fsck.h" -#include "problem.h" - -static void check_block_bitmaps(e2fsck_t ctx); -static void check_inode_bitmaps(e2fsck_t ctx); -static void check_inode_end(e2fsck_t ctx); -static void check_block_end(e2fsck_t ctx); - -void e2fsck_pass5(e2fsck_t ctx) -{ -#ifdef RESOURCE_TRACK - struct resource_track rtrack; -#endif - struct problem_context pctx; - -#ifdef MTRACE - mtrace_print("Pass 5"); -#endif - -#ifdef RESOURCE_TRACK - init_resource_track(&rtrack); -#endif - - clear_problem_context(&pctx); - - if (!(ctx->options & E2F_OPT_PREEN)) - fix_problem(ctx, PR_5_PASS_HEADER, &pctx); - - if (ctx->progress) - if ((ctx->progress)(ctx, 5, 0, ctx->fs->group_desc_count*2)) - return; - - e2fsck_read_bitmaps(ctx); - - check_block_bitmaps(ctx); - if (ctx->flags & E2F_FLAG_SIGNAL_MASK) - return; - check_inode_bitmaps(ctx); - if (ctx->flags & E2F_FLAG_SIGNAL_MASK) - return; - check_inode_end(ctx); - if (ctx->flags & E2F_FLAG_SIGNAL_MASK) - return; - check_block_end(ctx); - if (ctx->flags & E2F_FLAG_SIGNAL_MASK) - return; - - ext2fs_free_inode_bitmap(ctx->inode_used_map); - ctx->inode_used_map = 0; - ext2fs_free_inode_bitmap(ctx->inode_dir_map); - ctx->inode_dir_map = 0; - ext2fs_free_block_bitmap(ctx->block_found_map); - ctx->block_found_map = 0; - -#ifdef RESOURCE_TRACK - if (ctx->options & E2F_OPT_TIME2) { - e2fsck_clear_progbar(ctx); - print_resource_track(_("Pass 5"), &rtrack); - } -#endif -} - -#define NO_BLK ((blk_t) -1) - -static void print_bitmap_problem(e2fsck_t ctx, int problem, - struct problem_context *pctx) -{ - switch (problem) { - case PR_5_BLOCK_UNUSED: - if (pctx->blk == pctx->blk2) - pctx->blk2 = 0; - else - problem = PR_5_BLOCK_RANGE_UNUSED; - break; - case PR_5_BLOCK_USED: - if (pctx->blk == pctx->blk2) - pctx->blk2 = 0; - else - problem = PR_5_BLOCK_RANGE_USED; - break; - case PR_5_INODE_UNUSED: - if (pctx->ino == pctx->ino2) - pctx->ino2 = 0; - else - problem = PR_5_INODE_RANGE_UNUSED; - break; - case PR_5_INODE_USED: - if (pctx->ino == pctx->ino2) - pctx->ino2 = 0; - else - problem = PR_5_INODE_RANGE_USED; - break; - } - fix_problem(ctx, problem, pctx); - pctx->blk = pctx->blk2 = NO_BLK; - pctx->ino = pctx->ino2 = 0; -} - -static void check_block_bitmaps(e2fsck_t ctx) -{ - ext2_filsys fs = ctx->fs; - blk_t i; - int *free_array; - int group = 0; - unsigned int blocks = 0; - unsigned int free_blocks = 0; - int group_free = 0; - int actual, bitmap; - struct problem_context pctx; - int problem, save_problem, fixit, had_problem; - errcode_t retval; - - clear_problem_context(&pctx); - free_array = (int *) e2fsck_allocate_memory(ctx, - fs->group_desc_count * sizeof(int), "free block count array"); - - if ((fs->super->s_first_data_block < - ext2fs_get_block_bitmap_start(ctx->block_found_map)) || - (fs->super->s_blocks_count-1 > - ext2fs_get_block_bitmap_end(ctx->block_found_map))) { - pctx.num = 1; - pctx.blk = fs->super->s_first_data_block; - pctx.blk2 = fs->super->s_blocks_count -1; - pctx.ino = ext2fs_get_block_bitmap_start(ctx->block_found_map); - pctx.ino2 = ext2fs_get_block_bitmap_end(ctx->block_found_map); - fix_problem(ctx, PR_5_BMAP_ENDPOINTS, &pctx); - - ctx->flags |= E2F_FLAG_ABORT; /* fatal */ - return; - } - - if ((fs->super->s_first_data_block < - ext2fs_get_block_bitmap_start(fs->block_map)) || - (fs->super->s_blocks_count-1 > - ext2fs_get_block_bitmap_end(fs->block_map))) { - pctx.num = 2; - pctx.blk = fs->super->s_first_data_block; - pctx.blk2 = fs->super->s_blocks_count -1; - pctx.ino = ext2fs_get_block_bitmap_start(fs->block_map); - pctx.ino2 = ext2fs_get_block_bitmap_end(fs->block_map); - fix_problem(ctx, PR_5_BMAP_ENDPOINTS, &pctx); - - ctx->flags |= E2F_FLAG_ABORT; /* fatal */ - return; - } - -redo_counts: - had_problem = 0; - save_problem = 0; - pctx.blk = pctx.blk2 = NO_BLK; - for (i = fs->super->s_first_data_block; - i < fs->super->s_blocks_count; - i++) { - actual = ext2fs_fast_test_block_bitmap(ctx->block_found_map, i); - bitmap = ext2fs_fast_test_block_bitmap(fs->block_map, i); - - if (actual == bitmap) - goto do_counts; - - if (!actual && bitmap) { - /* - * Block not used, but marked in use in the bitmap. - */ - problem = PR_5_BLOCK_UNUSED; - } else { - /* - * Block used, but not marked in use in the bitmap. - */ - problem = PR_5_BLOCK_USED; - } - if (pctx.blk == NO_BLK) { - pctx.blk = pctx.blk2 = i; - save_problem = problem; - } else { - if ((problem == save_problem) && - (pctx.blk2 == i-1)) - pctx.blk2++; - else { - print_bitmap_problem(ctx, save_problem, &pctx); - pctx.blk = pctx.blk2 = i; - save_problem = problem; - } - } - ctx->flags |= E2F_FLAG_PROG_SUPPRESS; - had_problem++; - - do_counts: - if (!bitmap) { - group_free++; - free_blocks++; - } - blocks ++; - if ((blocks == fs->super->s_blocks_per_group) || - (i == fs->super->s_blocks_count-1)) { - free_array[group] = group_free; - group ++; - blocks = 0; - group_free = 0; - if (ctx->progress) - if ((ctx->progress)(ctx, 5, group, - fs->group_desc_count*2)) - return; - } - } - if (pctx.blk != NO_BLK) - print_bitmap_problem(ctx, save_problem, &pctx); - if (had_problem) - fixit = end_problem_latch(ctx, PR_LATCH_BBITMAP); - else - fixit = -1; - ctx->flags &= ~E2F_FLAG_PROG_SUPPRESS; - - if (fixit == 1) { - ext2fs_free_block_bitmap(fs->block_map); - retval = ext2fs_copy_bitmap(ctx->block_found_map, - &fs->block_map); - if (retval) { - clear_problem_context(&pctx); - fix_problem(ctx, PR_5_COPY_BBITMAP_ERROR, &pctx); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - ext2fs_set_bitmap_padding(fs->block_map); - ext2fs_mark_bb_dirty(fs); - - /* Redo the counts */ - blocks = 0; free_blocks = 0; group_free = 0; group = 0; - memset(free_array, 0, fs->group_desc_count * sizeof(int)); - goto redo_counts; - } else if (fixit == 0) - ext2fs_unmark_valid(fs); - - for (i = 0; i < fs->group_desc_count; i++) { - if (free_array[i] != fs->group_desc[i].bg_free_blocks_count) { - pctx.group = i; - pctx.blk = fs->group_desc[i].bg_free_blocks_count; - pctx.blk2 = free_array[i]; - - if (fix_problem(ctx, PR_5_FREE_BLOCK_COUNT_GROUP, - &pctx)) { - fs->group_desc[i].bg_free_blocks_count = - free_array[i]; - ext2fs_mark_super_dirty(fs); - } else - ext2fs_unmark_valid(fs); - } - } - if (free_blocks != fs->super->s_free_blocks_count) { - pctx.group = 0; - pctx.blk = fs->super->s_free_blocks_count; - pctx.blk2 = free_blocks; - - if (fix_problem(ctx, PR_5_FREE_BLOCK_COUNT, &pctx)) { - fs->super->s_free_blocks_count = free_blocks; - ext2fs_mark_super_dirty(fs); - } else - ext2fs_unmark_valid(fs); - } - ext2fs_free_mem(&free_array); -} - -static void check_inode_bitmaps(e2fsck_t ctx) -{ - ext2_filsys fs = ctx->fs; - ext2_ino_t i; - unsigned int free_inodes = 0; - int group_free = 0; - int dirs_count = 0; - int group = 0; - unsigned int inodes = 0; - int *free_array; - int *dir_array; - int actual, bitmap; - errcode_t retval; - struct problem_context pctx; - int problem, save_problem, fixit, had_problem; - - clear_problem_context(&pctx); - free_array = (int *) e2fsck_allocate_memory(ctx, - fs->group_desc_count * sizeof(int), "free inode count array"); - - dir_array = (int *) e2fsck_allocate_memory(ctx, - fs->group_desc_count * sizeof(int), "directory count array"); - - if ((1 < ext2fs_get_inode_bitmap_start(ctx->inode_used_map)) || - (fs->super->s_inodes_count > - ext2fs_get_inode_bitmap_end(ctx->inode_used_map))) { - pctx.num = 3; - pctx.blk = 1; - pctx.blk2 = fs->super->s_inodes_count; - pctx.ino = ext2fs_get_inode_bitmap_start(ctx->inode_used_map); - pctx.ino2 = ext2fs_get_inode_bitmap_end(ctx->inode_used_map); - fix_problem(ctx, PR_5_BMAP_ENDPOINTS, &pctx); - - ctx->flags |= E2F_FLAG_ABORT; /* fatal */ - return; - } - if ((1 < ext2fs_get_inode_bitmap_start(fs->inode_map)) || - (fs->super->s_inodes_count > - ext2fs_get_inode_bitmap_end(fs->inode_map))) { - pctx.num = 4; - pctx.blk = 1; - pctx.blk2 = fs->super->s_inodes_count; - pctx.ino = ext2fs_get_inode_bitmap_start(fs->inode_map); - pctx.ino2 = ext2fs_get_inode_bitmap_end(fs->inode_map); - fix_problem(ctx, PR_5_BMAP_ENDPOINTS, &pctx); - - ctx->flags |= E2F_FLAG_ABORT; /* fatal */ - return; - } - -redo_counts: - had_problem = 0; - save_problem = 0; - pctx.ino = pctx.ino2 = 0; - for (i = 1; i <= fs->super->s_inodes_count; i++) { - actual = ext2fs_fast_test_inode_bitmap(ctx->inode_used_map, i); - bitmap = ext2fs_fast_test_inode_bitmap(fs->inode_map, i); - - if (actual == bitmap) - goto do_counts; - - if (!actual && bitmap) { - /* - * Inode wasn't used, but marked in bitmap - */ - problem = PR_5_INODE_UNUSED; - } else /* if (actual && !bitmap) */ { - /* - * Inode used, but not in bitmap - */ - problem = PR_5_INODE_USED; - } - if (pctx.ino == 0) { - pctx.ino = pctx.ino2 = i; - save_problem = problem; - } else { - if ((problem == save_problem) && - (pctx.ino2 == i-1)) - pctx.ino2++; - else { - print_bitmap_problem(ctx, save_problem, &pctx); - pctx.ino = pctx.ino2 = i; - save_problem = problem; - } - } - ctx->flags |= E2F_FLAG_PROG_SUPPRESS; - had_problem++; - -do_counts: - if (!bitmap) { - group_free++; - free_inodes++; - } else { - if (ext2fs_test_inode_bitmap(ctx->inode_dir_map, i)) - dirs_count++; - } - inodes++; - if ((inodes == fs->super->s_inodes_per_group) || - (i == fs->super->s_inodes_count)) { - free_array[group] = group_free; - dir_array[group] = dirs_count; - group ++; - inodes = 0; - group_free = 0; - dirs_count = 0; - if (ctx->progress) - if ((ctx->progress)(ctx, 5, - group + fs->group_desc_count, - fs->group_desc_count*2)) - return; - } - } - if (pctx.ino) - print_bitmap_problem(ctx, save_problem, &pctx); - - if (had_problem) - fixit = end_problem_latch(ctx, PR_LATCH_IBITMAP); - else - fixit = -1; - ctx->flags &= ~E2F_FLAG_PROG_SUPPRESS; - - if (fixit == 1) { - ext2fs_free_inode_bitmap(fs->inode_map); - retval = ext2fs_copy_bitmap(ctx->inode_used_map, - &fs->inode_map); - if (retval) { - clear_problem_context(&pctx); - fix_problem(ctx, PR_5_COPY_IBITMAP_ERROR, &pctx); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - ext2fs_set_bitmap_padding(fs->inode_map); - ext2fs_mark_ib_dirty(fs); - - /* redo counts */ - inodes = 0; free_inodes = 0; group_free = 0; - dirs_count = 0; group = 0; - memset(free_array, 0, fs->group_desc_count * sizeof(int)); - memset(dir_array, 0, fs->group_desc_count * sizeof(int)); - goto redo_counts; - } else if (fixit == 0) - ext2fs_unmark_valid(fs); - - for (i = 0; i < fs->group_desc_count; i++) { - if (free_array[i] != fs->group_desc[i].bg_free_inodes_count) { - pctx.group = i; - pctx.ino = fs->group_desc[i].bg_free_inodes_count; - pctx.ino2 = free_array[i]; - if (fix_problem(ctx, PR_5_FREE_INODE_COUNT_GROUP, - &pctx)) { - fs->group_desc[i].bg_free_inodes_count = - free_array[i]; - ext2fs_mark_super_dirty(fs); - } else - ext2fs_unmark_valid(fs); - } - if (dir_array[i] != fs->group_desc[i].bg_used_dirs_count) { - pctx.group = i; - pctx.ino = fs->group_desc[i].bg_used_dirs_count; - pctx.ino2 = dir_array[i]; - - if (fix_problem(ctx, PR_5_FREE_DIR_COUNT_GROUP, - &pctx)) { - fs->group_desc[i].bg_used_dirs_count = - dir_array[i]; - ext2fs_mark_super_dirty(fs); - } else - ext2fs_unmark_valid(fs); - } - } - if (free_inodes != fs->super->s_free_inodes_count) { - pctx.group = -1; - pctx.ino = fs->super->s_free_inodes_count; - pctx.ino2 = free_inodes; - - if (fix_problem(ctx, PR_5_FREE_INODE_COUNT, &pctx)) { - fs->super->s_free_inodes_count = free_inodes; - ext2fs_mark_super_dirty(fs); - } else - ext2fs_unmark_valid(fs); - } - ext2fs_free_mem(&free_array); - ext2fs_free_mem(&dir_array); -} - -static void check_inode_end(e2fsck_t ctx) -{ - ext2_filsys fs = ctx->fs; - ext2_ino_t end, save_inodes_count, i; - struct problem_context pctx; - - clear_problem_context(&pctx); - - end = EXT2_INODES_PER_GROUP(fs->super) * fs->group_desc_count; - pctx.errcode = ext2fs_fudge_inode_bitmap_end(fs->inode_map, end, - &save_inodes_count); - if (pctx.errcode) { - pctx.num = 1; - fix_problem(ctx, PR_5_FUDGE_BITMAP_ERROR, &pctx); - ctx->flags |= E2F_FLAG_ABORT; /* fatal */ - return; - } - if (save_inodes_count == end) - return; - - for (i = save_inodes_count + 1; i <= end; i++) { - if (!ext2fs_test_inode_bitmap(fs->inode_map, i)) { - if (fix_problem(ctx, PR_5_INODE_BMAP_PADDING, &pctx)) { - for (i = save_inodes_count + 1; i <= end; i++) - ext2fs_mark_inode_bitmap(fs->inode_map, - i); - ext2fs_mark_ib_dirty(fs); - } else - ext2fs_unmark_valid(fs); - break; - } - } - - pctx.errcode = ext2fs_fudge_inode_bitmap_end(fs->inode_map, - save_inodes_count, 0); - if (pctx.errcode) { - pctx.num = 2; - fix_problem(ctx, PR_5_FUDGE_BITMAP_ERROR, &pctx); - ctx->flags |= E2F_FLAG_ABORT; /* fatal */ - return; - } -} - -static void check_block_end(e2fsck_t ctx) -{ - ext2_filsys fs = ctx->fs; - blk_t end, save_blocks_count, i; - struct problem_context pctx; - - clear_problem_context(&pctx); - - end = fs->block_map->start + - (EXT2_BLOCKS_PER_GROUP(fs->super) * fs->group_desc_count) - 1; - pctx.errcode = ext2fs_fudge_block_bitmap_end(fs->block_map, end, - &save_blocks_count); - if (pctx.errcode) { - pctx.num = 3; - fix_problem(ctx, PR_5_FUDGE_BITMAP_ERROR, &pctx); - ctx->flags |= E2F_FLAG_ABORT; /* fatal */ - return; - } - if (save_blocks_count == end) - return; - - for (i = save_blocks_count + 1; i <= end; i++) { - if (!ext2fs_test_block_bitmap(fs->block_map, i)) { - if (fix_problem(ctx, PR_5_BLOCK_BMAP_PADDING, &pctx)) { - for (i = save_blocks_count + 1; i <= end; i++) - ext2fs_mark_block_bitmap(fs->block_map, - i); - ext2fs_mark_bb_dirty(fs); - } else - ext2fs_unmark_valid(fs); - break; - } - } - - pctx.errcode = ext2fs_fudge_block_bitmap_end(fs->block_map, - save_blocks_count, 0); - if (pctx.errcode) { - pctx.num = 4; - fix_problem(ctx, PR_5_FUDGE_BITMAP_ERROR, &pctx); - ctx->flags |= E2F_FLAG_ABORT; /* fatal */ - return; - } -} - - - diff --git a/e2fsprogs/e2fsck/problem.c b/e2fsprogs/e2fsck/problem.c deleted file mode 100644 index 7be4d6245..000000000 --- a/e2fsprogs/e2fsck/problem.c +++ /dev/null @@ -1,1655 +0,0 @@ -/* - * problem.c --- report filesystem problems to the user - * - * Copyright 1996, 1997 by Theodore Ts'o - * - * %Begin-Header% - * This file may be redistributed under the terms of the GNU Public - * License. - * %End-Header% - */ - -#include -#include -#include -#include -#include - -#include "e2fsck.h" - -#include "problem.h" -#include "problemP.h" - -#define PROMPT_NONE 0 -#define PROMPT_FIX 1 -#define PROMPT_CLEAR 2 -#define PROMPT_RELOCATE 3 -#define PROMPT_ALLOCATE 4 -#define PROMPT_EXPAND 5 -#define PROMPT_CONNECT 6 -#define PROMPT_CREATE 7 -#define PROMPT_SALVAGE 8 -#define PROMPT_TRUNCATE 9 -#define PROMPT_CLEAR_INODE 10 -#define PROMPT_ABORT 11 -#define PROMPT_SPLIT 12 -#define PROMPT_CONTINUE 13 -#define PROMPT_CLONE 14 -#define PROMPT_DELETE 15 -#define PROMPT_SUPPRESS 16 -#define PROMPT_UNLINK 17 -#define PROMPT_CLEAR_HTREE 18 -#define PROMPT_RECREATE 19 -#define PROMPT_NULL 20 - -/* - * These are the prompts which are used to ask the user if they want - * to fix a problem. - */ -static const char *prompt[] = { - N_("(no prompt)"), /* 0 */ - N_("Fix"), /* 1 */ - N_("Clear"), /* 2 */ - N_("Relocate"), /* 3 */ - N_("Allocate"), /* 4 */ - N_("Expand"), /* 5 */ - N_("Connect to /lost+found"), /* 6 */ - N_("Create"), /* 7 */ - N_("Salvage"), /* 8 */ - N_("Truncate"), /* 9 */ - N_("Clear inode"), /* 10 */ - N_("Abort"), /* 11 */ - N_("Split"), /* 12 */ - N_("Continue"), /* 13 */ - N_("Clone duplicate/bad blocks"), /* 14 */ - N_("Delete file"), /* 15 */ - N_("Suppress messages"),/* 16 */ - N_("Unlink"), /* 17 */ - N_("Clear HTree index"),/* 18 */ - N_("Recreate"), /* 19 */ - "", /* 20 */ -}; - -/* - * These messages are printed when we are preen mode and we will be - * automatically fixing the problem. - */ -static const char *preen_msg[] = { - N_("(NONE)"), /* 0 */ - N_("FIXED"), /* 1 */ - N_("CLEARED"), /* 2 */ - N_("RELOCATED"), /* 3 */ - N_("ALLOCATED"), /* 4 */ - N_("EXPANDED"), /* 5 */ - N_("RECONNECTED"), /* 6 */ - N_("CREATED"), /* 7 */ - N_("SALVAGED"), /* 8 */ - N_("TRUNCATED"), /* 9 */ - N_("INODE CLEARED"), /* 10 */ - N_("ABORTED"), /* 11 */ - N_("SPLIT"), /* 12 */ - N_("CONTINUING"), /* 13 */ - N_("DUPLICATE/BAD BLOCKS CLONED"), /* 14 */ - N_("FILE DELETED"), /* 15 */ - N_("SUPPRESSED"), /* 16 */ - N_("UNLINKED"), /* 17 */ - N_("HTREE INDEX CLEARED"),/* 18 */ - N_("WILL RECREATE"), /* 19 */ - "", /* 20 */ -}; - -static const struct e2fsck_problem problem_table[] = { - - /* Pre-Pass 1 errors */ - - /* Block bitmap not in group */ - { PR_0_BB_NOT_GROUP, N_("@b @B for @g %g is not in @g. (@b %b)\n"), - PROMPT_RELOCATE, PR_LATCH_RELOC }, - - /* Inode bitmap not in group */ - { PR_0_IB_NOT_GROUP, N_("@i @B for @g %g is not in @g. (@b %b)\n"), - PROMPT_RELOCATE, PR_LATCH_RELOC }, - - /* Inode table not in group */ - { PR_0_ITABLE_NOT_GROUP, - N_("@i table for @g %g is not in @g. (@b %b)\n" - "WARNING: SEVERE DATA LOSS POSSIBLE.\n"), - PROMPT_RELOCATE, PR_LATCH_RELOC }, - - /* Superblock corrupt */ - { PR_0_SB_CORRUPT, - N_("\nThe @S could not be read or does not describe a correct ext2\n" - "@f. If the @v is valid and it really contains an ext2\n" - "@f (and not swap or ufs or something else), then the @S\n" - "is corrupt, and you might try running e2fsck with an alternate @S:\n" - " e2fsck -b %S <@v>\n\n"), - PROMPT_NONE, PR_FATAL }, - - /* Filesystem size is wrong */ - { PR_0_FS_SIZE_WRONG, - N_("The @f size (according to the @S) is %b @bs\n" - "The physical size of the @v is %c @bs\n" - "Either the @S or the partition table is likely to be corrupt!\n"), - PROMPT_ABORT, 0 }, - - /* Fragments not supported */ - { PR_0_NO_FRAGMENTS, - N_("@S @b_size = %b, fragsize = %c.\n" - "This version of e2fsck does not support fragment sizes different\n" - "from the @b size.\n"), - PROMPT_NONE, PR_FATAL }, - - /* Bad blocks_per_group */ - { PR_0_BLOCKS_PER_GROUP, - N_("@S @bs_per_group = %b, should have been %c\n"), - PROMPT_NONE, PR_AFTER_CODE, PR_0_SB_CORRUPT }, - - /* Bad first_data_block */ - { PR_0_FIRST_DATA_BLOCK, - N_("@S first_data_@b = %b, should have been %c\n"), - PROMPT_NONE, PR_AFTER_CODE, PR_0_SB_CORRUPT }, - - /* Adding UUID to filesystem */ - { PR_0_ADD_UUID, - N_("@f did not have a UUID; generating one.\n\n"), - PROMPT_NONE, 0 }, - - /* Relocate hint */ - { PR_0_RELOCATE_HINT, - N_("Note: if there is several inode or block bitmap blocks\n" - "which require relocation, or one part of the inode table\n" - "which must be moved, you may wish to try running e2fsck\n" - "with the '-b %S' option first. The problem may lie only\n" - "with the primary block group descriptor, and the backup\n" - "block group descriptor may be OK.\n\n"), - PROMPT_NONE, PR_PREEN_OK | PR_NOCOLLATE }, - - /* Miscellaneous superblock corruption */ - { PR_0_MISC_CORRUPT_SUPER, - N_("Corruption found in @S. (%s = %N).\n"), - PROMPT_NONE, PR_AFTER_CODE, PR_0_SB_CORRUPT }, - - /* Error determing physical device size of filesystem */ - { PR_0_GETSIZE_ERROR, - N_("Error determining size of the physical @v: %m\n"), - PROMPT_NONE, PR_FATAL }, - - /* Inode count in superblock is incorrect */ - { PR_0_INODE_COUNT_WRONG, - N_("@i count in @S is %i, should be %j.\n"), - PROMPT_FIX, 0 }, - - { PR_0_HURD_CLEAR_FILETYPE, - N_("The Hurd does not support the filetype feature.\n"), - PROMPT_CLEAR, 0 }, - - /* Journal inode is invalid */ - { PR_0_JOURNAL_BAD_INODE, - N_("@S has a bad ext3 @j (@i %i).\n"), - PROMPT_CLEAR, PR_PREEN_OK }, - - /* The external journal has (unsupported) multiple filesystems */ - { PR_0_JOURNAL_UNSUPP_MULTIFS, - N_("External @j has multiple @f users (unsupported).\n"), - PROMPT_NONE, PR_FATAL }, - - /* Can't find external journal */ - { PR_0_CANT_FIND_JOURNAL, - N_("Can't find external @j\n"), - PROMPT_NONE, PR_FATAL }, - - /* External journal has bad superblock */ - { PR_0_EXT_JOURNAL_BAD_SUPER, - N_("External @j has bad @S\n"), - PROMPT_NONE, PR_FATAL }, - - /* Superblock has a bad journal UUID */ - { PR_0_JOURNAL_BAD_UUID, - N_("External @j does not support this @f\n"), - PROMPT_NONE, PR_FATAL }, - - /* Journal has an unknown superblock type */ - { PR_0_JOURNAL_UNSUPP_SUPER, - N_("Ext3 @j @S is unknown type %N (unsupported).\n" - "It is likely that your copy of e2fsck is old and/or doesn't " - "support this @j format.\n" - "It is also possible the @j @S is corrupt.\n"), - PROMPT_ABORT, PR_NO_OK | PR_AFTER_CODE, PR_0_JOURNAL_BAD_SUPER }, - - /* Journal superblock is corrupt */ - { PR_0_JOURNAL_BAD_SUPER, - N_("Ext3 @j @S is corrupt.\n"), - PROMPT_FIX, PR_PREEN_OK }, - - /* Superblock flag should be cleared */ - { PR_0_JOURNAL_HAS_JOURNAL, - N_("@S doesn't have has_@j flag, but has ext3 @j %s.\n"), - PROMPT_CLEAR, PR_PREEN_OK }, - - /* Superblock flag is incorrect */ - { PR_0_JOURNAL_RECOVER_SET, - N_("@S has ext3 needs_recovery flag set, but no @j.\n"), - PROMPT_CLEAR, PR_PREEN_OK }, - - /* Journal has data, but recovery flag is clear */ - { PR_0_JOURNAL_RECOVERY_CLEAR, - N_("ext3 recovery flag clear, but @j has data.\n"), - PROMPT_NONE, 0 }, - - /* Ask if we should clear the journal */ - { PR_0_JOURNAL_RESET_JOURNAL, - N_("Clear @j"), - PROMPT_NULL, PR_PREEN_NOMSG }, - - /* Ask if we should run the journal anyway */ - { PR_0_JOURNAL_RUN, - N_("Run @j anyway"), - PROMPT_NULL, 0 }, - - /* Run the journal by default */ - { PR_0_JOURNAL_RUN_DEFAULT, - N_("Recovery flag not set in backup @S, so running @j anyway.\n"), - PROMPT_NONE, 0 }, - - /* Clearing orphan inode */ - { PR_0_ORPHAN_CLEAR_INODE, - N_("%s @o @i %i (uid=%Iu, gid=%Ig, mode=%Im, size=%Is)\n"), - PROMPT_NONE, 0 }, - - /* Illegal block found in orphaned inode */ - { PR_0_ORPHAN_ILLEGAL_BLOCK_NUM, - N_("@I @b #%B (%b) found in @o @i %i.\n"), - PROMPT_NONE, 0 }, - - /* Already cleared block found in orphaned inode */ - { PR_0_ORPHAN_ALREADY_CLEARED_BLOCK, - N_("Already cleared @b #%B (%b) found in @o @i %i.\n"), - PROMPT_NONE, 0 }, - - /* Illegal orphan inode in superblock */ - { PR_0_ORPHAN_ILLEGAL_HEAD_INODE, - N_("@I @o @i %i in @S.\n"), - PROMPT_NONE, 0 }, - - /* Illegal inode in orphaned inode list */ - { PR_0_ORPHAN_ILLEGAL_INODE, - N_("@I @i %i in @o @i list.\n"), - PROMPT_NONE, 0 }, - - /* Filesystem revision is 0, but feature flags are set */ - { PR_0_FS_REV_LEVEL, - "@f has feature flag(s) set, but is a revision 0 @f. ", - PROMPT_FIX, PR_PREEN_OK | PR_NO_OK }, - - /* Journal superblock has an unknown read-only feature flag set */ - { PR_0_JOURNAL_UNSUPP_ROCOMPAT, - N_("Ext3 @j @S has an unknown read-only feature flag set.\n"), - PROMPT_ABORT, 0 }, - - /* Journal superblock has an unknown incompatible feature flag set */ - { PR_0_JOURNAL_UNSUPP_INCOMPAT, - N_("Ext3 @j @S has an unknown incompatible feature flag set.\n"), - PROMPT_ABORT, 0 }, - - /* Journal has unsupported version number */ - { PR_0_JOURNAL_UNSUPP_VERSION, - N_("@j version not supported by this e2fsck.\n"), - PROMPT_ABORT, 0 }, - - /* Moving journal to hidden file */ - { PR_0_MOVE_JOURNAL, - N_("Moving @j from /%s to hidden inode.\n\n"), - PROMPT_NONE, 0 }, - - /* Error moving journal to hidden file */ - { PR_0_ERR_MOVE_JOURNAL, - N_("Error moving @j: %m\n\n"), - PROMPT_NONE, 0 }, - - /* Clearing V2 journal superblock */ - { PR_0_CLEAR_V2_JOURNAL, - N_("Found invalid V2 @j @S fields (from V1 journal).\n" - "Clearing fields beyond the V1 @j @S...\n\n"), - PROMPT_NONE, 0 }, - - /* Backup journal inode blocks */ - { PR_0_BACKUP_JNL, - N_("Backing up @j @i @b information.\n\n"), - PROMPT_NONE, 0 }, - - /* Reserved blocks w/o resize_inode */ - { PR_0_NONZERO_RESERVED_GDT_BLOCKS, - N_("@f does not have resize_@i enabled, but s_reserved_gdt_@bs\n" - "is %N; @s zero. "), - PROMPT_FIX, 0 }, - - /* Resize_inode not enabled, but resize inode is non-zero */ - { PR_0_CLEAR_RESIZE_INODE, - N_("Resize_@i not enabled, but the resize inode is non-zero. "), - PROMPT_CLEAR, 0 }, - - /* Resize inode invalid */ - { PR_0_RESIZE_INODE_INVALID, - N_("Resize @i not valid. "), - PROMPT_RECREATE, 0 }, - - /* Pass 1 errors */ - - /* Pass 1: Checking inodes, blocks, and sizes */ - { PR_1_PASS_HEADER, - N_("Pass 1: Checking @is, @bs, and sizes\n"), - PROMPT_NONE, 0 }, - - /* Root directory is not an inode */ - { PR_1_ROOT_NO_DIR, N_("@r is not a @d. "), - PROMPT_CLEAR, 0 }, - - /* Root directory has dtime set */ - { PR_1_ROOT_DTIME, - N_("@r has dtime set (probably due to old mke2fs). "), - PROMPT_FIX, PR_PREEN_OK }, - - /* Reserved inode has bad mode */ - { PR_1_RESERVED_BAD_MODE, - N_("Reserved @i %i %Q has bad mode. "), - PROMPT_CLEAR, PR_PREEN_OK }, - - /* Deleted inode has zero dtime */ - { PR_1_ZERO_DTIME, - N_("@D @i %i has zero dtime. "), - PROMPT_FIX, PR_PREEN_OK }, - - /* Inode in use, but dtime set */ - { PR_1_SET_DTIME, - N_("@i %i is in use, but has dtime set. "), - PROMPT_FIX, PR_PREEN_OK }, - - /* Zero-length directory */ - { PR_1_ZERO_LENGTH_DIR, - N_("@i %i is a @z @d. "), - PROMPT_CLEAR, PR_PREEN_OK }, - - /* Block bitmap conflicts with some other fs block */ - { PR_1_BB_CONFLICT, - N_("@g %g's @b @B at %b @C.\n"), - PROMPT_RELOCATE, 0 }, - - /* Inode bitmap conflicts with some other fs block */ - { PR_1_IB_CONFLICT, - N_("@g %g's @i @B at %b @C.\n"), - PROMPT_RELOCATE, 0 }, - - /* Inode table conflicts with some other fs block */ - { PR_1_ITABLE_CONFLICT, - N_("@g %g's @i table at %b @C.\n"), - PROMPT_RELOCATE, 0 }, - - /* Block bitmap is on a bad block */ - { PR_1_BB_BAD_BLOCK, - N_("@g %g's @b @B (%b) is bad. "), - PROMPT_RELOCATE, 0 }, - - /* Inode bitmap is on a bad block */ - { PR_1_IB_BAD_BLOCK, - N_("@g %g's @i @B (%b) is bad. "), - PROMPT_RELOCATE, 0 }, - - /* Inode has incorrect i_size */ - { PR_1_BAD_I_SIZE, - N_("@i %i, i_size is %Is, @s %N. "), - PROMPT_FIX, PR_PREEN_OK }, - - /* Inode has incorrect i_blocks */ - { PR_1_BAD_I_BLOCKS, - N_("@i %i, i_@bs is %Ib, @s %N. "), - PROMPT_FIX, PR_PREEN_OK }, - - /* Illegal blocknumber in inode */ - { PR_1_ILLEGAL_BLOCK_NUM, - N_("@I @b #%B (%b) in @i %i. "), - PROMPT_CLEAR, PR_LATCH_BLOCK }, - - /* Block number overlaps fs metadata */ - { PR_1_BLOCK_OVERLAPS_METADATA, - N_("@b #%B (%b) overlaps @f metadata in @i %i. "), - PROMPT_CLEAR, PR_LATCH_BLOCK }, - - /* Inode has illegal blocks (latch question) */ - { PR_1_INODE_BLOCK_LATCH, - N_("@i %i has illegal @b(s). "), - PROMPT_CLEAR, 0 }, - - /* Too many bad blocks in inode */ - { PR_1_TOO_MANY_BAD_BLOCKS, - N_("Too many illegal @bs in @i %i.\n"), - PROMPT_CLEAR_INODE, PR_NO_OK }, - - /* Illegal block number in bad block inode */ - { PR_1_BB_ILLEGAL_BLOCK_NUM, - N_("@I @b #%B (%b) in bad @b @i. "), - PROMPT_CLEAR, PR_LATCH_BBLOCK }, - - /* Bad block inode has illegal blocks (latch question) */ - { PR_1_INODE_BBLOCK_LATCH, - N_("Bad @b @i has illegal @b(s). "), - PROMPT_CLEAR, 0 }, - - /* Duplicate or bad blocks in use! */ - { PR_1_DUP_BLOCKS_PREENSTOP, - N_("Duplicate or bad @b in use!\n"), - PROMPT_NONE, 0 }, - - /* Bad block used as bad block indirect block */ - { PR_1_BBINODE_BAD_METABLOCK, - N_("Bad @b %b used as bad @b @i indirect @b. "), - PROMPT_CLEAR, PR_LATCH_BBLOCK }, - - /* Inconsistency can't be fixed prompt */ - { PR_1_BBINODE_BAD_METABLOCK_PROMPT, - N_("\nThe bad @b @i has probably been corrupted. You probably\n" - "should stop now and run ""e2fsck -c"" to scan for bad blocks\n" - "in the @f.\n"), - PROMPT_CONTINUE, PR_PREEN_NOMSG }, - - /* Bad primary block */ - { PR_1_BAD_PRIMARY_BLOCK, - N_("\nIf the @b is really bad, the @f can not be fixed.\n"), - PROMPT_NONE, PR_AFTER_CODE, PR_1_BAD_PRIMARY_BLOCK_PROMPT }, - - /* Bad primary block prompt */ - { PR_1_BAD_PRIMARY_BLOCK_PROMPT, - N_("You can clear the this @b (and hope for the best) from the\n" - "bad @b list and hope that @b is really OK, but there are no\n" - "guarantees.\n\n"), - PROMPT_CLEAR, PR_PREEN_NOMSG }, - - /* Bad primary superblock */ - { PR_1_BAD_PRIMARY_SUPERBLOCK, - N_("The primary @S (%b) is on the bad @b list.\n"), - PROMPT_NONE, PR_AFTER_CODE, PR_1_BAD_PRIMARY_BLOCK }, - - /* Bad primary block group descriptors */ - { PR_1_BAD_PRIMARY_GROUP_DESCRIPTOR, - N_("Block %b in the primary @g descriptors " - "is on the bad @b list\n"), - PROMPT_NONE, PR_AFTER_CODE, PR_1_BAD_PRIMARY_BLOCK }, - - /* Bad superblock in group */ - { PR_1_BAD_SUPERBLOCK, - N_("Warning: Group %g's @S (%b) is bad.\n"), - PROMPT_NONE, PR_PREEN_OK | PR_PREEN_NOMSG }, - - /* Bad block group descriptors in group */ - { PR_1_BAD_GROUP_DESCRIPTORS, - N_("Warning: Group %g's copy of the @g descriptors has a bad " - "@b (%b).\n"), - PROMPT_NONE, PR_PREEN_OK | PR_PREEN_NOMSG }, - - /* Block claimed for no reason */ - { PR_1_PROGERR_CLAIMED_BLOCK, - N_("Programming error? @b #%b claimed for no reason in " - "process_bad_@b.\n"), - PROMPT_NONE, PR_PREEN_OK }, - - /* Error allocating blocks for relocating metadata */ - { PR_1_RELOC_BLOCK_ALLOCATE, - N_("@A %N contiguous @b(s) in @b @g %g for %s: %m\n"), - PROMPT_NONE, PR_PREEN_OK }, - - /* Error allocating block buffer during relocation process */ - { PR_1_RELOC_MEMORY_ALLOCATE, - N_("@A @b buffer for relocating %s\n"), - PROMPT_NONE, PR_PREEN_OK }, - - /* Relocating metadata group information from X to Y */ - { PR_1_RELOC_FROM_TO, - N_("Relocating @g %g's %s from %b to %c...\n"), - PROMPT_NONE, PR_PREEN_OK }, - - /* Relocating metatdata group information to X */ - { PR_1_RELOC_TO, - N_("Relocating @g %g's %s to %c...\n"), /* xgettext:no-c-format */ - PROMPT_NONE, PR_PREEN_OK }, - - /* Block read error during relocation process */ - { PR_1_RELOC_READ_ERR, - N_("Warning: could not read @b %b of %s: %m\n"), - PROMPT_NONE, PR_PREEN_OK }, - - /* Block write error during relocation process */ - { PR_1_RELOC_WRITE_ERR, - N_("Warning: could not write @b %b for %s: %m\n"), - PROMPT_NONE, PR_PREEN_OK }, - - /* Error allocating inode bitmap */ - { PR_1_ALLOCATE_IBITMAP_ERROR, - "@A @i @B (%N): %m\n", - PROMPT_NONE, PR_FATAL }, - - /* Error allocating block bitmap */ - { PR_1_ALLOCATE_BBITMAP_ERROR, - "@A @b @B (%N): %m\n", - PROMPT_NONE, PR_FATAL }, - - /* Error allocating icount structure */ - { PR_1_ALLOCATE_ICOUNT, - N_("@A icount link information: %m\n"), - PROMPT_NONE, PR_FATAL }, - - /* Error allocating dbcount */ - { PR_1_ALLOCATE_DBCOUNT, - N_("@A @d @b array: %m\n"), - PROMPT_NONE, PR_FATAL }, - - /* Error while scanning inodes */ - { PR_1_ISCAN_ERROR, - N_("Error while scanning @is (%i): %m\n"), - PROMPT_NONE, PR_FATAL }, - - /* Error while iterating over blocks */ - { PR_1_BLOCK_ITERATE, - N_("Error while iterating over @bs in @i %i: %m\n"), - PROMPT_NONE, PR_FATAL }, - - /* Error while storing inode count information */ - { PR_1_ICOUNT_STORE, - N_("Error storing @i count information (@i=%i, count=%N): %m\n"), - PROMPT_NONE, PR_FATAL }, - - /* Error while storing directory block information */ - { PR_1_ADD_DBLOCK, - N_("Error storing @d @b information " - "(@i=%i, @b=%b, num=%N): %m\n"), - PROMPT_NONE, PR_FATAL }, - - /* Error while reading inode (for clearing) */ - { PR_1_READ_INODE, - N_("Error reading @i %i: %m\n"), - PROMPT_NONE, PR_FATAL }, - - /* Suppress messages prompt */ - { PR_1_SUPPRESS_MESSAGES, "", PROMPT_SUPPRESS, PR_NO_OK }, - - /* Imagic flag set on an inode when filesystem doesn't support it */ - { PR_1_SET_IMAGIC, - N_("@i %i has imagic flag set. "), - PROMPT_CLEAR, 0 }, - - /* Immutable flag set on a device or socket inode */ - { PR_1_SET_IMMUTABLE, - N_("Special (@v/socket/fifo/symlink) file (@i %i) has immutable\n" - "or append-only flag set. "), - PROMPT_CLEAR, PR_PREEN_OK | PR_PREEN_NO | PR_NO_OK }, - - /* Compression flag set on an inode when filesystem doesn't support it */ - { PR_1_COMPR_SET, - N_("@i %i has @cion flag set on @f without @cion support. "), - PROMPT_CLEAR, 0 }, - - /* Non-zero size for device, fifo or socket inode */ - { PR_1_SET_NONZSIZE, - "Special (@v/socket/fifo) @i %i has non-zero size. ", - PROMPT_FIX, PR_PREEN_OK }, - - /* Filesystem revision is 0, but feature flags are set */ - { PR_1_FS_REV_LEVEL, - "@f has feature flag(s) set, but is a revision 0 @f. ", - PROMPT_FIX, PR_PREEN_OK | PR_NO_OK }, - - /* Journal inode is not in use, but contains data */ - { PR_1_JOURNAL_INODE_NOT_CLEAR, - "@j @i is not in use, but contains data. ", - PROMPT_CLEAR, PR_PREEN_OK }, - - /* Journal has bad mode */ - { PR_1_JOURNAL_BAD_MODE, - N_("@j is not regular file. "), - PROMPT_FIX, PR_PREEN_OK }, - - /* Deal with inodes that were part of orphan linked list */ - { PR_1_LOW_DTIME, - N_("@i %i was part of the orphaned @i list. "), - PROMPT_FIX, PR_LATCH_LOW_DTIME, 0 }, - - /* Deal with inodes that were part of corrupted orphan linked - list (latch question) */ - { PR_1_ORPHAN_LIST_REFUGEES, - N_("@is that were part of a corrupted orphan linked list found. "), - PROMPT_FIX, 0 }, - - /* Error allocating refcount structure */ - { PR_1_ALLOCATE_REFCOUNT, - "@A refcount structure (%N): %m\n", - PROMPT_NONE, PR_FATAL }, - - /* Error reading extended attribute block */ - { PR_1_READ_EA_BLOCK, - N_("Error reading @a @b %b for @i %i. "), - PROMPT_CLEAR, 0 }, - - /* Invalid extended attribute block */ - { PR_1_BAD_EA_BLOCK, - N_("@i %i has a bad @a @b %b. "), - PROMPT_CLEAR, 0 }, - - /* Error reading Extended Attribute block while fixing refcount */ - { PR_1_EXTATTR_READ_ABORT, - N_("Error reading @a @b %b (%m). "), - PROMPT_ABORT, 0 }, - - /* Extended attribute reference count incorrect */ - { PR_1_EXTATTR_REFCOUNT, - N_("@a @b %b has reference count %B, should be %N. "), - PROMPT_FIX, 0 }, - - /* Error writing Extended Attribute block while fixing refcount */ - { PR_1_EXTATTR_WRITE, - N_("Error writing @a @b %b (%m). "), - PROMPT_ABORT, 0 }, - - /* Multiple EA blocks not supported */ - { PR_1_EA_MULTI_BLOCK, - N_("@a @b %b has h_blocks > 1. "), - PROMPT_CLEAR, 0}, - - /* Error allocating EA region allocation structure */ - { PR_1_EA_ALLOC_REGION, - N_("Error allocating @a @b %b. "), - PROMPT_ABORT, 0}, - - /* Error EA allocation collision */ - { PR_1_EA_ALLOC_COLLISION, - N_("@a @b %b is corrupt (allocation collision). "), - PROMPT_CLEAR, 0}, - - /* Bad extended attribute name */ - { PR_1_EA_BAD_NAME, - N_("@a @b %b is corrupt (invalid name). "), - PROMPT_CLEAR, 0}, - - /* Bad extended attribute value */ - { PR_1_EA_BAD_VALUE, - N_("@a @b %b is corrupt (invalid value). "), - PROMPT_CLEAR, 0}, - - /* Inode too big (latch question) */ - { PR_1_INODE_TOOBIG, - N_("@i %i is too big. "), PROMPT_TRUNCATE, 0 }, - - /* Directory too big */ - { PR_1_TOOBIG_DIR, - N_("@b #%B (%b) causes @d to be too big. "), - PROMPT_CLEAR, PR_LATCH_TOOBIG }, - - /* Regular file too big */ - { PR_1_TOOBIG_REG, - N_("@b #%B (%b) causes file to be too big. "), - PROMPT_CLEAR, PR_LATCH_TOOBIG }, - - /* Symlink too big */ - { PR_1_TOOBIG_SYMLINK, - N_("@b #%B (%b) causes symlink to be too big. "), - PROMPT_CLEAR, PR_LATCH_TOOBIG }, - - /* INDEX_FL flag set on a non-HTREE filesystem */ - { PR_1_HTREE_SET, - N_("@i %i has INDEX_FL flag set on @f without htree support.\n"), - PROMPT_CLEAR_HTREE, PR_PREEN_OK }, - - /* INDEX_FL flag set on a non-directory */ - { PR_1_HTREE_NODIR, - N_("@i %i has INDEX_FL flag set but is not a @d.\n"), - PROMPT_CLEAR_HTREE, PR_PREEN_OK }, - - /* Invalid root node in HTREE directory */ - { PR_1_HTREE_BADROOT, - N_("@h %i has an invalid root node.\n"), - PROMPT_CLEAR_HTREE, PR_PREEN_OK }, - - /* Unsupported hash version in HTREE directory */ - { PR_1_HTREE_HASHV, - N_("@h %i has an unsupported hash version (%N)\n"), - PROMPT_CLEAR_HTREE, PR_PREEN_OK }, - - /* Incompatible flag in HTREE root node */ - { PR_1_HTREE_INCOMPAT, - N_("@h %i uses an incompatible htree root node flag.\n"), - PROMPT_CLEAR_HTREE, PR_PREEN_OK }, - - /* HTREE too deep */ - { PR_1_HTREE_DEPTH, - N_("@h %i has a tree depth (%N) which is too big\n"), - PROMPT_CLEAR_HTREE, PR_PREEN_OK }, - - /* Bad block has indirect block that conflicts with filesystem block */ - { PR_1_BB_FS_BLOCK, - N_("Bad @b @i has an indirect @b (%b) that conflicts with\n" - "@f metadata. "), - PROMPT_CLEAR, PR_LATCH_BBLOCK }, - - /* Resize inode failed */ - { PR_1_RESIZE_INODE_CREATE, - N_("Resize @i (re)creation failed: %m."), - PROMPT_ABORT, 0 }, - - /* invalid inode->i_extra_isize */ - { PR_1_EXTRA_ISIZE, - N_("@i %i has a extra size (%IS) which is invalid\n"), - PROMPT_FIX, PR_PREEN_OK }, - - /* invalid ea entry->e_name_len */ - { PR_1_ATTR_NAME_LEN, - N_("@a in @i %i has a namelen (%N) which is invalid\n"), - PROMPT_CLEAR, PR_PREEN_OK }, - - /* invalid ea entry->e_value_size */ - { PR_1_ATTR_VALUE_SIZE, - N_("@a in @i %i has a value size (%N) which is invalid\n"), - PROMPT_CLEAR, PR_PREEN_OK }, - - /* invalid ea entry->e_value_offs */ - { PR_1_ATTR_VALUE_OFFSET, - N_("@a in @i %i has a value offset (%N) which is invalid\n"), - PROMPT_CLEAR, PR_PREEN_OK }, - - /* invalid ea entry->e_value_block */ - { PR_1_ATTR_VALUE_BLOCK, - N_("@a in @i %i has a value block (%N) which is invalid (must be 0)\n"), - PROMPT_CLEAR, PR_PREEN_OK }, - - /* invalid ea entry->e_hash */ - { PR_1_ATTR_HASH, - N_("@a in @i %i has a hash (%N) which is invalid (must be 0)\n"), - PROMPT_CLEAR, PR_PREEN_OK }, - - /* Pass 1b errors */ - - /* Pass 1B: Rescan for duplicate/bad blocks */ - { PR_1B_PASS_HEADER, - N_("Duplicate @bs found... invoking duplicate @b passes.\n" - "Pass 1B: Rescan for duplicate/bad @bs\n"), - PROMPT_NONE, 0 }, - - /* Duplicate/bad block(s) header */ - { PR_1B_DUP_BLOCK_HEADER, - N_("Duplicate/bad @b(s) in @i %i:"), - PROMPT_NONE, 0 }, - - /* Duplicate/bad block(s) in inode */ - { PR_1B_DUP_BLOCK, - " %b", - PROMPT_NONE, PR_LATCH_DBLOCK | PR_PREEN_NOHDR }, - - /* Duplicate/bad block(s) end */ - { PR_1B_DUP_BLOCK_END, - "\n", - PROMPT_NONE, PR_PREEN_NOHDR }, - - /* Error while scanning inodes */ - { PR_1B_ISCAN_ERROR, - N_("Error while scanning inodes (%i): %m\n"), - PROMPT_NONE, PR_FATAL }, - - /* Error allocating inode bitmap */ - { PR_1B_ALLOCATE_IBITMAP_ERROR, - N_("@A @i @B (inode_dup_map): %m\n"), - PROMPT_NONE, PR_FATAL }, - - /* Error while iterating over blocks */ - { PR_1B_BLOCK_ITERATE, - N_("Error while iterating over @bs in @i %i (%s): %m\n"), - PROMPT_NONE, 0 }, - - /* Error adjusting EA refcount */ - { PR_1B_ADJ_EA_REFCOUNT, - N_("Error addjusting refcount for @a @b %b (@i %i): %m\n"), - PROMPT_NONE, 0 }, - - - /* Pass 1C: Scan directories for inodes with dup blocks. */ - { PR_1C_PASS_HEADER, - N_("Pass 1C: Scan directories for @is with dup @bs.\n"), - PROMPT_NONE, 0 }, - - - /* Pass 1D: Reconciling duplicate blocks */ - { PR_1D_PASS_HEADER, - N_("Pass 1D: Reconciling duplicate @bs\n"), - PROMPT_NONE, 0 }, - - /* File has duplicate blocks */ - { PR_1D_DUP_FILE, - N_("File %Q (@i #%i, mod time %IM) \n" - " has %B duplicate @b(s), shared with %N file(s):\n"), - PROMPT_NONE, 0 }, - - /* List of files sharing duplicate blocks */ - { PR_1D_DUP_FILE_LIST, - N_("\t%Q (@i #%i, mod time %IM)\n"), - PROMPT_NONE, 0 }, - - /* File sharing blocks with filesystem metadata */ - { PR_1D_SHARE_METADATA, - N_("\t<@f metadata>\n"), - PROMPT_NONE, 0 }, - - /* Report of how many duplicate/bad inodes */ - { PR_1D_NUM_DUP_INODES, - N_("(There are %N @is containing duplicate/bad @bs.)\n\n"), - PROMPT_NONE, 0 }, - - /* Duplicated blocks already reassigned or cloned. */ - { PR_1D_DUP_BLOCKS_DEALT, - N_("Duplicated @bs already reassigned or cloned.\n\n"), - PROMPT_NONE, 0 }, - - /* Clone duplicate/bad blocks? */ - { PR_1D_CLONE_QUESTION, - "", PROMPT_CLONE, PR_NO_OK }, - - /* Delete file? */ - { PR_1D_DELETE_QUESTION, - "", PROMPT_DELETE, 0 }, - - /* Couldn't clone file (error) */ - { PR_1D_CLONE_ERROR, - N_("Couldn't clone file: %m\n"), PROMPT_NONE, 0 }, - - /* Pass 2 errors */ - - /* Pass 2: Checking directory structure */ - { PR_2_PASS_HEADER, - N_("Pass 2: Checking @d structure\n"), - PROMPT_NONE, 0 }, - - /* Bad inode number for '.' */ - { PR_2_BAD_INODE_DOT, - N_("Bad @i number for '.' in @d @i %i.\n"), - PROMPT_FIX, 0 }, - - /* Directory entry has bad inode number */ - { PR_2_BAD_INO, - N_("@E has bad @i #: %Di.\n"), - PROMPT_CLEAR, 0 }, - - /* Directory entry has deleted or unused inode */ - { PR_2_UNUSED_INODE, - N_("@E has @D/unused @i %Di. "), - PROMPT_CLEAR, PR_PREEN_OK }, - - /* Directry entry is link to '.' */ - { PR_2_LINK_DOT, - N_("@E @L to '.' "), - PROMPT_CLEAR, 0 }, - - /* Directory entry points to inode now located in a bad block */ - { PR_2_BB_INODE, - N_("@E points to @i (%Di) located in a bad @b.\n"), - PROMPT_CLEAR, 0 }, - - /* Directory entry contains a link to a directory */ - { PR_2_LINK_DIR, - N_("@E @L to @d %P (%Di).\n"), - PROMPT_CLEAR, 0 }, - - /* Directory entry contains a link to the root directry */ - { PR_2_LINK_ROOT, - N_("@E @L to the @r.\n"), - PROMPT_CLEAR, 0 }, - - /* Directory entry has illegal characters in its name */ - { PR_2_BAD_NAME, - N_("@E has illegal characters in its name.\n"), - PROMPT_FIX, 0 }, - - /* Missing '.' in directory inode */ - { PR_2_MISSING_DOT, - N_("Missing '.' in @d @i %i.\n"), - PROMPT_FIX, 0 }, - - /* Missing '..' in directory inode */ - { PR_2_MISSING_DOT_DOT, - N_("Missing '..' in @d @i %i.\n"), - PROMPT_FIX, 0 }, - - /* First entry in directory inode doesn't contain '.' */ - { PR_2_1ST_NOT_DOT, - N_("First @e '%Dn' (inode=%Di) in @d @i %i (%p) @s '.'\n"), - PROMPT_FIX, 0 }, - - /* Second entry in directory inode doesn't contain '..' */ - { PR_2_2ND_NOT_DOT_DOT, - N_("Second @e '%Dn' (inode=%Di) in @d @i %i @s '..'\n"), - PROMPT_FIX, 0 }, - - /* i_faddr should be zero */ - { PR_2_FADDR_ZERO, - N_("i_faddr @F %IF, @s zero.\n"), - PROMPT_CLEAR, 0 }, - - /* i_file_acl should be zero */ - { PR_2_FILE_ACL_ZERO, - N_("i_file_acl @F %If, @s zero.\n"), - PROMPT_CLEAR, 0 }, - - /* i_dir_acl should be zero */ - { PR_2_DIR_ACL_ZERO, - N_("i_dir_acl @F %Id, @s zero.\n"), - PROMPT_CLEAR, 0 }, - - /* i_frag should be zero */ - { PR_2_FRAG_ZERO, - N_("i_frag @F %N, @s zero.\n"), - PROMPT_CLEAR, 0 }, - - /* i_fsize should be zero */ - { PR_2_FSIZE_ZERO, - N_("i_fsize @F %N, @s zero.\n"), - PROMPT_CLEAR, 0 }, - - /* inode has bad mode */ - { PR_2_BAD_MODE, - N_("@i %i (%Q) has a bad mode (%Im).\n"), - PROMPT_CLEAR, 0 }, - - /* directory corrupted */ - { PR_2_DIR_CORRUPTED, - N_("@d @i %i, @b %B, offset %N: @d corrupted\n"), - PROMPT_SALVAGE, 0 }, - - /* filename too long */ - { PR_2_FILENAME_LONG, - N_("@d @i %i, @b %B, offset %N: filename too long\n"), - PROMPT_TRUNCATE, 0 }, - - /* Directory inode has a missing block (hole) */ - { PR_2_DIRECTORY_HOLE, - N_("@d @i %i has an unallocated @b #%B. "), - PROMPT_ALLOCATE, 0 }, - - /* '.' is not NULL terminated */ - { PR_2_DOT_NULL_TERM, - N_("'.' @d @e in @d @i %i is not NULL terminated\n"), - PROMPT_FIX, 0 }, - - /* '..' is not NULL terminated */ - { PR_2_DOT_DOT_NULL_TERM, - N_("'..' @d @e in @d @i %i is not NULL terminated\n"), - PROMPT_FIX, 0 }, - - /* Illegal character device inode */ - { PR_2_BAD_CHAR_DEV, - N_("@i %i (%Q) is an @I character @v.\n"), - PROMPT_CLEAR, 0 }, - - /* Illegal block device inode */ - { PR_2_BAD_BLOCK_DEV, - N_("@i %i (%Q) is an @I @b @v.\n"), - PROMPT_CLEAR, 0 }, - - /* Duplicate '.' entry */ - { PR_2_DUP_DOT, - N_("@E is duplicate '.' @e.\n"), - PROMPT_FIX, 0 }, - - /* Duplicate '..' entry */ - { PR_2_DUP_DOT_DOT, - N_("@E is duplicate '..' @e.\n"), - PROMPT_FIX, 0 }, - - /* Internal error: couldn't find dir_info */ - { PR_2_NO_DIRINFO, - N_("Internal error: couldn't find dir_info for %i.\n"), - PROMPT_NONE, PR_FATAL }, - - /* Final rec_len is wrong */ - { PR_2_FINAL_RECLEN, - N_("@E has rec_len of %Dr, should be %N.\n"), - PROMPT_FIX, 0 }, - - /* Error allocating icount structure */ - { PR_2_ALLOCATE_ICOUNT, - N_("@A icount structure: %m\n"), - PROMPT_NONE, PR_FATAL }, - - /* Error iterating over directory blocks */ - { PR_2_DBLIST_ITERATE, - N_("Error iterating over @d @bs: %m\n"), - PROMPT_NONE, PR_FATAL }, - - /* Error reading directory block */ - { PR_2_READ_DIRBLOCK, - N_("Error reading @d @b %b (@i %i): %m\n"), - PROMPT_CONTINUE, 0 }, - - /* Error writing directory block */ - { PR_2_WRITE_DIRBLOCK, - N_("Error writing @d @b %b (@i %i): %m\n"), - PROMPT_CONTINUE, 0 }, - - /* Error allocating new directory block */ - { PR_2_ALLOC_DIRBOCK, - N_("@A new @d @b for @i %i (%s): %m\n"), - PROMPT_NONE, 0 }, - - /* Error deallocating inode */ - { PR_2_DEALLOC_INODE, - N_("Error deallocating @i %i: %m\n"), - PROMPT_NONE, PR_FATAL }, - - /* Directory entry for '.' is big. Split? */ - { PR_2_SPLIT_DOT, - N_("@d @e for '.' is big. "), - PROMPT_SPLIT, PR_NO_OK }, - - /* Illegal FIFO inode */ - { PR_2_BAD_FIFO, - N_("@i %i (%Q) is an @I FIFO.\n"), - PROMPT_CLEAR, 0 }, - - /* Illegal socket inode */ - { PR_2_BAD_SOCKET, - N_("@i %i (%Q) is an @I socket.\n"), - PROMPT_CLEAR, 0 }, - - /* Directory filetype not set */ - { PR_2_SET_FILETYPE, - N_("Setting filetype for @E to %N.\n"), - PROMPT_NONE, PR_PREEN_OK | PR_NO_OK | PR_NO_NOMSG }, - - /* Directory filetype incorrect */ - { PR_2_BAD_FILETYPE, - N_("@E has an incorrect filetype (was %Dt, should be %N).\n"), - PROMPT_FIX, 0 }, - - /* Directory filetype set on filesystem */ - { PR_2_CLEAR_FILETYPE, - N_("@E has filetype set.\n"), - PROMPT_CLEAR, PR_PREEN_OK }, - - /* Directory filename is null */ - { PR_2_NULL_NAME, - N_("@E has a zero-length name.\n"), - PROMPT_CLEAR, 0 }, - - /* Invalid symlink */ - { PR_2_INVALID_SYMLINK, - N_("Symlink %Q (@i #%i) is invalid.\n"), - PROMPT_CLEAR, 0 }, - - /* i_file_acl (extended attribute block) is bad */ - { PR_2_FILE_ACL_BAD, - N_("@a @b @F invalid (%If).\n"), - PROMPT_CLEAR, 0 }, - - /* Filesystem contains large files, but has no such flag in sb */ - { PR_2_FEATURE_LARGE_FILES, - N_("@f contains large files, but lacks LARGE_FILE flag in @S.\n"), - PROMPT_FIX, 0 }, - - /* Node in HTREE directory not referenced */ - { PR_2_HTREE_NOTREF, - N_("@p @h %d: node (%B) not referenced\n"), - PROMPT_NONE, 0 }, - - /* Node in HTREE directory referenced twice */ - { PR_2_HTREE_DUPREF, - N_("@p @h %d: node (%B) referenced twice\n"), - PROMPT_NONE, 0 }, - - /* Node in HTREE directory has bad min hash */ - { PR_2_HTREE_MIN_HASH, - N_("@p @h %d: node (%B) has bad min hash\n"), - PROMPT_NONE, 0 }, - - /* Node in HTREE directory has bad max hash */ - { PR_2_HTREE_MAX_HASH, - N_("@p @h %d: node (%B) has bad max hash\n"), - PROMPT_NONE, 0 }, - - /* Clear invalid HTREE directory */ - { PR_2_HTREE_CLEAR, - N_("Invalid @h %d (%q). "), PROMPT_CLEAR, 0 }, - - /* Bad block in htree interior node */ - { PR_2_HTREE_BADBLK, - N_("@p @h %d (%q): bad @b number %b.\n"), - PROMPT_CLEAR_HTREE, 0 }, - - /* Error adjusting EA refcount */ - { PR_2_ADJ_EA_REFCOUNT, - N_("Error addjusting refcount for @a @b %b (@i %i): %m\n"), - PROMPT_NONE, PR_FATAL }, - - /* Invalid HTREE root node */ - { PR_2_HTREE_BAD_ROOT, - N_("@p @h %d: root node is invalid\n"), - PROMPT_CLEAR_HTREE, PR_PREEN_OK }, - - /* Invalid HTREE limit */ - { PR_2_HTREE_BAD_LIMIT, - N_("@p @h %d: node (%B) has bad limit (%N)\n"), - PROMPT_CLEAR_HTREE, PR_PREEN_OK }, - - /* Invalid HTREE count */ - { PR_2_HTREE_BAD_COUNT, - N_("@p @h %d: node (%B) has bad count (%N)\n"), - PROMPT_CLEAR_HTREE, PR_PREEN_OK }, - - /* HTREE interior node has out-of-order hashes in table */ - { PR_2_HTREE_HASH_ORDER, - N_("@p @h %d: node (%B) has an unordered hash table\n"), - PROMPT_CLEAR_HTREE, PR_PREEN_OK }, - - /* Node in HTREE directory has bad depth */ - { PR_2_HTREE_BAD_DEPTH, - N_("@p @h %d: node (%B) has bad depth\n"), - PROMPT_NONE, 0 }, - - /* Duplicate directory entry found */ - { PR_2_DUPLICATE_DIRENT, - N_("Duplicate @E found. "), - PROMPT_CLEAR, 0 }, - - /* Non-unique filename found */ - { PR_2_NON_UNIQUE_FILE, /* xgettext: no-c-format */ - N_("@E has a non-unique filename.\nRename to %s"), - PROMPT_NULL, 0 }, - - /* Duplicate directory entry found */ - { PR_2_REPORT_DUP_DIRENT, - N_("Duplicate @e '%Dn' found.\n\tMarking %p (%i) to be rebuilt.\n\n"), - PROMPT_NONE, 0 }, - - /* Pass 3 errors */ - - /* Pass 3: Checking directory connectivity */ - { PR_3_PASS_HEADER, - N_("Pass 3: Checking @d connectivity\n"), - PROMPT_NONE, 0 }, - - /* Root inode not allocated */ - { PR_3_NO_ROOT_INODE, - N_("@r not allocated. "), - PROMPT_ALLOCATE, 0 }, - - /* No room in lost+found */ - { PR_3_EXPAND_LF_DIR, - N_("No room in @l @d. "), - PROMPT_EXPAND, 0 }, - - /* Unconnected directory inode */ - { PR_3_UNCONNECTED_DIR, - N_("Unconnected @d @i %i (%p)\n"), - PROMPT_CONNECT, 0 }, - - /* /lost+found not found */ - { PR_3_NO_LF_DIR, - N_("/@l not found. "), - PROMPT_CREATE, PR_PREEN_OK }, - - /* .. entry is incorrect */ - { PR_3_BAD_DOT_DOT, - N_("'..' in %Q (%i) is %P (%j), @s %q (%d).\n"), - PROMPT_FIX, 0 }, - - /* Bad or non-existent /lost+found. Cannot reconnect */ - { PR_3_NO_LPF, - N_("Bad or non-existent /@l. Cannot reconnect.\n"), - PROMPT_NONE, 0 }, - - /* Could not expand /lost+found */ - { PR_3_CANT_EXPAND_LPF, - N_("Could not expand /@l: %m\n"), - PROMPT_NONE, 0 }, - - /* Could not reconnect inode */ - { PR_3_CANT_RECONNECT, - N_("Could not reconnect %i: %m\n"), - PROMPT_NONE, 0 }, - - /* Error while trying to find /lost+found */ - { PR_3_ERR_FIND_LPF, - N_("Error while trying to find /@l: %m\n"), - PROMPT_NONE, 0 }, - - /* Error in ext2fs_new_block while creating /lost+found */ - { PR_3_ERR_LPF_NEW_BLOCK, - N_("ext2fs_new_@b: %m while trying to create /@l @d\n"), - PROMPT_NONE, 0 }, - - /* Error in ext2fs_new_inode while creating /lost+found */ - { PR_3_ERR_LPF_NEW_INODE, - N_("ext2fs_new_@i: %m while trying to create /@l @d\n"), - PROMPT_NONE, 0 }, - - /* Error in ext2fs_new_dir_block while creating /lost+found */ - { PR_3_ERR_LPF_NEW_DIR_BLOCK, - N_("ext2fs_new_dir_@b: %m while creating new @d @b\n"), - PROMPT_NONE, 0 }, - - /* Error while writing directory block for /lost+found */ - { PR_3_ERR_LPF_WRITE_BLOCK, - N_("ext2fs_write_dir_@b: %m while writing the @d @b for /@l\n"), - PROMPT_NONE, 0 }, - - /* Error while adjusting inode count */ - { PR_3_ADJUST_INODE, - N_("Error while adjusting @i count on @i %i\n"), - PROMPT_NONE, 0 }, - - /* Couldn't fix parent directory -- error */ - { PR_3_FIX_PARENT_ERR, - N_("Couldn't fix parent of @i %i: %m\n\n"), - PROMPT_NONE, 0 }, - - /* Couldn't fix parent directory -- couldn't find it */ - { PR_3_FIX_PARENT_NOFIND, - N_("Couldn't fix parent of @i %i: Couldn't find parent @d entry\n\n"), - PROMPT_NONE, 0 }, - - /* Error allocating inode bitmap */ - { PR_3_ALLOCATE_IBITMAP_ERROR, - N_("@A @i @B (%N): %m\n"), - PROMPT_NONE, PR_FATAL }, - - /* Error creating root directory */ - { PR_3_CREATE_ROOT_ERROR, - N_("Error creating root @d (%s): %m\n"), - PROMPT_NONE, PR_FATAL }, - - /* Error creating lost and found directory */ - { PR_3_CREATE_LPF_ERROR, - N_("Error creating /@l @d (%s): %m\n"), - PROMPT_NONE, PR_FATAL }, - - /* Root inode is not directory; aborting */ - { PR_3_ROOT_NOT_DIR_ABORT, - N_("@r is not a @d; aborting.\n"), - PROMPT_NONE, PR_FATAL }, - - /* Cannot proceed without a root inode. */ - { PR_3_NO_ROOT_INODE_ABORT, - N_("Cannot proceed without a @r.\n"), - PROMPT_NONE, PR_FATAL }, - - /* Internal error: couldn't find dir_info */ - { PR_3_NO_DIRINFO, - N_("Internal error: couldn't find dir_info for %i.\n"), - PROMPT_NONE, PR_FATAL }, - - /* Lost+found not a directory */ - { PR_3_LPF_NOTDIR, - N_("/@l is not a @d (ino=%i)\n"), - PROMPT_UNLINK, 0 }, - - /* Pass 3A Directory Optimization */ - - /* Pass 3A: Optimizing directories */ - { PR_3A_PASS_HEADER, - N_("Pass 3A: Optimizing directories\n"), - PROMPT_NONE, PR_PREEN_NOMSG }, - - /* Error iterating over directories */ - { PR_3A_OPTIMIZE_ITER, - N_("Failed to create dirs_to_hash iterator: %m"), - PROMPT_NONE, 0 }, - - /* Error rehash directory */ - { PR_3A_OPTIMIZE_DIR_ERR, - N_("Failed to optimize directory %q (%d): %m"), - PROMPT_NONE, 0 }, - - /* Rehashing dir header */ - { PR_3A_OPTIMIZE_DIR_HEADER, - N_("Optimizing directories: "), - PROMPT_NONE, PR_MSG_ONLY }, - - /* Rehashing directory %d */ - { PR_3A_OPTIMIZE_DIR, - " %d", - PROMPT_NONE, PR_LATCH_OPTIMIZE_DIR | PR_PREEN_NOHDR}, - - /* Rehashing dir end */ - { PR_3A_OPTIMIZE_DIR_END, - "\n", - PROMPT_NONE, PR_PREEN_NOHDR }, - - /* Pass 4 errors */ - - /* Pass 4: Checking reference counts */ - { PR_4_PASS_HEADER, - N_("Pass 4: Checking reference counts\n"), - PROMPT_NONE, 0 }, - - /* Unattached zero-length inode */ - { PR_4_ZERO_LEN_INODE, - "@u @z @i %i. ", - PROMPT_CLEAR, PR_PREEN_OK|PR_NO_OK }, - - /* Unattached inode */ - { PR_4_UNATTACHED_INODE, - "@u @i %i\n", - PROMPT_CONNECT, 0 }, - - /* Inode ref count wrong */ - { PR_4_BAD_REF_COUNT, - N_("@i %i ref count is %Il, @s %N. "), - PROMPT_FIX, PR_PREEN_OK }, - - { PR_4_INCONSISTENT_COUNT, - N_("WARNING: PROGRAMMING BUG IN E2FSCK!\n" - "\tOR SOME BONEHEAD (YOU) IS CHECKING A MOUNTED (LIVE) FILESYSTEM.\n" - "@i_link_info[%i] is %N, @i.i_links_count is %Il. " - "They should be the same!\n"), - PROMPT_NONE, 0 }, - - /* Pass 5 errors */ - - /* Pass 5: Checking group summary information */ - { PR_5_PASS_HEADER, - N_("Pass 5: Checking @g summary information\n"), - PROMPT_NONE, 0 }, - - /* Padding at end of inode bitmap is not set. */ - { PR_5_INODE_BMAP_PADDING, - N_("Padding at end of @i @B is not set. "), - PROMPT_FIX, PR_PREEN_OK }, - - /* Padding at end of block bitmap is not set. */ - { PR_5_BLOCK_BMAP_PADDING, - N_("Padding at end of @b @B is not set. "), - PROMPT_FIX, PR_PREEN_OK }, - - /* Block bitmap differences header */ - { PR_5_BLOCK_BITMAP_HEADER, - N_("@b @B differences: "), - PROMPT_NONE, PR_PREEN_OK | PR_PREEN_NOMSG}, - - /* Block not used, but marked in bitmap */ - { PR_5_BLOCK_UNUSED, - " -%b", - PROMPT_NONE, PR_LATCH_BBITMAP | PR_PREEN_OK | PR_PREEN_NOMSG }, - - /* Block used, but not marked used in bitmap */ - { PR_5_BLOCK_USED, - " +%b", - PROMPT_NONE, PR_LATCH_BBITMAP | PR_PREEN_OK | PR_PREEN_NOMSG }, - - /* Block bitmap differences end */ - { PR_5_BLOCK_BITMAP_END, - "\n", - PROMPT_FIX, PR_PREEN_OK | PR_PREEN_NOMSG }, - - /* Inode bitmap differences header */ - { PR_5_INODE_BITMAP_HEADER, - N_("@i @B differences: "), - PROMPT_NONE, PR_PREEN_OK | PR_PREEN_NOMSG }, - - /* Inode not used, but marked in bitmap */ - { PR_5_INODE_UNUSED, - " -%i", - PROMPT_NONE, PR_LATCH_IBITMAP | PR_PREEN_OK | PR_PREEN_NOMSG }, - - /* Inode used, but not marked used in bitmap */ - { PR_5_INODE_USED, - " +%i", - PROMPT_NONE, PR_LATCH_IBITMAP | PR_PREEN_OK | PR_PREEN_NOMSG }, - - /* Inode bitmap differences end */ - { PR_5_INODE_BITMAP_END, - "\n", - PROMPT_FIX, PR_PREEN_OK | PR_PREEN_NOMSG }, - - /* Free inodes count for group wrong */ - { PR_5_FREE_INODE_COUNT_GROUP, - N_("Free @is count wrong for @g #%g (%i, counted=%j).\n"), - PROMPT_FIX, PR_PREEN_OK | PR_PREEN_NOMSG }, - - /* Directories count for group wrong */ - { PR_5_FREE_DIR_COUNT_GROUP, - N_("Directories count wrong for @g #%g (%i, counted=%j).\n"), - PROMPT_FIX, PR_PREEN_OK | PR_PREEN_NOMSG }, - - /* Free inodes count wrong */ - { PR_5_FREE_INODE_COUNT, - N_("Free @is count wrong (%i, counted=%j).\n"), - PROMPT_FIX, PR_PREEN_OK | PR_PREEN_NOMSG }, - - /* Free blocks count for group wrong */ - { PR_5_FREE_BLOCK_COUNT_GROUP, - N_("Free @bs count wrong for @g #%g (%b, counted=%c).\n"), - PROMPT_FIX, PR_PREEN_OK | PR_PREEN_NOMSG }, - - /* Free blocks count wrong */ - { PR_5_FREE_BLOCK_COUNT, - N_("Free @bs count wrong (%b, counted=%c).\n"), - PROMPT_FIX, PR_PREEN_OK | PR_PREEN_NOMSG }, - - /* Programming error: bitmap endpoints don't match */ - { PR_5_BMAP_ENDPOINTS, - N_("PROGRAMMING ERROR: @f (#%N) @B endpoints (%b, %c) don't " - "match calculated @B endpoints (%i, %j)\n"), - PROMPT_NONE, PR_FATAL }, - - /* Internal error: fudging end of bitmap */ - { PR_5_FUDGE_BITMAP_ERROR, - N_("Internal error: fudging end of bitmap (%N)\n"), - PROMPT_NONE, PR_FATAL }, - - /* Error copying in replacement inode bitmap */ - { PR_5_COPY_IBITMAP_ERROR, - "Error copying in replacement @i @B: %m\n", - PROMPT_NONE, PR_FATAL }, - - /* Error copying in replacement block bitmap */ - { PR_5_COPY_BBITMAP_ERROR, - "Error copying in replacement @b @B: %m\n", - PROMPT_NONE, PR_FATAL }, - - /* Block range not used, but marked in bitmap */ - { PR_5_BLOCK_RANGE_UNUSED, - " -(%b--%c)", - PROMPT_NONE, PR_LATCH_BBITMAP | PR_PREEN_OK | PR_PREEN_NOMSG }, - - /* Block range used, but not marked used in bitmap */ - { PR_5_BLOCK_RANGE_USED, - " +(%b--%c)", - PROMPT_NONE, PR_LATCH_BBITMAP | PR_PREEN_OK | PR_PREEN_NOMSG }, - - /* Inode range not used, but marked in bitmap */ - { PR_5_INODE_RANGE_UNUSED, - " -(%i--%j)", - PROMPT_NONE, PR_LATCH_IBITMAP | PR_PREEN_OK | PR_PREEN_NOMSG }, - - /* Inode range used, but not marked used in bitmap */ - { PR_5_INODE_RANGE_USED, - " +(%i--%j)", - PROMPT_NONE, PR_LATCH_IBITMAP | PR_PREEN_OK | PR_PREEN_NOMSG }, - - { 0 } -}; - -/* - * This is the latch flags register. It allows several problems to be - * "latched" together. This means that the user has to answer but one - * question for the set of problems, and all of the associated - * problems will be either fixed or not fixed. - */ -static struct latch_descr pr_latch_info[] = { - { PR_LATCH_BLOCK, PR_1_INODE_BLOCK_LATCH, 0 }, - { PR_LATCH_BBLOCK, PR_1_INODE_BBLOCK_LATCH, 0 }, - { PR_LATCH_IBITMAP, PR_5_INODE_BITMAP_HEADER, PR_5_INODE_BITMAP_END }, - { PR_LATCH_BBITMAP, PR_5_BLOCK_BITMAP_HEADER, PR_5_BLOCK_BITMAP_END }, - { PR_LATCH_RELOC, PR_0_RELOCATE_HINT, 0 }, - { PR_LATCH_DBLOCK, PR_1B_DUP_BLOCK_HEADER, PR_1B_DUP_BLOCK_END }, - { PR_LATCH_LOW_DTIME, PR_1_ORPHAN_LIST_REFUGEES, 0 }, - { PR_LATCH_TOOBIG, PR_1_INODE_TOOBIG, 0 }, - { PR_LATCH_OPTIMIZE_DIR, PR_3A_OPTIMIZE_DIR_HEADER, PR_3A_OPTIMIZE_DIR_END }, - { -1, 0, 0 }, -}; - -static const struct e2fsck_problem *find_problem(problem_t code) -{ - int i; - - for (i=0; problem_table[i].e2p_code; i++) { - if (problem_table[i].e2p_code == code) - return &problem_table[i]; - } - return 0; -} - -static struct latch_descr *find_latch(int code) -{ - int i; - - for (i=0; pr_latch_info[i].latch_code >= 0; i++) { - if (pr_latch_info[i].latch_code == code) - return &pr_latch_info[i]; - } - return 0; -} - -int end_problem_latch(e2fsck_t ctx, int mask) -{ - struct latch_descr *ldesc; - struct problem_context pctx; - int answer = -1; - - ldesc = find_latch(mask); - if (ldesc->end_message && (ldesc->flags & PRL_LATCHED)) { - clear_problem_context(&pctx); - answer = fix_problem(ctx, ldesc->end_message, &pctx); - } - ldesc->flags &= ~(PRL_VARIABLE); - return answer; -} - -int set_latch_flags(int mask, int setflags, int clearflags) -{ - struct latch_descr *ldesc; - - ldesc = find_latch(mask); - if (!ldesc) - return -1; - ldesc->flags |= setflags; - ldesc->flags &= ~clearflags; - return 0; -} - -int get_latch_flags(int mask, int *value) -{ - struct latch_descr *ldesc; - - ldesc = find_latch(mask); - if (!ldesc) - return -1; - *value = ldesc->flags; - return 0; -} - -void clear_problem_context(struct problem_context *ctx) -{ - memset(ctx, 0, sizeof(struct problem_context)); - ctx->blkcount = -1; - ctx->group = -1; -} - -int fix_problem(e2fsck_t ctx, problem_t code, struct problem_context *pctx) -{ - ext2_filsys fs = ctx->fs; - const struct e2fsck_problem *ptr; - struct latch_descr *ldesc = 0; - const char *message; - int def_yn, answer, ans; - int print_answer = 0; - int suppress = 0; - - ptr = find_problem(code); - if (!ptr) { - printf(_("Unhandled error code (0x%x)!\n"), code); - return 0; - } - def_yn = 1; - if ((ptr->flags & PR_NO_DEFAULT) || - ((ptr->flags & PR_PREEN_NO) && (ctx->options & E2F_OPT_PREEN)) || - (ctx->options & E2F_OPT_NO)) - def_yn= 0; - - /* - * Do special latch processing. This is where we ask the - * latch question, if it exists - */ - if (ptr->flags & PR_LATCH_MASK) { - ldesc = find_latch(ptr->flags & PR_LATCH_MASK); - if (ldesc->question && !(ldesc->flags & PRL_LATCHED)) { - ans = fix_problem(ctx, ldesc->question, pctx); - if (ans == 1) - ldesc->flags |= PRL_YES; - if (ans == 0) - ldesc->flags |= PRL_NO; - ldesc->flags |= PRL_LATCHED; - } - if (ldesc->flags & PRL_SUPPRESS) - suppress++; - } - if ((ptr->flags & PR_PREEN_NOMSG) && - (ctx->options & E2F_OPT_PREEN)) - suppress++; - if ((ptr->flags & PR_NO_NOMSG) && - (ctx->options & E2F_OPT_NO)) - suppress++; - if (!suppress) { - message = ptr->e2p_description; - if ((ctx->options & E2F_OPT_PREEN) && - !(ptr->flags & PR_PREEN_NOHDR)) { - printf("%s: ", ctx->device_name ? - ctx->device_name : ctx->filesystem_name); - } - if (*message) - print_e2fsck_message(ctx, _(message), pctx, 1); - } - if (!(ptr->flags & PR_PREEN_OK) && (ptr->prompt != PROMPT_NONE)) - preenhalt(ctx); - - if (ptr->flags & PR_FATAL) - fatal_error(ctx, 0); - - if (ptr->prompt == PROMPT_NONE) { - if (ptr->flags & PR_NOCOLLATE) - answer = -1; - else - answer = def_yn; - } else { - if (ctx->options & E2F_OPT_PREEN) { - answer = def_yn; - if (!(ptr->flags & PR_PREEN_NOMSG)) - print_answer = 1; - } else if ((ptr->flags & PR_LATCH_MASK) && - (ldesc->flags & (PRL_YES | PRL_NO))) { - if (!suppress) - print_answer = 1; - if (ldesc->flags & PRL_YES) - answer = 1; - else - answer = 0; - } else - answer = ask(ctx, _(prompt[(int) ptr->prompt]), def_yn); - if (!answer && !(ptr->flags & PR_NO_OK)) - ext2fs_unmark_valid(fs); - - if (print_answer) - printf("%s.\n", answer ? - _(preen_msg[(int) ptr->prompt]) : _("IGNORED")); - - } - - if ((ptr->prompt == PROMPT_ABORT) && answer) - fatal_error(ctx, 0); - - if (ptr->flags & PR_AFTER_CODE) - answer = fix_problem(ctx, ptr->second_code, pctx); - - return answer; -} diff --git a/e2fsprogs/e2fsck/problem.h b/e2fsprogs/e2fsck/problem.h deleted file mode 100644 index 0e39a2935..000000000 --- a/e2fsprogs/e2fsck/problem.h +++ /dev/null @@ -1,897 +0,0 @@ -/* - * problem.h --- e2fsck problem error codes - * - * Copyright 1996 by Theodore Ts'o - * - * %Begin-Header% - * This file may be redistributed under the terms of the GNU Public - * License. - * %End-Header% - */ - -typedef __u32 problem_t; - -struct problem_context { - errcode_t errcode; - ext2_ino_t ino, ino2, dir; - struct ext2_inode *inode; - struct ext2_dir_entry *dirent; - blk_t blk, blk2; - e2_blkcnt_t blkcount; - int group; - __u64 num; - const char *str; -}; - -/* - * We define a set of "latch groups"; these are problems which are - * handled as a set. The user answers once for a particular latch - * group. - */ -#define PR_LATCH_MASK 0x0ff0 /* Latch mask */ -#define PR_LATCH_BLOCK 0x0010 /* Latch for illegal blocks (pass 1) */ -#define PR_LATCH_BBLOCK 0x0020 /* Latch for bad block inode blocks (pass 1) */ -#define PR_LATCH_IBITMAP 0x0030 /* Latch for pass 5 inode bitmap proc. */ -#define PR_LATCH_BBITMAP 0x0040 /* Latch for pass 5 inode bitmap proc. */ -#define PR_LATCH_RELOC 0x0050 /* Latch for superblock relocate hint */ -#define PR_LATCH_DBLOCK 0x0060 /* Latch for pass 1b dup block headers */ -#define PR_LATCH_LOW_DTIME 0x0070 /* Latch for pass1 orphaned list refugees */ -#define PR_LATCH_TOOBIG 0x0080 /* Latch for file to big errors */ -#define PR_LATCH_OPTIMIZE_DIR 0x0090 /* Latch for optimize directories */ - -#define PR_LATCH(x) ((((x) & PR_LATCH_MASK) >> 4) - 1) - -/* - * Latch group descriptor flags - */ -#define PRL_YES 0x0001 /* Answer yes */ -#define PRL_NO 0x0002 /* Answer no */ -#define PRL_LATCHED 0x0004 /* The latch group is latched */ -#define PRL_SUPPRESS 0x0008 /* Suppress all latch group questions */ - -#define PRL_VARIABLE 0x000f /* All the flags that need to be reset */ - -/* - * Pre-Pass 1 errors - */ - -/* Block bitmap not in group */ -#define PR_0_BB_NOT_GROUP 0x000001 - -/* Inode bitmap not in group */ -#define PR_0_IB_NOT_GROUP 0x000002 - -/* Inode table not in group */ -#define PR_0_ITABLE_NOT_GROUP 0x000003 - -/* Superblock corrupt */ -#define PR_0_SB_CORRUPT 0x000004 - -/* Filesystem size is wrong */ -#define PR_0_FS_SIZE_WRONG 0x000005 - -/* Fragments not supported */ -#define PR_0_NO_FRAGMENTS 0x000006 - -/* Bad blocks_per_group */ -#define PR_0_BLOCKS_PER_GROUP 0x000007 - -/* Bad first_data_block */ -#define PR_0_FIRST_DATA_BLOCK 0x000008 - -/* Adding UUID to filesystem */ -#define PR_0_ADD_UUID 0x000009 - -/* Relocate hint */ -#define PR_0_RELOCATE_HINT 0x00000A - -/* Miscellaneous superblock corruption */ -#define PR_0_MISC_CORRUPT_SUPER 0x00000B - -/* Error determing physical device size of filesystem */ -#define PR_0_GETSIZE_ERROR 0x00000C - -/* Inode count in the superblock incorrect */ -#define PR_0_INODE_COUNT_WRONG 0x00000D - -/* The Hurd does not support the filetype feature */ -#define PR_0_HURD_CLEAR_FILETYPE 0x00000E - -/* Journal inode is invalid */ -#define PR_0_JOURNAL_BAD_INODE 0x00000F - -/* The external journal has multiple filesystems (which we can't handle yet) */ -#define PR_0_JOURNAL_UNSUPP_MULTIFS 0x000010 - -/* Can't find external journal */ -#define PR_0_CANT_FIND_JOURNAL 0x000011 - -/* External journal has bad superblock */ -#define PR_0_EXT_JOURNAL_BAD_SUPER 0x000012 - -/* Superblock has a bad journal UUID */ -#define PR_0_JOURNAL_BAD_UUID 0x000013 - -/* Journal has an unknown superblock type */ -#define PR_0_JOURNAL_UNSUPP_SUPER 0x000014 - -/* Journal superblock is corrupt */ -#define PR_0_JOURNAL_BAD_SUPER 0x000015 - -/* Journal superblock is corrupt */ -#define PR_0_JOURNAL_HAS_JOURNAL 0x000016 - -/* Superblock has recovery flag set but no journal */ -#define PR_0_JOURNAL_RECOVER_SET 0x000017 - -/* Journal has data, but recovery flag is clear */ -#define PR_0_JOURNAL_RECOVERY_CLEAR 0x000018 - -/* Ask if we should clear the journal */ -#define PR_0_JOURNAL_RESET_JOURNAL 0x000019 - -/* Filesystem revision is 0, but feature flags are set */ -#define PR_0_FS_REV_LEVEL 0x00001A - -/* Clearing orphan inode */ -#define PR_0_ORPHAN_CLEAR_INODE 0x000020 - -/* Illegal block found in orphaned inode */ -#define PR_0_ORPHAN_ILLEGAL_BLOCK_NUM 0x000021 - -/* Already cleared block found in orphaned inode */ -#define PR_0_ORPHAN_ALREADY_CLEARED_BLOCK 0x000022 - -/* Illegal orphan inode in superblock */ -#define PR_0_ORPHAN_ILLEGAL_HEAD_INODE 0x000023 - -/* Illegal inode in orphaned inode list */ -#define PR_0_ORPHAN_ILLEGAL_INODE 0x000024 - -/* Journal has unsupported read-only feature - abort */ -#define PR_0_JOURNAL_UNSUPP_ROCOMPAT 0x000025 - -/* Journal has unsupported incompatible feature - abort */ -#define PR_0_JOURNAL_UNSUPP_INCOMPAT 0x000026 - -/* Journal has unsupported version number */ -#define PR_0_JOURNAL_UNSUPP_VERSION 0x000027 - -/* Moving journal to hidden file */ -#define PR_0_MOVE_JOURNAL 0x000028 - -/* Error moving journal */ -#define PR_0_ERR_MOVE_JOURNAL 0x000029 - -/* Clearing V2 journal superblock */ -#define PR_0_CLEAR_V2_JOURNAL 0x00002A - -/* Run journal anyway */ -#define PR_0_JOURNAL_RUN 0x00002B - -/* Run journal anyway by default */ -#define PR_0_JOURNAL_RUN_DEFAULT 0x00002C - -/* Backup journal inode blocks */ -#define PR_0_BACKUP_JNL 0x00002D - -/* Reserved blocks w/o resize_inode */ -#define PR_0_NONZERO_RESERVED_GDT_BLOCKS 0x00002E - -/* Resize_inode not enabled, but resize inode is non-zero */ -#define PR_0_CLEAR_RESIZE_INODE 0x00002F - -/* Resize inode invalid */ -#define PR_0_RESIZE_INODE_INVALID 0x000030 - -/* - * Pass 1 errors - */ - -/* Pass 1: Checking inodes, blocks, and sizes */ -#define PR_1_PASS_HEADER 0x010000 - -/* Root directory is not an inode */ -#define PR_1_ROOT_NO_DIR 0x010001 - -/* Root directory has dtime set */ -#define PR_1_ROOT_DTIME 0x010002 - -/* Reserved inode has bad mode */ -#define PR_1_RESERVED_BAD_MODE 0x010003 - -/* Deleted inode has zero dtime */ -#define PR_1_ZERO_DTIME 0x010004 - -/* Inode in use, but dtime set */ -#define PR_1_SET_DTIME 0x010005 - -/* Zero-length directory */ -#define PR_1_ZERO_LENGTH_DIR 0x010006 - -/* Block bitmap conflicts with some other fs block */ -#define PR_1_BB_CONFLICT 0x010007 - -/* Inode bitmap conflicts with some other fs block */ -#define PR_1_IB_CONFLICT 0x010008 - -/* Inode table conflicts with some other fs block */ -#define PR_1_ITABLE_CONFLICT 0x010009 - -/* Block bitmap is on a bad block */ -#define PR_1_BB_BAD_BLOCK 0x01000A - -/* Inode bitmap is on a bad block */ -#define PR_1_IB_BAD_BLOCK 0x01000B - -/* Inode has incorrect i_size */ -#define PR_1_BAD_I_SIZE 0x01000C - -/* Inode has incorrect i_blocks */ -#define PR_1_BAD_I_BLOCKS 0x01000D - -/* Illegal block number in inode */ -#define PR_1_ILLEGAL_BLOCK_NUM 0x01000E - -/* Block number overlaps fs metadata */ -#define PR_1_BLOCK_OVERLAPS_METADATA 0x01000F - -/* Inode has illegal blocks (latch question) */ -#define PR_1_INODE_BLOCK_LATCH 0x010010 - -/* Too many bad blocks in inode */ -#define PR_1_TOO_MANY_BAD_BLOCKS 0x010011 - -/* Illegal block number in bad block inode */ -#define PR_1_BB_ILLEGAL_BLOCK_NUM 0x010012 - -/* Bad block inode has illegal blocks (latch question) */ -#define PR_1_INODE_BBLOCK_LATCH 0x010013 - -/* Duplicate or bad blocks in use! */ -#define PR_1_DUP_BLOCKS_PREENSTOP 0x010014 - -/* Bad block used as bad block indirect block */ -#define PR_1_BBINODE_BAD_METABLOCK 0x010015 - -/* Inconsistency can't be fixed prompt */ -#define PR_1_BBINODE_BAD_METABLOCK_PROMPT 0x010016 - -/* Bad primary block */ -#define PR_1_BAD_PRIMARY_BLOCK 0x010017 - -/* Bad primary block prompt */ -#define PR_1_BAD_PRIMARY_BLOCK_PROMPT 0x010018 - -/* Bad primary superblock */ -#define PR_1_BAD_PRIMARY_SUPERBLOCK 0x010019 - -/* Bad primary block group descriptors */ -#define PR_1_BAD_PRIMARY_GROUP_DESCRIPTOR 0x01001A - -/* Bad superblock in group */ -#define PR_1_BAD_SUPERBLOCK 0x01001B - -/* Bad block group descriptors in group */ -#define PR_1_BAD_GROUP_DESCRIPTORS 0x01001C - -/* Block claimed for no reason */ -#define PR_1_PROGERR_CLAIMED_BLOCK 0x01001D - -/* Error allocating blocks for relocating metadata */ -#define PR_1_RELOC_BLOCK_ALLOCATE 0x01001E - -/* Error allocating block buffer during relocation process */ -#define PR_1_RELOC_MEMORY_ALLOCATE 0x01001F - -/* Relocating metadata group information from X to Y */ -#define PR_1_RELOC_FROM_TO 0x010020 - -/* Relocating metatdata group information to X */ -#define PR_1_RELOC_TO 0x010021 - -/* Block read error during relocation process */ -#define PR_1_RELOC_READ_ERR 0x010022 - -/* Block write error during relocation process */ -#define PR_1_RELOC_WRITE_ERR 0x010023 - -/* Error allocating inode bitmap */ -#define PR_1_ALLOCATE_IBITMAP_ERROR 0x010024 - -/* Error allocating block bitmap */ -#define PR_1_ALLOCATE_BBITMAP_ERROR 0x010025 - -/* Error allocating icount structure */ -#define PR_1_ALLOCATE_ICOUNT 0x010026 - -/* Error allocating dbcount */ -#define PR_1_ALLOCATE_DBCOUNT 0x010027 - -/* Error while scanning inodes */ -#define PR_1_ISCAN_ERROR 0x010028 - -/* Error while iterating over blocks */ -#define PR_1_BLOCK_ITERATE 0x010029 - -/* Error while storing inode count information */ -#define PR_1_ICOUNT_STORE 0x01002A - -/* Error while storing directory block information */ -#define PR_1_ADD_DBLOCK 0x01002B - -/* Error while reading inode (for clearing) */ -#define PR_1_READ_INODE 0x01002C - -/* Suppress messages prompt */ -#define PR_1_SUPPRESS_MESSAGES 0x01002D - -/* Imagic flag set on an inode when filesystem doesn't support it */ -#define PR_1_SET_IMAGIC 0x01002F - -/* Immutable flag set on a device or socket inode */ -#define PR_1_SET_IMMUTABLE 0x010030 - -/* Compression flag set on a non-compressed filesystem */ -#define PR_1_COMPR_SET 0x010031 - -/* Non-zero size on on device, fifo or socket inode */ -#define PR_1_SET_NONZSIZE 0x010032 - -/* Filesystem revision is 0, but feature flags are set */ -#define PR_1_FS_REV_LEVEL 0x010033 - -/* Journal inode not in use, needs clearing */ -#define PR_1_JOURNAL_INODE_NOT_CLEAR 0x010034 - -/* Journal inode has wrong mode */ -#define PR_1_JOURNAL_BAD_MODE 0x010035 - -/* Inode that was part of orphan linked list */ -#define PR_1_LOW_DTIME 0x010036 - -/* Latch question which asks how to deal with low dtime inodes */ -#define PR_1_ORPHAN_LIST_REFUGEES 0x010037 - -/* Error allocating refcount structure */ -#define PR_1_ALLOCATE_REFCOUNT 0x010038 - -/* Error reading Extended Attribute block */ -#define PR_1_READ_EA_BLOCK 0x010039 - -/* Invalid Extended Attribute block */ -#define PR_1_BAD_EA_BLOCK 0x01003A - -/* Error reading Extended Attribute block while fixing refcount -- abort */ -#define PR_1_EXTATTR_READ_ABORT 0x01003B - -/* Extended attribute reference count incorrect */ -#define PR_1_EXTATTR_REFCOUNT 0x01003C - -/* Error writing Extended Attribute block while fixing refcount */ -#define PR_1_EXTATTR_WRITE 0x01003D - -/* Multiple EA blocks not supported */ -#define PR_1_EA_MULTI_BLOCK 0x01003E - -/* Error allocating EA region allocation structure */ -#define PR_1_EA_ALLOC_REGION 0x01003F - -/* Error EA allocation collision */ -#define PR_1_EA_ALLOC_COLLISION 0x010040 - -/* Bad extended attribute name */ -#define PR_1_EA_BAD_NAME 0x010041 - -/* Bad extended attribute value */ -#define PR_1_EA_BAD_VALUE 0x010042 - -/* Inode too big (latch question) */ -#define PR_1_INODE_TOOBIG 0x010043 - -/* Directory too big */ -#define PR_1_TOOBIG_DIR 0x010044 - -/* Regular file too big */ -#define PR_1_TOOBIG_REG 0x010045 - -/* Symlink too big */ -#define PR_1_TOOBIG_SYMLINK 0x010046 - -/* INDEX_FL flag set on a non-HTREE filesystem */ -#define PR_1_HTREE_SET 0x010047 - -/* INDEX_FL flag set on a non-directory */ -#define PR_1_HTREE_NODIR 0x010048 - -/* Invalid root node in HTREE directory */ -#define PR_1_HTREE_BADROOT 0x010049 - -/* Unsupported hash version in HTREE directory */ -#define PR_1_HTREE_HASHV 0x01004A - -/* Incompatible flag in HTREE root node */ -#define PR_1_HTREE_INCOMPAT 0x01004B - -/* HTREE too deep */ -#define PR_1_HTREE_DEPTH 0x01004C - -/* Bad block has indirect block that conflicts with filesystem block */ -#define PR_1_BB_FS_BLOCK 0x01004D - -/* Resize inode failed */ -#define PR_1_RESIZE_INODE_CREATE 0x01004E - -/* inode->i_size is too long */ -#define PR_1_EXTRA_ISIZE 0x01004F - -/* attribute name is too long */ -#define PR_1_ATTR_NAME_LEN 0x010050 - -/* wrong EA value offset */ -#define PR_1_ATTR_VALUE_OFFSET 0x010051 - -/* wrong EA blocknumber */ -#define PR_1_ATTR_VALUE_BLOCK 0x010052 - -/* wrong EA value size */ -#define PR_1_ATTR_VALUE_SIZE 0x010053 - -/* wrong EA hash value */ -#define PR_1_ATTR_HASH 0x010054 - -/* - * Pass 1b errors - */ - -/* Pass 1B: Rescan for duplicate/bad blocks */ -#define PR_1B_PASS_HEADER 0x011000 - -/* Duplicate/bad block(s) header */ -#define PR_1B_DUP_BLOCK_HEADER 0x011001 - -/* Duplicate/bad block(s) in inode */ -#define PR_1B_DUP_BLOCK 0x011002 - -/* Duplicate/bad block(s) end */ -#define PR_1B_DUP_BLOCK_END 0x011003 - -/* Error while scanning inodes */ -#define PR_1B_ISCAN_ERROR 0x011004 - -/* Error allocating inode bitmap */ -#define PR_1B_ALLOCATE_IBITMAP_ERROR 0x011005 - -/* Error while iterating over blocks */ -#define PR_1B_BLOCK_ITERATE 0x0110006 - -/* Error adjusting EA refcount */ -#define PR_1B_ADJ_EA_REFCOUNT 0x0110007 - - -/* Pass 1C: Scan directories for inodes with dup blocks. */ -#define PR_1C_PASS_HEADER 0x012000 - - -/* Pass 1D: Reconciling duplicate blocks */ -#define PR_1D_PASS_HEADER 0x013000 - -/* File has duplicate blocks */ -#define PR_1D_DUP_FILE 0x013001 - -/* List of files sharing duplicate blocks */ -#define PR_1D_DUP_FILE_LIST 0x013002 - -/* File sharing blocks with filesystem metadata */ -#define PR_1D_SHARE_METADATA 0x013003 - -/* Report of how many duplicate/bad inodes */ -#define PR_1D_NUM_DUP_INODES 0x013004 - -/* Duplicated blocks already reassigned or cloned. */ -#define PR_1D_DUP_BLOCKS_DEALT 0x013005 - -/* Clone duplicate/bad blocks? */ -#define PR_1D_CLONE_QUESTION 0x013006 - -/* Delete file? */ -#define PR_1D_DELETE_QUESTION 0x013007 - -/* Couldn't clone file (error) */ -#define PR_1D_CLONE_ERROR 0x013008 - -/* - * Pass 2 errors - */ - -/* Pass 2: Checking directory structure */ -#define PR_2_PASS_HEADER 0x020000 - -/* Bad inode number for '.' */ -#define PR_2_BAD_INODE_DOT 0x020001 - -/* Directory entry has bad inode number */ -#define PR_2_BAD_INO 0x020002 - -/* Directory entry has deleted or unused inode */ -#define PR_2_UNUSED_INODE 0x020003 - -/* Directry entry is link to '.' */ -#define PR_2_LINK_DOT 0x020004 - -/* Directory entry points to inode now located in a bad block */ -#define PR_2_BB_INODE 0x020005 - -/* Directory entry contains a link to a directory */ -#define PR_2_LINK_DIR 0x020006 - -/* Directory entry contains a link to the root directry */ -#define PR_2_LINK_ROOT 0x020007 - -/* Directory entry has illegal characters in its name */ -#define PR_2_BAD_NAME 0x020008 - -/* Missing '.' in directory inode */ -#define PR_2_MISSING_DOT 0x020009 - -/* Missing '..' in directory inode */ -#define PR_2_MISSING_DOT_DOT 0x02000A - -/* First entry in directory inode doesn't contain '.' */ -#define PR_2_1ST_NOT_DOT 0x02000B - -/* Second entry in directory inode doesn't contain '..' */ -#define PR_2_2ND_NOT_DOT_DOT 0x02000C - -/* i_faddr should be zero */ -#define PR_2_FADDR_ZERO 0x02000D - -/* i_file_acl should be zero */ -#define PR_2_FILE_ACL_ZERO 0x02000E - -/* i_dir_acl should be zero */ -#define PR_2_DIR_ACL_ZERO 0x02000F - -/* i_frag should be zero */ -#define PR_2_FRAG_ZERO 0x020010 - -/* i_fsize should be zero */ -#define PR_2_FSIZE_ZERO 0x020011 - -/* inode has bad mode */ -#define PR_2_BAD_MODE 0x020012 - -/* directory corrupted */ -#define PR_2_DIR_CORRUPTED 0x020013 - -/* filename too long */ -#define PR_2_FILENAME_LONG 0x020014 - -/* Directory inode has a missing block (hole) */ -#define PR_2_DIRECTORY_HOLE 0x020015 - -/* '.' is not NULL terminated */ -#define PR_2_DOT_NULL_TERM 0x020016 - -/* '..' is not NULL terminated */ -#define PR_2_DOT_DOT_NULL_TERM 0x020017 - -/* Illegal character device in inode */ -#define PR_2_BAD_CHAR_DEV 0x020018 - -/* Illegal block device in inode */ -#define PR_2_BAD_BLOCK_DEV 0x020019 - -/* Duplicate '.' entry */ -#define PR_2_DUP_DOT 0x02001A - -/* Duplicate '..' entry */ -#define PR_2_DUP_DOT_DOT 0x02001B - -/* Internal error: couldn't find dir_info */ -#define PR_2_NO_DIRINFO 0x02001C - -/* Final rec_len is wrong */ -#define PR_2_FINAL_RECLEN 0x02001D - -/* Error allocating icount structure */ -#define PR_2_ALLOCATE_ICOUNT 0x02001E - -/* Error iterating over directory blocks */ -#define PR_2_DBLIST_ITERATE 0x02001F - -/* Error reading directory block */ -#define PR_2_READ_DIRBLOCK 0x020020 - -/* Error writing directory block */ -#define PR_2_WRITE_DIRBLOCK 0x020021 - -/* Error allocating new directory block */ -#define PR_2_ALLOC_DIRBOCK 0x020022 - -/* Error deallocating inode */ -#define PR_2_DEALLOC_INODE 0x020023 - -/* Directory entry for '.' is big. Split? */ -#define PR_2_SPLIT_DOT 0x020024 - -/* Illegal FIFO */ -#define PR_2_BAD_FIFO 0x020025 - -/* Illegal socket */ -#define PR_2_BAD_SOCKET 0x020026 - -/* Directory filetype not set */ -#define PR_2_SET_FILETYPE 0x020027 - -/* Directory filetype incorrect */ -#define PR_2_BAD_FILETYPE 0x020028 - -/* Directory filetype set when it shouldn't be */ -#define PR_2_CLEAR_FILETYPE 0x020029 - -/* Directory filename can't be zero-length */ -#define PR_2_NULL_NAME 0x020030 - -/* Invalid symlink */ -#define PR_2_INVALID_SYMLINK 0x020031 - -/* i_file_acl (extended attribute) is bad */ -#define PR_2_FILE_ACL_BAD 0x020032 - -/* Filesystem contains large files, but has no such flag in sb */ -#define PR_2_FEATURE_LARGE_FILES 0x020033 - -/* Node in HTREE directory not referenced */ -#define PR_2_HTREE_NOTREF 0x020034 - -/* Node in HTREE directory referenced twice */ -#define PR_2_HTREE_DUPREF 0x020035 - -/* Node in HTREE directory has bad min hash */ -#define PR_2_HTREE_MIN_HASH 0x020036 - -/* Node in HTREE directory has bad max hash */ -#define PR_2_HTREE_MAX_HASH 0x020037 - -/* Clear invalid HTREE directory */ -#define PR_2_HTREE_CLEAR 0x020038 - -/* Clear the htree flag forcibly */ -/* #define PR_2_HTREE_FCLR 0x020039 */ - -/* Bad block in htree interior node */ -#define PR_2_HTREE_BADBLK 0x02003A - -/* Error adjusting EA refcount */ -#define PR_2_ADJ_EA_REFCOUNT 0x02003B - -/* Invalid HTREE root node */ -#define PR_2_HTREE_BAD_ROOT 0x02003C - -/* Invalid HTREE limit */ -#define PR_2_HTREE_BAD_LIMIT 0x02003D - -/* Invalid HTREE count */ -#define PR_2_HTREE_BAD_COUNT 0x02003E - -/* HTREE interior node has out-of-order hashes in table */ -#define PR_2_HTREE_HASH_ORDER 0x02003F - -/* Node in HTREE directory has bad depth */ -#define PR_2_HTREE_BAD_DEPTH 0x020040 - -/* Duplicate directory entry found */ -#define PR_2_DUPLICATE_DIRENT 0x020041 - -/* Non-unique filename found */ -#define PR_2_NON_UNIQUE_FILE 0x020042 - -/* Duplicate directory entry found */ -#define PR_2_REPORT_DUP_DIRENT 0x020043 - -/* - * Pass 3 errors - */ - -/* Pass 3: Checking directory connectivity */ -#define PR_3_PASS_HEADER 0x030000 - -/* Root inode not allocated */ -#define PR_3_NO_ROOT_INODE 0x030001 - -/* No room in lost+found */ -#define PR_3_EXPAND_LF_DIR 0x030002 - -/* Unconnected directory inode */ -#define PR_3_UNCONNECTED_DIR 0x030003 - -/* /lost+found not found */ -#define PR_3_NO_LF_DIR 0x030004 - -/* .. entry is incorrect */ -#define PR_3_BAD_DOT_DOT 0x030005 - -/* Bad or non-existent /lost+found. Cannot reconnect */ -#define PR_3_NO_LPF 0x030006 - -/* Could not expand /lost+found */ -#define PR_3_CANT_EXPAND_LPF 0x030007 - -/* Could not reconnect inode */ -#define PR_3_CANT_RECONNECT 0x030008 - -/* Error while trying to find /lost+found */ -#define PR_3_ERR_FIND_LPF 0x030009 - -/* Error in ext2fs_new_block while creating /lost+found */ -#define PR_3_ERR_LPF_NEW_BLOCK 0x03000A - -/* Error in ext2fs_new_inode while creating /lost+found */ -#define PR_3_ERR_LPF_NEW_INODE 0x03000B - -/* Error in ext2fs_new_dir_block while creating /lost+found */ -#define PR_3_ERR_LPF_NEW_DIR_BLOCK 0x03000C - -/* Error while writing directory block for /lost+found */ -#define PR_3_ERR_LPF_WRITE_BLOCK 0x03000D - -/* Error while adjusting inode count */ -#define PR_3_ADJUST_INODE 0x03000E - -/* Couldn't fix parent directory -- error */ -#define PR_3_FIX_PARENT_ERR 0x03000F - -/* Couldn't fix parent directory -- couldn't find it */ -#define PR_3_FIX_PARENT_NOFIND 0x030010 - -/* Error allocating inode bitmap */ -#define PR_3_ALLOCATE_IBITMAP_ERROR 0x030011 - -/* Error creating root directory */ -#define PR_3_CREATE_ROOT_ERROR 0x030012 - -/* Error creating lost and found directory */ -#define PR_3_CREATE_LPF_ERROR 0x030013 - -/* Root inode is not directory; aborting */ -#define PR_3_ROOT_NOT_DIR_ABORT 0x030014 - -/* Cannot proceed without a root inode. */ -#define PR_3_NO_ROOT_INODE_ABORT 0x030015 - -/* Internal error: couldn't find dir_info */ -#define PR_3_NO_DIRINFO 0x030016 - -/* Lost+found is not a directory */ -#define PR_3_LPF_NOTDIR 0x030017 - -/* - * Pass 3a --- rehashing diretories - */ -/* Pass 3a: Reindexing directories */ -#define PR_3A_PASS_HEADER 0x031000 - -/* Error iterating over directories */ -#define PR_3A_OPTIMIZE_ITER 0x031001 - -/* Error rehash directory */ -#define PR_3A_OPTIMIZE_DIR_ERR 0x031002 - -/* Rehashing dir header */ -#define PR_3A_OPTIMIZE_DIR_HEADER 0x031003 - -/* Rehashing directory %d */ -#define PR_3A_OPTIMIZE_DIR 0x031004 - -/* Rehashing dir end */ -#define PR_3A_OPTIMIZE_DIR_END 0x031005 - -/* - * Pass 4 errors - */ - -/* Pass 4: Checking reference counts */ -#define PR_4_PASS_HEADER 0x040000 - -/* Unattached zero-length inode */ -#define PR_4_ZERO_LEN_INODE 0x040001 - -/* Unattached inode */ -#define PR_4_UNATTACHED_INODE 0x040002 - -/* Inode ref count wrong */ -#define PR_4_BAD_REF_COUNT 0x040003 - -/* Inconsistent inode count information cached */ -#define PR_4_INCONSISTENT_COUNT 0x040004 - -/* - * Pass 5 errors - */ - -/* Pass 5: Checking group summary information */ -#define PR_5_PASS_HEADER 0x050000 - -/* Padding at end of inode bitmap is not set. */ -#define PR_5_INODE_BMAP_PADDING 0x050001 - -/* Padding at end of block bitmap is not set. */ -#define PR_5_BLOCK_BMAP_PADDING 0x050002 - -/* Block bitmap differences header */ -#define PR_5_BLOCK_BITMAP_HEADER 0x050003 - -/* Block not used, but marked in bitmap */ -#define PR_5_BLOCK_UNUSED 0x050004 - -/* Block used, but not marked used in bitmap */ -#define PR_5_BLOCK_USED 0x050005 - -/* Block bitmap differences end */ -#define PR_5_BLOCK_BITMAP_END 0x050006 - -/* Inode bitmap differences header */ -#define PR_5_INODE_BITMAP_HEADER 0x050007 - -/* Inode not used, but marked in bitmap */ -#define PR_5_INODE_UNUSED 0x050008 - -/* Inode used, but not marked used in bitmap */ -#define PR_5_INODE_USED 0x050009 - -/* Inode bitmap differences end */ -#define PR_5_INODE_BITMAP_END 0x05000A - -/* Free inodes count for group wrong */ -#define PR_5_FREE_INODE_COUNT_GROUP 0x05000B - -/* Directories count for group wrong */ -#define PR_5_FREE_DIR_COUNT_GROUP 0x05000C - -/* Free inodes count wrong */ -#define PR_5_FREE_INODE_COUNT 0x05000D - -/* Free blocks count for group wrong */ -#define PR_5_FREE_BLOCK_COUNT_GROUP 0x05000E - -/* Free blocks count wrong */ -#define PR_5_FREE_BLOCK_COUNT 0x05000F - -/* Programming error: bitmap endpoints don't match */ -#define PR_5_BMAP_ENDPOINTS 0x050010 - -/* Internal error: fudging end of bitmap */ -#define PR_5_FUDGE_BITMAP_ERROR 0x050011 - -/* Error copying in replacement inode bitmap */ -#define PR_5_COPY_IBITMAP_ERROR 0x050012 - -/* Error copying in replacement block bitmap */ -#define PR_5_COPY_BBITMAP_ERROR 0x050013 - -/* Block range not used, but marked in bitmap */ -#define PR_5_BLOCK_RANGE_UNUSED 0x050014 - -/* Block range used, but not marked used in bitmap */ -#define PR_5_BLOCK_RANGE_USED 0x050015 - -/* Inode range not used, but marked in bitmap */ -#define PR_5_INODE_RANGE_UNUSED 0x050016 - -/* Inode rangeused, but not marked used in bitmap */ -#define PR_5_INODE_RANGE_USED 0x050017 - -/* - * Function declarations - */ -int fix_problem(e2fsck_t ctx, problem_t code, struct problem_context *pctx); -int end_problem_latch(e2fsck_t ctx, int mask); -int set_latch_flags(int mask, int setflags, int clearflags); -int get_latch_flags(int mask, int *value); -void clear_problem_context(struct problem_context *ctx); - -/* message.c */ -void print_e2fsck_message(e2fsck_t ctx, const char *msg, - struct problem_context *pctx, int first); - diff --git a/e2fsprogs/e2fsck/problemP.h b/e2fsprogs/e2fsck/problemP.h deleted file mode 100644 index 329056b95..000000000 --- a/e2fsprogs/e2fsck/problemP.h +++ /dev/null @@ -1,42 +0,0 @@ -/* - * problemP.h --- Private header file for fix_problem() - * - * Copyright 1997 by Theodore Ts'o - * - * %Begin-Header% - * This file may be redistributed under the terms of the GNU Public - * License. - * %End-Header% - */ - -struct e2fsck_problem { - problem_t e2p_code; - const char * e2p_description; - char prompt; - int flags; - problem_t second_code; -}; - -struct latch_descr { - int latch_code; - problem_t question; - problem_t end_message; - int flags; -}; - -#define PR_PREEN_OK 0x000001 /* Don't need to do preenhalt */ -#define PR_NO_OK 0x000002 /* If user answers no, don't make fs invalid */ -#define PR_NO_DEFAULT 0x000004 /* Default to no */ -#define PR_MSG_ONLY 0x000008 /* Print message only */ - -/* Bit positions 0x000ff0 are reserved for the PR_LATCH flags */ - -#define PR_FATAL 0x001000 /* Fatal error */ -#define PR_AFTER_CODE 0x002000 /* After asking the first question, */ - /* ask another */ -#define PR_PREEN_NOMSG 0x004000 /* Don't print a message if we're preening */ -#define PR_NOCOLLATE 0x008000 /* Don't collate answers for this latch */ -#define PR_NO_NOMSG 0x010000 /* Don't print a message if e2fsck -n */ -#define PR_PREEN_NO 0x020000 /* Use No as an answer if preening */ -#define PR_PREEN_NOHDR 0x040000 /* Don't print the preen header */ - diff --git a/e2fsprogs/e2fsck/recovery.c b/e2fsprogs/e2fsck/recovery.c deleted file mode 100644 index edfa9bc83..000000000 --- a/e2fsprogs/e2fsck/recovery.c +++ /dev/null @@ -1,586 +0,0 @@ -/* - * linux/fs/recovery.c - * - * Written by Stephen C. Tweedie , 1999 - * - * Copyright 1999-2000 Red Hat Software --- All Rights Reserved - * - * This file is part of the Linux kernel and is made available under - * the terms of the GNU General Public License, version 2, or at your - * option, any later version, incorporated herein by reference. - * - * Journal recovery routines for the generic filesystem journaling code; - * part of the ext2fs journaling system. - */ - -#ifndef __KERNEL__ -#include "jfs_user.h" -#else -#include -#include -#include -#include -#include -#endif - -/* - * Maintain information about the progress of the recovery job, so that - * the different passes can carry information between them. - */ -struct recovery_info -{ - tid_t start_transaction; - tid_t end_transaction; - - int nr_replays; - int nr_revokes; - int nr_revoke_hits; -}; - -enum passtype {PASS_SCAN, PASS_REVOKE, PASS_REPLAY}; -static int do_one_pass(journal_t *journal, - struct recovery_info *info, enum passtype pass); -static int scan_revoke_records(journal_t *, struct buffer_head *, - tid_t, struct recovery_info *); - -#ifdef __KERNEL__ - -/* Release readahead buffers after use */ -void journal_brelse_array(struct buffer_head *b[], int n) -{ - while (--n >= 0) - brelse (b[n]); -} - - -/* - * When reading from the journal, we are going through the block device - * layer directly and so there is no readahead being done for us. We - * need to implement any readahead ourselves if we want it to happen at - * all. Recovery is basically one long sequential read, so make sure we - * do the IO in reasonably large chunks. - * - * This is not so critical that we need to be enormously clever about - * the readahead size, though. 128K is a purely arbitrary, good-enough - * fixed value. - */ - -#define MAXBUF 8 -static int do_readahead(journal_t *journal, unsigned int start) -{ - int err; - unsigned int max, nbufs, next; - unsigned long blocknr; - struct buffer_head *bh; - - struct buffer_head * bufs[MAXBUF]; - - /* Do up to 128K of readahead */ - max = start + (128 * 1024 / journal->j_blocksize); - if (max > journal->j_maxlen) - max = journal->j_maxlen; - - /* Do the readahead itself. We'll submit MAXBUF buffer_heads at - * a time to the block device IO layer. */ - - nbufs = 0; - - for (next = start; next < max; next++) { - err = journal_bmap(journal, next, &blocknr); - - if (err) { - printk (KERN_ERR "JBD: bad block at offset %u\n", - next); - goto failed; - } - - bh = __getblk(journal->j_dev, blocknr, journal->j_blocksize); - if (!bh) { - err = -ENOMEM; - goto failed; - } - - if (!buffer_uptodate(bh) && !buffer_locked(bh)) { - bufs[nbufs++] = bh; - if (nbufs == MAXBUF) { - ll_rw_block(READ, nbufs, bufs); - journal_brelse_array(bufs, nbufs); - nbufs = 0; - } - } else - brelse(bh); - } - - if (nbufs) - ll_rw_block(READ, nbufs, bufs); - err = 0; - -failed: - if (nbufs) - journal_brelse_array(bufs, nbufs); - return err; -} - -#endif /* __KERNEL__ */ - - -/* - * Read a block from the journal - */ - -static int jread(struct buffer_head **bhp, journal_t *journal, - unsigned int offset) -{ - int err; - unsigned long blocknr; - struct buffer_head *bh; - - *bhp = NULL; - - J_ASSERT (offset < journal->j_maxlen); - - err = journal_bmap(journal, offset, &blocknr); - - if (err) { - printk (KERN_ERR "JBD: bad block at offset %u\n", - offset); - return err; - } - - bh = __getblk(journal->j_dev, blocknr, journal->j_blocksize); - if (!bh) - return -ENOMEM; - - if (!buffer_uptodate(bh)) { - /* If this is a brand new buffer, start readahead. - Otherwise, we assume we are already reading it. */ - if (!buffer_req(bh)) - do_readahead(journal, offset); - wait_on_buffer(bh); - } - - if (!buffer_uptodate(bh)) { - printk (KERN_ERR "JBD: Failed to read block at offset %u\n", - offset); - brelse(bh); - return -EIO; - } - - *bhp = bh; - return 0; -} - - -/* - * Count the number of in-use tags in a journal descriptor block. - */ - -static int count_tags(struct buffer_head *bh, int size) -{ - char * tagp; - journal_block_tag_t * tag; - int nr = 0; - - tagp = &bh->b_data[sizeof(journal_header_t)]; - - while ((tagp - bh->b_data + sizeof(journal_block_tag_t)) <= size) { - tag = (journal_block_tag_t *) tagp; - - nr++; - tagp += sizeof(journal_block_tag_t); - if (!(tag->t_flags & htonl(JFS_FLAG_SAME_UUID))) - tagp += 16; - - if (tag->t_flags & htonl(JFS_FLAG_LAST_TAG)) - break; - } - - return nr; -} - - -/* Make sure we wrap around the log correctly! */ -#define wrap(journal, var) \ -do { \ - if (var >= (journal)->j_last) \ - var -= ((journal)->j_last - (journal)->j_first); \ -} while (0) - -/** - * int journal_recover(journal_t *journal) - recovers a on-disk journal - * @journal: the journal to recover - * - * The primary function for recovering the log contents when mounting a - * journaled device. - * - * Recovery is done in three passes. In the first pass, we look for the - * end of the log. In the second, we assemble the list of revoke - * blocks. In the third and final pass, we replay any un-revoked blocks - * in the log. - */ -int journal_recover(journal_t *journal) -{ - int err; - journal_superblock_t * sb; - - struct recovery_info info; - - memset(&info, 0, sizeof(info)); - sb = journal->j_superblock; - - /* - * The journal superblock's s_start field (the current log head) - * is always zero if, and only if, the journal was cleanly - * unmounted. - */ - - if (!sb->s_start) { - jbd_debug(1, "No recovery required, last transaction %d\n", - ntohl(sb->s_sequence)); - journal->j_transaction_sequence = ntohl(sb->s_sequence) + 1; - return 0; - } - - err = do_one_pass(journal, &info, PASS_SCAN); - if (!err) - err = do_one_pass(journal, &info, PASS_REVOKE); - if (!err) - err = do_one_pass(journal, &info, PASS_REPLAY); - - jbd_debug(0, "JBD: recovery, exit status %d, " - "recovered transactions %u to %u\n", - err, info.start_transaction, info.end_transaction); - jbd_debug(0, "JBD: Replayed %d and revoked %d/%d blocks\n", - info.nr_replays, info.nr_revoke_hits, info.nr_revokes); - - /* Restart the log at the next transaction ID, thus invalidating - * any existing commit records in the log. */ - journal->j_transaction_sequence = ++info.end_transaction; - - journal_clear_revoke(journal); - sync_blockdev(journal->j_fs_dev); - return err; -} - -/** - * int journal_skip_recovery() - Start journal and wipe exiting records - * @journal: journal to startup - * - * Locate any valid recovery information from the journal and set up the - * journal structures in memory to ignore it (presumably because the - * caller has evidence that it is out of date). - * This function does'nt appear to be exorted.. - * - * We perform one pass over the journal to allow us to tell the user how - * much recovery information is being erased, and to let us initialise - * the journal transaction sequence numbers to the next unused ID. - */ -int journal_skip_recovery(journal_t *journal) -{ - int err; - journal_superblock_t * sb; - - struct recovery_info info; - - memset (&info, 0, sizeof(info)); - sb = journal->j_superblock; - - err = do_one_pass(journal, &info, PASS_SCAN); - - if (err) { - printk(KERN_ERR "JBD: error %d scanning journal\n", err); - ++journal->j_transaction_sequence; - } else { -#ifdef __CONFIG_JBD_DEBUG__E2FS - int dropped = info.end_transaction - ntohl(sb->s_sequence); -#endif - jbd_debug(0, - "JBD: ignoring %d transaction%s from the journal.\n", - dropped, (dropped == 1) ? "" : "s"); - journal->j_transaction_sequence = ++info.end_transaction; - } - - journal->j_tail = 0; - return err; -} - -static int do_one_pass(journal_t *journal, - struct recovery_info *info, enum passtype pass) -{ - unsigned int first_commit_ID, next_commit_ID; - unsigned long next_log_block; - int err, success = 0; - journal_superblock_t * sb; - journal_header_t * tmp; - struct buffer_head * bh; - unsigned int sequence; - int blocktype; - - /* Precompute the maximum metadata descriptors in a descriptor block */ - int MAX_BLOCKS_PER_DESC; - MAX_BLOCKS_PER_DESC = ((journal->j_blocksize-sizeof(journal_header_t)) - / sizeof(journal_block_tag_t)); - - /* - * First thing is to establish what we expect to find in the log - * (in terms of transaction IDs), and where (in terms of log - * block offsets): query the superblock. - */ - - sb = journal->j_superblock; - next_commit_ID = ntohl(sb->s_sequence); - next_log_block = ntohl(sb->s_start); - - first_commit_ID = next_commit_ID; - if (pass == PASS_SCAN) - info->start_transaction = first_commit_ID; - - jbd_debug(1, "Starting recovery pass %d\n", pass); - - /* - * Now we walk through the log, transaction by transaction, - * making sure that each transaction has a commit block in the - * expected place. Each complete transaction gets replayed back - * into the main filesystem. - */ - - while (1) { - int flags; - char * tagp; - journal_block_tag_t * tag; - struct buffer_head * obh; - struct buffer_head * nbh; - - /* If we already know where to stop the log traversal, - * check right now that we haven't gone past the end of - * the log. */ - - if (pass != PASS_SCAN) - if (tid_geq(next_commit_ID, info->end_transaction)) - break; - - jbd_debug(2, "Scanning for sequence ID %u at %lu/%lu\n", - next_commit_ID, next_log_block, journal->j_last); - - /* Skip over each chunk of the transaction looking - * either the next descriptor block or the final commit - * record. */ - - jbd_debug(3, "JBD: checking block %ld\n", next_log_block); - err = jread(&bh, journal, next_log_block); - if (err) - goto failed; - - next_log_block++; - wrap(journal, next_log_block); - - /* What kind of buffer is it? - * - * If it is a descriptor block, check that it has the - * expected sequence number. Otherwise, we're all done - * here. */ - - tmp = (journal_header_t *)bh->b_data; - - if (tmp->h_magic != htonl(JFS_MAGIC_NUMBER)) { - brelse(bh); - break; - } - - blocktype = ntohl(tmp->h_blocktype); - sequence = ntohl(tmp->h_sequence); - jbd_debug(3, "Found magic %d, sequence %d\n", - blocktype, sequence); - - if (sequence != next_commit_ID) { - brelse(bh); - break; - } - - /* OK, we have a valid descriptor block which matches - * all of the sequence number checks. What are we going - * to do with it? That depends on the pass... */ - - switch(blocktype) { - case JFS_DESCRIPTOR_BLOCK: - /* If it is a valid descriptor block, replay it - * in pass REPLAY; otherwise, just skip over the - * blocks it describes. */ - if (pass != PASS_REPLAY) { - next_log_block += - count_tags(bh, journal->j_blocksize); - wrap(journal, next_log_block); - brelse(bh); - continue; - } - - /* A descriptor block: we can now write all of - * the data blocks. Yay, useful work is finally - * getting done here! */ - - tagp = &bh->b_data[sizeof(journal_header_t)]; - while ((tagp - bh->b_data +sizeof(journal_block_tag_t)) - <= journal->j_blocksize) { - unsigned long io_block; - - tag = (journal_block_tag_t *) tagp; - flags = ntohl(tag->t_flags); - - io_block = next_log_block++; - wrap(journal, next_log_block); - err = jread(&obh, journal, io_block); - if (err) { - /* Recover what we can, but - * report failure at the end. */ - success = err; - printk (KERN_ERR - "JBD: IO error %d recovering " - "block %ld in log\n", - err, io_block); - } else { - unsigned long blocknr; - - J_ASSERT(obh != NULL); - blocknr = ntohl(tag->t_blocknr); - - /* If the block has been - * revoked, then we're all done - * here. */ - if (journal_test_revoke - (journal, blocknr, - next_commit_ID)) { - brelse(obh); - ++info->nr_revoke_hits; - goto skip_write; - } - - /* Find a buffer for the new - * data being restored */ - nbh = __getblk(journal->j_fs_dev, - blocknr, - journal->j_blocksize); - if (nbh == NULL) { - printk(KERN_ERR - "JBD: Out of memory " - "during recovery.\n"); - err = -ENOMEM; - brelse(bh); - brelse(obh); - goto failed; - } - - lock_buffer(nbh); - memcpy(nbh->b_data, obh->b_data, - journal->j_blocksize); - if (flags & JFS_FLAG_ESCAPE) { - *((unsigned int *)bh->b_data) = - htonl(JFS_MAGIC_NUMBER); - } - - BUFFER_TRACE(nbh, "marking dirty"); - set_buffer_uptodate(nbh); - mark_buffer_dirty(nbh); - BUFFER_TRACE(nbh, "marking uptodate"); - ++info->nr_replays; - /* ll_rw_block(WRITE, 1, &nbh); */ - unlock_buffer(nbh); - brelse(obh); - brelse(nbh); - } - - skip_write: - tagp += sizeof(journal_block_tag_t); - if (!(flags & JFS_FLAG_SAME_UUID)) - tagp += 16; - - if (flags & JFS_FLAG_LAST_TAG) - break; - } - - brelse(bh); - continue; - - case JFS_COMMIT_BLOCK: - /* Found an expected commit block: not much to - * do other than move on to the next sequence - * number. */ - brelse(bh); - next_commit_ID++; - continue; - - case JFS_REVOKE_BLOCK: - /* If we aren't in the REVOKE pass, then we can - * just skip over this block. */ - if (pass != PASS_REVOKE) { - brelse(bh); - continue; - } - - err = scan_revoke_records(journal, bh, - next_commit_ID, info); - brelse(bh); - if (err) - goto failed; - continue; - - default: - jbd_debug(3, "Unrecognised magic %d, end of scan.\n", - blocktype); - goto done; - } - } - - done: - /* - * We broke out of the log scan loop: either we came to the - * known end of the log or we found an unexpected block in the - * log. If the latter happened, then we know that the "current" - * transaction marks the end of the valid log. - */ - - if (pass == PASS_SCAN) - info->end_transaction = next_commit_ID; - else { - /* It's really bad news if different passes end up at - * different places (but possible due to IO errors). */ - if (info->end_transaction != next_commit_ID) { - printk (KERN_ERR "JBD: recovery pass %d ended at " - "transaction %u, expected %u\n", - pass, next_commit_ID, info->end_transaction); - if (!success) - success = -EIO; - } - } - - return success; - - failed: - return err; -} - - -/* Scan a revoke record, marking all blocks mentioned as revoked. */ - -static int scan_revoke_records(journal_t *journal, struct buffer_head *bh, - tid_t sequence, struct recovery_info *info) -{ - journal_revoke_header_t *header; - int offset, max; - - header = (journal_revoke_header_t *) bh->b_data; - offset = sizeof(journal_revoke_header_t); - max = ntohl(header->r_count); - - while (offset < max) { - unsigned long blocknr; - int err; - - blocknr = ntohl(* ((unsigned int *) (bh->b_data+offset))); - offset += 4; - err = journal_set_revoke(journal, blocknr, sequence); - if (err) - return err; - ++info->nr_revokes; - } - return 0; -} diff --git a/e2fsprogs/e2fsck/region.c b/e2fsprogs/e2fsck/region.c deleted file mode 100644 index 9ccb684a3..000000000 --- a/e2fsprogs/e2fsck/region.c +++ /dev/null @@ -1,204 +0,0 @@ -/* - * region.c --- code which manages allocations within a region. - * - * Copyright (C) 2001 Theodore Ts'o. - * - * %Begin-Header% - * This file may be redistributed under the terms of the GNU Public - * License. - * %End-Header% - */ - -#if HAVE_UNISTD_H -#include -#endif -#include - -#include "e2fsck.h" - -struct region_el { - region_addr_t start; - region_addr_t end; - struct region_el *next; -}; - -struct region_struct { - region_addr_t min; - region_addr_t max; - struct region_el *allocated; -}; - -region_t region_create(region_addr_t min, region_addr_t max) -{ - region_t region; - - region = malloc(sizeof(struct region_struct)); - if (!region) - return NULL; - memset(region, 0, sizeof(struct region_struct)); - region->min = min; - region->max = max; - return region; -} - -void region_free(region_t region) -{ - struct region_el *r, *next; - - for (r = region->allocated; r; r = next) { - next = r->next; - free(r); - } - memset(region, 0, sizeof(struct region_struct)); - free(region); -} - -int region_allocate(region_t region, region_addr_t start, int n) -{ - struct region_el *r, *new_region, *prev, *next; - region_addr_t end; - - end = start+n; - if ((start < region->min) || (end > region->max)) - return -1; - if (n == 0) - return 1; - - /* - * Search through the linked list. If we find that it - * conflicts witih something that's already allocated, return - * 1; if we can find an existing region which we can grow, do - * so. Otherwise, stop when we find the appropriate place - * insert a new region element into the linked list. - */ - for (r = region->allocated, prev=NULL; r; prev = r, r = r->next) { - if (((start >= r->start) && (start < r->end)) || - ((end > r->start) && (end <= r->end)) || - ((start <= r->start) && (end >= r->end))) - return 1; - if (end == r->start) { - r->start = start; - return 0; - } - if (start == r->end) { - if ((next = r->next)) { - if (end > next->start) - return 1; - if (end == next->start) { - r->end = next->end; - r->next = next->next; - free(next); - return 0; - } - } - r->end = end; - return 0; - } - if (start < r->start) - break; - } - /* - * Insert a new region element structure into the linked list - */ - new_region = malloc(sizeof(struct region_el)); - if (!new_region) - return -1; - new_region->start = start; - new_region->end = start + n; - new_region->next = r; - if (prev) - prev->next = new_region; - else - region->allocated = new_region; - return 0; -} - -#ifdef TEST_PROGRAM -#include - -#define BCODE_END 0 -#define BCODE_CREATE 1 -#define BCODE_FREE 2 -#define BCODE_ALLOCATE 3 -#define BCODE_PRINT 4 - -int bcode_program[] = { - BCODE_CREATE, 1, 1001, - BCODE_PRINT, - BCODE_ALLOCATE, 10, 10, - BCODE_ALLOCATE, 30, 10, - BCODE_PRINT, - BCODE_ALLOCATE, 1, 15, - BCODE_ALLOCATE, 15, 8, - BCODE_ALLOCATE, 1, 20, - BCODE_ALLOCATE, 1, 8, - BCODE_PRINT, - BCODE_ALLOCATE, 40, 10, - BCODE_PRINT, - BCODE_ALLOCATE, 22, 5, - BCODE_PRINT, - BCODE_ALLOCATE, 27, 3, - BCODE_PRINT, - BCODE_ALLOCATE, 20, 2, - BCODE_PRINT, - BCODE_ALLOCATE, 49, 1, - BCODE_ALLOCATE, 50, 5, - BCODE_ALLOCATE, 9, 2, - BCODE_ALLOCATE, 9, 1, - BCODE_PRINT, - BCODE_FREE, - BCODE_END -}; - -void region_print(region_t region, FILE *f) -{ - struct region_el *r; - int i = 0; - - fprintf(f, "Printing region (min=%d. max=%d)\n\t", region->min, - region->max); - for (r = region->allocated; r; r = r->next) { - fprintf(f, "(%d, %d) ", r->start, r->end); - if (++i >= 8) - fprintf(f, "\n\t"); - } - fprintf(f, "\n"); -} - -int main(int argc, char **argv) -{ - region_t r; - int pc = 0, ret; - region_addr_t start, end, len; - - - while (1) { - switch (bcode_program[pc++]) { - case BCODE_END: - exit(0); - case BCODE_CREATE: - start = bcode_program[pc++]; - end = bcode_program[pc++]; - printf("Creating region with args(%d, %d)\n", - start, end); - r = region_create(start, end); - if (!r) { - fprintf(stderr, "Couldn't create region.\n"); - exit(1); - } - break; - case BCODE_ALLOCATE: - start = bcode_program[pc++]; - end = bcode_program[pc++]; - ret = region_allocate(r, start, end); - printf("Region_allocate(%d, %d) returns %d\n", - start, end, ret); - break; - case BCODE_PRINT: - region_print(r, stdout); - break; - } - } -} - -#endif /* TEST_PROGRAM */ diff --git a/e2fsprogs/e2fsck/rehash.c b/e2fsprogs/e2fsck/rehash.c deleted file mode 100644 index 727e08c2b..000000000 --- a/e2fsprogs/e2fsck/rehash.c +++ /dev/null @@ -1,840 +0,0 @@ -/* - * rehash.c --- rebuild hash tree directories - * - * Copyright (C) 2002 Theodore Ts'o - * - * %Begin-Header% - * This file may be redistributed under the terms of the GNU Public - * License. - * %End-Header% - * - * This algorithm is designed for simplicity of implementation and to - * pack the directory as much as possible. It however requires twice - * as much memory as the size of the directory. The maximum size - * directory supported using a 4k blocksize is roughly a gigabyte, and - * so there may very well be problems with machines that don't have - * virtual memory, and obscenely large directories. - * - * An alternate algorithm which is much more disk intensive could be - * written, and probably will need to be written in the future. The - * design goals of such an algorithm are: (a) use (roughly) constant - * amounts of memory, no matter how large the directory, (b) the - * directory must be safe at all times, even if e2fsck is interrupted - * in the middle, (c) we must use minimal amounts of extra disk - * blocks. This pretty much requires an incremental approach, where - * we are reading from one part of the directory, and inserting into - * the front half. So the algorithm will have to keep track of a - * moving block boundary between the new tree and the old tree, and - * files will need to be moved from the old directory and inserted - * into the new tree. If the new directory requires space which isn't - * yet available, blocks from the beginning part of the old directory - * may need to be moved to the end of the directory to make room for - * the new tree: - * - * -------------------------------------------------------- - * | new tree | | old tree | - * -------------------------------------------------------- - * ^ ptr ^ptr - * tail new head old - * - * This is going to be a pain in the tuckus to implement, and will - * require a lot more disk accesses. So I'm going to skip it for now; - * it's only really going to be an issue for really, really big - * filesystems (when we reach the level of tens of millions of files - * in a single directory). It will probably be easier to simply - * require that e2fsck use VM first. - */ - -#include -#include -#include -#include "e2fsck.h" -#include "problem.h" - -struct fill_dir_struct { - char *buf; - struct ext2_inode *inode; - int err; - e2fsck_t ctx; - struct hash_entry *harray; - int max_array, num_array; - int dir_size; - int compress; - ino_t parent; -}; - -struct hash_entry { - ext2_dirhash_t hash; - ext2_dirhash_t minor_hash; - struct ext2_dir_entry *dir; -}; - -struct out_dir { - int num; - int max; - char *buf; - ext2_dirhash_t *hashes; -}; - -static int fill_dir_block(ext2_filsys fs, - blk_t *block_nr, - e2_blkcnt_t blockcnt, - blk_t ref_block EXT2FS_ATTR((unused)), - int ref_offset EXT2FS_ATTR((unused)), - void *priv_data) -{ - struct fill_dir_struct *fd = (struct fill_dir_struct *) priv_data; - struct hash_entry *new_array, *ent; - struct ext2_dir_entry *dirent; - char *dir; - unsigned int offset, dir_offset; - - if (blockcnt < 0) - return 0; - - offset = blockcnt * fs->blocksize; - if (offset + fs->blocksize > fd->inode->i_size) { - fd->err = EXT2_ET_DIR_CORRUPTED; - return BLOCK_ABORT; - } - dir = (fd->buf+offset); - if (HOLE_BLKADDR(*block_nr)) { - memset(dir, 0, fs->blocksize); - dirent = (struct ext2_dir_entry *) dir; - dirent->rec_len = fs->blocksize; - } else { - fd->err = ext2fs_read_dir_block(fs, *block_nr, dir); - if (fd->err) - return BLOCK_ABORT; - } - /* While the directory block is "hot", index it. */ - dir_offset = 0; - while (dir_offset < fs->blocksize) { - dirent = (struct ext2_dir_entry *) (dir + dir_offset); - if (((dir_offset + dirent->rec_len) > fs->blocksize) || - (dirent->rec_len < 8) || - ((dirent->rec_len % 4) != 0) || - (((dirent->name_len & 0xFF)+8) > dirent->rec_len)) { - fd->err = EXT2_ET_DIR_CORRUPTED; - return BLOCK_ABORT; - } - dir_offset += dirent->rec_len; - if (dirent->inode == 0) - continue; - if (!fd->compress && ((dirent->name_len&0xFF) == 1) && - (dirent->name[0] == '.')) - continue; - if (!fd->compress && ((dirent->name_len&0xFF) == 2) && - (dirent->name[0] == '.') && (dirent->name[1] == '.')) { - fd->parent = dirent->inode; - continue; - } - if (fd->num_array >= fd->max_array) { - new_array = realloc(fd->harray, - sizeof(struct hash_entry) * (fd->max_array+500)); - if (!new_array) { - fd->err = ENOMEM; - return BLOCK_ABORT; - } - fd->harray = new_array; - fd->max_array += 500; - } - ent = fd->harray + fd->num_array++; - ent->dir = dirent; - fd->dir_size += EXT2_DIR_REC_LEN(dirent->name_len & 0xFF); - if (fd->compress) - ent->hash = ent->minor_hash = 0; - else { - fd->err = ext2fs_dirhash(fs->super->s_def_hash_version, - dirent->name, - dirent->name_len & 0xFF, - fs->super->s_hash_seed, - &ent->hash, &ent->minor_hash); - if (fd->err) - return BLOCK_ABORT; - } - } - - return 0; -} - -/* Used for sorting the hash entry */ -static EXT2_QSORT_TYPE name_cmp(const void *a, const void *b) -{ - const struct hash_entry *he_a = (const struct hash_entry *) a; - const struct hash_entry *he_b = (const struct hash_entry *) b; - int ret; - int min_len; - - min_len = he_a->dir->name_len; - if (min_len > he_b->dir->name_len) - min_len = he_b->dir->name_len; - - ret = strncmp(he_a->dir->name, he_b->dir->name, min_len); - if (ret == 0) { - if (he_a->dir->name_len > he_b->dir->name_len) - ret = 1; - else if (he_a->dir->name_len < he_b->dir->name_len) - ret = -1; - else - ret = he_b->dir->inode - he_a->dir->inode; - } - return ret; -} - -/* Used for sorting the hash entry */ -static EXT2_QSORT_TYPE hash_cmp(const void *a, const void *b) -{ - const struct hash_entry *he_a = (const struct hash_entry *) a; - const struct hash_entry *he_b = (const struct hash_entry *) b; - int ret; - - if (he_a->hash > he_b->hash) - ret = 1; - else if (he_a->hash < he_b->hash) - ret = -1; - else { - if (he_a->minor_hash > he_b->minor_hash) - ret = 1; - else if (he_a->minor_hash < he_b->minor_hash) - ret = -1; - else - ret = name_cmp(a, b); - } - return ret; -} - -static errcode_t alloc_size_dir(ext2_filsys fs, struct out_dir *outdir, - int blocks) -{ - void *new_mem; - - if (outdir->max) { - new_mem = realloc(outdir->buf, blocks * fs->blocksize); - if (!new_mem) - return ENOMEM; - outdir->buf = new_mem; - new_mem = realloc(outdir->hashes, - blocks * sizeof(ext2_dirhash_t)); - if (!new_mem) - return ENOMEM; - outdir->hashes = new_mem; - } else { - outdir->buf = malloc(blocks * fs->blocksize); - outdir->hashes = malloc(blocks * sizeof(ext2_dirhash_t)); - outdir->num = 0; - } - outdir->max = blocks; - return 0; -} - -static void free_out_dir(struct out_dir *outdir) -{ - if (outdir->buf) - free(outdir->buf); - if (outdir->hashes) - free(outdir->hashes); - outdir->max = 0; - outdir->num =0; -} - -static errcode_t get_next_block(ext2_filsys fs, struct out_dir *outdir, - char ** ret) -{ - errcode_t retval; - - if (outdir->num >= outdir->max) { - retval = alloc_size_dir(fs, outdir, outdir->max + 50); - if (retval) - return retval; - } - *ret = outdir->buf + (outdir->num++ * fs->blocksize); - memset(*ret, 0, fs->blocksize); - return 0; -} - -/* - * This function is used to make a unique filename. We do this by - * appending ~0, and then incrementing the number. However, we cannot - * expand the length of the filename beyond the padding available in - * the directory entry. - */ -static void mutate_name(char *str, __u16 *len) -{ - int i; - __u16 l = *len & 0xFF, h = *len & 0xff00; - - /* - * First check to see if it looks the name has been mutated - * already - */ - for (i = l-1; i > 0; i--) { - if (!isdigit(str[i])) - break; - } - if ((i == l-1) || (str[i] != '~')) { - if (((l-1) & 3) < 2) - l += 2; - else - l = (l+3) & ~3; - str[l-2] = '~'; - str[l-1] = '0'; - *len = l | h; - return; - } - for (i = l-1; i >= 0; i--) { - if (isdigit(str[i])) { - if (str[i] == '9') - str[i] = '0'; - else { - str[i]++; - return; - } - continue; - } - if (i == 1) { - if (str[0] == 'z') - str[0] = 'A'; - else if (str[0] == 'Z') { - str[0] = '~'; - str[1] = '0'; - } else - str[0]++; - } else if (i > 0) { - str[i] = '1'; - str[i-1] = '~'; - } else { - if (str[0] == '~') - str[0] = 'a'; - else - str[0]++; - } - break; - } -} - -static int duplicate_search_and_fix(e2fsck_t ctx, ext2_filsys fs, - ext2_ino_t ino, - struct fill_dir_struct *fd) -{ - struct problem_context pctx; - struct hash_entry *ent, *prev; - int i, j; - int fixed = 0; - char new_name[256]; - __u16 new_len; - - clear_problem_context(&pctx); - pctx.ino = ino; - - for (i=1; i < fd->num_array; i++) { - ent = fd->harray + i; - prev = ent - 1; - if (!ent->dir->inode || - ((ent->dir->name_len & 0xFF) != - (prev->dir->name_len & 0xFF)) || - (strncmp(ent->dir->name, prev->dir->name, - ent->dir->name_len & 0xFF))) - continue; - pctx.dirent = ent->dir; - if ((ent->dir->inode == prev->dir->inode) && - fix_problem(ctx, PR_2_DUPLICATE_DIRENT, &pctx)) { - e2fsck_adjust_inode_count(ctx, ent->dir->inode, -1); - ent->dir->inode = 0; - fixed++; - continue; - } - memcpy(new_name, ent->dir->name, ent->dir->name_len & 0xFF); - new_len = ent->dir->name_len; - mutate_name(new_name, &new_len); - for (j=0; j < fd->num_array; j++) { - if ((i==j) || - ((ent->dir->name_len & 0xFF) != - (fd->harray[j].dir->name_len & 0xFF)) || - (strncmp(new_name, fd->harray[j].dir->name, - new_len & 0xFF))) - continue; - mutate_name(new_name, &new_len); - - j = -1; - } - new_name[new_len & 0xFF] = 0; - pctx.str = new_name; - if (fix_problem(ctx, PR_2_NON_UNIQUE_FILE, &pctx)) { - memcpy(ent->dir->name, new_name, new_len & 0xFF); - ent->dir->name_len = new_len; - ext2fs_dirhash(fs->super->s_def_hash_version, - ent->dir->name, - ent->dir->name_len & 0xFF, - fs->super->s_hash_seed, - &ent->hash, &ent->minor_hash); - fixed++; - } - } - return fixed; -} - - -static errcode_t copy_dir_entries(ext2_filsys fs, - struct fill_dir_struct *fd, - struct out_dir *outdir) -{ - errcode_t retval; - char *block_start; - struct hash_entry *ent; - struct ext2_dir_entry *dirent; - int i, rec_len, left; - ext2_dirhash_t prev_hash; - int offset; - - outdir->max = 0; - retval = alloc_size_dir(fs, outdir, - (fd->dir_size / fs->blocksize) + 2); - if (retval) - return retval; - outdir->num = fd->compress ? 0 : 1; - offset = 0; - outdir->hashes[0] = 0; - prev_hash = 1; - if ((retval = get_next_block(fs, outdir, &block_start))) - return retval; - dirent = (struct ext2_dir_entry *) block_start; - left = fs->blocksize; - for (i=0; i < fd->num_array; i++) { - ent = fd->harray + i; - if (ent->dir->inode == 0) - continue; - rec_len = EXT2_DIR_REC_LEN(ent->dir->name_len & 0xFF); - if (rec_len > left) { - if (left) - dirent->rec_len += left; - if ((retval = get_next_block(fs, outdir, - &block_start))) - return retval; - offset = 0; - } - left = fs->blocksize - offset; - dirent = (struct ext2_dir_entry *) (block_start + offset); - if (offset == 0) { - if (ent->hash == prev_hash) - outdir->hashes[outdir->num-1] = ent->hash | 1; - else - outdir->hashes[outdir->num-1] = ent->hash; - } - dirent->inode = ent->dir->inode; - dirent->name_len = ent->dir->name_len; - dirent->rec_len = rec_len; - memcpy(dirent->name, ent->dir->name, dirent->name_len & 0xFF); - offset += rec_len; - left -= rec_len; - if (left < 12) { - dirent->rec_len += left; - offset += left; - left = 0; - } - prev_hash = ent->hash; - } - if (left) - dirent->rec_len += left; - - return 0; -} - - -static struct ext2_dx_root_info *set_root_node(ext2_filsys fs, char *buf, - ext2_ino_t ino, ext2_ino_t parent) -{ - struct ext2_dir_entry *dir; - struct ext2_dx_root_info *root; - struct ext2_dx_countlimit *limits; - int filetype = 0; - - if (fs->super->s_feature_incompat & EXT2_FEATURE_INCOMPAT_FILETYPE) - filetype = EXT2_FT_DIR << 8; - - memset(buf, 0, fs->blocksize); - dir = (struct ext2_dir_entry *) buf; - dir->inode = ino; - dir->name[0] = '.'; - dir->name_len = 1 | filetype; - dir->rec_len = 12; - dir = (struct ext2_dir_entry *) (buf + 12); - dir->inode = parent; - dir->name[0] = '.'; - dir->name[1] = '.'; - dir->name_len = 2 | filetype; - dir->rec_len = fs->blocksize - 12; - - root = (struct ext2_dx_root_info *) (buf+24); - root->reserved_zero = 0; - root->hash_version = fs->super->s_def_hash_version; - root->info_length = 8; - root->indirect_levels = 0; - root->unused_flags = 0; - - limits = (struct ext2_dx_countlimit *) (buf+32); - limits->limit = (fs->blocksize - 32) / sizeof(struct ext2_dx_entry); - limits->count = 0; - - return root; -} - - -static struct ext2_dx_entry *set_int_node(ext2_filsys fs, char *buf) -{ - struct ext2_dir_entry *dir; - struct ext2_dx_countlimit *limits; - - memset(buf, 0, fs->blocksize); - dir = (struct ext2_dir_entry *) buf; - dir->inode = 0; - dir->rec_len = fs->blocksize; - - limits = (struct ext2_dx_countlimit *) (buf+8); - limits->limit = (fs->blocksize - 8) / sizeof(struct ext2_dx_entry); - limits->count = 0; - - return (struct ext2_dx_entry *) limits; -} - -/* - * This function takes the leaf nodes which have been written in - * outdir, and populates the root node and any necessary interior nodes. - */ -static errcode_t calculate_tree(ext2_filsys fs, - struct out_dir *outdir, - ext2_ino_t ino, - ext2_ino_t parent) -{ - struct ext2_dx_root_info *root_info; - struct ext2_dx_entry *root, *dx_ent = 0; - struct ext2_dx_countlimit *root_limit, *limit; - errcode_t retval; - char * block_start; - int i, c1, c2, nblks; - int limit_offset, root_offset; - - root_info = set_root_node(fs, outdir->buf, ino, parent); - root_offset = limit_offset = ((char *) root_info - outdir->buf) + - root_info->info_length; - root_limit = (struct ext2_dx_countlimit *) (outdir->buf + limit_offset); - c1 = root_limit->limit; - nblks = outdir->num; - - /* Write out the pointer blocks */ - if (nblks-1 <= c1) { - /* Just write out the root block, and we're done */ - root = (struct ext2_dx_entry *) (outdir->buf + root_offset); - for (i=1; i < nblks; i++) { - root->block = ext2fs_cpu_to_le32(i); - if (i != 1) - root->hash = - ext2fs_cpu_to_le32(outdir->hashes[i]); - root++; - c1--; - } - } else { - c2 = 0; - limit = 0; - root_info->indirect_levels = 1; - for (i=1; i < nblks; i++) { - if (c1 == 0) - return ENOSPC; - if (c2 == 0) { - if (limit) - limit->limit = limit->count = - ext2fs_cpu_to_le16(limit->limit); - root = (struct ext2_dx_entry *) - (outdir->buf + root_offset); - root->block = ext2fs_cpu_to_le32(outdir->num); - if (i != 1) - root->hash = - ext2fs_cpu_to_le32(outdir->hashes[i]); - if ((retval = get_next_block(fs, outdir, - &block_start))) - return retval; - dx_ent = set_int_node(fs, block_start); - limit = (struct ext2_dx_countlimit *) dx_ent; - c2 = limit->limit; - root_offset += sizeof(struct ext2_dx_entry); - c1--; - } - dx_ent->block = ext2fs_cpu_to_le32(i); - if (c2 != limit->limit) - dx_ent->hash = - ext2fs_cpu_to_le32(outdir->hashes[i]); - dx_ent++; - c2--; - } - limit->count = ext2fs_cpu_to_le16(limit->limit - c2); - limit->limit = ext2fs_cpu_to_le16(limit->limit); - } - root_limit = (struct ext2_dx_countlimit *) (outdir->buf + limit_offset); - root_limit->count = ext2fs_cpu_to_le16(root_limit->limit - c1); - root_limit->limit = ext2fs_cpu_to_le16(root_limit->limit); - - return 0; -} - -struct write_dir_struct { - struct out_dir *outdir; - errcode_t err; - e2fsck_t ctx; - int cleared; -}; - -/* - * Helper function which writes out a directory block. - */ -static int write_dir_block(ext2_filsys fs, - blk_t *block_nr, - e2_blkcnt_t blockcnt, - blk_t ref_block EXT2FS_ATTR((unused)), - int ref_offset EXT2FS_ATTR((unused)), - void *priv_data) -{ - struct write_dir_struct *wd = (struct write_dir_struct *) priv_data; - blk_t blk; - char *dir; - - if (*block_nr == 0) - return 0; - if (blockcnt >= wd->outdir->num) { - e2fsck_read_bitmaps(wd->ctx); - blk = *block_nr; - ext2fs_unmark_block_bitmap(wd->ctx->block_found_map, blk); - ext2fs_block_alloc_stats(fs, blk, -1); - *block_nr = 0; - wd->cleared++; - return BLOCK_CHANGED; - } - if (blockcnt < 0) - return 0; - - dir = wd->outdir->buf + (blockcnt * fs->blocksize); - wd->err = ext2fs_write_dir_block(fs, *block_nr, dir); - if (wd->err) - return BLOCK_ABORT; - return 0; -} - -static errcode_t write_directory(e2fsck_t ctx, ext2_filsys fs, - struct out_dir *outdir, - ext2_ino_t ino, int compress) -{ - struct write_dir_struct wd; - errcode_t retval; - struct ext2_inode inode; - - retval = e2fsck_expand_directory(ctx, ino, -1, outdir->num); - if (retval) - return retval; - - wd.outdir = outdir; - wd.err = 0; - wd.ctx = ctx; - wd.cleared = 0; - - retval = ext2fs_block_iterate2(fs, ino, 0, 0, - write_dir_block, &wd); - if (retval) - return retval; - if (wd.err) - return wd.err; - - e2fsck_read_inode(ctx, ino, &inode, "rehash_dir"); - if (compress) - inode.i_flags &= ~EXT2_INDEX_FL; - else - inode.i_flags |= EXT2_INDEX_FL; - inode.i_size = outdir->num * fs->blocksize; - inode.i_blocks -= (fs->blocksize / 512) * wd.cleared; - e2fsck_write_inode(ctx, ino, &inode, "rehash_dir"); - - return 0; -} - -errcode_t e2fsck_rehash_dir(e2fsck_t ctx, ext2_ino_t ino) -{ - ext2_filsys fs = ctx->fs; - errcode_t retval; - struct ext2_inode inode; - char *dir_buf = 0; - struct fill_dir_struct fd; - struct out_dir outdir; - - outdir.max = outdir.num = 0; - outdir.buf = 0; - outdir.hashes = 0; - e2fsck_read_inode(ctx, ino, &inode, "rehash_dir"); - - retval = ENOMEM; - fd.harray = 0; - dir_buf = malloc(inode.i_size); - if (!dir_buf) - goto errout; - - fd.max_array = inode.i_size / 32; - fd.num_array = 0; - fd.harray = malloc(fd.max_array * sizeof(struct hash_entry)); - if (!fd.harray) - goto errout; - - fd.ctx = ctx; - fd.buf = dir_buf; - fd.inode = &inode; - fd.err = 0; - fd.dir_size = 0; - fd.compress = 0; - if (!(fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_DIR_INDEX) || - (inode.i_size / fs->blocksize) < 2) - fd.compress = 1; - fd.parent = 0; - - /* Read in the entire directory into memory */ - retval = ext2fs_block_iterate2(fs, ino, 0, 0, - fill_dir_block, &fd); - if (fd.err) { - retval = fd.err; - goto errout; - } - -#if 0 - printf("%d entries (%d bytes) found in inode %d\n", - fd.num_array, fd.dir_size, ino); -#endif - - /* Sort the list */ -resort: - if (fd.compress) - qsort(fd.harray+2, fd.num_array-2, - sizeof(struct hash_entry), name_cmp); - else - qsort(fd.harray, fd.num_array, - sizeof(struct hash_entry), hash_cmp); - - /* - * Look for duplicates - */ - if (duplicate_search_and_fix(ctx, fs, ino, &fd)) - goto resort; - - if (ctx->options & E2F_OPT_NO) { - retval = 0; - goto errout; - } - - /* - * Copy the directory entries. In a htree directory these - * will become the leaf nodes. - */ - retval = copy_dir_entries(fs, &fd, &outdir); - if (retval) - goto errout; - - free(dir_buf); dir_buf = 0; - - if (!fd.compress) { - /* Calculate the interior nodes */ - retval = calculate_tree(fs, &outdir, ino, fd.parent); - if (retval) - goto errout; - } - - retval = write_directory(ctx, fs, &outdir, ino, fd.compress); - if (retval) - goto errout; - -errout: - if (dir_buf) - free(dir_buf); - if (fd.harray) - free(fd.harray); - - free_out_dir(&outdir); - return retval; -} - -void e2fsck_rehash_directories(e2fsck_t ctx) -{ - struct problem_context pctx; -#ifdef RESOURCE_TRACK - struct resource_track rtrack; -#endif - struct dir_info *dir; - ext2_u32_iterate iter; - ext2_ino_t ino; - errcode_t retval; - int i, cur, max, all_dirs, dir_index, first = 1; - -#ifdef RESOURCE_TRACK - init_resource_track(&rtrack); -#endif - - all_dirs = ctx->options & E2F_OPT_COMPRESS_DIRS; - - if (!ctx->dirs_to_hash && !all_dirs) - return; - - e2fsck_get_lost_and_found(ctx, 0); - - clear_problem_context(&pctx); - - dir_index = ctx->fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_DIR_INDEX; - cur = 0; - if (all_dirs) { - i = 0; - max = e2fsck_get_num_dirinfo(ctx); - } else { - retval = ext2fs_u32_list_iterate_begin(ctx->dirs_to_hash, - &iter); - if (retval) { - pctx.errcode = retval; - fix_problem(ctx, PR_3A_OPTIMIZE_ITER, &pctx); - return; - } - max = ext2fs_u32_list_count(ctx->dirs_to_hash); - } - while (1) { - if (all_dirs) { - if ((dir = e2fsck_dir_info_iter(ctx, &i)) == 0) - break; - ino = dir->ino; - } else { - if (!ext2fs_u32_list_iterate(iter, &ino)) - break; - } - if (ino == ctx->lost_and_found) - continue; - pctx.dir = ino; - if (first) { - fix_problem(ctx, PR_3A_PASS_HEADER, &pctx); - first = 0; - } -#if 0 - fix_problem(ctx, PR_3A_OPTIMIZE_DIR, &pctx); -#endif - pctx.errcode = e2fsck_rehash_dir(ctx, ino); - if (pctx.errcode) { - end_problem_latch(ctx, PR_LATCH_OPTIMIZE_DIR); - fix_problem(ctx, PR_3A_OPTIMIZE_DIR_ERR, &pctx); - } - if (ctx->progress && !ctx->progress_fd) - e2fsck_simple_progress(ctx, "Rebuilding directory", - 100.0 * (float) (++cur) / (float) max, ino); - } - end_problem_latch(ctx, PR_LATCH_OPTIMIZE_DIR); - if (!all_dirs) - ext2fs_u32_list_iterate_end(iter); - - if (ctx->dirs_to_hash) - ext2fs_u32_list_free(ctx->dirs_to_hash); - ctx->dirs_to_hash = 0; - -#ifdef RESOURCE_TRACK - if (ctx->options & E2F_OPT_TIME2) { - e2fsck_clear_progbar(ctx); - print_resource_track("Pass 3A", &rtrack); - } -#endif -} diff --git a/e2fsprogs/e2fsck/revoke.c b/e2fsprogs/e2fsck/revoke.c deleted file mode 100644 index 388bf5b5d..000000000 --- a/e2fsprogs/e2fsck/revoke.c +++ /dev/null @@ -1,640 +0,0 @@ -/* - * linux/fs/revoke.c - * - * Written by Stephen C. Tweedie , 2000 - * - * Copyright 2000 Red Hat corp --- All Rights Reserved - * - * This file is part of the Linux kernel and is made available under - * the terms of the GNU General Public License, version 2, or at your - * option, any later version, incorporated herein by reference. - * - * Journal revoke routines for the generic filesystem journaling code; - * part of the ext2fs journaling system. - * - * Revoke is the mechanism used to prevent old log records for deleted - * metadata from being replayed on top of newer data using the same - * blocks. The revoke mechanism is used in two separate places: - * - * + Commit: during commit we write the entire list of the current - * transaction's revoked blocks to the journal - * - * + Recovery: during recovery we record the transaction ID of all - * revoked blocks. If there are multiple revoke records in the log - * for a single block, only the last one counts, and if there is a log - * entry for a block beyond the last revoke, then that log entry still - * gets replayed. - * - * We can get interactions between revokes and new log data within a - * single transaction: - * - * Block is revoked and then journaled: - * The desired end result is the journaling of the new block, so we - * cancel the revoke before the transaction commits. - * - * Block is journaled and then revoked: - * The revoke must take precedence over the write of the block, so we - * need either to cancel the journal entry or to write the revoke - * later in the log than the log block. In this case, we choose the - * latter: journaling a block cancels any revoke record for that block - * in the current transaction, so any revoke for that block in the - * transaction must have happened after the block was journaled and so - * the revoke must take precedence. - * - * Block is revoked and then written as data: - * The data write is allowed to succeed, but the revoke is _not_ - * cancelled. We still need to prevent old log records from - * overwriting the new data. We don't even need to clear the revoke - * bit here. - * - * Revoke information on buffers is a tri-state value: - * - * RevokeValid clear: no cached revoke status, need to look it up - * RevokeValid set, Revoked clear: - * buffer has not been revoked, and cancel_revoke - * need do nothing. - * RevokeValid set, Revoked set: - * buffer has been revoked. - */ - -#ifndef __KERNEL__ -#include "jfs_user.h" -#else -#include -#include -#include -#include -#include -#include -#include -#include -#include -#endif - -static kmem_cache_t *revoke_record_cache; -static kmem_cache_t *revoke_table_cache; - -/* Each revoke record represents one single revoked block. During - journal replay, this involves recording the transaction ID of the - last transaction to revoke this block. */ - -struct jbd_revoke_record_s -{ - struct list_head hash; - tid_t sequence; /* Used for recovery only */ - unsigned long blocknr; -}; - - -/* The revoke table is just a simple hash table of revoke records. */ -struct jbd_revoke_table_s -{ - /* It is conceivable that we might want a larger hash table - * for recovery. Must be a power of two. */ - int hash_size; - int hash_shift; - struct list_head *hash_table; -}; - - -#ifdef __KERNEL__ -static void write_one_revoke_record(journal_t *, transaction_t *, - struct journal_head **, int *, - struct jbd_revoke_record_s *); -static void flush_descriptor(journal_t *, struct journal_head *, int); -#endif - -/* Utility functions to maintain the revoke table */ - -/* Borrowed from buffer.c: this is a tried and tested block hash function */ -static inline int hash(journal_t *journal, unsigned long block) -{ - struct jbd_revoke_table_s *table = journal->j_revoke; - int hash_shift = table->hash_shift; - - return ((block << (hash_shift - 6)) ^ - (block >> 13) ^ - (block << (hash_shift - 12))) & (table->hash_size - 1); -} - -static int insert_revoke_hash(journal_t *journal, unsigned long blocknr, - tid_t seq) -{ - struct list_head *hash_list; - struct jbd_revoke_record_s *record; - -#ifdef __KERNEL__ -repeat: -#endif - record = kmem_cache_alloc(revoke_record_cache, GFP_NOFS); - if (!record) - goto oom; - - record->sequence = seq; - record->blocknr = blocknr; - hash_list = &journal->j_revoke->hash_table[hash(journal, blocknr)]; - list_add(&record->hash, hash_list); - return 0; - -oom: -#ifdef __KERNEL__ - if (!journal_oom_retry) - return -ENOMEM; - jbd_debug(1, "ENOMEM in " __FUNCTION__ ", retrying.\n"); - current->policy |= SCHED_YIELD; - schedule(); - goto repeat; -#else - return -ENOMEM; -#endif -} - -/* Find a revoke record in the journal's hash table. */ - -static struct jbd_revoke_record_s *find_revoke_record(journal_t *journal, - unsigned long blocknr) -{ - struct list_head *hash_list; - struct jbd_revoke_record_s *record; - - hash_list = &journal->j_revoke->hash_table[hash(journal, blocknr)]; - - record = (struct jbd_revoke_record_s *) hash_list->next; - while (&(record->hash) != hash_list) { - if (record->blocknr == blocknr) - return record; - record = (struct jbd_revoke_record_s *) record->hash.next; - } - return NULL; -} - -int __init journal_init_revoke_caches(void) -{ - revoke_record_cache = kmem_cache_create("revoke_record", - sizeof(struct jbd_revoke_record_s), - 0, SLAB_HWCACHE_ALIGN, NULL, NULL); - if (revoke_record_cache == 0) - return -ENOMEM; - - revoke_table_cache = kmem_cache_create("revoke_table", - sizeof(struct jbd_revoke_table_s), - 0, 0, NULL, NULL); - if (revoke_table_cache == 0) { - kmem_cache_destroy(revoke_record_cache); - revoke_record_cache = NULL; - return -ENOMEM; - } - return 0; -} - -void journal_destroy_revoke_caches(void) -{ - kmem_cache_destroy(revoke_record_cache); - revoke_record_cache = 0; - kmem_cache_destroy(revoke_table_cache); - revoke_table_cache = 0; -} - -/* Initialise the revoke table for a given journal to a given size. */ - -int journal_init_revoke(journal_t *journal, int hash_size) -{ - int shift, tmp; - - J_ASSERT (journal->j_revoke == NULL); - - journal->j_revoke = kmem_cache_alloc(revoke_table_cache, GFP_KERNEL); - if (!journal->j_revoke) - return -ENOMEM; - - /* Check that the hash_size is a power of two */ - J_ASSERT ((hash_size & (hash_size-1)) == 0); - - journal->j_revoke->hash_size = hash_size; - - shift = 0; - tmp = hash_size; - while((tmp >>= 1UL) != 0UL) - shift++; - journal->j_revoke->hash_shift = shift; - - journal->j_revoke->hash_table = - kmalloc(hash_size * sizeof(struct list_head), GFP_KERNEL); - if (!journal->j_revoke->hash_table) { - kmem_cache_free(revoke_table_cache, journal->j_revoke); - journal->j_revoke = NULL; - return -ENOMEM; - } - - for (tmp = 0; tmp < hash_size; tmp++) - INIT_LIST_HEAD(&journal->j_revoke->hash_table[tmp]); - - return 0; -} - -/* Destoy a journal's revoke table. The table must already be empty! */ - -void journal_destroy_revoke(journal_t *journal) -{ - struct jbd_revoke_table_s *table; - struct list_head *hash_list; - int i; - - table = journal->j_revoke; - if (!table) - return; - - for (i=0; ihash_size; i++) { - hash_list = &table->hash_table[i]; - J_ASSERT (list_empty(hash_list)); - } - - kfree(table->hash_table); - kmem_cache_free(revoke_table_cache, table); - journal->j_revoke = NULL; -} - - -#ifdef __KERNEL__ - -/* - * journal_revoke: revoke a given buffer_head from the journal. This - * prevents the block from being replayed during recovery if we take a - * crash after this current transaction commits. Any subsequent - * metadata writes of the buffer in this transaction cancel the - * revoke. - * - * Note that this call may block --- it is up to the caller to make - * sure that there are no further calls to journal_write_metadata - * before the revoke is complete. In ext3, this implies calling the - * revoke before clearing the block bitmap when we are deleting - * metadata. - * - * Revoke performs a journal_forget on any buffer_head passed in as a - * parameter, but does _not_ forget the buffer_head if the bh was only - * found implicitly. - * - * bh_in may not be a journalled buffer - it may have come off - * the hash tables without an attached journal_head. - * - * If bh_in is non-zero, journal_revoke() will decrement its b_count - * by one. - */ - -int journal_revoke(handle_t *handle, unsigned long blocknr, - struct buffer_head *bh_in) -{ - struct buffer_head *bh = NULL; - journal_t *journal; - kdev_t dev; - int err; - - if (bh_in) - BUFFER_TRACE(bh_in, "enter"); - - journal = handle->h_transaction->t_journal; - if (!journal_set_features(journal, 0, 0, JFS_FEATURE_INCOMPAT_REVOKE)){ - J_ASSERT (!"Cannot set revoke feature!"); - return -EINVAL; - } - - dev = journal->j_fs_dev; - bh = bh_in; - - if (!bh) { - bh = get_hash_table(dev, blocknr, journal->j_blocksize); - if (bh) - BUFFER_TRACE(bh, "found on hash"); - } -#ifdef JBD_EXPENSIVE_CHECKING - else { - struct buffer_head *bh2; - - /* If there is a different buffer_head lying around in - * memory anywhere... */ - bh2 = get_hash_table(dev, blocknr, journal->j_blocksize); - if (bh2) { - /* ... and it has RevokeValid status... */ - if ((bh2 != bh) && - test_bit(BH_RevokeValid, &bh2->b_state)) - /* ...then it better be revoked too, - * since it's illegal to create a revoke - * record against a buffer_head which is - * not marked revoked --- that would - * risk missing a subsequent revoke - * cancel. */ - J_ASSERT_BH(bh2, test_bit(BH_Revoked, & - bh2->b_state)); - __brelse(bh2); - } - } -#endif - - /* We really ought not ever to revoke twice in a row without - first having the revoke cancelled: it's illegal to free a - block twice without allocating it in between! */ - if (bh) { - J_ASSERT_BH(bh, !test_bit(BH_Revoked, &bh->b_state)); - set_bit(BH_Revoked, &bh->b_state); - set_bit(BH_RevokeValid, &bh->b_state); - if (bh_in) { - BUFFER_TRACE(bh_in, "call journal_forget"); - journal_forget(handle, bh_in); - } else { - BUFFER_TRACE(bh, "call brelse"); - __brelse(bh); - } - } - - lock_journal(journal); - jbd_debug(2, "insert revoke for block %lu, bh_in=%p\n", blocknr, bh_in); - err = insert_revoke_hash(journal, blocknr, - handle->h_transaction->t_tid); - unlock_journal(journal); - BUFFER_TRACE(bh_in, "exit"); - return err; -} - -/* - * Cancel an outstanding revoke. For use only internally by the - * journaling code (called from journal_get_write_access). - * - * We trust the BH_Revoked bit on the buffer if the buffer is already - * being journaled: if there is no revoke pending on the buffer, then we - * don't do anything here. - * - * This would break if it were possible for a buffer to be revoked and - * discarded, and then reallocated within the same transaction. In such - * a case we would have lost the revoked bit, but when we arrived here - * the second time we would still have a pending revoke to cancel. So, - * do not trust the Revoked bit on buffers unless RevokeValid is also - * set. - * - * The caller must have the journal locked. - */ -int journal_cancel_revoke(handle_t *handle, struct journal_head *jh) -{ - struct jbd_revoke_record_s *record; - journal_t *journal = handle->h_transaction->t_journal; - int need_cancel; - int did_revoke = 0; /* akpm: debug */ - struct buffer_head *bh = jh2bh(jh); - - jbd_debug(4, "journal_head %p, cancelling revoke\n", jh); - - /* Is the existing Revoke bit valid? If so, we trust it, and - * only perform the full cancel if the revoke bit is set. If - * not, we can't trust the revoke bit, and we need to do the - * full search for a revoke record. */ - if (test_and_set_bit(BH_RevokeValid, &bh->b_state)) - need_cancel = (test_and_clear_bit(BH_Revoked, &bh->b_state)); - else { - need_cancel = 1; - clear_bit(BH_Revoked, &bh->b_state); - } - - if (need_cancel) { - record = find_revoke_record(journal, bh->b_blocknr); - if (record) { - jbd_debug(4, "cancelled existing revoke on " - "blocknr %lu\n", bh->b_blocknr); - list_del(&record->hash); - kmem_cache_free(revoke_record_cache, record); - did_revoke = 1; - } - } - -#ifdef JBD_EXPENSIVE_CHECKING - /* There better not be one left behind by now! */ - record = find_revoke_record(journal, bh->b_blocknr); - J_ASSERT_JH(jh, record == NULL); -#endif - - /* Finally, have we just cleared revoke on an unhashed - * buffer_head? If so, we'd better make sure we clear the - * revoked status on any hashed alias too, otherwise the revoke - * state machine will get very upset later on. */ - if (need_cancel && !bh->b_pprev) { - struct buffer_head *bh2; - bh2 = get_hash_table(bh->b_dev, bh->b_blocknr, bh->b_size); - if (bh2) { - clear_bit(BH_Revoked, &bh2->b_state); - __brelse(bh2); - } - } - - return did_revoke; -} - - -/* - * Write revoke records to the journal for all entries in the current - * revoke hash, deleting the entries as we go. - * - * Called with the journal lock held. - */ - -void journal_write_revoke_records(journal_t *journal, - transaction_t *transaction) -{ - struct journal_head *descriptor; - struct jbd_revoke_record_s *record; - struct jbd_revoke_table_s *revoke; - struct list_head *hash_list; - int i, offset, count; - - descriptor = NULL; - offset = 0; - count = 0; - revoke = journal->j_revoke; - - for (i = 0; i < revoke->hash_size; i++) { - hash_list = &revoke->hash_table[i]; - - while (!list_empty(hash_list)) { - record = (struct jbd_revoke_record_s *) - hash_list->next; - write_one_revoke_record(journal, transaction, - &descriptor, &offset, - record); - count++; - list_del(&record->hash); - kmem_cache_free(revoke_record_cache, record); - } - } - if (descriptor) - flush_descriptor(journal, descriptor, offset); - jbd_debug(1, "Wrote %d revoke records\n", count); -} - -/* - * Write out one revoke record. We need to create a new descriptor - * block if the old one is full or if we have not already created one. - */ - -static void write_one_revoke_record(journal_t *journal, - transaction_t *transaction, - struct journal_head **descriptorp, - int *offsetp, - struct jbd_revoke_record_s *record) -{ - struct journal_head *descriptor; - int offset; - journal_header_t *header; - - /* If we are already aborting, this all becomes a noop. We - still need to go round the loop in - journal_write_revoke_records in order to free all of the - revoke records: only the IO to the journal is omitted. */ - if (is_journal_aborted(journal)) - return; - - descriptor = *descriptorp; - offset = *offsetp; - - /* Make sure we have a descriptor with space left for the record */ - if (descriptor) { - if (offset == journal->j_blocksize) { - flush_descriptor(journal, descriptor, offset); - descriptor = NULL; - } - } - - if (!descriptor) { - descriptor = journal_get_descriptor_buffer(journal); - if (!descriptor) - return; - header = (journal_header_t *) &jh2bh(descriptor)->b_data[0]; - header->h_magic = htonl(JFS_MAGIC_NUMBER); - header->h_blocktype = htonl(JFS_REVOKE_BLOCK); - header->h_sequence = htonl(transaction->t_tid); - - /* Record it so that we can wait for IO completion later */ - JBUFFER_TRACE(descriptor, "file as BJ_LogCtl"); - journal_file_buffer(descriptor, transaction, BJ_LogCtl); - - offset = sizeof(journal_revoke_header_t); - *descriptorp = descriptor; - } - - * ((unsigned int *)(&jh2bh(descriptor)->b_data[offset])) = - htonl(record->blocknr); - offset += 4; - *offsetp = offset; -} - -/* - * Flush a revoke descriptor out to the journal. If we are aborting, - * this is a noop; otherwise we are generating a buffer which needs to - * be waited for during commit, so it has to go onto the appropriate - * journal buffer list. - */ - -static void flush_descriptor(journal_t *journal, - struct journal_head *descriptor, - int offset) -{ - journal_revoke_header_t *header; - - if (is_journal_aborted(journal)) { - JBUFFER_TRACE(descriptor, "brelse"); - __brelse(jh2bh(descriptor)); - return; - } - - header = (journal_revoke_header_t *) jh2bh(descriptor)->b_data; - header->r_count = htonl(offset); - set_bit(BH_JWrite, &jh2bh(descriptor)->b_state); - { - struct buffer_head *bh = jh2bh(descriptor); - BUFFER_TRACE(bh, "write"); - ll_rw_block (WRITE, 1, &bh); - } -} - -#endif - -/* - * Revoke support for recovery. - * - * Recovery needs to be able to: - * - * record all revoke records, including the tid of the latest instance - * of each revoke in the journal - * - * check whether a given block in a given transaction should be replayed - * (ie. has not been revoked by a revoke record in that or a subsequent - * transaction) - * - * empty the revoke table after recovery. - */ - -/* - * First, setting revoke records. We create a new revoke record for - * every block ever revoked in the log as we scan it for recovery, and - * we update the existing records if we find multiple revokes for a - * single block. - */ - -int journal_set_revoke(journal_t *journal, - unsigned long blocknr, - tid_t sequence) -{ - struct jbd_revoke_record_s *record; - - record = find_revoke_record(journal, blocknr); - if (record) { - /* If we have multiple occurences, only record the - * latest sequence number in the hashed record */ - if (tid_gt(sequence, record->sequence)) - record->sequence = sequence; - return 0; - } - return insert_revoke_hash(journal, blocknr, sequence); -} - -/* - * Test revoke records. For a given block referenced in the log, has - * that block been revoked? A revoke record with a given transaction - * sequence number revokes all blocks in that transaction and earlier - * ones, but later transactions still need replayed. - */ - -int journal_test_revoke(journal_t *journal, - unsigned long blocknr, - tid_t sequence) -{ - struct jbd_revoke_record_s *record; - - record = find_revoke_record(journal, blocknr); - if (!record) - return 0; - if (tid_gt(sequence, record->sequence)) - return 0; - return 1; -} - -/* - * Finally, once recovery is over, we need to clear the revoke table so - * that it can be reused by the running filesystem. - */ - -void journal_clear_revoke(journal_t *journal) -{ - int i; - struct list_head *hash_list; - struct jbd_revoke_record_s *record; - struct jbd_revoke_table_s *revoke_var; - - revoke_var = journal->j_revoke; - - for (i = 0; i < revoke_var->hash_size; i++) { - hash_list = &revoke_var->hash_table[i]; - while (!list_empty(hash_list)) { - record = (struct jbd_revoke_record_s*) hash_list->next; - list_del(&record->hash); - kmem_cache_free(revoke_record_cache, record); - } - } -} - diff --git a/e2fsprogs/e2fsck/super.c b/e2fsprogs/e2fsck/super.c deleted file mode 100644 index 294cd80e4..000000000 --- a/e2fsprogs/e2fsck/super.c +++ /dev/null @@ -1,713 +0,0 @@ -/* - * e2fsck.c - superblock checks - * - * Copyright (C) 1993, 1994, 1995, 1996, 1997 Theodore Ts'o. - * - * %Begin-Header% - * This file may be redistributed under the terms of the GNU Public - * License. - * %End-Header% - */ - -#ifdef HAVE_ERRNO_H -#include -#endif - -#ifndef EXT2_SKIP_UUID -#include "uuid/uuid.h" -#endif -#include "e2fsck.h" -#include "problem.h" - -#define MIN_CHECK 1 -#define MAX_CHECK 2 - -static void check_super_value(e2fsck_t ctx, const char *descr, - unsigned long value, int flags, - unsigned long min_val, unsigned long max_val) -{ - struct problem_context pctx; - - if (((flags & MIN_CHECK) && (value < min_val)) || - ((flags & MAX_CHECK) && (value > max_val))) { - clear_problem_context(&pctx); - pctx.num = value; - pctx.str = descr; - fix_problem(ctx, PR_0_MISC_CORRUPT_SUPER, &pctx); - ctx->flags |= E2F_FLAG_ABORT; /* never get here! */ - } -} - -/* - * This routine may get stubbed out in special compilations of the - * e2fsck code.. - */ -#ifndef EXT2_SPECIAL_DEVICE_SIZE -errcode_t e2fsck_get_device_size(e2fsck_t ctx) -{ - return (ext2fs_get_device_size(ctx->filesystem_name, - EXT2_BLOCK_SIZE(ctx->fs->super), - &ctx->num_blocks)); -} -#endif - -/* - * helper function to release an inode - */ -struct process_block_struct { - e2fsck_t ctx; - char *buf; - struct problem_context *pctx; - int truncating; - int truncate_offset; - e2_blkcnt_t truncate_block; - int truncated_blocks; - int abort; - errcode_t errcode; -}; - -static int release_inode_block(ext2_filsys fs, - blk_t *block_nr, - e2_blkcnt_t blockcnt, - blk_t ref_blk EXT2FS_ATTR((unused)), - int ref_offset EXT2FS_ATTR((unused)), - void *priv_data) -{ - struct process_block_struct *pb; - e2fsck_t ctx; - struct problem_context *pctx; - blk_t blk = *block_nr; - int retval = 0; - - pb = (struct process_block_struct *) priv_data; - ctx = pb->ctx; - pctx = pb->pctx; - - pctx->blk = blk; - pctx->blkcount = blockcnt; - - if (HOLE_BLKADDR(blk)) - return 0; - - if ((blk < fs->super->s_first_data_block) || - (blk >= fs->super->s_blocks_count)) { - fix_problem(ctx, PR_0_ORPHAN_ILLEGAL_BLOCK_NUM, pctx); - return_abort: - pb->abort = 1; - return BLOCK_ABORT; - } - - if (!ext2fs_test_block_bitmap(fs->block_map, blk)) { - fix_problem(ctx, PR_0_ORPHAN_ALREADY_CLEARED_BLOCK, pctx); - goto return_abort; - } - - /* - * If we are deleting an orphan, then we leave the fields alone. - * If we are truncating an orphan, then update the inode fields - * and clean up any partial block data. - */ - if (pb->truncating) { - /* - * We only remove indirect blocks if they are - * completely empty. - */ - if (blockcnt < 0) { - int i, limit; - blk_t *bp; - - pb->errcode = io_channel_read_blk(fs->io, blk, 1, - pb->buf); - if (pb->errcode) - goto return_abort; - - limit = fs->blocksize >> 2; - for (i = 0, bp = (blk_t *) pb->buf; - i < limit; i++, bp++) - if (*bp) - return 0; - } - /* - * We don't remove direct blocks until we've reached - * the truncation block. - */ - if (blockcnt >= 0 && blockcnt < pb->truncate_block) - return 0; - /* - * If part of the last block needs truncating, we do - * it here. - */ - if ((blockcnt == pb->truncate_block) && pb->truncate_offset) { - pb->errcode = io_channel_read_blk(fs->io, blk, 1, - pb->buf); - if (pb->errcode) - goto return_abort; - memset(pb->buf + pb->truncate_offset, 0, - fs->blocksize - pb->truncate_offset); - pb->errcode = io_channel_write_blk(fs->io, blk, 1, - pb->buf); - if (pb->errcode) - goto return_abort; - } - pb->truncated_blocks++; - *block_nr = 0; - retval |= BLOCK_CHANGED; - } - - ext2fs_block_alloc_stats(fs, blk, -1); - return retval; -} - -/* - * This function releases an inode. Returns 1 if an inconsistency was - * found. If the inode has a link count, then it is being truncated and - * not deleted. - */ -static int release_inode_blocks(e2fsck_t ctx, ext2_ino_t ino, - struct ext2_inode *inode, char *block_buf, - struct problem_context *pctx) -{ - struct process_block_struct pb; - ext2_filsys fs = ctx->fs; - errcode_t retval; - __u32 count; - - if (!ext2fs_inode_has_valid_blocks(inode)) - return 0; - - pb.buf = block_buf + 3 * ctx->fs->blocksize; - pb.ctx = ctx; - pb.abort = 0; - pb.errcode = 0; - pb.pctx = pctx; - if (inode->i_links_count) { - pb.truncating = 1; - pb.truncate_block = (e2_blkcnt_t) - ((((long long)inode->i_size_high << 32) + - inode->i_size + fs->blocksize - 1) / - fs->blocksize); - pb.truncate_offset = inode->i_size % fs->blocksize; - } else { - pb.truncating = 0; - pb.truncate_block = 0; - pb.truncate_offset = 0; - } - pb.truncated_blocks = 0; - retval = ext2fs_block_iterate2(fs, ino, BLOCK_FLAG_DEPTH_TRAVERSE, - block_buf, release_inode_block, &pb); - if (retval) { - com_err("release_inode_blocks", retval, - _("while calling ext2fs_block_iterate for inode %d"), - ino); - return 1; - } - if (pb.abort) - return 1; - - /* Refresh the inode since ext2fs_block_iterate may have changed it */ - e2fsck_read_inode(ctx, ino, inode, "release_inode_blocks"); - - if (pb.truncated_blocks) - inode->i_blocks -= pb.truncated_blocks * - (fs->blocksize / 512); - - if (inode->i_file_acl) { - retval = ext2fs_adjust_ea_refcount(fs, inode->i_file_acl, - block_buf, -1, &count); - if (retval == EXT2_ET_BAD_EA_BLOCK_NUM) { - retval = 0; - count = 1; - } - if (retval) { - com_err("release_inode_blocks", retval, - _("while calling ext2fs_adjust_ea_refocunt for inode %d"), - ino); - return 1; - } - if (count == 0) - ext2fs_block_alloc_stats(fs, inode->i_file_acl, -1); - inode->i_file_acl = 0; - } - return 0; -} - -/* - * This function releases all of the orphan inodes. It returns 1 if - * it hit some error, and 0 on success. - */ -static int release_orphan_inodes(e2fsck_t ctx) -{ - ext2_filsys fs = ctx->fs; - ext2_ino_t ino, next_ino; - struct ext2_inode inode; - struct problem_context pctx; - char *block_buf; - - if ((ino = fs->super->s_last_orphan) == 0) - return 0; - - /* - * Win or lose, we won't be using the head of the orphan inode - * list again. - */ - fs->super->s_last_orphan = 0; - ext2fs_mark_super_dirty(fs); - - /* - * If the filesystem contains errors, don't run the orphan - * list, since the orphan list can't be trusted; and we're - * going to be running a full e2fsck run anyway... - */ - if (fs->super->s_state & EXT2_ERROR_FS) - return 0; - - if ((ino < EXT2_FIRST_INODE(fs->super)) || - (ino > fs->super->s_inodes_count)) { - clear_problem_context(&pctx); - pctx.ino = ino; - fix_problem(ctx, PR_0_ORPHAN_ILLEGAL_HEAD_INODE, &pctx); - return 1; - } - - block_buf = (char *) e2fsck_allocate_memory(ctx, fs->blocksize * 4, - "block iterate buffer"); - e2fsck_read_bitmaps(ctx); - - while (ino) { - e2fsck_read_inode(ctx, ino, &inode, "release_orphan_inodes"); - clear_problem_context(&pctx); - pctx.ino = ino; - pctx.inode = &inode; - pctx.str = inode.i_links_count ? _("Truncating") : - _("Clearing"); - - fix_problem(ctx, PR_0_ORPHAN_CLEAR_INODE, &pctx); - - next_ino = inode.i_dtime; - if (next_ino && - ((next_ino < EXT2_FIRST_INODE(fs->super)) || - (next_ino > fs->super->s_inodes_count))) { - pctx.ino = next_ino; - fix_problem(ctx, PR_0_ORPHAN_ILLEGAL_INODE, &pctx); - goto return_abort; - } - - if (release_inode_blocks(ctx, ino, &inode, block_buf, &pctx)) - goto return_abort; - - if (!inode.i_links_count) { - ext2fs_inode_alloc_stats2(fs, ino, -1, - LINUX_S_ISDIR(inode.i_mode)); - inode.i_dtime = time(0); - } else { - inode.i_dtime = 0; - } - e2fsck_write_inode(ctx, ino, &inode, "delete_file"); - ino = next_ino; - } - ext2fs_free_mem(&block_buf); - return 0; -return_abort: - ext2fs_free_mem(&block_buf); - return 1; -} - -/* - * Check the resize inode to make sure it is sane. We check both for - * the case where on-line resizing is not enabled (in which case the - * resize inode should be cleared) as well as the case where on-line - * resizing is enabled. - */ -void check_resize_inode(e2fsck_t ctx) -{ - ext2_filsys fs = ctx->fs; - struct ext2_inode inode; - struct problem_context pctx; - int i, j, gdt_off, ind_off; - blk_t blk, pblk, expect; - __u32 *dind_buf = 0, *ind_buf; - errcode_t retval; - - clear_problem_context(&pctx); - - /* - * If the resize inode feature isn't set, then - * s_reserved_gdt_blocks must be zero. - */ - if (!(fs->super->s_feature_compat & - EXT2_FEATURE_COMPAT_RESIZE_INODE)) { - if (fs->super->s_reserved_gdt_blocks) { - pctx.num = fs->super->s_reserved_gdt_blocks; - if (fix_problem(ctx, PR_0_NONZERO_RESERVED_GDT_BLOCKS, - &pctx)) { - fs->super->s_reserved_gdt_blocks = 0; - ext2fs_mark_super_dirty(fs); - } - } - } - - /* Read the resizde inode */ - pctx.ino = EXT2_RESIZE_INO; - retval = ext2fs_read_inode(fs, EXT2_RESIZE_INO, &inode); - if (retval) { - if (fs->super->s_feature_compat & - EXT2_FEATURE_COMPAT_RESIZE_INODE) - ctx->flags |= E2F_FLAG_RESIZE_INODE; - return; - } - - /* - * If the resize inode feature isn't set, check to make sure - * the resize inode is cleared; then we're done. - */ - if (!(fs->super->s_feature_compat & - EXT2_FEATURE_COMPAT_RESIZE_INODE)) { - for (i=0; i < EXT2_N_BLOCKS; i++) { - if (inode.i_block[i]) - break; - } - if ((i < EXT2_N_BLOCKS) && - fix_problem(ctx, PR_0_CLEAR_RESIZE_INODE, &pctx)) { - memset(&inode, 0, sizeof(inode)); - e2fsck_write_inode(ctx, EXT2_RESIZE_INO, &inode, - "clear_resize"); - } - return; - } - - /* - * The resize inode feature is enabled; check to make sure the - * only block in use is the double indirect block - */ - blk = inode.i_block[EXT2_DIND_BLOCK]; - for (i=0; i < EXT2_N_BLOCKS; i++) { - if (i != EXT2_DIND_BLOCK && inode.i_block[i]) - break; - } - if ((i < EXT2_N_BLOCKS) || !blk || !inode.i_links_count || - !(inode.i_mode & LINUX_S_IFREG) || - (blk < fs->super->s_first_data_block || - blk >= fs->super->s_blocks_count)) { - resize_inode_invalid: - if (fix_problem(ctx, PR_0_RESIZE_INODE_INVALID, &pctx)) { - memset(&inode, 0, sizeof(inode)); - e2fsck_write_inode(ctx, EXT2_RESIZE_INO, &inode, - "clear_resize"); - ctx->flags |= E2F_FLAG_RESIZE_INODE; - } - if (!(ctx->options & E2F_OPT_READONLY)) { - fs->super->s_state &= ~EXT2_VALID_FS; - ext2fs_mark_super_dirty(fs); - } - goto cleanup; - } - dind_buf = (__u32 *) e2fsck_allocate_memory(ctx, fs->blocksize * 2, - "resize dind buffer"); - ind_buf = (__u32 *) ((char *) dind_buf + fs->blocksize); - - retval = ext2fs_read_ind_block(fs, blk, dind_buf); - if (retval) - goto resize_inode_invalid; - - gdt_off = fs->desc_blocks; - pblk = fs->super->s_first_data_block + 1 + fs->desc_blocks; - for (i = 0; i < fs->super->s_reserved_gdt_blocks / 4; - i++, gdt_off++, pblk++) { - gdt_off %= fs->blocksize/4; - if (dind_buf[gdt_off] != pblk) - goto resize_inode_invalid; - retval = ext2fs_read_ind_block(fs, pblk, ind_buf); - if (retval) - goto resize_inode_invalid; - ind_off = 0; - for (j = 1; j < fs->group_desc_count; j++) { - if (!ext2fs_bg_has_super(fs, j)) - continue; - expect = pblk + (j * fs->super->s_blocks_per_group); - if (ind_buf[ind_off] != expect) - goto resize_inode_invalid; - ind_off++; - } - } - -cleanup: - if (dind_buf) - ext2fs_free_mem(&dind_buf); - - } - -void check_super_block(e2fsck_t ctx) -{ - ext2_filsys fs = ctx->fs; - blk_t first_block, last_block; - struct ext2_super_block *sb = fs->super; - struct ext2_group_desc *gd; - blk_t blocks_per_group = fs->super->s_blocks_per_group; - blk_t bpg_max; - int inodes_per_block; - int ipg_max; - int inode_size; - dgrp_t i; - blk_t should_be; - struct problem_context pctx; - __u32 free_blocks = 0, free_inodes = 0; - - inodes_per_block = EXT2_INODES_PER_BLOCK(fs->super); - ipg_max = inodes_per_block * (blocks_per_group - 4); - if (ipg_max > EXT2_MAX_INODES_PER_GROUP(sb)) - ipg_max = EXT2_MAX_INODES_PER_GROUP(sb); - bpg_max = 8 * EXT2_BLOCK_SIZE(sb); - if (bpg_max > EXT2_MAX_BLOCKS_PER_GROUP(sb)) - bpg_max = EXT2_MAX_BLOCKS_PER_GROUP(sb); - - ctx->invalid_inode_bitmap_flag = (int *) e2fsck_allocate_memory(ctx, - sizeof(int) * fs->group_desc_count, "invalid_inode_bitmap"); - ctx->invalid_block_bitmap_flag = (int *) e2fsck_allocate_memory(ctx, - sizeof(int) * fs->group_desc_count, "invalid_block_bitmap"); - ctx->invalid_inode_table_flag = (int *) e2fsck_allocate_memory(ctx, - sizeof(int) * fs->group_desc_count, "invalid_inode_table"); - - clear_problem_context(&pctx); - - /* - * Verify the super block constants... - */ - check_super_value(ctx, "inodes_count", sb->s_inodes_count, - MIN_CHECK, 1, 0); - check_super_value(ctx, "blocks_count", sb->s_blocks_count, - MIN_CHECK, 1, 0); - check_super_value(ctx, "first_data_block", sb->s_first_data_block, - MAX_CHECK, 0, sb->s_blocks_count); - check_super_value(ctx, "log_block_size", sb->s_log_block_size, - MIN_CHECK | MAX_CHECK, 0, - EXT2_MAX_BLOCK_LOG_SIZE - EXT2_MIN_BLOCK_LOG_SIZE); - check_super_value(ctx, "log_frag_size", sb->s_log_frag_size, - MIN_CHECK | MAX_CHECK, 0, sb->s_log_block_size); - check_super_value(ctx, "frags_per_group", sb->s_frags_per_group, - MIN_CHECK | MAX_CHECK, sb->s_blocks_per_group, - bpg_max); - check_super_value(ctx, "blocks_per_group", sb->s_blocks_per_group, - MIN_CHECK | MAX_CHECK, 8, bpg_max); - check_super_value(ctx, "inodes_per_group", sb->s_inodes_per_group, - MIN_CHECK | MAX_CHECK, inodes_per_block, ipg_max); - check_super_value(ctx, "r_blocks_count", sb->s_r_blocks_count, - MAX_CHECK, 0, sb->s_blocks_count / 2); - check_super_value(ctx, "reserved_gdt_blocks", - sb->s_reserved_gdt_blocks, MAX_CHECK, 0, - fs->blocksize/4); - inode_size = EXT2_INODE_SIZE(sb); - check_super_value(ctx, "inode_size", - inode_size, MIN_CHECK | MAX_CHECK, - EXT2_GOOD_OLD_INODE_SIZE, fs->blocksize); - if (inode_size & (inode_size - 1)) { - pctx.num = inode_size; - pctx.str = "inode_size"; - fix_problem(ctx, PR_0_MISC_CORRUPT_SUPER, &pctx); - ctx->flags |= E2F_FLAG_ABORT; /* never get here! */ - return; - } - - if (!ctx->num_blocks) { - pctx.errcode = e2fsck_get_device_size(ctx); - if (pctx.errcode && pctx.errcode != EXT2_ET_UNIMPLEMENTED) { - fix_problem(ctx, PR_0_GETSIZE_ERROR, &pctx); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - if ((pctx.errcode != EXT2_ET_UNIMPLEMENTED) && - (ctx->num_blocks < sb->s_blocks_count)) { - pctx.blk = sb->s_blocks_count; - pctx.blk2 = ctx->num_blocks; - if (fix_problem(ctx, PR_0_FS_SIZE_WRONG, &pctx)) { - ctx->flags |= E2F_FLAG_ABORT; - return; - } - } - } - - if (sb->s_log_block_size != (__u32) sb->s_log_frag_size) { - pctx.blk = EXT2_BLOCK_SIZE(sb); - pctx.blk2 = EXT2_FRAG_SIZE(sb); - fix_problem(ctx, PR_0_NO_FRAGMENTS, &pctx); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - - should_be = sb->s_frags_per_group >> - (sb->s_log_block_size - sb->s_log_frag_size); - if (sb->s_blocks_per_group != should_be) { - pctx.blk = sb->s_blocks_per_group; - pctx.blk2 = should_be; - fix_problem(ctx, PR_0_BLOCKS_PER_GROUP, &pctx); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - - should_be = (sb->s_log_block_size == 0) ? 1 : 0; - if (sb->s_first_data_block != should_be) { - pctx.blk = sb->s_first_data_block; - pctx.blk2 = should_be; - fix_problem(ctx, PR_0_FIRST_DATA_BLOCK, &pctx); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - - should_be = sb->s_inodes_per_group * fs->group_desc_count; - if (sb->s_inodes_count != should_be) { - pctx.ino = sb->s_inodes_count; - pctx.ino2 = should_be; - if (fix_problem(ctx, PR_0_INODE_COUNT_WRONG, &pctx)) { - sb->s_inodes_count = should_be; - ext2fs_mark_super_dirty(fs); - } - } - - /* - * Verify the group descriptors.... - */ - first_block = sb->s_first_data_block; - last_block = first_block + blocks_per_group; - - for (i = 0, gd=fs->group_desc; i < fs->group_desc_count; i++, gd++) { - pctx.group = i; - - if (i == fs->group_desc_count - 1) - last_block = sb->s_blocks_count; - if ((gd->bg_block_bitmap < first_block) || - (gd->bg_block_bitmap >= last_block)) { - pctx.blk = gd->bg_block_bitmap; - if (fix_problem(ctx, PR_0_BB_NOT_GROUP, &pctx)) - gd->bg_block_bitmap = 0; - } - if (gd->bg_block_bitmap == 0) { - ctx->invalid_block_bitmap_flag[i]++; - ctx->invalid_bitmaps++; - } - if ((gd->bg_inode_bitmap < first_block) || - (gd->bg_inode_bitmap >= last_block)) { - pctx.blk = gd->bg_inode_bitmap; - if (fix_problem(ctx, PR_0_IB_NOT_GROUP, &pctx)) - gd->bg_inode_bitmap = 0; - } - if (gd->bg_inode_bitmap == 0) { - ctx->invalid_inode_bitmap_flag[i]++; - ctx->invalid_bitmaps++; - } - if ((gd->bg_inode_table < first_block) || - ((gd->bg_inode_table + - fs->inode_blocks_per_group - 1) >= last_block)) { - pctx.blk = gd->bg_inode_table; - if (fix_problem(ctx, PR_0_ITABLE_NOT_GROUP, &pctx)) - gd->bg_inode_table = 0; - } - if (gd->bg_inode_table == 0) { - ctx->invalid_inode_table_flag[i]++; - ctx->invalid_bitmaps++; - } - free_blocks += gd->bg_free_blocks_count; - free_inodes += gd->bg_free_inodes_count; - first_block += sb->s_blocks_per_group; - last_block += sb->s_blocks_per_group; - - if ((gd->bg_free_blocks_count > sb->s_blocks_per_group) || - (gd->bg_free_inodes_count > sb->s_inodes_per_group) || - (gd->bg_used_dirs_count > sb->s_inodes_per_group)) - ext2fs_unmark_valid(fs); - - } - - /* - * Update the global counts from the block group counts. This - * is needed for an experimental patch which eliminates - * locking the entire filesystem when allocating blocks or - * inodes; if the filesystem is not unmounted cleanly, the - * global counts may not be accurate. - */ - if ((free_blocks != sb->s_free_blocks_count) || - (free_inodes != sb->s_free_inodes_count)) { - if (ctx->options & E2F_OPT_READONLY) - ext2fs_unmark_valid(fs); - else { - sb->s_free_blocks_count = free_blocks; - sb->s_free_inodes_count = free_inodes; - ext2fs_mark_super_dirty(fs); - } - } - - if ((sb->s_free_blocks_count > sb->s_blocks_count) || - (sb->s_free_inodes_count > sb->s_inodes_count)) - ext2fs_unmark_valid(fs); - - - /* - * If we have invalid bitmaps, set the error state of the - * filesystem. - */ - if (ctx->invalid_bitmaps && !(ctx->options & E2F_OPT_READONLY)) { - sb->s_state &= ~EXT2_VALID_FS; - ext2fs_mark_super_dirty(fs); - } - - clear_problem_context(&pctx); - -#ifndef EXT2_SKIP_UUID - /* - * If the UUID field isn't assigned, assign it. - */ - if (!(ctx->options & E2F_OPT_READONLY) && uuid_is_null(sb->s_uuid)) { - if (fix_problem(ctx, PR_0_ADD_UUID, &pctx)) { - uuid_generate(sb->s_uuid); - ext2fs_mark_super_dirty(fs); - fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY; - } - } -#endif - - /* - * For the Hurd, check to see if the filetype option is set, - * since it doesn't support it. - */ - if (!(ctx->options & E2F_OPT_READONLY) && - fs->super->s_creator_os == EXT2_OS_HURD && - (fs->super->s_feature_incompat & - EXT2_FEATURE_INCOMPAT_FILETYPE)) { - if (fix_problem(ctx, PR_0_HURD_CLEAR_FILETYPE, &pctx)) { - fs->super->s_feature_incompat &= - ~EXT2_FEATURE_INCOMPAT_FILETYPE; - ext2fs_mark_super_dirty(fs); - - } - } - - /* - * If we have any of the compatibility flags set, we need to have a - * revision 1 filesystem. Most kernels will not check the flags on - * a rev 0 filesystem and we may have corruption issues because of - * the incompatible changes to the filesystem. - */ - if (!(ctx->options & E2F_OPT_READONLY) && - fs->super->s_rev_level == EXT2_GOOD_OLD_REV && - (fs->super->s_feature_compat || - fs->super->s_feature_ro_compat || - fs->super->s_feature_incompat) && - fix_problem(ctx, PR_0_FS_REV_LEVEL, &pctx)) { - ext2fs_update_dynamic_rev(fs); - ext2fs_mark_super_dirty(fs); - } - - check_resize_inode(ctx); - - /* - * Clean up any orphan inodes, if present. - */ - if (!(ctx->options & E2F_OPT_READONLY) && release_orphan_inodes(ctx)) { - fs->super->s_state &= ~EXT2_VALID_FS; - ext2fs_mark_super_dirty(fs); - } - - /* - * Move the ext3 journal file, if necessary. - */ - e2fsck_move_ext3_journal(ctx); - return; -} diff --git a/e2fsprogs/e2fsck/swapfs.c b/e2fsprogs/e2fsck/swapfs.c deleted file mode 100644 index a737b9624..000000000 --- a/e2fsprogs/e2fsck/swapfs.c +++ /dev/null @@ -1,268 +0,0 @@ -/* - * swapfs.c --- byte-swap an ext2 filesystem - * - * Copyright 1996, 1997 by Theodore Ts'o - * - * %Begin-Header% - * This file may be redistributed under the terms of the GNU Public - * License. - * %End-Header% - * - */ - -#ifdef HAVE_ERRNO_H -#include -#endif -#include "e2fsck.h" - -#ifdef ENABLE_SWAPFS - -struct swap_block_struct { - ext2_ino_t ino; - int isdir; - errcode_t errcode; - char *dir_buf; - struct ext2_inode *inode; -}; - -/* - * This is a helper function for block_iterate. We mark all of the - * indirect and direct blocks as changed, so that block_iterate will - * write them out. - */ -static int swap_block(ext2_filsys fs, blk_t *block_nr, int blockcnt, - void *priv_data) -{ - errcode_t retval; - - struct swap_block_struct *sb = (struct swap_block_struct *) priv_data; - - if (sb->isdir && (blockcnt >= 0) && *block_nr) { - retval = ext2fs_read_dir_block(fs, *block_nr, sb->dir_buf); - if (retval) { - sb->errcode = retval; - return BLOCK_ABORT; - } - retval = ext2fs_write_dir_block(fs, *block_nr, sb->dir_buf); - if (retval) { - sb->errcode = retval; - return BLOCK_ABORT; - } - } - if (blockcnt >= 0) { - if (blockcnt < EXT2_NDIR_BLOCKS) - return 0; - return BLOCK_CHANGED; - } - if (blockcnt == BLOCK_COUNT_IND) { - if (*block_nr == sb->inode->i_block[EXT2_IND_BLOCK]) - return 0; - return BLOCK_CHANGED; - } - if (blockcnt == BLOCK_COUNT_DIND) { - if (*block_nr == sb->inode->i_block[EXT2_DIND_BLOCK]) - return 0; - return BLOCK_CHANGED; - } - if (blockcnt == BLOCK_COUNT_TIND) { - if (*block_nr == sb->inode->i_block[EXT2_TIND_BLOCK]) - return 0; - return BLOCK_CHANGED; - } - return BLOCK_CHANGED; -} - -/* - * This function is responsible for byte-swapping all of the indirect, - * block pointers. It is also responsible for byte-swapping directories. - */ -static void swap_inode_blocks(e2fsck_t ctx, ext2_ino_t ino, char *block_buf, - struct ext2_inode *inode) -{ - errcode_t retval; - struct swap_block_struct sb; - - sb.ino = ino; - sb.inode = inode; - sb.dir_buf = block_buf + ctx->fs->blocksize*3; - sb.errcode = 0; - sb.isdir = 0; - if (LINUX_S_ISDIR(inode->i_mode)) - sb.isdir = 1; - - retval = ext2fs_block_iterate(ctx->fs, ino, 0, block_buf, - swap_block, &sb); - if (retval) { - com_err("swap_inode_blocks", retval, - _("while calling ext2fs_block_iterate")); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - if (sb.errcode) { - com_err("swap_inode_blocks", sb.errcode, - _("while calling iterator function")); - ctx->flags |= E2F_FLAG_ABORT; - return; - } -} - -static void swap_inodes(e2fsck_t ctx) -{ - ext2_filsys fs = ctx->fs; - dgrp_t group; - unsigned int i; - ext2_ino_t ino = 1; - char *buf, *block_buf; - errcode_t retval; - struct ext2_inode * inode; - - e2fsck_use_inode_shortcuts(ctx, 1); - - retval = ext2fs_get_mem(fs->blocksize * fs->inode_blocks_per_group, - &buf); - if (retval) { - com_err("swap_inodes", retval, - _("while allocating inode buffer")); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - block_buf = (char *) e2fsck_allocate_memory(ctx, fs->blocksize * 4, - "block interate buffer"); - for (group = 0; group < fs->group_desc_count; group++) { - retval = io_channel_read_blk(fs->io, - fs->group_desc[group].bg_inode_table, - fs->inode_blocks_per_group, buf); - if (retval) { - com_err("swap_inodes", retval, - _("while reading inode table (group %d)"), - group); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - inode = (struct ext2_inode *) buf; - for (i=0; i < fs->super->s_inodes_per_group; - i++, ino++, inode++) { - ctx->stashed_ino = ino; - ctx->stashed_inode = inode; - - if (fs->flags & EXT2_FLAG_SWAP_BYTES_READ) - ext2fs_swap_inode(fs, inode, inode, 0); - - /* - * Skip deleted files. - */ - if (inode->i_links_count == 0) - continue; - - if (LINUX_S_ISDIR(inode->i_mode) || - ((inode->i_block[EXT2_IND_BLOCK] || - inode->i_block[EXT2_DIND_BLOCK] || - inode->i_block[EXT2_TIND_BLOCK]) && - ext2fs_inode_has_valid_blocks(inode))) - swap_inode_blocks(ctx, ino, block_buf, inode); - - if (ctx->flags & E2F_FLAG_SIGNAL_MASK) - return; - - if (fs->flags & EXT2_FLAG_SWAP_BYTES_WRITE) - ext2fs_swap_inode(fs, inode, inode, 1); - } - retval = io_channel_write_blk(fs->io, - fs->group_desc[group].bg_inode_table, - fs->inode_blocks_per_group, buf); - if (retval) { - com_err("swap_inodes", retval, - _("while writing inode table (group %d)"), - group); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - } - ext2fs_free_mem(&buf); - ext2fs_free_mem(&block_buf); - e2fsck_use_inode_shortcuts(ctx, 0); - ext2fs_flush_icache(fs); -} - -#if defined(__powerpc__) && defined(EXT2FS_ENABLE_SWAPFS) -/* - * On the PowerPC, the big-endian variant of the ext2 filesystem - * has its bitmaps stored as 32-bit words with bit 0 as the LSB - * of each word. Thus a bitmap with only bit 0 set would be, as - * a string of bytes, 00 00 00 01 00 ... - * To cope with this, we byte-reverse each word of a bitmap if - * we have a big-endian filesystem, that is, if we are *not* - * byte-swapping other word-sized numbers. - */ -#define EXT2_BIG_ENDIAN_BITMAPS -#endif - -#ifdef EXT2_BIG_ENDIAN_BITMAPS -static void ext2fs_swap_bitmap(ext2fs_generic_bitmap bmap) -{ - __u32 *p = (__u32 *) bmap->bitmap; - int n, nbytes = (bmap->end - bmap->start + 7) / 8; - - for (n = nbytes / sizeof(__u32); n > 0; --n, ++p) - *p = ext2fs_swab32(*p); -} -#endif - - -void swap_filesys(e2fsck_t ctx) -{ - ext2_filsys fs = ctx->fs; -#ifdef RESOURCE_TRACK - struct resource_track rtrack; - - init_resource_track(&rtrack); -#endif - - if (!(ctx->options & E2F_OPT_PREEN)) - printf(_("Pass 0: Doing byte-swap of filesystem\n")); - -#ifdef MTRACE - mtrace_print("Byte swap"); -#endif - - if (fs->super->s_mnt_count) { - fprintf(stderr, _("%s: the filesystem must be freshly " - "checked using fsck\n" - "and not mounted before trying to " - "byte-swap it.\n"), ctx->device_name); - ctx->flags |= E2F_FLAG_ABORT; - return; - } - if (fs->flags & EXT2_FLAG_SWAP_BYTES) { - fs->flags &= ~(EXT2_FLAG_SWAP_BYTES| - EXT2_FLAG_SWAP_BYTES_WRITE); - fs->flags |= EXT2_FLAG_SWAP_BYTES_READ; - } else { - fs->flags &= ~EXT2_FLAG_SWAP_BYTES_READ; - fs->flags |= EXT2_FLAG_SWAP_BYTES_WRITE; - } - swap_inodes(ctx); - if (ctx->flags & E2F_FLAG_SIGNAL_MASK) - return; - if (fs->flags & EXT2_FLAG_SWAP_BYTES_WRITE) - fs->flags |= EXT2_FLAG_SWAP_BYTES; - fs->flags &= ~(EXT2_FLAG_SWAP_BYTES_READ| - EXT2_FLAG_SWAP_BYTES_WRITE); - -#ifdef EXT2_BIG_ENDIAN_BITMAPS - e2fsck_read_bitmaps(ctx); - ext2fs_swap_bitmap(fs->inode_map); - ext2fs_swap_bitmap(fs->block_map); - fs->flags |= EXT2_FLAG_BB_DIRTY | EXT2_FLAG_IB_DIRTY; -#endif - fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY; - ext2fs_flush(fs); - fs->flags |= EXT2_FLAG_MASTER_SB_ONLY; - -#ifdef RESOURCE_TRACK - if (ctx->options & E2F_OPT_TIME2) - print_resource_track(_("Byte swap"), &rtrack); -#endif -} - -#endif diff --git a/e2fsprogs/e2fsck/util.c b/e2fsprogs/e2fsck/util.c deleted file mode 100644 index 311156e23..000000000 --- a/e2fsprogs/e2fsck/util.c +++ /dev/null @@ -1,503 +0,0 @@ -/* - * util.c --- miscellaneous utilities - * - * Copyright (C) 1993, 1994, 1995, 1996, 1997 Theodore Ts'o. - * - * %Begin-Header% - * This file may be redistributed under the terms of the GNU Public - * License. - * %End-Header% - */ - -#include -#include -#include -#include - -#ifdef HAVE_CONIO_H -#undef HAVE_TERMIOS_H -#include -#define read_a_char() getch() -#else -#ifdef HAVE_TERMIOS_H -#include -#endif -#include -#endif - -#ifdef HAVE_MALLOC_H -#include -#endif - -#include "e2fsck.h" - -extern e2fsck_t e2fsck_global_ctx; /* Try your very best not to use this! */ - -#include -#include - -#if 0 -void fatal_error(e2fsck_t ctx, const char *msg) -{ - if (msg) - fprintf (stderr, "e2fsck: %s\n", msg); - if (ctx->fs && ctx->fs->io) { - if (ctx->fs->io->magic == EXT2_ET_MAGIC_IO_CHANNEL) - io_channel_flush(ctx->fs->io); - else - fprintf(stderr, "e2fsck: io manager magic bad!\n"); - } - ctx->flags |= E2F_FLAG_ABORT; - if (ctx->flags & E2F_FLAG_SETJMP_OK) - longjmp(ctx->abort_loc, 1); - exit(FSCK_ERROR); -} -#endif - -void *e2fsck_allocate_memory(e2fsck_t ctx, unsigned int size, - const char *description) -{ - void *ret; - char buf[256]; - -#ifdef DEBUG_ALLOCATE_MEMORY - printf("Allocating %d bytes for %s...\n", size, description); -#endif - ret = malloc(size); - if (!ret) { - sprintf(buf, "Can't allocate %s\n", description); - fatal_error(ctx, buf); - } - memset(ret, 0, size); - return ret; -} - -char *string_copy(e2fsck_t ctx EXT2FS_ATTR((unused)), - const char *str, int len) -{ - char *ret; - - if (!str) - return NULL; - if (!len) - len = strlen(str); - ret = malloc(len+1); - if (ret) { - strncpy(ret, str, len); - ret[len] = 0; - } - return ret; -} - -#ifndef HAVE_STRNLEN -/* - * Incredibly, libc5 doesn't appear to have strnlen. So we have to - * provide our own. - */ -int e2fsck_strnlen(const char * s, int count) -{ - const char *cp = s; - - while (count-- && *cp) - cp++; - return cp - s; -} -#endif - -#ifndef HAVE_CONIO_H -static int read_a_char(void) -{ - char c; - int r; - int fail = 0; - - while(1) { - if (e2fsck_global_ctx && - (e2fsck_global_ctx->flags & E2F_FLAG_CANCEL)) { - return 3; - } - r = read(0, &c, 1); - if (r == 1) - return c; - if (fail++ > 100) - break; - } - return EOF; -} -#endif - -int ask_yn(const char * string, int def) -{ - int c; - const char *defstr; - const char *short_yes = _("yY"); - const char *short_no = _("nN"); - -#ifdef HAVE_TERMIOS_H - struct termios termios, tmp; - - tcgetattr (0, &termios); - tmp = termios; - tmp.c_lflag &= ~(ICANON | ECHO); - tmp.c_cc[VMIN] = 1; - tmp.c_cc[VTIME] = 0; - tcsetattr (0, TCSANOW, &tmp); -#endif - - if (def == 1) - defstr = _(_("")); - else if (def == 0) - defstr = _(_("")); - else - defstr = _(" (y/n)"); - printf("%s%s? ", string, defstr); - while (1) { - fflush (stdout); - if ((c = read_a_char()) == EOF) - break; - if (c == 3) { -#ifdef HAVE_TERMIOS_H - tcsetattr (0, TCSANOW, &termios); -#endif - if (e2fsck_global_ctx && - e2fsck_global_ctx->flags & E2F_FLAG_SETJMP_OK) { - puts("\n"); - longjmp(e2fsck_global_ctx->abort_loc, 1); - } - puts(_("cancelled!\n")); - return 0; - } - if (strchr(short_yes, (char) c)) { - def = 1; - break; - } - else if (strchr(short_no, (char) c)) { - def = 0; - break; - } - else if ((c == ' ' || c == '\n') && (def != -1)) - break; - } - if (def) - puts(_("yes\n")); - else - puts (_("no\n")); -#ifdef HAVE_TERMIOS_H - tcsetattr (0, TCSANOW, &termios); -#endif - return def; -} - -int ask (e2fsck_t ctx, const char * string, int def) -{ - if (ctx->options & E2F_OPT_NO) { - printf (_("%s? no\n\n"), string); - return 0; - } - if (ctx->options & E2F_OPT_YES) { - printf (_("%s? yes\n\n"), string); - return 1; - } - if (ctx->options & E2F_OPT_PREEN) { - printf ("%s? %s\n\n", string, def ? _("yes") : _("no")); - return def; - } - return ask_yn(string, def); -} - -void e2fsck_read_bitmaps(e2fsck_t ctx) -{ - ext2_filsys fs = ctx->fs; - errcode_t retval; - - if (ctx->invalid_bitmaps) { - com_err(ctx->program_name, 0, - _("e2fsck_read_bitmaps: illegal bitmap block(s) for %s"), - ctx->device_name); - fatal_error(ctx, 0); - } - - ehandler_operation(_("reading inode and block bitmaps")); - retval = ext2fs_read_bitmaps(fs); - ehandler_operation(0); - if (retval) { - com_err(ctx->program_name, retval, - _("while retrying to read bitmaps for %s"), - ctx->device_name); - fatal_error(ctx, 0); - } -} - -void e2fsck_write_bitmaps(e2fsck_t ctx) -{ - ext2_filsys fs = ctx->fs; - errcode_t retval; - - if (ext2fs_test_bb_dirty(fs)) { - ehandler_operation(_("writing block bitmaps")); - retval = ext2fs_write_block_bitmap(fs); - ehandler_operation(0); - if (retval) { - com_err(ctx->program_name, retval, - _("while retrying to write block bitmaps for %s"), - ctx->device_name); - fatal_error(ctx, 0); - } - } - - if (ext2fs_test_ib_dirty(fs)) { - ehandler_operation(_("writing inode bitmaps")); - retval = ext2fs_write_inode_bitmap(fs); - ehandler_operation(0); - if (retval) { - com_err(ctx->program_name, retval, - _("while retrying to write inode bitmaps for %s"), - ctx->device_name); - fatal_error(ctx, 0); - } - } -} - -void preenhalt(e2fsck_t ctx) -{ - ext2_filsys fs = ctx->fs; - - if (!(ctx->options & E2F_OPT_PREEN)) - return; - fprintf(stderr, _("\n\n%s: UNEXPECTED INCONSISTENCY; " - "RUN fsck MANUALLY.\n\t(i.e., without -a or -p options)\n"), - ctx->device_name); - if (fs != NULL) { - fs->super->s_state |= EXT2_ERROR_FS; - ext2fs_mark_super_dirty(fs); - ext2fs_close(fs); - } - exit(FSCK_UNCORRECTED); -} - -#ifdef RESOURCE_TRACK -void init_resource_track(struct resource_track *track) -{ -#ifdef HAVE_GETRUSAGE - struct rusage r; -#endif - - track->brk_start = sbrk(0); - gettimeofday(&track->time_start, 0); -#ifdef HAVE_GETRUSAGE -#ifdef sun - memset(&r, 0, sizeof(struct rusage)); -#endif - getrusage(RUSAGE_SELF, &r); - track->user_start = r.ru_utime; - track->system_start = r.ru_stime; -#else - track->user_start.tv_sec = track->user_start.tv_usec = 0; - track->system_start.tv_sec = track->system_start.tv_usec = 0; -#endif -} - -#ifdef __GNUC__ -#define _INLINE_ __inline__ -#else -#define _INLINE_ -#endif - -static _INLINE_ float timeval_subtract(struct timeval *tv1, - struct timeval *tv2) -{ - return ((tv1->tv_sec - tv2->tv_sec) + - ((float) (tv1->tv_usec - tv2->tv_usec)) / 1000000); -} - -void print_resource_track(const char *desc, struct resource_track *track) -{ -#ifdef HAVE_GETRUSAGE - struct rusage r; -#endif -#ifdef HAVE_MALLINFO - struct mallinfo malloc_info; -#endif - struct timeval time_end; - - gettimeofday(&time_end, 0); - - if (desc) - printf("%s: ", desc); - -#ifdef HAVE_MALLINFO -#define kbytes(x) (((x) + 1023) / 1024) - - malloc_info = mallinfo(); - printf(_("Memory used: %dk/%dk (%dk/%dk), "), - kbytes(malloc_info.arena), kbytes(malloc_info.hblkhd), - kbytes(malloc_info.uordblks), kbytes(malloc_info.fordblks)); -#else - printf(_("Memory used: %d, "), - (int) (((char *) sbrk(0)) - ((char *) track->brk_start))); -#endif -#ifdef HAVE_GETRUSAGE - getrusage(RUSAGE_SELF, &r); - - printf(_("time: %5.2f/%5.2f/%5.2f\n"), - timeval_subtract(&time_end, &track->time_start), - timeval_subtract(&r.ru_utime, &track->user_start), - timeval_subtract(&r.ru_stime, &track->system_start)); -#else - printf(_("elapsed time: %6.3f\n"), - timeval_subtract(&time_end, &track->time_start)); -#endif -} -#endif /* RESOURCE_TRACK */ - -void e2fsck_read_inode(e2fsck_t ctx, unsigned long ino, - struct ext2_inode * inode, const char *proc) -{ - int retval; - - retval = ext2fs_read_inode(ctx->fs, ino, inode); - if (retval) { - com_err("ext2fs_read_inode", retval, - _("while reading inode %ld in %s"), ino, proc); - fatal_error(ctx, 0); - } -} - -extern void e2fsck_write_inode_full(e2fsck_t ctx, unsigned long ino, - struct ext2_inode * inode, int bufsize, - const char *proc) -{ - int retval; - - retval = ext2fs_write_inode_full(ctx->fs, ino, inode, bufsize); - if (retval) { - com_err("ext2fs_write_inode", retval, - _("while writing inode %ld in %s"), ino, proc); - fatal_error(ctx, 0); - } -} - -extern void e2fsck_write_inode(e2fsck_t ctx, unsigned long ino, - struct ext2_inode * inode, const char *proc) -{ - int retval; - - retval = ext2fs_write_inode(ctx->fs, ino, inode); - if (retval) { - com_err("ext2fs_write_inode", retval, - _("while writing inode %ld in %s"), ino, proc); - fatal_error(ctx, 0); - } -} - -#ifdef MTRACE -void mtrace_print(char *mesg) -{ - FILE *malloc_get_mallstream(); - FILE *f = malloc_get_mallstream(); - - if (f) - fprintf(f, "============= %s\n", mesg); -} -#endif - -blk_t get_backup_sb(e2fsck_t ctx, ext2_filsys fs, const char *name, - io_manager manager) -{ - struct ext2_super_block *sb; - io_channel io = NULL; - void *buf = NULL; - int blocksize; - blk_t superblock, ret_sb = 8193; - - if (fs && fs->super) { - ret_sb = (fs->super->s_blocks_per_group + - fs->super->s_first_data_block); - if (ctx) { - ctx->superblock = ret_sb; - ctx->blocksize = fs->blocksize; - } - return ret_sb; - } - - if (ctx) { - if (ctx->blocksize) { - ret_sb = ctx->blocksize * 8; - if (ctx->blocksize == 1024) - ret_sb++; - ctx->superblock = ret_sb; - return ret_sb; - } - ctx->superblock = ret_sb; - ctx->blocksize = 1024; - } - - if (!name || !manager) - goto cleanup; - - if (manager->open(name, 0, &io) != 0) - goto cleanup; - - if (ext2fs_get_mem(SUPERBLOCK_SIZE, &buf)) - goto cleanup; - sb = (struct ext2_super_block *) buf; - - for (blocksize = EXT2_MIN_BLOCK_SIZE; - blocksize <= EXT2_MAX_BLOCK_SIZE ; blocksize *= 2) { - superblock = blocksize*8; - if (blocksize == 1024) - superblock++; - io_channel_set_blksize(io, blocksize); - if (io_channel_read_blk(io, superblock, - -SUPERBLOCK_SIZE, buf)) - continue; -#ifdef EXT2FS_ENABLE_SWAPFS - if (sb->s_magic == ext2fs_swab16(EXT2_SUPER_MAGIC)) - ext2fs_swap_super(sb); -#endif - if (sb->s_magic == EXT2_SUPER_MAGIC) { - ret_sb = superblock; - if (ctx) { - ctx->superblock = superblock; - ctx->blocksize = blocksize; - } - break; - } - } - -cleanup: - if (io) - io_channel_close(io); - if (buf) - ext2fs_free_mem(&buf); - return (ret_sb); -} - -/* - * Given a mode, return the ext2 file type - */ -int ext2_file_type(unsigned int mode) -{ - if (LINUX_S_ISREG(mode)) - return EXT2_FT_REG_FILE; - - if (LINUX_S_ISDIR(mode)) - return EXT2_FT_DIR; - - if (LINUX_S_ISCHR(mode)) - return EXT2_FT_CHRDEV; - - if (LINUX_S_ISBLK(mode)) - return EXT2_FT_BLKDEV; - - if (LINUX_S_ISLNK(mode)) - return EXT2_FT_SYMLINK; - - if (LINUX_S_ISFIFO(mode)) - return EXT2_FT_FIFO; - - if (LINUX_S_ISSOCK(mode)) - return EXT2_FT_SOCK; - - return 0; -}