From 464df1d5e5ab1322e2dd0a7796939fff1aeefa9a Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 17:49:25 +0200 Subject: Adding upstream version 1.47.0. Signed-off-by: Daniel Baumann --- e2fsck/Android.bp | 86 + e2fsck/CHANGES | 53 + e2fsck/Makefile.in | 656 +++++++ e2fsck/badblocks.c | 142 ++ e2fsck/dirinfo.c | 489 +++++ e2fsck/dx_dirinfo.c | 154 ++ e2fsck/e2fsck.8.in | 509 ++++++ e2fsck/e2fsck.c | 271 +++ e2fsck/e2fsck.conf.5.in | 501 ++++++ e2fsck/e2fsck.h | 738 ++++++++ e2fsck/ea_refcount.c | 476 +++++ e2fsck/ehandler.c | 133 ++ e2fsck/emptydir.c | 194 ++ e2fsck/encrypted_files.c | 458 +++++ e2fsck/extend.c | 83 + e2fsck/extents.c | 620 +++++++ e2fsck/flushb.c | 67 + e2fsck/iscan.c | 265 +++ e2fsck/jfs_user.h | 321 ++++ e2fsck/journal.c | 1900 ++++++++++++++++++++ e2fsck/logfile.c | 411 +++++ e2fsck/message.c | 556 ++++++ e2fsck/mtrace.awk | 37 + e2fsck/mtrace.c | 160 ++ e2fsck/mtrace.h | 231 +++ e2fsck/pass1.c | 4466 ++++++++++++++++++++++++++++++++++++++++++++++ e2fsck/pass1b.c | 1046 +++++++++++ e2fsck/pass2.c | 2171 ++++++++++++++++++++++ e2fsck/pass3.c | 921 ++++++++++ e2fsck/pass4.c | 302 ++++ e2fsck/pass5.c | 958 ++++++++++ e2fsck/problem.c | 2756 ++++++++++++++++++++++++++++ e2fsck/problem.h | 1359 ++++++++++++++ e2fsck/problemP.h | 48 + e2fsck/quota.c | 127 ++ e2fsck/readahead.c | 254 +++ e2fsck/recovery.c | 931 ++++++++++ e2fsck/region.c | 236 +++ e2fsck/rehash.c | 1189 ++++++++++++ e2fsck/revoke.c | 743 ++++++++ e2fsck/scantest.c | 141 ++ e2fsck/sigcatcher.c | 446 +++++ e2fsck/super.c | 1461 +++++++++++++++ e2fsck/unix.c | 2171 ++++++++++++++++++++++ e2fsck/util.c | 900 ++++++++++ 45 files changed, 32137 insertions(+) create mode 100644 e2fsck/Android.bp create mode 100644 e2fsck/CHANGES create mode 100644 e2fsck/Makefile.in create mode 100644 e2fsck/badblocks.c create mode 100644 e2fsck/dirinfo.c create mode 100644 e2fsck/dx_dirinfo.c create mode 100644 e2fsck/e2fsck.8.in create mode 100644 e2fsck/e2fsck.c create mode 100644 e2fsck/e2fsck.conf.5.in create mode 100644 e2fsck/e2fsck.h create mode 100644 e2fsck/ea_refcount.c create mode 100644 e2fsck/ehandler.c create mode 100644 e2fsck/emptydir.c create mode 100644 e2fsck/encrypted_files.c create mode 100644 e2fsck/extend.c create mode 100644 e2fsck/extents.c create mode 100644 e2fsck/flushb.c create mode 100644 e2fsck/iscan.c create mode 100644 e2fsck/jfs_user.h create mode 100644 e2fsck/journal.c create mode 100644 e2fsck/logfile.c create mode 100644 e2fsck/message.c create mode 100644 e2fsck/mtrace.awk create mode 100644 e2fsck/mtrace.c create mode 100644 e2fsck/mtrace.h create mode 100644 e2fsck/pass1.c create mode 100644 e2fsck/pass1b.c create mode 100644 e2fsck/pass2.c create mode 100644 e2fsck/pass3.c create mode 100644 e2fsck/pass4.c create mode 100644 e2fsck/pass5.c create mode 100644 e2fsck/problem.c create mode 100644 e2fsck/problem.h create mode 100644 e2fsck/problemP.h create mode 100644 e2fsck/quota.c create mode 100644 e2fsck/readahead.c create mode 100644 e2fsck/recovery.c create mode 100644 e2fsck/region.c create mode 100644 e2fsck/rehash.c create mode 100644 e2fsck/revoke.c create mode 100644 e2fsck/scantest.c create mode 100644 e2fsck/sigcatcher.c create mode 100644 e2fsck/super.c create mode 100644 e2fsck/unix.c create mode 100644 e2fsck/util.c (limited to 'e2fsck') diff --git a/e2fsck/Android.bp b/e2fsck/Android.bp new file mode 100644 index 0000000..b42de9d --- /dev/null +++ b/e2fsck/Android.bp @@ -0,0 +1,86 @@ +// Copyright 2017 The Android Open Source Project + +//######################## +// Build the e2fsck binary + +package { + // See: http://go/android-license-faq + // A large-scale-change added 'default_applicable_licenses' to import + // all of the 'license_kinds' from "external_e2fsprogs_license" + // to get the below license kinds: + // SPDX-license-identifier-GPL + // SPDX-license-identifier-GPL-2.0 + // SPDX-license-identifier-LGPL + default_applicable_licenses: ["external_e2fsprogs_license"], +} + +cc_defaults { + name: "e2fsck-defaults", + defaults: ["e2fsprogs-defaults"], + srcs: [ + "e2fsck.c", + "super.c", + "pass1.c", + "pass1b.c", + "pass2.c", + "pass3.c", + "pass4.c", + "pass5.c", + "logfile.c", + "journal.c", + "recovery.c", + "revoke.c", + "badblocks.c", + "util.c", + "unix.c", + "dirinfo.c", + "dx_dirinfo.c", + "ehandler.c", + "problem.c", + "message.c", + "ea_refcount.c", + "quota.c", + "rehash.c", + "region.c", + "sigcatcher.c", + "readahead.c", + "extents.c", + "encrypted_files.c", + ], +} + +e2fsck_libs = [ + "libext2fs", + "libext2_blkid", + "libext2_com_err", + "libext2_uuid", + "libext2_quota", + "libext2_e2p", +] + +cc_binary { + name: "e2fsck", + host_supported: true, + vendor_ramdisk_available: true, + defaults: ["e2fsck-defaults"], + + shared_libs: e2fsck_libs, + required: ["badblocks"], +} + +cc_binary { + name: "e2fsck_static", + static_executable: true, + defaults: ["e2fsck-defaults"], + + static_libs: e2fsck_libs, +} + +cc_binary { + name: "e2fsck_ramdisk", + stem: "e2fsck", + static_executable: true, + ramdisk: true, + defaults: ["e2fsck-defaults"], + static_libs: e2fsck_libs, +} diff --git a/e2fsck/CHANGES b/e2fsck/CHANGES new file mode 100644 index 0000000..eb4cfde --- /dev/null +++ b/e2fsck/CHANGES @@ -0,0 +1,53 @@ +[tytso:19940101.1200EST] + +Add new options -l and -L, to append to and modify the bad-blocks list. + +Fix bugs in bad-block cloning. + +[tytso:19931230.1832EST] + +Clean up e2fsck and library to be clean even when compiling with full +warnings enabled. + +Make e2fsck deal with zero-length directories correctly. + +Deleted inodes from old ext2fs code (inodes with dtime set but +non-zero link count) are detected, and the user is given the +opportunity to clear them. + +The last bit in the last group of the block bitmap padding was not +being checked; now fixed. + +The free_blocks and free_inodes count in the last group weren't being +checked. Now fixed. + +[tytso:19931101.0007EST] + +Fixed bugs with root reallocation; previously the parent pointers in +the dirinfo structure would get corrupted, causing many different '..' +links to be wrong. Also, the inode link count for the root directory +wasn't always being set correctly. (All of this would be fixed on +the second e2fsck, however). + +Fixed to recognize filesystem corruption caused by mke2fs 0.2b (where +/ and /lost+found had non-zero dtime entries). Offers to fix /'s +dtime entry. + +e2fsck will now expand the /lost+found directory if it runs out of room. + +Fixed dependency on BLOCK_SIZE in pass2. e2fsck will now handle 4k +filesystems w/o problems. + +e2fsck will now move bad blocks found in the inode bitmaps, block +bitmaps, and in the inode tables. (Can't handle bad blocks found in +the superblock and the group descriptors.) (Doesn't update alternate +superblocks, group descriptors.) + +e2fsck now supports the -b option, to allow a user to specify an +alternate superblock. + +The -B option now specifies the blocksize of the filesystem. (If not +specified, and the -b option is specified, e2fsck will attempt to +search through various blocksizes to find the correct one.) + +Added manual page. diff --git a/e2fsck/Makefile.in b/e2fsck/Makefile.in new file mode 100644 index 0000000..fbb7b15 --- /dev/null +++ b/e2fsck/Makefile.in @@ -0,0 +1,656 @@ +# +# Makefile for e2fsck +# + +srcdir = @srcdir@ +top_srcdir = @top_srcdir@ +VPATH = @srcdir@ +top_builddir = .. +my_dir = e2fsck +INSTALL = @INSTALL@ +MKDIR_P = @MKDIR_P@ + +@MCONFIG@ + +PROGS= e2fsck +MANPAGES= e2fsck.8 +FMANPAGES= e2fsck.conf.5 + +LIBS= $(LIBSUPPORT) $(LIBEXT2FS) $(LIBCOM_ERR) $(LIBBLKID) $(LIBUUID) \ + $(LIBINTL) $(LIBE2P) $(LIBMAGIC) $(SYSLIBS) +DEPLIBS= $(DEPLIBSUPPORT) $(LIBEXT2FS) $(DEPLIBCOM_ERR) $(DEPLIBBLKID) \ + $(DEPLIBUUID) $(DEPLIBE2P) + +STATIC_LIBS= $(STATIC_LIBSUPPORT) $(STATIC_LIBEXT2FS) $(STATIC_LIBCOM_ERR) \ + $(STATIC_LIBBLKID) $(STATIC_LIBUUID) $(LIBINTL) $(STATIC_LIBE2P) \ + $(LIBMAGIC) $(SYSLIBS) +STATIC_DEPLIBS= $(DEPSTATIC_LIBSUPPORT) $(STATIC_LIBEXT2FS) \ + $(DEPSTATIC_LIBCOM_ERR) $(DEPSTATIC_LIBBLKID) \ + $(DEPSTATIC_LIBUUID) $(DEPSTATIC_LIBE2P) + +PROFILED_LIBS= $(PROFILED_LIBSUPPORT) $(PROFILED_LIBEXT2FS) \ + $(PROFILED_LIBCOM_ERR) $(PROFILED_LIBBLKID) $(PROFILED_LIBUUID) \ + $(PROFILED_LIBE2P) $(LIBINTL) $(LIBMAGIC) $(SYSLIBS) +PROFILED_DEPLIBS= $(DEPPROFILED_LIBSUPPORT) $(PROFILED_LIBEXT2FS) \ + $(DEPPROFILED_LIBCOM_ERR) $(DEPPROFILED_LIBBLKID) \ + $(DEPPROFILED_LIBUUID) $(DEPPROFILED_LIBE2P) + +COMPILE_ET= _ET_DIR_OVERRIDE=$(srcdir)/../lib/et/et ../lib/et/compile_et + +.c.o: + $(E) " CC $<" + $(Q) $(CC) -c $(ALL_CFLAGS) $< -o $@ + $(Q) $(CHECK_CMD) $(ALL_CFLAGS) $< + $(Q) $(CPPCHECK_CMD) $(CPPFLAGS) $< +@PROFILE_CMT@ $(Q) $(CC) $(ALL_CFLAGS) -g -pg -o profiled/$*.o -c $< + +# +# Flags for doing mtrace --- uncomment to produce mtracing e2fsck +# Note: The optimization flags must include -g +# +#MTRACE= -DMTRACE +#MTRACE_OBJ= mtrace.o +#MTRACE_SRC= $(srcdir)/mtrace.c +#OPT= -g + +# +# Flags for doing mcheck --- uncomment to produce mchecking e2fsck +# Note: The optimization flags must include -g +# +#MCHECK= -DMCHECK + +OBJS= unix.o e2fsck.o super.o pass1.o pass1b.o pass2.o \ + pass3.o pass4.o pass5.o journal.o badblocks.o util.o dirinfo.o \ + dx_dirinfo.o ehandler.o problem.o message.o quota.o recovery.o \ + region.o revoke.o ea_refcount.o rehash.o \ + logfile.o sigcatcher.o $(MTRACE_OBJ) readahead.o \ + extents.o encrypted_files.o + +PROFILED_OBJS= profiled/unix.o profiled/e2fsck.o \ + profiled/super.o profiled/pass1.o profiled/pass1b.o \ + profiled/pass2.o profiled/pass3.o profiled/pass4.o profiled/pass5.o \ + profiled/journal.o profiled/badblocks.o profiled/util.o \ + profiled/dirinfo.o profiled/dx_dirinfo.o profiled/ehandler.o \ + profiled/message.o profiled/problem.o profiled/quota.o \ + profiled/recovery.o profiled/region.o profiled/revoke.o \ + profiled/ea_refcount.o profiled/rehash.o \ + profiled/logfile.o profiled/sigcatcher.o \ + profiled/readahead.o profiled/extents.o \ + profiled/encrypted_files.o + +SRCS= $(srcdir)/e2fsck.c \ + $(srcdir)/super.c \ + $(srcdir)/pass1.c \ + $(srcdir)/pass1b.c \ + $(srcdir)/pass2.c \ + $(srcdir)/pass3.c \ + $(srcdir)/pass4.c \ + $(srcdir)/pass5.c \ + $(srcdir)/journal.c \ + $(srcdir)/recovery.c \ + $(srcdir)/revoke.c \ + $(srcdir)/badblocks.c \ + $(srcdir)/util.c \ + $(srcdir)/unix.c \ + $(srcdir)/dirinfo.c \ + $(srcdir)/dx_dirinfo.c \ + $(srcdir)/ehandler.c \ + $(srcdir)/problem.c \ + $(srcdir)/message.c \ + $(srcdir)/ea_refcount.c \ + $(srcdir)/rehash.c \ + $(srcdir)/readahead.c \ + $(srcdir)/region.c \ + $(srcdir)/sigcatcher.c \ + $(srcdir)/logfile.c \ + $(srcdir)/quota.c \ + $(srcdir)/extents.c \ + $(srcdir)/encrypted_files.c \ + $(MTRACE_SRC) + +all:: profiled $(PROGS) e2fsck $(MANPAGES) $(FMANPAGES) + +@PROFILE_CMT@all:: e2fsck.profiled + +all-static:: e2fsck.static + +e2fsck: $(OBJS) $(DEPLIBS) + $(E) " LD $@" + $(Q) $(LD) $(ALL_LDFLAGS) $(RDYNAMIC) -o e2fsck $(OBJS) $(LIBS) + +e2fsck.static: $(OBJS) $(STATIC_DEPLIBS) + $(E) " LD $@" + $(Q) $(LD) $(LDFLAGS_STATIC) -o e2fsck.static $(OBJS) $(STATIC_LIBS) + +e2fsck.profiled: $(OBJS) $(PROFILED_DEPLIBS) + $(E) " LD $@" + $(Q) $(LD) $(ALL_LDFLAGS) -g -pg -o e2fsck.profiled $(PROFILED_OBJS) \ + $(PROFILED_LIBS) + +tst_sigcatcher: $(srcdir)/sigcatcher.c sigcatcher.o + $(E) " CC $@" + $(Q) $(CC) $(ALL_CFLAGS) $(ALL_LDFLAGS) $(RDYNAMIC) \ + $(srcdir)/sigcatcher.c -DDEBUG -o tst_sigcatcher + +tst_problem: $(srcdir)/problem.c $(srcdir)/problem.h $(LIBEXT2FS) \ + $(DEPLIBCOM_ERR) + $(Q) $(CC) $(ALL_CFLAGS) $(ALL_LDFLAGS) -o tst_problem \ + $(srcdir)/problem.c -DUNITTEST $(LIBEXT2FS) $(LIBCOM_ERR) \ + $(LIBINTL) $(SYSLIBS) + +tst_refcount: ea_refcount.c $(DEPLIBCOM_ERR) $(LIBEXT2FS) + $(E) " LD $@" + $(Q) $(CC) -o tst_refcount $(srcdir)/ea_refcount.c \ + $(ALL_CFLAGS) $(ALL_LDFLAGS) -DTEST_PROGRAM \ + $(LIBCOM_ERR) $(LIBEXT2FS) $(SYSLIBS) + +tst_logfile: $(srcdir)/logfile.c + $(E) " LD $@" + $(Q) $(CC) -o tst_logfile $(srcdir)/logfile.c \ + $(ALL_CFLAGS) $(ALL_LDFLAGS) -DTEST_PROGRAM $(SYSLIBS) + +tst_region: region.c $(LIBEXT2FS) $(DEPLIBCOM_ERR) + $(E) " LD $@" + $(Q) $(CC) -o tst_region $(srcdir)/region.c \ + $(ALL_CFLAGS) $(ALL_LDFLAGS) -DTEST_PROGRAM \ + $(LIBEXT2FS) $(LIBCOM_ERR) $(SYSLIBS) + +fullcheck check:: tst_refcount tst_region tst_problem + $(TESTENV) ./tst_refcount + $(TESTENV) ./tst_region + $(TESTENV) ./tst_problem + +extend: extend.o + $(E) " LD $@" + $(Q) $(LD) $(ALL_LDFLAGS) -o extend extend.o $(CHECKLIB) + +flushb: flushb.o + $(E) " LD $@" + $(Q) $(LD) $(ALL_LDFLAGS) -o flushb flushb.o $(CHECKLIB) + +iscan: iscan.o $(DEPLIBS) + $(E) " LD $@" + $(Q) $(LD) $(ALL_LDFLAGS) -o iscan iscan.o $(LIBS) + +iscan.static: iscan.o $(STATIC_DEPLIBS) + $(E) " LD $@" + $(Q) $(LD) $(LDFLAGS_STATIC) -o iscan.static iscan.o $(STATIC_LIBS) + +test_profile: $(srcdir)/profile.c profile_helpers.o argv_parse.o \ + prof_err.o profile.h $(DEPSTATIC_LIBCOM_ERR) + $(E) " LD $@" + $(Q) $(CC) -o test_profile -DDEBUG_PROGRAM $(srcdir)/profile.c prof_err.o \ + profile_helpers.o argv_parse.o $(STATIC_LIBCOM_ERR) \ + $(ALL_CFLAGS) + +profiled: +@PROFILE_CMT@ $(E) " MKDIR $@" +@PROFILE_CMT@ $(Q) mkdir profiled + +e2fsck.8: $(DEP_SUBSTITUTE) $(srcdir)/e2fsck.8.in + $(E) " SUBST $@" + $(Q) $(SUBSTITUTE_UPTIME) $(srcdir)/e2fsck.8.in e2fsck.8 + +e2fsck.conf.5: $(DEP_SUBSTITUTE) $(srcdir)/e2fsck.conf.5.in + $(E) " SUBST $@" + $(Q) $(SUBSTITUTE_UPTIME) $(srcdir)/e2fsck.conf.5.in e2fsck.conf.5 + +installdirs: + $(E) " MKDIR_P $(root_sbindir) $(man8dir)" + $(Q) $(MKDIR_P) $(DESTDIR)$(root_sbindir) \ + $(DESTDIR)$(man8dir) $(DESTDIR)$(man5dir) + +install: $(PROGS) $(MANPAGES) $(FMANPAGES) installdirs + $(Q) for i in $(PROGS); do \ + $(ES) " INSTALL $(root_sbindir)/$$i"; \ + $(INSTALL_PROGRAM) $$i $(DESTDIR)$(root_sbindir)/$$i; \ + done + $(Q) for i in ext2 ext3 ext4; do \ + $(ES) " LINK $(root_sbindir)/fsck.$$i"; \ + (cd $(DESTDIR)$(root_sbindir); \ + $(LN) $(LINK_INSTALL_FLAGS) e2fsck fsck.$$i); \ + done + $(Q) for i in $(MANPAGES); do \ + for j in $(COMPRESS_EXT); do \ + $(RM) -f $(DESTDIR)$(man8dir)/$$i.$$j; \ + done; \ + $(ES) " INSTALL_DATA $(man8dir)/$$i"; \ + $(INSTALL_DATA) $$i $(DESTDIR)$(man8dir)/$$i; \ + done + $(Q) for i in $(FMANPAGES); do \ + for j in $(COMPRESS_EXT); do \ + $(RM) -f $(DESTDIR)$(man5dir)/$$i.$$j; \ + done; \ + $(ES) " INSTALL_DATA $(man5dir)/$$i"; \ + $(INSTALL_DATA) $$i $(DESTDIR)$(man5dir)/$$i; \ + done + $(Q) for i in ext2 ext3 ext4; do \ + $(ES) " LINK $(man8dir)/fsck.$$i.8"; \ + (cd $(DESTDIR)$(man8dir); \ + $(LN) $(LINK_INSTALL_FLAGS) e2fsck.8 fsck.$$i.8); \ + done + +install-strip: install + $(Q) for i in $(PROGS); do \ + $(ES) " STRIP $(root_sbindir)/$$i"; \ + $(STRIP) $(DESTDIR)$(root_sbindir)/$$i; \ + done + +uninstall: + for i in $(PROGS); do \ + $(RM) -f $(DESTDIR)$(root_sbindir)/$$i; \ + done + $(RM) -f $(DESTDIR)$(root_sbindir)/fsck.ext2 \ + $(DESTDIR)$(root_sbindir)/fsck.ext3 \ + $(DESTDIR)$(root_sbindir)/fsck.ext4 + for i in $(MANPAGES); do \ + $(RM) -f $(DESTDIR)$(man8dir)/$$i; \ + done + for i in $(FMANPAGES); do \ + $(RM) -f $(DESTDIR)$(man5dir)/$$i; \ + done + $(RM) -f $(DESTDIR)$(root_sbindir)/fsck.ext2 \ + $(DESTDIR)$(root_sbindir)/fsck.ext3 \ + $(DESTDIR)$(root_sbindir)/fsck.ext4 + +clean:: + $(RM) -f $(PROGS) \#* *\# *.s *.o *.a *~ core e2fsck.static \ + e2fsck.shared e2fsck.profiled flushb e2fsck.8 \ + tst_problem tst_region tst_refcount tst_crc32 \ + gen_crc32table e2fsck.conf.5 \ + prof_err.c prof_err.h test_profile iscan iscan.static + $(RM) -rf profiled + +mostlyclean: clean +distclean: clean + $(RM) -f .depend Makefile $(srcdir)/TAGS $(srcdir)/Makefile.in.old + +# +++ Dependency line eater +++ +# +# Makefile dependencies follow. This must be the last section in +# the Makefile.in file +# +e2fsck.o: $(srcdir)/e2fsck.c $(top_builddir)/lib/config.h \ + $(top_builddir)/lib/dirpaths.h $(srcdir)/e2fsck.h \ + $(top_srcdir)/lib/ext2fs/ext2_fs.h $(top_builddir)/lib/ext2fs/ext2_types.h \ + $(top_srcdir)/lib/ext2fs/ext2fs.h $(top_srcdir)/lib/ext2fs/ext3_extents.h \ + $(top_srcdir)/lib/et/com_err.h $(top_srcdir)/lib/ext2fs/ext2_io.h \ + $(top_builddir)/lib/ext2fs/ext2_err.h \ + $(top_srcdir)/lib/ext2fs/ext2_ext_attr.h $(top_srcdir)/lib/ext2fs/hashmap.h \ + $(top_srcdir)/lib/ext2fs/bitops.h $(top_srcdir)/lib/support/profile.h \ + $(top_builddir)/lib/support/prof_err.h $(top_srcdir)/lib/support/quotaio.h \ + $(top_srcdir)/lib/support/dqblk_v2.h \ + $(top_srcdir)/lib/support/quotaio_tree.h \ + $(top_srcdir)/lib/ext2fs/fast_commit.h $(top_srcdir)/lib/ext2fs/jfs_compat.h \ + $(top_srcdir)/lib/ext2fs/kernel-list.h $(top_srcdir)/lib/ext2fs/compiler.h \ + $(srcdir)/problem.h +super.o: $(srcdir)/super.c $(top_builddir)/lib/config.h \ + $(top_builddir)/lib/dirpaths.h $(srcdir)/e2fsck.h \ + $(top_srcdir)/lib/ext2fs/ext2_fs.h $(top_builddir)/lib/ext2fs/ext2_types.h \ + $(top_srcdir)/lib/ext2fs/ext2fs.h $(top_srcdir)/lib/ext2fs/ext3_extents.h \ + $(top_srcdir)/lib/et/com_err.h $(top_srcdir)/lib/ext2fs/ext2_io.h \ + $(top_builddir)/lib/ext2fs/ext2_err.h \ + $(top_srcdir)/lib/ext2fs/ext2_ext_attr.h $(top_srcdir)/lib/ext2fs/hashmap.h \ + $(top_srcdir)/lib/ext2fs/bitops.h $(top_srcdir)/lib/support/profile.h \ + $(top_builddir)/lib/support/prof_err.h $(top_srcdir)/lib/support/quotaio.h \ + $(top_srcdir)/lib/support/dqblk_v2.h \ + $(top_srcdir)/lib/support/quotaio_tree.h \ + $(top_srcdir)/lib/ext2fs/fast_commit.h $(top_srcdir)/lib/ext2fs/jfs_compat.h \ + $(top_srcdir)/lib/ext2fs/kernel-list.h $(top_srcdir)/lib/ext2fs/compiler.h \ + $(srcdir)/problem.h +pass1.o: $(srcdir)/pass1.c $(top_builddir)/lib/config.h \ + $(top_builddir)/lib/dirpaths.h $(srcdir)/e2fsck.h \ + $(top_srcdir)/lib/ext2fs/ext2_fs.h $(top_builddir)/lib/ext2fs/ext2_types.h \ + $(top_srcdir)/lib/ext2fs/ext2fs.h $(top_srcdir)/lib/ext2fs/ext3_extents.h \ + $(top_srcdir)/lib/et/com_err.h $(top_srcdir)/lib/ext2fs/ext2_io.h \ + $(top_builddir)/lib/ext2fs/ext2_err.h \ + $(top_srcdir)/lib/ext2fs/ext2_ext_attr.h $(top_srcdir)/lib/ext2fs/hashmap.h \ + $(top_srcdir)/lib/ext2fs/bitops.h $(top_srcdir)/lib/support/profile.h \ + $(top_builddir)/lib/support/prof_err.h $(top_srcdir)/lib/support/quotaio.h \ + $(top_srcdir)/lib/support/dqblk_v2.h \ + $(top_srcdir)/lib/support/quotaio_tree.h \ + $(top_srcdir)/lib/ext2fs/fast_commit.h $(top_srcdir)/lib/ext2fs/jfs_compat.h \ + $(top_srcdir)/lib/ext2fs/kernel-list.h $(top_srcdir)/lib/ext2fs/compiler.h \ + $(top_srcdir)/lib/e2p/e2p.h $(srcdir)/problem.h +pass1b.o: $(srcdir)/pass1b.c $(top_builddir)/lib/config.h \ + $(top_builddir)/lib/dirpaths.h $(top_srcdir)/lib/et/com_err.h \ + $(srcdir)/e2fsck.h $(top_srcdir)/lib/ext2fs/ext2_fs.h \ + $(top_builddir)/lib/ext2fs/ext2_types.h $(top_srcdir)/lib/ext2fs/ext2fs.h \ + $(top_srcdir)/lib/ext2fs/ext3_extents.h $(top_srcdir)/lib/ext2fs/ext2_io.h \ + $(top_builddir)/lib/ext2fs/ext2_err.h \ + $(top_srcdir)/lib/ext2fs/ext2_ext_attr.h $(top_srcdir)/lib/ext2fs/hashmap.h \ + $(top_srcdir)/lib/ext2fs/bitops.h $(top_srcdir)/lib/support/profile.h \ + $(top_builddir)/lib/support/prof_err.h $(top_srcdir)/lib/support/quotaio.h \ + $(top_srcdir)/lib/support/dqblk_v2.h \ + $(top_srcdir)/lib/support/quotaio_tree.h \ + $(top_srcdir)/lib/ext2fs/fast_commit.h $(top_srcdir)/lib/ext2fs/jfs_compat.h \ + $(top_srcdir)/lib/ext2fs/kernel-list.h $(top_srcdir)/lib/ext2fs/compiler.h \ + $(srcdir)/problem.h $(top_srcdir)/lib/support/dict.h +pass2.o: $(srcdir)/pass2.c $(top_builddir)/lib/config.h \ + $(top_builddir)/lib/dirpaths.h $(srcdir)/e2fsck.h \ + $(top_srcdir)/lib/ext2fs/ext2_fs.h $(top_builddir)/lib/ext2fs/ext2_types.h \ + $(top_srcdir)/lib/ext2fs/ext2fs.h $(top_srcdir)/lib/ext2fs/ext3_extents.h \ + $(top_srcdir)/lib/et/com_err.h $(top_srcdir)/lib/ext2fs/ext2_io.h \ + $(top_builddir)/lib/ext2fs/ext2_err.h \ + $(top_srcdir)/lib/ext2fs/ext2_ext_attr.h $(top_srcdir)/lib/ext2fs/hashmap.h \ + $(top_srcdir)/lib/ext2fs/bitops.h $(top_srcdir)/lib/support/profile.h \ + $(top_builddir)/lib/support/prof_err.h $(top_srcdir)/lib/support/quotaio.h \ + $(top_srcdir)/lib/support/dqblk_v2.h \ + $(top_srcdir)/lib/support/quotaio_tree.h \ + $(top_srcdir)/lib/ext2fs/fast_commit.h $(top_srcdir)/lib/ext2fs/jfs_compat.h \ + $(top_srcdir)/lib/ext2fs/kernel-list.h $(top_srcdir)/lib/ext2fs/compiler.h \ + $(srcdir)/problem.h $(top_srcdir)/lib/support/dict.h +pass3.o: $(srcdir)/pass3.c $(top_builddir)/lib/config.h \ + $(top_builddir)/lib/dirpaths.h $(srcdir)/e2fsck.h \ + $(top_srcdir)/lib/ext2fs/ext2_fs.h $(top_builddir)/lib/ext2fs/ext2_types.h \ + $(top_srcdir)/lib/ext2fs/ext2fs.h $(top_srcdir)/lib/ext2fs/ext3_extents.h \ + $(top_srcdir)/lib/et/com_err.h $(top_srcdir)/lib/ext2fs/ext2_io.h \ + $(top_builddir)/lib/ext2fs/ext2_err.h \ + $(top_srcdir)/lib/ext2fs/ext2_ext_attr.h $(top_srcdir)/lib/ext2fs/hashmap.h \ + $(top_srcdir)/lib/ext2fs/bitops.h $(top_srcdir)/lib/support/profile.h \ + $(top_builddir)/lib/support/prof_err.h $(top_srcdir)/lib/support/quotaio.h \ + $(top_srcdir)/lib/support/dqblk_v2.h \ + $(top_srcdir)/lib/support/quotaio_tree.h \ + $(top_srcdir)/lib/ext2fs/fast_commit.h $(top_srcdir)/lib/ext2fs/jfs_compat.h \ + $(top_srcdir)/lib/ext2fs/kernel-list.h $(top_srcdir)/lib/ext2fs/compiler.h \ + $(srcdir)/problem.h +pass4.o: $(srcdir)/pass4.c $(top_builddir)/lib/config.h \ + $(top_builddir)/lib/dirpaths.h $(srcdir)/e2fsck.h \ + $(top_srcdir)/lib/ext2fs/ext2_fs.h $(top_builddir)/lib/ext2fs/ext2_types.h \ + $(top_srcdir)/lib/ext2fs/ext2fs.h $(top_srcdir)/lib/ext2fs/ext3_extents.h \ + $(top_srcdir)/lib/et/com_err.h $(top_srcdir)/lib/ext2fs/ext2_io.h \ + $(top_builddir)/lib/ext2fs/ext2_err.h \ + $(top_srcdir)/lib/ext2fs/ext2_ext_attr.h $(top_srcdir)/lib/ext2fs/hashmap.h \ + $(top_srcdir)/lib/ext2fs/bitops.h $(top_srcdir)/lib/support/profile.h \ + $(top_builddir)/lib/support/prof_err.h $(top_srcdir)/lib/support/quotaio.h \ + $(top_srcdir)/lib/support/dqblk_v2.h \ + $(top_srcdir)/lib/support/quotaio_tree.h \ + $(top_srcdir)/lib/ext2fs/fast_commit.h $(top_srcdir)/lib/ext2fs/jfs_compat.h \ + $(top_srcdir)/lib/ext2fs/kernel-list.h $(top_srcdir)/lib/ext2fs/compiler.h \ + $(srcdir)/problem.h +pass5.o: $(srcdir)/pass5.c $(top_builddir)/lib/config.h \ + $(top_builddir)/lib/dirpaths.h $(srcdir)/e2fsck.h \ + $(top_srcdir)/lib/ext2fs/ext2_fs.h $(top_builddir)/lib/ext2fs/ext2_types.h \ + $(top_srcdir)/lib/ext2fs/ext2fs.h $(top_srcdir)/lib/ext2fs/ext3_extents.h \ + $(top_srcdir)/lib/et/com_err.h $(top_srcdir)/lib/ext2fs/ext2_io.h \ + $(top_builddir)/lib/ext2fs/ext2_err.h \ + $(top_srcdir)/lib/ext2fs/ext2_ext_attr.h $(top_srcdir)/lib/ext2fs/hashmap.h \ + $(top_srcdir)/lib/ext2fs/bitops.h $(top_srcdir)/lib/support/profile.h \ + $(top_builddir)/lib/support/prof_err.h $(top_srcdir)/lib/support/quotaio.h \ + $(top_srcdir)/lib/support/dqblk_v2.h \ + $(top_srcdir)/lib/support/quotaio_tree.h \ + $(top_srcdir)/lib/ext2fs/fast_commit.h $(top_srcdir)/lib/ext2fs/jfs_compat.h \ + $(top_srcdir)/lib/ext2fs/kernel-list.h $(top_srcdir)/lib/ext2fs/compiler.h \ + $(srcdir)/problem.h +journal.o: $(srcdir)/journal.c $(top_builddir)/lib/config.h \ + $(top_builddir)/lib/dirpaths.h $(srcdir)/jfs_user.h $(srcdir)/e2fsck.h \ + $(top_srcdir)/lib/ext2fs/ext2_fs.h $(top_builddir)/lib/ext2fs/ext2_types.h \ + $(top_srcdir)/lib/ext2fs/ext2fs.h $(top_srcdir)/lib/ext2fs/ext3_extents.h \ + $(top_srcdir)/lib/et/com_err.h $(top_srcdir)/lib/ext2fs/ext2_io.h \ + $(top_builddir)/lib/ext2fs/ext2_err.h \ + $(top_srcdir)/lib/ext2fs/ext2_ext_attr.h $(top_srcdir)/lib/ext2fs/hashmap.h \ + $(top_srcdir)/lib/ext2fs/bitops.h $(top_srcdir)/lib/support/profile.h \ + $(top_builddir)/lib/support/prof_err.h $(top_srcdir)/lib/support/quotaio.h \ + $(top_srcdir)/lib/support/dqblk_v2.h \ + $(top_srcdir)/lib/support/quotaio_tree.h \ + $(top_srcdir)/lib/ext2fs/fast_commit.h $(top_srcdir)/lib/ext2fs/jfs_compat.h \ + $(top_srcdir)/lib/ext2fs/kernel-list.h $(top_srcdir)/lib/ext2fs/compiler.h \ + $(top_srcdir)/lib/ext2fs/kernel-jbd.h $(srcdir)/problem.h +recovery.o: $(srcdir)/recovery.c $(srcdir)/jfs_user.h \ + $(top_builddir)/lib/config.h $(top_builddir)/lib/dirpaths.h \ + $(srcdir)/e2fsck.h $(top_srcdir)/lib/ext2fs/ext2_fs.h \ + $(top_builddir)/lib/ext2fs/ext2_types.h $(top_srcdir)/lib/ext2fs/ext2fs.h \ + $(top_srcdir)/lib/ext2fs/ext3_extents.h $(top_srcdir)/lib/et/com_err.h \ + $(top_srcdir)/lib/ext2fs/ext2_io.h $(top_builddir)/lib/ext2fs/ext2_err.h \ + $(top_srcdir)/lib/ext2fs/ext2_ext_attr.h $(top_srcdir)/lib/ext2fs/hashmap.h \ + $(top_srcdir)/lib/ext2fs/bitops.h $(top_srcdir)/lib/support/profile.h \ + $(top_builddir)/lib/support/prof_err.h $(top_srcdir)/lib/support/quotaio.h \ + $(top_srcdir)/lib/support/dqblk_v2.h \ + $(top_srcdir)/lib/support/quotaio_tree.h \ + $(top_srcdir)/lib/ext2fs/fast_commit.h $(top_srcdir)/lib/ext2fs/jfs_compat.h \ + $(top_srcdir)/lib/ext2fs/kernel-list.h $(top_srcdir)/lib/ext2fs/compiler.h \ + $(top_srcdir)/lib/ext2fs/kernel-jbd.h +revoke.o: $(srcdir)/revoke.c $(srcdir)/jfs_user.h \ + $(top_builddir)/lib/config.h $(top_builddir)/lib/dirpaths.h \ + $(srcdir)/e2fsck.h $(top_srcdir)/lib/ext2fs/ext2_fs.h \ + $(top_builddir)/lib/ext2fs/ext2_types.h $(top_srcdir)/lib/ext2fs/ext2fs.h \ + $(top_srcdir)/lib/ext2fs/ext3_extents.h $(top_srcdir)/lib/et/com_err.h \ + $(top_srcdir)/lib/ext2fs/ext2_io.h $(top_builddir)/lib/ext2fs/ext2_err.h \ + $(top_srcdir)/lib/ext2fs/ext2_ext_attr.h $(top_srcdir)/lib/ext2fs/hashmap.h \ + $(top_srcdir)/lib/ext2fs/bitops.h $(top_srcdir)/lib/support/profile.h \ + $(top_builddir)/lib/support/prof_err.h $(top_srcdir)/lib/support/quotaio.h \ + $(top_srcdir)/lib/support/dqblk_v2.h \ + $(top_srcdir)/lib/support/quotaio_tree.h \ + $(top_srcdir)/lib/ext2fs/fast_commit.h $(top_srcdir)/lib/ext2fs/jfs_compat.h \ + $(top_srcdir)/lib/ext2fs/kernel-list.h $(top_srcdir)/lib/ext2fs/compiler.h \ + $(top_srcdir)/lib/ext2fs/kernel-jbd.h +badblocks.o: $(srcdir)/badblocks.c $(top_builddir)/lib/config.h \ + $(top_builddir)/lib/dirpaths.h $(top_srcdir)/lib/et/com_err.h \ + $(srcdir)/e2fsck.h $(top_srcdir)/lib/ext2fs/ext2_fs.h \ + $(top_builddir)/lib/ext2fs/ext2_types.h $(top_srcdir)/lib/ext2fs/ext2fs.h \ + $(top_srcdir)/lib/ext2fs/ext3_extents.h $(top_srcdir)/lib/ext2fs/ext2_io.h \ + $(top_builddir)/lib/ext2fs/ext2_err.h \ + $(top_srcdir)/lib/ext2fs/ext2_ext_attr.h $(top_srcdir)/lib/ext2fs/hashmap.h \ + $(top_srcdir)/lib/ext2fs/bitops.h $(top_srcdir)/lib/support/profile.h \ + $(top_builddir)/lib/support/prof_err.h $(top_srcdir)/lib/support/quotaio.h \ + $(top_srcdir)/lib/support/dqblk_v2.h \ + $(top_srcdir)/lib/support/quotaio_tree.h \ + $(top_srcdir)/lib/ext2fs/fast_commit.h $(top_srcdir)/lib/ext2fs/jfs_compat.h \ + $(top_srcdir)/lib/ext2fs/kernel-list.h $(top_srcdir)/lib/ext2fs/compiler.h +util.o: $(srcdir)/util.c $(top_builddir)/lib/config.h \ + $(top_builddir)/lib/dirpaths.h $(srcdir)/e2fsck.h \ + $(top_srcdir)/lib/ext2fs/ext2_fs.h $(top_builddir)/lib/ext2fs/ext2_types.h \ + $(top_srcdir)/lib/ext2fs/ext2fs.h $(top_srcdir)/lib/ext2fs/ext3_extents.h \ + $(top_srcdir)/lib/et/com_err.h $(top_srcdir)/lib/ext2fs/ext2_io.h \ + $(top_builddir)/lib/ext2fs/ext2_err.h \ + $(top_srcdir)/lib/ext2fs/ext2_ext_attr.h $(top_srcdir)/lib/ext2fs/hashmap.h \ + $(top_srcdir)/lib/ext2fs/bitops.h $(top_srcdir)/lib/support/profile.h \ + $(top_builddir)/lib/support/prof_err.h $(top_srcdir)/lib/support/quotaio.h \ + $(top_srcdir)/lib/support/dqblk_v2.h \ + $(top_srcdir)/lib/support/quotaio_tree.h \ + $(top_srcdir)/lib/ext2fs/fast_commit.h $(top_srcdir)/lib/ext2fs/jfs_compat.h \ + $(top_srcdir)/lib/ext2fs/kernel-list.h $(top_srcdir)/lib/ext2fs/compiler.h +unix.o: $(srcdir)/unix.c $(top_builddir)/lib/config.h \ + $(top_builddir)/lib/dirpaths.h $(top_srcdir)/lib/e2p/e2p.h \ + $(top_srcdir)/lib/ext2fs/ext2_fs.h $(top_builddir)/lib/ext2fs/ext2_types.h \ + $(top_srcdir)/lib/et/com_err.h $(top_srcdir)/lib/support/plausible.h \ + $(top_srcdir)/lib/support/devname.h $(srcdir)/e2fsck.h \ + $(top_srcdir)/lib/ext2fs/ext2fs.h $(top_srcdir)/lib/ext2fs/ext3_extents.h \ + $(top_srcdir)/lib/ext2fs/ext2_io.h $(top_builddir)/lib/ext2fs/ext2_err.h \ + $(top_srcdir)/lib/ext2fs/ext2_ext_attr.h $(top_srcdir)/lib/ext2fs/hashmap.h \ + $(top_srcdir)/lib/ext2fs/bitops.h $(top_srcdir)/lib/support/profile.h \ + $(top_builddir)/lib/support/prof_err.h $(top_srcdir)/lib/support/quotaio.h \ + $(top_srcdir)/lib/support/dqblk_v2.h \ + $(top_srcdir)/lib/support/quotaio_tree.h \ + $(top_srcdir)/lib/ext2fs/fast_commit.h $(top_srcdir)/lib/ext2fs/jfs_compat.h \ + $(top_srcdir)/lib/ext2fs/kernel-list.h $(top_srcdir)/lib/ext2fs/compiler.h \ + $(srcdir)/problem.h $(srcdir)/jfs_user.h \ + $(top_srcdir)/lib/ext2fs/kernel-jbd.h $(top_srcdir)/version.h +dirinfo.o: $(srcdir)/dirinfo.c $(top_builddir)/lib/config.h \ + $(top_builddir)/lib/dirpaths.h $(srcdir)/e2fsck.h \ + $(top_srcdir)/lib/ext2fs/ext2_fs.h $(top_builddir)/lib/ext2fs/ext2_types.h \ + $(top_srcdir)/lib/ext2fs/ext2fs.h $(top_srcdir)/lib/ext2fs/ext3_extents.h \ + $(top_srcdir)/lib/et/com_err.h $(top_srcdir)/lib/ext2fs/ext2_io.h \ + $(top_builddir)/lib/ext2fs/ext2_err.h \ + $(top_srcdir)/lib/ext2fs/ext2_ext_attr.h $(top_srcdir)/lib/ext2fs/hashmap.h \ + $(top_srcdir)/lib/ext2fs/bitops.h $(top_srcdir)/lib/support/profile.h \ + $(top_builddir)/lib/support/prof_err.h $(top_srcdir)/lib/support/quotaio.h \ + $(top_srcdir)/lib/support/dqblk_v2.h \ + $(top_srcdir)/lib/support/quotaio_tree.h \ + $(top_srcdir)/lib/ext2fs/fast_commit.h $(top_srcdir)/lib/ext2fs/jfs_compat.h \ + $(top_srcdir)/lib/ext2fs/kernel-list.h $(top_srcdir)/lib/ext2fs/compiler.h \ + $(top_srcdir)/lib/ext2fs/tdb.h +dx_dirinfo.o: $(srcdir)/dx_dirinfo.c $(top_builddir)/lib/config.h \ + $(top_builddir)/lib/dirpaths.h $(srcdir)/e2fsck.h \ + $(top_srcdir)/lib/ext2fs/ext2_fs.h $(top_builddir)/lib/ext2fs/ext2_types.h \ + $(top_srcdir)/lib/ext2fs/ext2fs.h $(top_srcdir)/lib/ext2fs/ext3_extents.h \ + $(top_srcdir)/lib/et/com_err.h $(top_srcdir)/lib/ext2fs/ext2_io.h \ + $(top_builddir)/lib/ext2fs/ext2_err.h \ + $(top_srcdir)/lib/ext2fs/ext2_ext_attr.h $(top_srcdir)/lib/ext2fs/hashmap.h \ + $(top_srcdir)/lib/ext2fs/bitops.h $(top_srcdir)/lib/support/profile.h \ + $(top_builddir)/lib/support/prof_err.h $(top_srcdir)/lib/support/quotaio.h \ + $(top_srcdir)/lib/support/dqblk_v2.h \ + $(top_srcdir)/lib/support/quotaio_tree.h \ + $(top_srcdir)/lib/ext2fs/fast_commit.h $(top_srcdir)/lib/ext2fs/jfs_compat.h \ + $(top_srcdir)/lib/ext2fs/kernel-list.h $(top_srcdir)/lib/ext2fs/compiler.h +ehandler.o: $(srcdir)/ehandler.c $(top_builddir)/lib/config.h \ + $(top_builddir)/lib/dirpaths.h $(srcdir)/e2fsck.h \ + $(top_srcdir)/lib/ext2fs/ext2_fs.h $(top_builddir)/lib/ext2fs/ext2_types.h \ + $(top_srcdir)/lib/ext2fs/ext2fs.h $(top_srcdir)/lib/ext2fs/ext3_extents.h \ + $(top_srcdir)/lib/et/com_err.h $(top_srcdir)/lib/ext2fs/ext2_io.h \ + $(top_builddir)/lib/ext2fs/ext2_err.h \ + $(top_srcdir)/lib/ext2fs/ext2_ext_attr.h $(top_srcdir)/lib/ext2fs/hashmap.h \ + $(top_srcdir)/lib/ext2fs/bitops.h $(top_srcdir)/lib/support/profile.h \ + $(top_builddir)/lib/support/prof_err.h $(top_srcdir)/lib/support/quotaio.h \ + $(top_srcdir)/lib/support/dqblk_v2.h \ + $(top_srcdir)/lib/support/quotaio_tree.h \ + $(top_srcdir)/lib/ext2fs/fast_commit.h $(top_srcdir)/lib/ext2fs/jfs_compat.h \ + $(top_srcdir)/lib/ext2fs/kernel-list.h $(top_srcdir)/lib/ext2fs/compiler.h +problem.o: $(srcdir)/problem.c $(top_builddir)/lib/config.h \ + $(top_builddir)/lib/dirpaths.h $(srcdir)/e2fsck.h \ + $(top_srcdir)/lib/ext2fs/ext2_fs.h $(top_builddir)/lib/ext2fs/ext2_types.h \ + $(top_srcdir)/lib/ext2fs/ext2fs.h $(top_srcdir)/lib/ext2fs/ext3_extents.h \ + $(top_srcdir)/lib/et/com_err.h $(top_srcdir)/lib/ext2fs/ext2_io.h \ + $(top_builddir)/lib/ext2fs/ext2_err.h \ + $(top_srcdir)/lib/ext2fs/ext2_ext_attr.h $(top_srcdir)/lib/ext2fs/hashmap.h \ + $(top_srcdir)/lib/ext2fs/bitops.h $(top_srcdir)/lib/support/profile.h \ + $(top_builddir)/lib/support/prof_err.h $(top_srcdir)/lib/support/quotaio.h \ + $(top_srcdir)/lib/support/dqblk_v2.h \ + $(top_srcdir)/lib/support/quotaio_tree.h \ + $(top_srcdir)/lib/ext2fs/fast_commit.h $(top_srcdir)/lib/ext2fs/jfs_compat.h \ + $(top_srcdir)/lib/ext2fs/kernel-list.h $(top_srcdir)/lib/ext2fs/compiler.h \ + $(srcdir)/problem.h $(srcdir)/problemP.h +message.o: $(srcdir)/message.c $(top_builddir)/lib/config.h \ + $(top_builddir)/lib/dirpaths.h $(top_srcdir)/lib/support/quotaio.h \ + $(top_srcdir)/lib/ext2fs/ext2_fs.h $(top_builddir)/lib/ext2fs/ext2_types.h \ + $(top_srcdir)/lib/ext2fs/ext2fs.h $(top_srcdir)/lib/ext2fs/ext3_extents.h \ + $(top_srcdir)/lib/et/com_err.h $(top_srcdir)/lib/ext2fs/ext2_io.h \ + $(top_builddir)/lib/ext2fs/ext2_err.h \ + $(top_srcdir)/lib/ext2fs/ext2_ext_attr.h $(top_srcdir)/lib/ext2fs/hashmap.h \ + $(top_srcdir)/lib/ext2fs/bitops.h $(top_srcdir)/lib/support/dqblk_v2.h \ + $(top_srcdir)/lib/support/quotaio_tree.h $(srcdir)/e2fsck.h \ + $(top_srcdir)/lib/support/profile.h $(top_builddir)/lib/support/prof_err.h \ + $(top_srcdir)/lib/ext2fs/fast_commit.h $(top_srcdir)/lib/ext2fs/jfs_compat.h \ + $(top_srcdir)/lib/ext2fs/kernel-list.h $(top_srcdir)/lib/ext2fs/compiler.h \ + $(srcdir)/problem.h +ea_refcount.o: $(srcdir)/ea_refcount.c $(top_builddir)/lib/config.h \ + $(top_builddir)/lib/dirpaths.h $(srcdir)/e2fsck.h \ + $(top_srcdir)/lib/ext2fs/ext2_fs.h $(top_builddir)/lib/ext2fs/ext2_types.h \ + $(top_srcdir)/lib/ext2fs/ext2fs.h $(top_srcdir)/lib/ext2fs/ext3_extents.h \ + $(top_srcdir)/lib/et/com_err.h $(top_srcdir)/lib/ext2fs/ext2_io.h \ + $(top_builddir)/lib/ext2fs/ext2_err.h \ + $(top_srcdir)/lib/ext2fs/ext2_ext_attr.h $(top_srcdir)/lib/ext2fs/hashmap.h \ + $(top_srcdir)/lib/ext2fs/bitops.h $(top_srcdir)/lib/support/profile.h \ + $(top_builddir)/lib/support/prof_err.h $(top_srcdir)/lib/support/quotaio.h \ + $(top_srcdir)/lib/support/dqblk_v2.h \ + $(top_srcdir)/lib/support/quotaio_tree.h \ + $(top_srcdir)/lib/ext2fs/fast_commit.h $(top_srcdir)/lib/ext2fs/jfs_compat.h \ + $(top_srcdir)/lib/ext2fs/kernel-list.h $(top_srcdir)/lib/ext2fs/compiler.h +rehash.o: $(srcdir)/rehash.c $(top_builddir)/lib/config.h \ + $(top_builddir)/lib/dirpaths.h $(srcdir)/e2fsck.h \ + $(top_srcdir)/lib/ext2fs/ext2_fs.h $(top_builddir)/lib/ext2fs/ext2_types.h \ + $(top_srcdir)/lib/ext2fs/ext2fs.h $(top_srcdir)/lib/ext2fs/ext3_extents.h \ + $(top_srcdir)/lib/et/com_err.h $(top_srcdir)/lib/ext2fs/ext2_io.h \ + $(top_builddir)/lib/ext2fs/ext2_err.h \ + $(top_srcdir)/lib/ext2fs/ext2_ext_attr.h $(top_srcdir)/lib/ext2fs/hashmap.h \ + $(top_srcdir)/lib/ext2fs/bitops.h $(top_srcdir)/lib/support/profile.h \ + $(top_builddir)/lib/support/prof_err.h $(top_srcdir)/lib/support/quotaio.h \ + $(top_srcdir)/lib/support/dqblk_v2.h \ + $(top_srcdir)/lib/support/quotaio_tree.h \ + $(top_srcdir)/lib/ext2fs/fast_commit.h $(top_srcdir)/lib/ext2fs/jfs_compat.h \ + $(top_srcdir)/lib/ext2fs/kernel-list.h $(top_srcdir)/lib/ext2fs/compiler.h \ + $(srcdir)/problem.h $(top_srcdir)/lib/support/sort_r.h +readahead.o: $(srcdir)/readahead.c $(top_builddir)/lib/config.h \ + $(top_builddir)/lib/dirpaths.h $(srcdir)/e2fsck.h \ + $(top_srcdir)/lib/ext2fs/ext2_fs.h $(top_builddir)/lib/ext2fs/ext2_types.h \ + $(top_srcdir)/lib/ext2fs/ext2fs.h $(top_srcdir)/lib/ext2fs/ext3_extents.h \ + $(top_srcdir)/lib/et/com_err.h $(top_srcdir)/lib/ext2fs/ext2_io.h \ + $(top_builddir)/lib/ext2fs/ext2_err.h \ + $(top_srcdir)/lib/ext2fs/ext2_ext_attr.h $(top_srcdir)/lib/ext2fs/hashmap.h \ + $(top_srcdir)/lib/ext2fs/bitops.h $(top_srcdir)/lib/support/profile.h \ + $(top_builddir)/lib/support/prof_err.h $(top_srcdir)/lib/support/quotaio.h \ + $(top_srcdir)/lib/support/dqblk_v2.h \ + $(top_srcdir)/lib/support/quotaio_tree.h \ + $(top_srcdir)/lib/ext2fs/fast_commit.h $(top_srcdir)/lib/ext2fs/jfs_compat.h \ + $(top_srcdir)/lib/ext2fs/kernel-list.h $(top_srcdir)/lib/ext2fs/compiler.h +region.o: $(srcdir)/region.c $(top_builddir)/lib/config.h \ + $(top_builddir)/lib/dirpaths.h $(srcdir)/e2fsck.h \ + $(top_srcdir)/lib/ext2fs/ext2_fs.h $(top_builddir)/lib/ext2fs/ext2_types.h \ + $(top_srcdir)/lib/ext2fs/ext2fs.h $(top_srcdir)/lib/ext2fs/ext3_extents.h \ + $(top_srcdir)/lib/et/com_err.h $(top_srcdir)/lib/ext2fs/ext2_io.h \ + $(top_builddir)/lib/ext2fs/ext2_err.h \ + $(top_srcdir)/lib/ext2fs/ext2_ext_attr.h $(top_srcdir)/lib/ext2fs/hashmap.h \ + $(top_srcdir)/lib/ext2fs/bitops.h $(top_srcdir)/lib/support/profile.h \ + $(top_builddir)/lib/support/prof_err.h $(top_srcdir)/lib/support/quotaio.h \ + $(top_srcdir)/lib/support/dqblk_v2.h \ + $(top_srcdir)/lib/support/quotaio_tree.h \ + $(top_srcdir)/lib/ext2fs/fast_commit.h $(top_srcdir)/lib/ext2fs/jfs_compat.h \ + $(top_srcdir)/lib/ext2fs/kernel-list.h $(top_srcdir)/lib/ext2fs/compiler.h +sigcatcher.o: $(srcdir)/sigcatcher.c $(top_builddir)/lib/config.h \ + $(top_builddir)/lib/dirpaths.h $(srcdir)/e2fsck.h \ + $(top_srcdir)/lib/ext2fs/ext2_fs.h $(top_builddir)/lib/ext2fs/ext2_types.h \ + $(top_srcdir)/lib/ext2fs/ext2fs.h $(top_srcdir)/lib/ext2fs/ext3_extents.h \ + $(top_srcdir)/lib/et/com_err.h $(top_srcdir)/lib/ext2fs/ext2_io.h \ + $(top_builddir)/lib/ext2fs/ext2_err.h \ + $(top_srcdir)/lib/ext2fs/ext2_ext_attr.h $(top_srcdir)/lib/ext2fs/hashmap.h \ + $(top_srcdir)/lib/ext2fs/bitops.h $(top_srcdir)/lib/support/profile.h \ + $(top_builddir)/lib/support/prof_err.h $(top_srcdir)/lib/support/quotaio.h \ + $(top_srcdir)/lib/support/dqblk_v2.h \ + $(top_srcdir)/lib/support/quotaio_tree.h \ + $(top_srcdir)/lib/ext2fs/fast_commit.h $(top_srcdir)/lib/ext2fs/jfs_compat.h \ + $(top_srcdir)/lib/ext2fs/kernel-list.h $(top_srcdir)/lib/ext2fs/compiler.h +logfile.o: $(srcdir)/logfile.c $(top_builddir)/lib/config.h \ + $(top_builddir)/lib/dirpaths.h $(srcdir)/e2fsck.h \ + $(top_srcdir)/lib/ext2fs/ext2_fs.h $(top_builddir)/lib/ext2fs/ext2_types.h \ + $(top_srcdir)/lib/ext2fs/ext2fs.h $(top_srcdir)/lib/ext2fs/ext3_extents.h \ + $(top_srcdir)/lib/et/com_err.h $(top_srcdir)/lib/ext2fs/ext2_io.h \ + $(top_builddir)/lib/ext2fs/ext2_err.h \ + $(top_srcdir)/lib/ext2fs/ext2_ext_attr.h $(top_srcdir)/lib/ext2fs/hashmap.h \ + $(top_srcdir)/lib/ext2fs/bitops.h $(top_srcdir)/lib/support/profile.h \ + $(top_builddir)/lib/support/prof_err.h $(top_srcdir)/lib/support/quotaio.h \ + $(top_srcdir)/lib/support/dqblk_v2.h \ + $(top_srcdir)/lib/support/quotaio_tree.h \ + $(top_srcdir)/lib/ext2fs/fast_commit.h $(top_srcdir)/lib/ext2fs/jfs_compat.h \ + $(top_srcdir)/lib/ext2fs/kernel-list.h $(top_srcdir)/lib/ext2fs/compiler.h +quota.o: $(srcdir)/quota.c $(top_builddir)/lib/config.h \ + $(top_builddir)/lib/dirpaths.h $(srcdir)/e2fsck.h \ + $(top_srcdir)/lib/ext2fs/ext2_fs.h $(top_builddir)/lib/ext2fs/ext2_types.h \ + $(top_srcdir)/lib/ext2fs/ext2fs.h $(top_srcdir)/lib/ext2fs/ext3_extents.h \ + $(top_srcdir)/lib/et/com_err.h $(top_srcdir)/lib/ext2fs/ext2_io.h \ + $(top_builddir)/lib/ext2fs/ext2_err.h \ + $(top_srcdir)/lib/ext2fs/ext2_ext_attr.h $(top_srcdir)/lib/ext2fs/hashmap.h \ + $(top_srcdir)/lib/ext2fs/bitops.h $(top_srcdir)/lib/support/profile.h \ + $(top_builddir)/lib/support/prof_err.h $(top_srcdir)/lib/support/quotaio.h \ + $(top_srcdir)/lib/support/dqblk_v2.h \ + $(top_srcdir)/lib/support/quotaio_tree.h \ + $(top_srcdir)/lib/ext2fs/fast_commit.h $(top_srcdir)/lib/ext2fs/jfs_compat.h \ + $(top_srcdir)/lib/ext2fs/kernel-list.h $(top_srcdir)/lib/ext2fs/compiler.h \ + $(srcdir)/problem.h +extents.o: $(srcdir)/extents.c $(top_builddir)/lib/config.h \ + $(top_builddir)/lib/dirpaths.h $(srcdir)/e2fsck.h \ + $(top_srcdir)/lib/ext2fs/ext2_fs.h $(top_builddir)/lib/ext2fs/ext2_types.h \ + $(top_srcdir)/lib/ext2fs/ext2fs.h $(top_srcdir)/lib/ext2fs/ext3_extents.h \ + $(top_srcdir)/lib/et/com_err.h $(top_srcdir)/lib/ext2fs/ext2_io.h \ + $(top_builddir)/lib/ext2fs/ext2_err.h \ + $(top_srcdir)/lib/ext2fs/ext2_ext_attr.h $(top_srcdir)/lib/ext2fs/hashmap.h \ + $(top_srcdir)/lib/ext2fs/bitops.h $(top_srcdir)/lib/support/profile.h \ + $(top_builddir)/lib/support/prof_err.h $(top_srcdir)/lib/support/quotaio.h \ + $(top_srcdir)/lib/support/dqblk_v2.h \ + $(top_srcdir)/lib/support/quotaio_tree.h \ + $(top_srcdir)/lib/ext2fs/fast_commit.h $(top_srcdir)/lib/ext2fs/jfs_compat.h \ + $(top_srcdir)/lib/ext2fs/kernel-list.h $(top_srcdir)/lib/ext2fs/compiler.h \ + $(srcdir)/problem.h +encrypted_files.o: $(srcdir)/encrypted_files.c $(top_builddir)/lib/config.h \ + $(top_builddir)/lib/dirpaths.h $(srcdir)/e2fsck.h \ + $(top_srcdir)/lib/ext2fs/ext2_fs.h $(top_builddir)/lib/ext2fs/ext2_types.h \ + $(top_srcdir)/lib/ext2fs/ext2fs.h $(top_srcdir)/lib/ext2fs/ext3_extents.h \ + $(top_srcdir)/lib/et/com_err.h $(top_srcdir)/lib/ext2fs/ext2_io.h \ + $(top_builddir)/lib/ext2fs/ext2_err.h \ + $(top_srcdir)/lib/ext2fs/ext2_ext_attr.h $(top_srcdir)/lib/ext2fs/hashmap.h \ + $(top_srcdir)/lib/ext2fs/bitops.h $(top_srcdir)/lib/support/profile.h \ + $(top_builddir)/lib/support/prof_err.h $(top_srcdir)/lib/support/quotaio.h \ + $(top_srcdir)/lib/support/dqblk_v2.h \ + $(top_srcdir)/lib/support/quotaio_tree.h \ + $(top_srcdir)/lib/ext2fs/fast_commit.h $(top_srcdir)/lib/ext2fs/jfs_compat.h \ + $(top_srcdir)/lib/ext2fs/kernel-list.h $(top_srcdir)/lib/ext2fs/compiler.h \ + $(srcdir)/problem.h $(top_srcdir)/lib/ext2fs/rbtree.h diff --git a/e2fsck/badblocks.c b/e2fsck/badblocks.c new file mode 100644 index 0000000..fec5f10 --- /dev/null +++ b/e2fsck/badblocks.c @@ -0,0 +1,142 @@ +/* + * 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 "config.h" +#include +#ifdef HAVE_ERRNO_H +#include +#endif + +#include +#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, "%s", + _("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, "%s", + _("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 -X %s%s%s %llu", fs->blocksize, + (ctx->options & E2F_OPT_PREEN) ? "" : "-s ", + (ctx->options & E2F_OPT_WRITECHECK) ? "-n " : "", + fs->device_name, + (unsigned long long) ext2fs_blocks_count(fs->super)-1); + 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, "%s", + _("while reading in list of bad blocks from file")); + goto fatal; + } + + /* + * Finally, update the bad blocks from the bad_block_map + */ + printf("%s: Updating bad block inode.\n", ctx->device_name); + retval = ext2fs_update_bb_inode(fs, bb_list); + if (retval) { + com_err("ext2fs_update_bb_inode", retval, "%s", + _("while updating bad block inode")); + goto fatal; + } + + ext2fs_badblocks_list_free(bb_list); + return; + +fatal: + ctx->flags |= E2F_FLAG_ABORT; + if (bb_list) + ext2fs_badblocks_list_free(bb_list); + 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 >= ext2fs_blocks_count(fs->super) || + *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/e2fsck/dirinfo.c b/e2fsck/dirinfo.c new file mode 100644 index 0000000..9873e38 --- /dev/null +++ b/e2fsck/dirinfo.c @@ -0,0 +1,489 @@ +/* + * 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. + */ + +#undef DIRINFO_DEBUG + +#include "config.h" +#include "e2fsck.h" +#include +#include +#include "uuid/uuid.h" + +#include "ext2fs/ext2fs.h" +#include + +struct dir_info_db { + ext2_ino_t count; + ext2_ino_t size; + struct dir_info *array; + struct dir_info *last_lookup; +#ifdef CONFIG_TDB + char *tdb_fn; + TDB_CONTEXT *tdb; +#endif +}; + +struct dir_info_iter { + ext2_ino_t i; +#ifdef CONFIG_TDB + TDB_DATA tdb_iter; +#endif +}; + +struct dir_info_ent { + ext2_ino_t dotdot; /* Parent according to '..' */ + ext2_ino_t parent; /* Parent according to treewalk */ +}; + + +static void e2fsck_put_dir_info(e2fsck_t ctx, struct dir_info *dir); + +#ifdef CONFIG_TDB +static void setup_tdb(e2fsck_t ctx, ext2_ino_t num_dirs) +{ + struct dir_info_db *db = ctx->dir_info; + ext2_ino_t threshold; + errcode_t retval; + mode_t save_umask; + char *tdb_dir, uuid[40]; + int fd, enable; + + profile_get_string(ctx->profile, "scratch_files", "directory", 0, 0, + &tdb_dir); + profile_get_uint(ctx->profile, "scratch_files", + "numdirs_threshold", 0, 0, &threshold); + profile_get_boolean(ctx->profile, "scratch_files", + "dirinfo", 0, 1, &enable); + + if (!enable || !tdb_dir || access(tdb_dir, W_OK) || + (threshold && num_dirs <= threshold)) + return; + + retval = ext2fs_get_mem(strlen(tdb_dir) + 64, &db->tdb_fn); + if (retval) + return; + + uuid_unparse(ctx->fs->super->s_uuid, uuid); + sprintf(db->tdb_fn, "%s/%s-dirinfo-XXXXXX", tdb_dir, uuid); + save_umask = umask(077); + fd = mkstemp(db->tdb_fn); + umask(save_umask); + if (fd < 0) { + db->tdb = NULL; + return; + } + + if (num_dirs < 99991) + num_dirs = 99991; /* largest 5 digit prime */ + + db->tdb = tdb_open(db->tdb_fn, num_dirs, TDB_NOLOCK | TDB_NOSYNC, + O_RDWR | O_CREAT | O_TRUNC, 0600); + close(fd); +} +#endif + +static void setup_db(e2fsck_t ctx) +{ + struct dir_info_db *db; + ext2_ino_t num_dirs; + errcode_t retval; + + db = (struct dir_info_db *) + e2fsck_allocate_memory(ctx, sizeof(struct dir_info_db), + "directory map db"); + db->count = db->size = 0; + db->array = 0; + + ctx->dir_info = db; + + retval = ext2fs_get_num_dirs(ctx->fs, &num_dirs); + if (retval) + num_dirs = 1024; /* Guess */ + +#ifdef CONFIG_TDB + setup_tdb(ctx, num_dirs); + + if (db->tdb) { +#ifdef DIRINFO_DEBUG + printf("Note: using tdb!\n"); +#endif + return; + } +#endif + + db->size = num_dirs + 10; + db->array = (struct dir_info *) + e2fsck_allocate_memory(ctx, db->size + * sizeof (struct dir_info), + "directory map"); +} + +/* + * 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, *old_array; + ext2_ino_t i, j; + errcode_t retval; + unsigned long old_size; + +#ifdef DIRINFO_DEBUG + printf("add_dir_info for inode (%u, %u)...\n", ino, parent); +#endif + if (!ctx->dir_info) + setup_db(ctx); + + if (ctx->dir_info->count >= ctx->dir_info->size) { + old_size = ctx->dir_info->size * sizeof(struct dir_info); + ctx->dir_info->size += 10; + old_array = ctx->dir_info->array; + retval = ext2fs_resize_mem(old_size, ctx->dir_info->size * + sizeof(struct dir_info), + &ctx->dir_info->array); + if (retval) { + fprintf(stderr, "Couldn't reallocate dir_info " + "structure to %u entries\n", + ctx->dir_info->size); + fatal_error(ctx, 0); + ctx->dir_info->size -= 10; + return; + } + if (old_array != ctx->dir_info->array) + ctx->dir_info->last_lookup = NULL; + } + +#ifdef CONFIG_TDB + if (ctx->dir_info->tdb) { + struct dir_info ent; + + ent.ino = ino; + ent.parent = parent; + ent.dotdot = parent; + e2fsck_put_dir_info(ctx, &ent); + return; + } +#endif + + /* + * 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->array[ctx->dir_info->count-1].ino >= ino) { + for (i = ctx->dir_info->count-1; i > 0; i--) + if (ctx->dir_info->array[i-1].ino < ino) + break; + dir = &ctx->dir_info->array[i]; + if (dir->ino != ino) + for (j = ctx->dir_info->count++; j > i; j--) + ctx->dir_info->array[j] = ctx->dir_info->array[j-1]; + } else + dir = &ctx->dir_info->array[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. + */ +static struct dir_info *e2fsck_get_dir_info(e2fsck_t ctx, ext2_ino_t ino) +{ + struct dir_info_db *db = ctx->dir_info; + ext2_ino_t low, high, mid; + + if (!db) + return 0; + +#ifdef DIRINFO_DEBUG + printf("e2fsck_get_dir_info %u...", ino); +#endif + +#ifdef CONFIG_TDB + if (db->tdb) { + static struct dir_info ret_dir_info; + TDB_DATA key, data; + struct dir_info_ent *buf; + + key.dptr = (unsigned char *) &ino; + key.dsize = sizeof(ext2_ino_t); + + data = tdb_fetch(db->tdb, key); + if (!data.dptr) { + if (tdb_error(db->tdb) != TDB_ERR_NOEXIST) + printf("fetch failed: %s\n", + tdb_errorstr(db->tdb)); + return 0; + } + + buf = (struct dir_info_ent *) data.dptr; + ret_dir_info.ino = ino; + ret_dir_info.dotdot = buf->dotdot; + ret_dir_info.parent = buf->parent; +#ifdef DIRINFO_DEBUG + printf("(%u,%u,%u)\n", ino, buf->dotdot, buf->parent); +#endif + free(data.dptr); + return &ret_dir_info; + } +#endif + + if (db->last_lookup && db->last_lookup->ino == ino) + return db->last_lookup; + + low = 0; + high = ctx->dir_info->count - 1; + if (ino == ctx->dir_info->array[low].ino) { +#ifdef DIRINFO_DEBUG + printf("(%u,%u,%u)\n", ino, + ctx->dir_info->array[low].dotdot, + ctx->dir_info->array[low].parent); +#endif + return &ctx->dir_info->array[low]; + } + if (ino == ctx->dir_info->array[high].ino) { +#ifdef DIRINFO_DEBUG + printf("(%u,%u,%u)\n", ino, + ctx->dir_info->array[high].dotdot, + ctx->dir_info->array[high].parent); +#endif + return &ctx->dir_info->array[high]; + } + + while (low < high) { + /* sum may overflow, but result will fit into mid again */ + mid = (unsigned long long)(low + high) / 2; + if (mid == low || mid == high) + break; + if (ino == ctx->dir_info->array[mid].ino) { +#ifdef DIRINFO_DEBUG + printf("(%u,%u,%u)\n", ino, + ctx->dir_info->array[mid].dotdot, + ctx->dir_info->array[mid].parent); +#endif + return &ctx->dir_info->array[mid]; + } + if (ino < ctx->dir_info->array[mid].ino) + high = mid; + else + low = mid; + } + return 0; +} + +static void e2fsck_put_dir_info(e2fsck_t ctx EXT2FS_NO_TDB_UNUSED, + struct dir_info *dir EXT2FS_NO_TDB_UNUSED) +{ +#ifdef CONFIG_TDB + struct dir_info_db *db = ctx->dir_info; + struct dir_info_ent buf; + TDB_DATA key, data; +#endif + +#ifdef DIRINFO_DEBUG + printf("e2fsck_put_dir_info (%u, %u, %u)...", dir->ino, dir->dotdot, + dir->parent); +#endif + +#ifdef CONFIG_TDB + if (!db->tdb) + return; + + buf.parent = dir->parent; + buf.dotdot = dir->dotdot; + + key.dptr = (unsigned char *) &dir->ino; + key.dsize = sizeof(ext2_ino_t); + data.dptr = (unsigned char *) &buf; + data.dsize = sizeof(buf); + + if (tdb_store(db->tdb, key, data, TDB_REPLACE) == -1) { + printf("store failed: %s\n", tdb_errorstr(db->tdb)); + } +#endif +} + +/* + * Free the dir_info structure when it isn't needed any more. + */ +void e2fsck_free_dir_info(e2fsck_t ctx) +{ + if (ctx->dir_info) { +#ifdef CONFIG_TDB + if (ctx->dir_info->tdb) + tdb_close(ctx->dir_info->tdb); + if (ctx->dir_info->tdb_fn) { + if (unlink(ctx->dir_info->tdb_fn) < 0) + com_err("e2fsck_free_dir_info", errno, + _("while freeing dir_info tdb file")); + ext2fs_free_mem(&ctx->dir_info->tdb_fn); + } +#endif + if (ctx->dir_info->array) + ext2fs_free_mem(&ctx->dir_info->array); + ctx->dir_info->array = 0; + ctx->dir_info->size = 0; + ctx->dir_info->count = 0; + ext2fs_free_mem(&ctx->dir_info); + ctx->dir_info = 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 ? ctx->dir_info->count : 0; +} + +struct dir_info_iter *e2fsck_dir_info_iter_begin(e2fsck_t ctx) +{ + struct dir_info_iter *iter; + + iter = e2fsck_allocate_memory(ctx, sizeof(struct dir_info_iter), + "dir_info iterator"); + +#ifdef CONFIG_TDB + if (ctx->dir_info->tdb) + iter->tdb_iter = tdb_firstkey(ctx->dir_info->tdb); +#endif + + return iter; +} + +void e2fsck_dir_info_iter_end(e2fsck_t ctx EXT2FS_ATTR((unused)), + struct dir_info_iter *iter) +{ +#ifdef CONFIG_TDB + free(iter->tdb_iter.dptr); +#endif + ext2fs_free_mem(&iter); +} + +/* + * A simple iterator function + */ +struct dir_info *e2fsck_dir_info_iter(e2fsck_t ctx, struct dir_info_iter *iter) +{ + if (!ctx->dir_info || !iter) + return 0; + +#ifdef CONFIG_TDB + if (ctx->dir_info->tdb) { + static struct dir_info ret_dir_info; + struct dir_info_ent *buf; + TDB_DATA data, key; + + if (iter->tdb_iter.dptr == 0) + return 0; + key = iter->tdb_iter; + data = tdb_fetch(ctx->dir_info->tdb, key); + if (!data.dptr) { + printf("iter fetch failed: %s\n", + tdb_errorstr(ctx->dir_info->tdb)); + return 0; + } + buf = (struct dir_info_ent *) data.dptr; + ret_dir_info.ino = *((ext2_ino_t *) iter->tdb_iter.dptr); + ret_dir_info.dotdot = buf->dotdot; + ret_dir_info.parent = buf->parent; + iter->tdb_iter = tdb_nextkey(ctx->dir_info->tdb, key); + free(key.dptr); + free(data.dptr); + return &ret_dir_info; + } +#endif + + if (iter->i >= ctx->dir_info->count) + return 0; + +#ifdef DIRINFO_DEBUG + printf("iter(%u, %u, %u)...", ctx->dir_info->array[iter->i].ino, + ctx->dir_info->array[iter->i].dotdot, + ctx->dir_info->array[iter->i].parent); +#endif + ctx->dir_info->last_lookup = ctx->dir_info->array + iter->i++; + return(ctx->dir_info->last_lookup); +} + +/* + * This function only sets the parent pointer, and requires that + * dirinfo structure has already been created. + */ +int e2fsck_dir_info_set_parent(e2fsck_t ctx, ext2_ino_t ino, + ext2_ino_t parent) +{ + struct dir_info *p; + + p = e2fsck_get_dir_info(ctx, ino); + if (!p) + return 1; + p->parent = parent; + e2fsck_put_dir_info(ctx, p); + return 0; +} + +/* + * This function only sets the dot dot pointer, and requires that + * dirinfo structure has already been created. + */ +int e2fsck_dir_info_set_dotdot(e2fsck_t ctx, ext2_ino_t ino, + ext2_ino_t dotdot) +{ + struct dir_info *p; + + p = e2fsck_get_dir_info(ctx, ino); + if (!p) + return 1; + p->dotdot = dotdot; + e2fsck_put_dir_info(ctx, p); + return 0; +} + +/* + * This function only sets the parent pointer, and requires that + * dirinfo structure has already been created. + */ +int e2fsck_dir_info_get_parent(e2fsck_t ctx, ext2_ino_t ino, + ext2_ino_t *parent) +{ + struct dir_info *p; + + p = e2fsck_get_dir_info(ctx, ino); + if (!p) + return 1; + *parent = p->parent; + return 0; +} + +/* + * This function only sets the dot dot pointer, and requires that + * dirinfo structure has already been created. + */ +int e2fsck_dir_info_get_dotdot(e2fsck_t ctx, ext2_ino_t ino, + ext2_ino_t *dotdot) +{ + struct dir_info *p; + + p = e2fsck_get_dir_info(ctx, ino); + if (!p) + return 1; + *dotdot = p->dotdot; + return 0; +} + diff --git a/e2fsck/dx_dirinfo.c b/e2fsck/dx_dirinfo.c new file mode 100644 index 0000000..4b764b0 --- /dev/null +++ b/e2fsck/dx_dirinfo.c @@ -0,0 +1,154 @@ +/* + * 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 "config.h" +#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_dx_dir(e2fsck_t ctx, ext2_ino_t ino, struct ext2_inode *inode, + int num_blocks) +{ + struct dx_dir_info *dir; + ext2_ino_t 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) { + fprintf(stderr, "Couldn't reallocate dx_dir_info " + "structure to %u entries\n", + ctx->dx_dir_info_size); + fatal_error(ctx, 0); + 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->casefolded_hash = !!(inode->i_flags & EXT4_CASEFOLD_FL); + 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) +{ + ext2_ino_t 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) { + /* sum may overflow, but result will fit into mid again */ + mid = (unsigned long long)(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) +{ + struct dx_dir_info *dir; + ext2_ino_t i; + + if (ctx->dx_dir_info) { + dir = ctx->dx_dir_info; + for (i=0; i < ctx->dx_dir_info_count; i++,dir++) { + 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 + */ +ext2_ino_t e2fsck_get_num_dx_dirinfo(e2fsck_t ctx) +{ + return ctx->dx_dir_info_count; +} + +/* + * A simple iterator function + */ +struct dx_dir_info *e2fsck_dx_dir_info_iter(e2fsck_t ctx, ext2_ino_t *control) +{ + if (*control >= ctx->dx_dir_info_count) + return 0; + + return ctx->dx_dir_info + (*control)++; +} diff --git a/e2fsck/e2fsck.8.in b/e2fsck/e2fsck.8.in new file mode 100644 index 0000000..dc6a585 --- /dev/null +++ b/e2fsck/e2fsck.8.in @@ -0,0 +1,509 @@ +.\" -*- nroff -*- +.\" Copyright 1993, 1994, 1995 by Theodore Ts'o. All Rights Reserved. +.\" This file may be copied under the terms of the GNU Public License. +.\" +.TH E2FSCK 8 "@E2FSPROGS_MONTH@ @E2FSPROGS_YEAR@" "E2fsprogs version @E2FSPROGS_VERSION@" +.SH NAME +e2fsck \- check a Linux ext2/ext3/ext4 file system +.SH SYNOPSIS +.B e2fsck +[ +.B \-pacnyrdfkvtDFV +] +[ +.B \-b +.I superblock +] +[ +.B \-B +.I blocksize +] +[ +.BR \-l | \-L +.I bad_blocks_file +] +[ +.B \-C +.I fd +] +@JDEV@[ +@JDEV@.B \-j +@JDEV@.I external-journal +@JDEV@] +[ +.B \-E +.I extended_options +] +[ +.B \-z +.I undo_file +] +.I device +.SH DESCRIPTION +.B e2fsck +is used to check the ext2/ext3/ext4 family of file systems. +For ext3 and ext4 file systems that use a journal, if the system has been +shut down uncleanly without any errors, normally, after replaying the +committed transactions in the journal, the file system should be +marked as clean. Hence, for file systems that use journaling, +.B e2fsck +will normally replay the journal and exit, unless its superblock +indicates that further checking is required. +.PP +.I device +is a block device (e.g., +.IR /dev/sdc1 ) +or file containing the file system. +.PP +Note that in general it is not safe to run +.B e2fsck +on mounted file systems. The only exception is if the +.B \-n +option is specified, and +.BR \-c , +.BR \-l , +or +.B -L +options are +.I not +specified. However, even if it is safe to do so, the results printed by +.B e2fsck +are not valid if the file system is mounted. If +.B e2fsck +asks whether or not you should check a file system which is mounted, +the only correct answer is ``no''. Only experts who really know what +they are doing should consider answering this question in any other way. +.PP +If +.B e2fsck +is run in interactive mode (meaning that none of +.BR \-y , +.BR \-n , +or +.BR \-p +are specified), the program will ask the user to fix each problem found in the +file system. A response of 'y' will fix the error; 'n' will leave the error +unfixed; and 'a' will fix the problem and all subsequent problems; pressing +Enter will proceed with the default response, which is printed before the +question mark. Pressing Control-C terminates e2fsck immediately. +.SH OPTIONS +.TP +.B \-a +This option does the same thing as the +.B \-p +option. It is provided for backwards compatibility only; it is +suggested that people use +.B \-p +option whenever possible. +.TP +.BI \-b " superblock" +Instead of using the normal superblock, use an alternative superblock +specified by +.IR superblock . +This option is normally used when the primary superblock has been +corrupted. The location of backup superblocks is dependent on the +file system's blocksize, the number of blocks per group, and features +such as +.BR sparse_super . +.IP +Additional backup superblocks can be determined by using the +.B mke2fs +program using the +.B \-n +option to print out where the superblocks exist, supposing +.B mke2fs +is supplied with arguments that are consistent with the file system's layout +(e.g. blocksize, blocks per group, +.BR sparse_super , +etc.). +.IP +If an alternative superblock is specified and +the file system is not opened read-only, e2fsck will make sure that the +primary superblock is updated appropriately upon completion of the +file system check. +.TP +.BI \-B " blocksize" +Normally, +.B e2fsck +will search for the superblock at various different +block sizes in an attempt to find the appropriate block size. +This search can be fooled in some cases. This option forces +.B e2fsck +to only try locating the superblock at a particular blocksize. +If the superblock is not found, +.B e2fsck +will terminate with a fatal error. +.TP +.B \-c +This option causes +.B e2fsck +to use +.BR badblocks (8) +program to do a read-only scan of the device in order to find any bad +blocks. If any bad blocks are found, they are added to the bad block +inode to prevent them from being allocated to a file or directory. If +this option is specified twice, then the bad block scan will be done +using a non-destructive read-write test. +.TP +.BI \-C " fd" +This option causes +.B e2fsck +to write completion information to the specified file descriptor +so that the progress of the file system +check can be monitored. This option is typically used by programs +which are running +.BR e2fsck . +If the file descriptor number is negative, then absolute value of +the file descriptor will be used, and the progress information will be +suppressed initially. It can later be enabled by sending the +.B e2fsck +process a SIGUSR1 signal. +If the file descriptor specified is 0, +.B e2fsck +will print a completion bar as it goes about its business. This requires +that e2fsck is running on a video console or terminal. +.TP +.B \-d +Print debugging output (useless unless you are debugging +.BR e2fsck ). +.TP +.B \-D +Optimize directories in file system. This option causes e2fsck to +try to optimize all directories, either by re-indexing them if the +file system supports directory indexing, or by sorting and compressing +directories for smaller directories, or for file systems using +traditional linear directories. +.IP +Even without the +.B \-D +option, +.B e2fsck +may sometimes optimize a few directories --- for example, if +directory indexing is enabled and a directory is not indexed and would +benefit from being indexed, or if the index structures are corrupted +and need to be rebuilt. The +.B \-D +option forces all directories in the file system to be optimized. This can +sometimes make them a little smaller and slightly faster to search, but +in practice, you should rarely need to use this option. +.IP +The +.B \-D +option will detect directory entries with duplicate names in a single +directory, which e2fsck normally does not enforce for performance reasons. +.TP +.BI \-E " extended_options" +Set e2fsck extended options. Extended options are comma +separated, and may take an argument using the equals ('=') sign. The +following options are supported: +.RS 1.2i +.TP +.BI ea_ver= extended_attribute_version +Set the version of the extended attribute blocks which +.B e2fsck +will require while checking the file system. The version number may +be 1 or 2. The default extended attribute version format is 2. +.TP +.BI journal_only +Only replay the journal if required, but do not perform any further checks +or repairs. +.TP +.BI fragcheck +During pass 1, print a detailed report of any discontiguous blocks for +files in the file system. +.TP +.BI discard +Attempt to discard free blocks and unused inode blocks after the full +file system check (discarding blocks is useful on solid state devices and sparse +/ thin-provisioned storage). Note that discard is done in pass 5 AFTER the +file system has been fully checked and only if it does not contain recognizable +errors. However there might be cases where +.B e2fsck +does not fully recognize a problem and hence in this case this +option may prevent you from further manual data recovery. +.TP +.BI nodiscard +Do not attempt to discard free blocks and unused inode blocks. This option is +exactly the opposite of discard option. This is set as default. +.TP +.BI no_optimize_extents +Do not offer to optimize the extent tree by eliminating unnecessary +width or depth. This can also be enabled in the options section of +.BR /etc/e2fsck.conf . +.TP +.BI optimize_extents +Offer to optimize the extent tree by eliminating unnecessary +width or depth. This is the default unless otherwise specified in +.BR /etc/e2fsck.conf . +.TP +.BI inode_count_fullmap +Trade off using memory for speed when checking a file system with a +large number of hard-linked files. The amount of memory required is +proportional to the number of inodes in the file system. For large file +systems, this can be gigabytes of memory. (For example, a 40TB file system +with 2.8 billion inodes will consume an additional 5.7 GB memory if this +optimization is enabled.) This optimization can also be enabled in the +options section of +.BR /etc/e2fsck.conf . +.TP +.BI no_inode_count_fullmap +Disable the +.B inode_count_fullmap +optimization. This is the default unless otherwise specified in +.BR /etc/e2fsck.conf . +.TP +.BI readahead_kb +Use this many KiB of memory to pre-fetch metadata in the hopes of reducing +e2fsck runtime. By default, this is set to the size of two block groups' inode +tables (typically 4MiB on a regular ext4 file system); if this amount is more +than 1/50th of total physical memory, readahead is disabled. Set this to zero +to disable readahead entirely. +.TP +.BI bmap2extent +Convert block-mapped files to extent-mapped files. +.TP +.BI fixes_only +Only fix damaged metadata; do not optimize htree directories or compress +extent trees. This option is incompatible with the -D and -E bmap2extent +options. +.TP +.BI check_encoding +Force verification of encoded filenames in case-insensitive directories. +This is the default mode if the file system has the strict flag enabled. +.TP +.BI unshare_blocks +If the file system has shared blocks, with the shared blocks read-only feature +enabled, then this will unshare all shared blocks and unset the read-only +feature bit. If there is not enough free space then the operation will fail. +If the file system does not have the read-only feature bit, but has shared +blocks anyway, then this option will have no effect. Note when using this +option, if there is no free space to clone blocks, there is no prompt to +delete files and instead the operation will fail. +.IP +Note that unshare_blocks implies the "-f" option to ensure that all passes +are run. Additionally, if "-n" is also specified, e2fsck will simulate trying +to allocate enough space to deduplicate. If this fails, the exit code will +be non-zero. +.RE +.TP +.B \-f +Force checking even if the file system seems clean. +.TP +.B \-F +Flush the file system device's buffer caches before beginning. Only +really useful for doing +.B e2fsck +time trials. +@JDEV@.TP +@JDEV@.BI \-j " external-journal" +@JDEV@Set the pathname where the external-journal for this file system can be +@JDEV@found. +.TP +.BI \-k +When combined with the +.B \-c +option, any existing bad blocks in the bad blocks list are preserved, +and any new bad blocks found by running +.BR badblocks (8) +will be added to the existing bad blocks list. +.TP +.BI \-l " filename" +Add the block numbers listed in the file specified by +.I filename +to the list of bad blocks. The format of this file is the same as the +one generated by the +.BR badblocks (8) +program. Note that the block numbers are based on the blocksize +of the file system. Hence, +.BR badblocks (8) +must be given the blocksize of the file system in order to obtain correct +results. As a result, it is much simpler and safer to use the +.B -c +option to +.BR e2fsck , +since it will assure that the correct parameters are passed to the +.B badblocks +program. +.TP +.BI \-L " filename" +Set the bad blocks list to be the list of blocks specified by +.IR filename . +(This option is the same as the +.B \-l +option, except the bad blocks list is cleared before the blocks listed +in the file are added to the bad blocks list.) +.TP +.B \-n +Open the file system read-only, and assume an answer of `no' to all +questions. Allows +.B e2fsck +to be used non-interactively. This option +may not be specified at the same time as the +.B \-p +or +.B \-y +options. +.TP +.B \-p +Automatically repair ("preen") the file system. This option will cause +.B e2fsck +to automatically +fix any file system problems that can be safely fixed without human +intervention. If +.B e2fsck +discovers a problem which may require the system administrator +to take additional corrective action, +.B e2fsck +will print a description of the problem and then exit with the value 4 +logically or'ed into the exit code. (See the \fBEXIT CODE\fR section.) +This option is normally used by the system's boot scripts. It may not +be specified at the same time as the +.B \-n +or +.B \-y +options. +.TP +.B \-r +This option does nothing at all; it is provided only for backwards +compatibility. +.TP +.B \-t +Print timing statistics for +.BR e2fsck . +If this option is used twice, additional timing statistics are printed +on a pass by pass basis. +.TP +.B \-v +Verbose mode. +.TP +.B \-V +Print version information and exit. +.TP +.B \-y +Assume an answer of `yes' to all questions; allows +.B e2fsck +to be used non-interactively. This option +may not be specified at the same time as the +.B \-n +or +.B \-p +options. +.TP +.BI \-z " undo_file" +Before overwriting a file system block, write the old contents of the block to +an undo file. This undo file can be used with e2undo(8) to restore the old +contents of the file system should something go wrong. If the empty string is +passed as the undo_file argument, the undo file will be written to a file named +e2fsck-\fIdevice\fR.e2undo in the directory specified via the +\fIE2FSPROGS_UNDO_DIR\fR environment variable. + +WARNING: The undo file cannot be used to recover from a power or system crash. +.SH EXIT CODE +The exit code returned by +.B e2fsck +is the sum of the following conditions: +.br +\ 0\ \-\ No errors +.br +\ 1\ \-\ File system errors corrected +.br +\ 2\ \-\ File system errors corrected, system should +.br +\ \ \ \ be rebooted +.br +\ 4\ \-\ File system errors left uncorrected +.br +\ 8\ \-\ Operational error +.br +\ 16\ \-\ Usage or syntax error +.br +\ 32\ \-\ E2fsck canceled by user request +.br +\ 128\ \-\ Shared library error +.br +.SH SIGNALS +The following signals have the following effect when sent to +.BR e2fsck . +.TP +.B SIGUSR1 +This signal causes +.B e2fsck +to start displaying a completion bar or emitting progress information. +(See discussion of the +.B \-C +option.) +.TP +.B SIGUSR2 +This signal causes +.B e2fsck +to stop displaying a completion bar or emitting progress information. +.SH REPORTING BUGS +Almost any piece of software will have bugs. If you manage to find a +file system which causes +.B e2fsck +to crash, or which +.B e2fsck +is unable to repair, please report it to the author. +.PP +Please include as much information as possible in your bug report. +Ideally, include a complete transcript of the +.B e2fsck +run, so I can see exactly what error messages are displayed. (Make sure +the messages printed by +.B e2fsck +are in English; if your system has been +configured so that +.BR e2fsck 's +messages have been translated into another language, please set the the +.B LC_ALL +environment variable to +.B C +so that the transcript of e2fsck's output will be useful to me.) +If you +have a writable file system where the transcript can be stored, the +.BR script (1) +program is a handy way to save the output of +.B e2fsck +to a file. +.PP +It is also useful to send the output of +.BR dumpe2fs (8). +If a specific inode or inodes seems to be giving +.B e2fsck +trouble, try running the +.BR debugfs (8) +command and send the output of the +.BR stat (1u) +command run on the relevant inode(s). If the inode is a directory, the +.B debugfs +.I dump +command will allow you to extract the contents of the directory inode, +which can sent to me after being first run through +.BR uuencode (1). +The most useful data you can send to help reproduce +the bug is a compressed raw image dump of the file system, generated using +.BR e2image (8). +See the +.BR e2image (8) +man page for more details. +.PP +Always include the full version string which +.B e2fsck +displays when it is run, so I know which version you are running. +.SH ENVIRONMENT +.TP +.BI E2FSCK_CONFIG +Determines the location of the configuration file (see +.BR e2fsck.conf (5)). +.SH AUTHOR +This version of +.B e2fsck +was written by Theodore Ts'o . +.SH SEE ALSO +.BR e2fsck.conf (5), +.BR badblocks (8), +.BR dumpe2fs (8), +.BR debugfs (8), +.BR e2image (8), +.BR mke2fs (8), +.BR tune2fs (8) diff --git a/e2fsck/e2fsck.c b/e2fsck/e2fsck.c new file mode 100644 index 0000000..1e295e3 --- /dev/null +++ b/e2fsck/e2fsck.c @@ -0,0 +1,271 @@ +/* + * 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 "config.h" +#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; + char *time_env; + + 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; + context->blocks_per_page = 1; + context->htree_slack_percentage = 255; + + time_env = getenv("E2FSCK_TIME"); + if (time_env) + context->now = (time_t) strtoull(time_env, NULL, 0); + else { + context->now = time(0); + if (context->now < 1262322000) /* January 1 2010 */ + context->flags |= E2F_FLAG_TIME_INSANE; + } + + *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) +{ + int i; + + ctx->flags &= E2F_RESET_FLAGS; + 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_casefold_map) { + ext2fs_free_block_bitmap(ctx->inode_casefold_map); + ctx->inode_casefold_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); + e2fsck_free_dx_dir_info(ctx); + 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->ea_block_quota_blocks) { + ea_refcount_free(ctx->ea_block_quota_blocks); + ctx->ea_block_quota_blocks = 0; + } + if (ctx->ea_block_quota_inodes) { + ea_refcount_free(ctx->ea_block_quota_inodes); + ctx->ea_block_quota_inodes = 0; + } + if (ctx->ea_inode_refs) { + ea_refcount_free(ctx->ea_inode_refs); + ctx->ea_inode_refs = 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->block_metadata_map) { + ext2fs_free_block_bitmap(ctx->block_metadata_map); + ctx->block_metadata_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; + } + destroy_encrypted_file_info(ctx); + + /* + * 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; + } + if (ctx->casefolded_dirs) { + ext2fs_u32_list_free(ctx->casefolded_dirs); + ctx->casefolded_dirs = 0; + } + if (ctx->inode_count) { + ext2fs_free_icount(ctx->inode_count); + ctx->inode_count = 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->fs_fragmented_dir = 0; + ctx->large_files = 0; + ctx->large_dirs = 0; + + for (i=0; i < MAX_EXTENT_DEPTH_COUNT; i++) + ctx->extent_depth_count[i] = 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); + + if (ctx->profile) + profile_release(ctx->profile); + + if (ctx->filesystem_name) + ext2fs_free_mem(&ctx->filesystem_name); + + if (ctx->device_name) + ext2fs_free_mem(&ctx->device_name); + + if (ctx->log_fn) + free(ctx->log_fn); + + if (ctx->logf) + fclose(ctx->logf); + + if (ctx->problem_log_fn) + free(ctx->problem_log_fn); + + if (ctx->problem_logf) { + fputs("\n", ctx->problem_logf); + fclose(ctx->problem_logf); + } + 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_pass1e, e2fsck_pass2, e2fsck_pass3, + e2fsck_pass4, e2fsck_pass5, 0 }; + +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; + if (e2fsck_mmp_update(ctx->fs)) + fatal_error(ctx, 0); + 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/e2fsck/e2fsck.conf.5.in b/e2fsck/e2fsck.conf.5.in new file mode 100644 index 0000000..e82610d --- /dev/null +++ b/e2fsck/e2fsck.conf.5.in @@ -0,0 +1,501 @@ +.\" -*- nroff -*- +.\" Copyright 2006 by Theodore Ts'o. All Rights Reserved. +.\" This file may be copied under the terms of the GNU Public License. +.\" +.TH e2fsck.conf 5 "@E2FSPROGS_MONTH@ @E2FSPROGS_YEAR@" "E2fsprogs version @E2FSPROGS_VERSION@" +.SH NAME +e2fsck.conf \- Configuration file for e2fsck +.SH DESCRIPTION +.I e2fsck.conf +is the configuration file for +.BR e2fsck (8). +It controls the default behavior of +.BR e2fsck (8) +while it is checking ext2, ext3, or ext4 file systems. +.PP +The +.I e2fsck.conf +file uses an INI-style format. Stanzas, or top-level sections, are +delimited by square braces: [ ]. Within each section, each line +defines a relation, which assigns tags to values, or to a subsection, +which contains further relations or subsections. +.\" Tags can be assigned multiple values +An example of the INI-style format used by this configuration file +follows below: +.P + [section1] +.br + tag1 = value_a +.br + tag1 = value_b +.br + tag2 = value_c +.P + [section 2] +.br + tag3 = { +.br + subtag1 = subtag_value_a +.br + subtag1 = subtag_value_b +.br + subtag2 = subtag_value_c +.br + } +.br + tag1 = value_d +.br + tag2 = value_e +.br + } +.P +Comments are delimited by a semicolon (';') or a hash ('#') character +at the beginning of the comment, and are terminated by the end of +line character. +.P +Tags and values must be quoted using double quotes if they contain +spaces. Within a quoted string, the standard backslash interpretations +apply: "\en" (for the newline character), +"\et" (for the tab character), "\eb" (for the backspace character), +and "\e\e" (for the backslash character). +.P +The following stanzas are used in the +.I e2fsck.conf +file. They will be described in more detail in future sections of this +document. +.TP +.I [options] +This stanza contains general configuration parameters for +.BR e2fsck 's +behavior. +.TP +.I [defaults] +Contains relations which define the default parameters used by +.BR e2fsck (8). +In general, these defaults may be overridden by command-line options +provided by the user. +.TP +.I [problems] +This stanza allows the administrator to reconfigure how e2fsck handles +various file system inconsistencies. +@TDB_MAN_COMMENT@.TP +@TDB_MAN_COMMENT@.I [scratch_files] +@TDB_MAN_COMMENT@This stanza controls when e2fsck will attempt to use +@TDB_MAN_COMMENT@scratch files to reduce the need for memory. +.SH THE [options] STANZA +The following relations are defined in the +.I [options] +stanza. +.TP +.I allow_cancellation +If this relation is set to a boolean value of true, then if the user +interrupts e2fsck using ^C, and the file system is not explicitly flagged +as containing errors, e2fsck will exit with an exit status of 0 instead +of 32. This setting defaults to false. +.TP +.I accept_time_fudge +Unfortunately, due to Windows' unfortunate design decision +to configure the hardware clock to tick localtime, instead +of the more proper and less error-prone UTC time, many +users end up in the situation where the system clock is +incorrectly set at the time when e2fsck is run. +.IP +Historically this was usually due to some distributions +having buggy init scripts and/or installers that didn't +correctly detect this case and take appropriate +countermeasures. Unfortunately, this is occasionally +true even today, usually due to a +buggy or misconfigured virtualization manager or the +installer not having access to a network time server +during the installation process. So by default, we allow +the superblock times to be fudged by up to 24 hours. +This can be disabled by setting +.I accept_time_fudge +to the +boolean value of false. This setting defaults to true. +.TP +.I broken_system_clock +The +.BR e2fsck (8) +program has some heuristics that assume that the system clock is +correct. In addition, many system programs make similar assumptions. +For example, the UUID library depends on time not going backwards in +order for it to be able to make its guarantees about issuing universally +unique ID's. Systems with broken system clocks, are well, broken. +However, broken system clocks, particularly in embedded systems, do +exist. E2fsck will attempt to use heuristics to determine if the time +can not be trusted; and to skip time-based checks if this is true. If +this boolean is set to true, then e2fsck will always assume that the +system clock can not be trusted. +.TP +.I buggy_init_scripts +This boolean relation is an alias for +.I accept_time_fudge +for backwards compatibility; it used to +be that the behavior defined by +.I accept_time_fudge +above defaulted to false, and +.I buggy_init_scripts +would enable superblock time field to be wrong by up to 24 hours. When +we changed the default, we also renamed this boolean relation to +.IR accept_time_fudge. +.TP +.I clear_test_fs_flag +This boolean relation controls whether or not +.BR e2fsck (8) +will offer to clear +the test_fs flag if the ext4 file system is available on the system. It +defaults to true. +.TP +.I defer_check_on_battery +This boolean relation controls whether or not the interval between +file system checks (either based on time or number of mounts) should +be doubled if the system is running on battery. This setting defaults to +true. +.TP +.I indexed_dir_slack_percentage +When +.BR e2fsck (8) +repacks a indexed directory, reserve the specified percentage of +empty space in each leaf nodes so that a few new entries can +be added to the directory without splitting leaf nodes, so that +the average fill ratio of directories can be maintained at a +higher, more efficient level. This relation defaults to 20 +percent. +.TP +.I inode_count_fullmap +If this boolean relation is true, trade off using memory for speed when +checking a file system with a large number of hard-linked files. The +amount of memory required is proportional to the number of inodes in the +file system. For large file systems, this can be gigabytes of memory. +(For example a 40TB file system with 2.8 billion inodes will consume an +additional 5.7 GB memory if this optimization is enabled.) This setting +defaults to false. +.TP +.I log_dir +If the +.I log_filename +or +.I problem_log_filename +relations contains a relative pathname, then the log file will be placed +in the directory named by the +.I log_dir +relation. +.TP +.I log_dir_fallback +This relation contains an alternate directory that will be used if the +directory specified by +.I log_dir +is not available or is not writable. +.TP +.I log_dir_wait +If this boolean relation is true, them if the directories specified by +.I log_dir +or +.I log_dir_fallback +are not available or are not yet writable, e2fsck will save the output +in a memory buffer, and a child process will periodically test to see if +the log directory has become available after the boot sequence has +mounted the requested file system for reading/writing. This implements the +functionality provided by +.BR logsave (8) +for e2fsck log files. +.TP +.I log_filename +This relation specifies the file name where a copy of e2fsck's output +will be written. If certain problem reports are suppressed using the +.I max_count_problems +relation, (or on a per-problem basis using the +.I max_count +relation), the full set of problem reports will be written to the log +file. The filename may contain various percent-expressions (%D, %T, %N, +etc.) which will be expanded so that the file name for the log file can +include things like date, time, device name, and other run-time +parameters. See the +.B LOGGING +section for more details. +.TP +.I max_count_problems +This relation specifies the maximum number of problem reports of a +particular type will be printed to stdout before further problem reports +of that type are squelched. This can be useful if the console is slow +(i.e., connected to a serial port) and so a large amount of output could +end up delaying the boot process for a long time (potentially hours). +.TP +.I no_optimize_extents +If this boolean relation is true, do not offer to optimize the extent +tree by reducing the tree's width or depth. This setting defaults to false. +.TP +.I problem_log_filename +This relation specifies the file name where a log of problem codes +found by e2fsck be written. The filename may contain various +percent-expressions (%D, %T, %N, +etc.) which will be expanded so that the file name for the log file can +include things like date, time, device name, and other run-time +parameters. See the +.B LOGGING +section for more details. +.TP +.I readahead_mem_pct +Use this percentage of memory to try to read in metadata blocks ahead of the +main e2fsck thread. This should reduce run times, depending on the speed of +the underlying storage and the amount of free memory. There is no default, but +see +.B readahead_kb +for more details. +.TP +.I readahead_kb +Use this amount of memory to read in metadata blocks ahead of the main checking +thread. Setting this value to zero disables readahead entirely. By default, +this is set the size of two block groups' inode tables (typically 4MiB on a +regular ext4 file system); if this amount is more than 1/50th of total physical +memory, readahead is disabled. +.TP +.I report_features +If this boolean relation is true, e2fsck will print the file system +features as part of its verbose reporting (i.e., if the +.B -v +option is specified) +.TP +.I report_time +If this boolean relation is true, e2fsck will run as if the options +.B -tt +are always specified. This will cause e2fsck to print timing statistics +on a pass by pass basis for full file system checks. +.TP +.I report_verbose +If this boolean relation is true, e2fsck will run as if the option +.B -v +is always specified. This will cause e2fsck to print some additional +information at the end of each full file system check. +.SH THE [defaults] STANZA +The following relations are defined in the +.I [defaults] +stanza. +.TP +.I undo_dir +This relation specifies the directory where the undo file should be +stored. It can be overridden via the +.B E2FSPROGS_UNDO_DIR +environment variable. If the directory location is set to the value +.IR none , +.B e2fsck +will not create an undo file. +.SH THE [problems] STANZA +Each tag in the +.I [problems] +stanza names a problem code specified with a leading "0x" followed by +six hex digits. +The value of the tag is a subsection where the relations in that +subsection override the default treatment of that particular problem +code. +.P +Note that inappropriate settings in this stanza may cause +.B e2fsck +to behave incorrectly, or even crash. Most system administrators should +not be making changes to this section without referring to source code. +.P +Within each problem code's subsection, the following tags may be used: +.TP +.I description +This relation allows the message which is printed when this file system +inconsistency is detected to be overridden. +.TP +.I preen_ok +This boolean relation overrides the default behavior controlling +whether this file system problem should be automatically fixed when +.B e2fsck +is running in preen mode. +.TP +.I max_count +This integer relation overrides the +.I max_count_problems +parameter (set in the options section) for this particular problem. +.TP +.I no_ok +This boolean relation overrides the default behavior determining +whether or not the file system will be marked as inconsistent if the user +declines to fix the reported problem. +.TP +.I no_default +This boolean relation overrides whether the default answer for this +problem (or question) should be "no". +.TP +.I preen_nomessage +This boolean relation overrides the default behavior controlling +whether or not the description for this file system problem should +be suppressed when +.B e2fsck +is running in preen mode. +.TP +.I no_nomsg +This boolean relation overrides the default behavior controlling +whether or not the description for this file system problem should +be suppressed when a problem forced not to be fixed, either because +.B e2fsck +is run with the +.B -n +option or because the +.I force_no +flag has been set for the problem. +.TP +.I force_no +This boolean option, if set to true, forces a problem to never be fixed. +That is, it will be as if the user problem responds 'no' to the question +of 'should this problem be fixed?'. The +.I force_no +option even overrides the +.B -y +option given on the command-line (just for the specific problem, of course). +.TP +.I not_a_fix +This boolean option, it set to true, marks the problem as +one where if the user gives permission to make the requested change, +it does not mean that the file system had a problem which has since +been fixed. This is used for requests to optimize the file system's +data structure, such as pruning an extent tree. +@TDB_MAN_COMMENT@.SH THE [scratch_files] STANZA +@TDB_MAN_COMMENT@The following relations are defined in the +@TDB_MAN_COMMENT@.I [scratch_files] +@TDB_MAN_COMMENT@stanza. +@TDB_MAN_COMMENT@.TP +@TDB_MAN_COMMENT@.I directory +@TDB_MAN_COMMENT@If the directory named by this relation exists and is +@TDB_MAN_COMMENT@writeable, then e2fsck will attempt to use this +@TDB_MAN_COMMENT@directory to store scratch files instead of using +@TDB_MAN_COMMENT@in-memory data structures. +@TDB_MAN_COMMENT@.TP +@TDB_MAN_COMMENT@.I numdirs_threshold +@TDB_MAN_COMMENT@If this relation is set, then in-memory data structures +@TDB_MAN_COMMENT@will be used if the number of directories in the file system +@TDB_MAN_COMMENT@are fewer than amount specified. +@TDB_MAN_COMMENT@.TP +@TDB_MAN_COMMENT@.I dirinfo +@TDB_MAN_COMMENT@This relation controls whether or not the scratch file +@TDB_MAN_COMMENT@directory is used instead of an in-memory data +@TDB_MAN_COMMENT@structure for directory information. It defaults to +@TDB_MAN_COMMENT@true. +@TDB_MAN_COMMENT@.TP +@TDB_MAN_COMMENT@.I icount +@TDB_MAN_COMMENT@This relation controls whether or not the scratch file +@TDB_MAN_COMMENT@directory is used instead of an in-memory data +@TDB_MAN_COMMENT@structure when tracking inode counts. It defaults to +@TDB_MAN_COMMENT@true. +.SH LOGGING +E2fsck has the facility to save the information from an e2fsck run in a +directory so that a system administrator can review its output at their +leisure. This allows information captured during the automatic e2fsck +preen run, as well as a manually started e2fsck run, to be saved for +posterity. This facility is controlled by the +.IR log_filename , +.IR log_dir , +.IR log_dir_fallback , +and +.I log_dir_wait +relations in the +.I [options] +stanza. +.PP +The filename in +.I log_filename +may contain the following percent-expressions that will be expanded as +follows. +.TP +.B %d +The current day of the month +.TP +.B %D +The current date; this is a equivalent of +.B %Y%m%d +.TP +.B %h +The hostname of the system. +.TP +.B %H +The current hour in 24-hour format (00..23) +.TP +.B %m +The current month as a two-digit number (01..12) +.TP +.B %M +The current minute (00..59) +.TP +.B %N +The name of the block device containing the file system, with any +directory pathname stripped off. +.TP +.B %p +The pid of the e2fsck process +.TP +.B %s +The current time expressed as the number of seconds since 1970-01-01 +00:00:00 UTC +.TP +.B %S +The current second (00..59) +.TP +.B %T +The current time; this is equivalent of +.B %H%M%S +.TP +.B %u +The name of the user running e2fsck. +.TP +.B %U +This percent expression does not expand to anything, but it signals that +any following date or time expressions should be expressed in UTC time +instead of the local timezone. +.TP +.B %y +The last two digits of the current year (00..99) +.TP +.B %Y +The current year (i.e., 2012). +.SH EXAMPLES +The following recipe will prevent e2fsck from aborting during the boot +process when a file system contains orphaned files. (Of course, this is +not always a good idea, since critical files that are needed for the +security of the system could potentially end up in lost+found, and +starting the system without first having a system administrator check +things out may be dangerous.) +.P +.br + [problems] +.br + 0x040002 = { +.br + preen_ok = true +.br + description = "@u @i %i. " +.br + } +.P +The following recipe will cause an e2fsck logfile to be written to the +directory /var/log/e2fsck, with a filename that contains the device +name, the hostname of the system, the date, and time: e.g., +"e2fsck-sda3.server.INFO.20120314-112142". If the directory containing +/var/log is located on the root file system +which is initially mounted read-only, then the output will be saved in +memory and written out once the root file system has been remounted +read/write. To avoid too much detail from being written to the serial +console (which could potentially slow down the boot sequence), only print +no more than 16 instances of each type of file system corruption. +.P +.br + [options] +.br + max_count_problems = 16 +.br + log_dir = /var/log/e2fsck +.br + log_filename = e2fsck-%N.%h.INFO.%D-%T +.br + log_dir_wait = true +.P +.SH FILES +.TP +.I /etc/e2fsck.conf +The configuration file for +.BR e2fsck (8). +.SH SEE ALSO +.BR e2fsck (8) diff --git a/e2fsck/e2fsck.h b/e2fsck/e2fsck.h new file mode 100644 index 0000000..3f2dc30 --- /dev/null +++ b/e2fsck/e2fsck.h @@ -0,0 +1,738 @@ +/* + * e2fsck.h + * + * Copyright (C) 1993, 1994 Theodore Ts'o. This file may be + * redistributed under the terms of the GNU Public License. + * + */ + +#ifndef _E2FSCK_H +#define _E2FSCK_H + +#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 + +#include "support/profile.h" +#include "support/prof_err.h" + +#ifdef ENABLE_NLS +#include +#include +#define _(a) (gettext (a)) +#ifdef gettext_noop +#define N_(a) gettext_noop (a) +#else +#define N_(a) (a) +#endif +#define P_(singular, plural, n) (ngettext (singular, plural, n)) +#ifndef NLS_CAT_NAME +#define NLS_CAT_NAME "e2fsprogs" +#endif +#ifndef LOCALEDIR +#define LOCALEDIR "/usr/share/locale" +#endif +#else +#define _(a) (a) +#define N_(a) a +#define P_(singular, plural, n) ((n) == 1 ? (singular) : (plural)) +#endif + +#ifdef __GNUC__ +#define E2FSCK_ATTR(x) __attribute__(x) +#else +#define E2FSCK_ATTR(x) +#endif + +#include "support/quotaio.h" +#if __GNUC_PREREQ (4, 6) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wunused-function" +#endif +#include "ext2fs/fast_commit.h" +#if __GNUC_PREREQ (4, 6) +#pragma GCC diagnostic pop +#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 */ + short depth; /* depth of tree (15 bits) */ + __u8 hashversion; + __u8 casefolded_hash:1; + blk_t numblocks; /* number of blocks in dir */ + 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; + int flags; + blk64_t phys; + blk64_t parent; + blk64_t previous; + 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 + +struct encrypted_file_info; + +#define RESOURCE_TRACK + +#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; + unsigned long long bytes_read; + unsigned long long bytes_written; +}; +#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 +#define E2F_OPT_FRAGCHECK 0x0800 +#define E2F_OPT_JOURNAL_ONLY 0x1000 /* only replay the journal */ +#define E2F_OPT_DISCARD 0x2000 +#define E2F_OPT_CONVERT_BMAP 0x4000 /* convert blockmap to extent */ +#define E2F_OPT_FIXES_ONLY 0x8000 /* skip all optimizations */ +#define E2F_OPT_NOOPT_EXTENTS 0x10000 /* don't optimize extents */ +#define E2F_OPT_ICOUNT_FULLMAP 0x20000 /* use an array for inode counts */ +#define E2F_OPT_UNSHARE_BLOCKS 0x40000 +#define E2F_OPT_CLEAR_UNINIT 0x80000 /* Hack to clear the uninit bit */ +#define E2F_OPT_CHECK_ENCODING 0x100000 /* Force verification of encoded filenames */ + +/* + * E2fsck flags + */ +#define E2F_FLAG_ABORT 0x0001 /* Abort signaled */ +#define E2F_FLAG_CANCEL 0x0002 /* Cancel signaled */ +#define E2F_FLAG_SIGNAL_MASK (E2F_FLAG_ABORT | E2F_FLAG_CANCEL) +#define E2F_FLAG_RESTART 0x0004 /* Restart signaled */ +#define E2F_FLAG_RUN_RETURN (E2F_FLAG_SIGNAL_MASK | E2F_FLAG_RESTART) +#define E2F_FLAG_RESTART_LATER 0x0008 /* Restart after all iterations done */ +#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 */ +#define E2F_FLAG_GOT_DEVSIZE 0x0800 /* Device size has been fetched */ +#define E2F_FLAG_EXITING 0x1000 /* E2fsck exiting due to errors */ +#define E2F_FLAG_TIME_INSANE 0x2000 /* Time is insane */ +#define E2F_FLAG_PROBLEMS_FIXED 0x4000 /* At least one problem was fixed */ +#define E2F_FLAG_ALLOC_OK 0x8000 /* Can we allocate blocks? */ + +#define E2F_RESET_FLAGS (E2F_FLAG_TIME_INSANE | E2F_FLAG_PROBLEMS_FIXED) + +/* + * 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; + +#define MAX_EXTENT_DEPTH_COUNT 8 + +/* + * This structure is used to manage the list of extents in a file. Placing + * it here since this is used by fast_commit.h. + */ +struct extent_list { + blk64_t blocks_freed; + struct ext2fs_extent *extents; + unsigned int count; + unsigned int size; + unsigned int ext_read; + errcode_t retval; + ext2_ino_t ino; +}; + +/* State structure for fast commit replay */ +struct e2fsck_fc_replay_state { + struct extent_list fc_extent_list; + int fc_replay_num_tags; + int fc_replay_expected_off; + enum passtype fc_current_pass; + int fc_cur_tag; + unsigned int fc_crc; + __u16 fc_super_state; +}; + +struct e2fsck_struct { + ext2_filsys fs; + const char *program_name; + char *filesystem_name; + char *device_name; + char *io_options; + FILE *logf; + char *log_fn; + FILE *problem_logf; + char *problem_log_fn; + int flags; /* E2fsck internal flags */ + int options; + unsigned blocksize; /* blocksize */ + blk64_t use_superblock; /* sb requested by user */ + blk64_t superblock; /* sb used to open fs */ + blk64_t num_blocks; /* Total number of blocks */ + blk64_t free_blocks; + ext2_ino_t free_inodes; + int mount_flags; + int openfs_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_inode_bitmap inode_casefold_map; /* Inodes which are casefolded */ + + 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; + + /* + * Quota blocks and inodes to be charged for each ea block. + */ + ext2_refcount_t ea_block_quota_blocks; + ext2_refcount_t ea_block_quota_inodes; + + /* + * ea_inode references from attr entries. + */ + ext2_refcount_t ea_inode_refs; + + /* + * 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 + */ + struct dir_info_db *dir_info; + + /* + * Indexed directory information + */ + ext2_ino_t dx_dir_info_count; + ext2_ino_t dx_dir_info_size; + struct dx_dir_info *dx_dir_info; + + /* + * Directories to hash + */ + ext2_u32_list dirs_to_hash; + + /* + * Encrypted file information + */ + struct encrypted_file_info *encrypted_files; + + /* + * Tuning parameters + */ + int process_inode_size; + int inode_buffer_blocks; + unsigned int htree_slack_percentage; + + /* + * ext3 journal support + */ + io_channel journal_io; + char *journal_name; + + /* + * Ext4 quota support + */ + quota_ctx_t qctx; +#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 */ + __u32 fs_directory_count; + __u32 fs_regular_count; + __u32 fs_blockdev_count; + __u32 fs_chardev_count; + __u32 fs_links_count; + __u32 fs_symlinks_count; + __u32 fs_fast_symlinks_count; + __u32 fs_fifo_count; + __u32 fs_total_count; + __u32 fs_badblocks_count; + __u32 fs_sockets_count; + __u32 fs_ind_count; + __u32 fs_dind_count; + __u32 fs_tind_count; + __u32 fs_fragmented; + __u32 fs_fragmented_dir; + __u32 large_files; + __u32 large_dirs; + __u32 fs_ext_attr_inodes; + __u32 fs_ext_attr_blocks; + __u32 extent_depth_count[MAX_EXTENT_DEPTH_COUNT]; + + /* misc fields */ + time_t now; + time_t time_fudge; /* For working around buggy init scripts */ + int ext_attr_ver; + profile_t profile; + int blocks_per_page; + ext2_u32_list casefolded_dirs; + + /* Reserve blocks for root and l+f re-creation */ + blk64_t root_repair_block, lnf_repair_block; + + /* + * For the use of callers of the e2fsck functions; not used by + * e2fsck functions themselves. + */ + void *priv_data; + ext2fs_block_bitmap block_metadata_map; /* Metadata blocks */ + + /* How much are we allowed to readahead? */ + unsigned long long readahead_kb; + + /* + * Inodes to rebuild extent trees + */ + ext2fs_inode_bitmap inodes_to_rebuild; + + /* Undo file */ + char *undo_file; + + /* Fast commit replay state */ + struct e2fsck_fc_replay_state fc_replay_state; +}; + +/* Data structures to evaluate whether an extent tree needs rebuilding. */ +struct extent_tree_level { + unsigned int num_extents; + unsigned int max_extents; +}; + +struct extent_tree_info { + ext2_ino_t ino; + int force_rebuild; + struct extent_tree_level ext_info[MAX_EXTENT_DEPTH_COUNT]; +}; + +/* Used by the region allocation code */ +typedef __u64 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 void e2fsck_free_dir_info(e2fsck_t ctx); +extern int e2fsck_get_num_dirinfo(e2fsck_t ctx); +extern struct dir_info_iter *e2fsck_dir_info_iter_begin(e2fsck_t ctx); +extern struct dir_info *e2fsck_dir_info_iter(e2fsck_t ctx, + struct dir_info_iter *); +extern void e2fsck_dir_info_iter_end(e2fsck_t ctx, struct dir_info_iter *); +extern int e2fsck_dir_info_set_parent(e2fsck_t ctx, ext2_ino_t ino, + ext2_ino_t parent); +extern int e2fsck_dir_info_set_dotdot(e2fsck_t ctx, ext2_ino_t ino, + ext2_ino_t dotdot); +extern int e2fsck_dir_info_get_parent(e2fsck_t ctx, ext2_ino_t ino, + ext2_ino_t *parent); +extern int e2fsck_dir_info_get_dotdot(e2fsck_t ctx, ext2_ino_t ino, + ext2_ino_t *dotdot); + +/* dx_dirinfo.c */ +extern void e2fsck_add_dx_dir(e2fsck_t ctx, ext2_ino_t ino, + struct ext2_inode *inode, 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 ext2_ino_t e2fsck_get_num_dx_dirinfo(e2fsck_t ctx); +extern struct dx_dir_info *e2fsck_dx_dir_info_iter(e2fsck_t ctx, + ext2_ino_t *control); + +/* ea_refcount.c */ +typedef __u64 ea_key_t; +typedef __u64 ea_value_t; + +extern errcode_t ea_refcount_create(size_t size, ext2_refcount_t *ret); +extern void ea_refcount_free(ext2_refcount_t refcount); +extern errcode_t ea_refcount_fetch(ext2_refcount_t refcount, ea_key_t ea_key, + ea_value_t *ret); +extern errcode_t ea_refcount_increment(ext2_refcount_t refcount, + ea_key_t ea_key, ea_value_t *ret); +extern errcode_t ea_refcount_decrement(ext2_refcount_t refcount, + ea_key_t ea_key, ea_value_t *ret); +extern errcode_t ea_refcount_store(ext2_refcount_t refcount, ea_key_t ea_key, + ea_value_t count); +extern size_t ext2fs_get_refcount_size(ext2_refcount_t refcount); +extern void ea_refcount_intr_begin(ext2_refcount_t refcount); +extern ea_key_t ea_refcount_intr_next(ext2_refcount_t refcount, + ea_value_t *ret); + +/* ehandler.c */ +extern const char *ehandler_operation(const char *op); +extern void ehandler_init(io_channel channel); + +/* encrypted_files.c */ + +struct problem_context; +int add_encrypted_file(e2fsck_t ctx, struct problem_context *pctx); + +#define NO_ENCRYPTION_POLICY ((__u32)-1) +#define CORRUPT_ENCRYPTION_POLICY ((__u32)-2) +#define UNRECOGNIZED_ENCRYPTION_POLICY ((__u32)-3) +__u32 find_encryption_policy(e2fsck_t ctx, ext2_ino_t ino); + +void destroy_encryption_policy_map(e2fsck_t ctx); +void destroy_encrypted_file_info(e2fsck_t ctx); + +/* extents.c */ +errcode_t e2fsck_rebuild_extents_later(e2fsck_t ctx, ext2_ino_t ino); +int e2fsck_ino_will_be_rebuilt(e2fsck_t ctx, ext2_ino_t ino); +void e2fsck_pass1e(e2fsck_t ctx); +errcode_t e2fsck_check_rebuild_extents(e2fsck_t ctx, ext2_ino_t ino, + struct ext2_inode *inode, + struct problem_context *pctx); +errcode_t e2fsck_should_rebuild_extents(e2fsck_t ctx, + struct problem_context *pctx, + struct extent_tree_info *eti, + struct ext2_extent_info *info); +errcode_t e2fsck_read_extents(e2fsck_t ctx, struct extent_list *extents); +errcode_t e2fsck_rewrite_extent_tree(e2fsck_t ctx, + struct extent_list *extents); + +/* journal.c */ +extern errcode_t e2fsck_check_ext3_journal(e2fsck_t ctx); +extern errcode_t e2fsck_run_ext3_journal(e2fsck_t ctx); +extern void e2fsck_move_ext3_journal(e2fsck_t ctx); +extern int e2fsck_fix_ext3_journal_hint(e2fsck_t ctx); + +/* logfile.c */ +extern void set_up_logging(e2fsck_t ctx); + +/* quota.c */ +extern void e2fsck_hide_quota(e2fsck_t ctx); +extern void e2fsck_validate_quota_inodes(e2fsck_t ctx); + +/* pass1.c */ +extern errcode_t e2fsck_setup_icount(e2fsck_t ctx, const char *icount_name, + int flags, ext2_icount_t hint, + ext2_icount_t *ret); +extern void e2fsck_use_inode_shortcuts(e2fsck_t ctx, int use_shortcuts); +extern int e2fsck_pass1_check_device_inode(ext2_filsys fs, + struct ext2_inode *inode); +extern int e2fsck_pass1_check_symlink(ext2_filsys fs, ext2_ino_t ino, + struct ext2_inode *inode, char *buf); +extern void e2fsck_clear_inode(e2fsck_t ctx, ext2_ino_t ino, + struct ext2_inode *inode, int restart_flag, + const char *source); +extern void e2fsck_intercept_block_allocations(e2fsck_t ctx); + +/* 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); + +/* readahead.c */ +#define E2FSCK_READA_SUPER (0x01) +#define E2FSCK_READA_GDT (0x02) +#define E2FSCK_READA_BBITMAP (0x04) +#define E2FSCK_READA_IBITMAP (0x08) +#define E2FSCK_READA_ITABLE (0x10) +#define E2FSCK_READA_ALL_FLAGS (0x1F) +errcode_t e2fsck_readahead(ext2_filsys fs, int flags, dgrp_t start, + dgrp_t ngroups); +#define E2FSCK_RA_DBLIST_IGNORE_BLOCKCNT (0x01) +#define E2FSCK_RA_DBLIST_ALL_FLAGS (0x01) +errcode_t e2fsck_readahead_dblist(ext2_filsys fs, int flags, + ext2_dblist dblist, + unsigned long long start, + unsigned long long count); +int e2fsck_can_readahead(ext2_filsys fs); +unsigned long long e2fsck_guess_readahead(ext2_filsys fs); + +/* 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 */ +void e2fsck_rehash_dir_later(e2fsck_t ctx, ext2_ino_t ino); +int e2fsck_dir_will_be_rehashed(e2fsck_t ctx, ext2_ino_t ino); +errcode_t e2fsck_rehash_dir(e2fsck_t ctx, ext2_ino_t ino, + struct problem_context *pctx); +void e2fsck_rehash_directories(e2fsck_t ctx); + +/* sigcatcher.c */ +void sigcatcher_setup(void); + +/* super.c */ +void check_super_block(e2fsck_t ctx); +int check_backup_super_block(e2fsck_t ctx); +void check_resize_inode(e2fsck_t ctx); +int check_init_orphan_file(e2fsck_t ctx); + +/* util.c */ +extern void *e2fsck_allocate_memory(e2fsck_t ctx, unsigned long size, + const char *description); +extern int ask(e2fsck_t ctx, const char * string, int def); +extern int ask_yn(e2fsck_t ctx, const char * string, int def); +extern void fatal_error(e2fsck_t ctx, const char * fmt_string); +extern void log_out(e2fsck_t ctx, const char *fmt, ...) + E2FSCK_ATTR((format(printf, 2, 3))); +extern void log_err(e2fsck_t ctx, const char *fmt, ...) + E2FSCK_ATTR((format(printf, 2, 3))); +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, size_t len); +extern int fs_proc_check(const char *fs_name); +extern int check_for_modules(const char *fs_name); +#ifdef RESOURCE_TRACK +extern void print_resource_track(e2fsck_t ctx, + const char *desc, + struct resource_track *track, + io_channel channel); +extern void init_resource_track(struct resource_track *track, + io_channel channel); +#else +#define print_resource_track(ctx, desc, track, channel) do { } while (0) +#define init_resource_track(track, channel) do { } while (0) +#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_read_inode_full(e2fsck_t ctx, unsigned long ino, + struct ext2_inode *inode, + const int bufsize, const char *proc); +extern void e2fsck_write_inode(e2fsck_t ctx, unsigned long ino, + struct ext2_inode * inode, const char * proc); +extern void e2fsck_write_inode_full(e2fsck_t ctx, unsigned long ino, + struct ext2_inode * inode, int bufsize, + const char *proc); +#ifdef MTRACE +extern void mtrace_print(char *mesg); +#endif +extern blk64_t get_backup_sb(e2fsck_t ctx, ext2_filsys fs, + const char *name, io_manager manager); +extern int ext2_file_type(unsigned int mode); +extern int write_all(int fd, char *buf, size_t count); +void dump_mmp_msg(struct mmp_struct *mmp, const char *fmt, ...) + E2FSCK_ATTR((format(printf, 2, 3))); +errcode_t e2fsck_mmp_update(ext2_filsys fs); + +extern void e2fsck_set_bitmap_type(ext2_filsys fs, + unsigned int default_type, + const char *profile_name, + unsigned int *old_type); +extern errcode_t e2fsck_allocate_inode_bitmap(ext2_filsys fs, + const char *descr, + int default_type, + const char *profile_name, + ext2fs_inode_bitmap *ret); +extern errcode_t e2fsck_allocate_block_bitmap(ext2_filsys fs, + const char *descr, + int default_type, + const char *profile_name, + ext2fs_block_bitmap *ret); +extern errcode_t e2fsck_allocate_subcluster_bitmap(ext2_filsys fs, + const char *descr, + int default_type, + const char *profile_name, + ext2fs_block_bitmap *ret); +unsigned long long get_memory_size(void); + +/* 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); + +#define DIV_ROUND_UP(n,d) (((n) + (d) - 1) / (d)) + +#endif /* _E2FSCK_H */ diff --git a/e2fsck/ea_refcount.c b/e2fsck/ea_refcount.c new file mode 100644 index 0000000..7154b47 --- /dev/null +++ b/e2fsck/ea_refcount.c @@ -0,0 +1,476 @@ +/* + * ea_refcount.c + * + * Copyright (C) 2001 Theodore Ts'o. This file may be + * redistributed under the terms of the GNU Public License. + */ + +#include "config.h" +#if HAVE_UNISTD_H +#include +#endif +#include +#include + +#ifdef TEST_PROGRAM +#undef ENABLE_NLS +#endif +#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 { + /* ea_key could either be an inode number or block number. */ + ea_key_t ea_key; + ea_value_t ea_value; +}; + +struct ea_refcount { + size_t count; + size_t size; + size_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(size_t size, ext2_refcount_t *ret) +{ + ext2_refcount_t refcount; + errcode_t retval; + size_t bytes; + + retval = ext2fs_get_memzero(sizeof(struct ea_refcount), &refcount); + if (retval) + return retval; + + if (!size) + size = 500; + refcount->size = size; + bytes = size * sizeof(struct ea_refcount_el); +#ifdef DEBUG + printf("Refcount allocated %zu entries, %zu bytes.\n", + refcount->size, bytes); +#endif + retval = ext2fs_get_memzero(bytes, &refcount->list); + if (retval) + goto errout; + + 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_value) { + if (i != j) + list[j] = list[i]; + j++; + } + } +#if defined(DEBUG) || defined(TEST_PROGRAM) + printf("Refcount_collapse: size was %zu, 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, + ea_key_t ea_key, int pos) +{ + struct ea_refcount_el *el; + errcode_t retval; + size_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_key = ea_key; + el->ea_value = 0; + 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, + ea_key_t ea_key, int create) +{ + int low, high, mid; + + if (!refcount || !refcount->list) + return 0; +retry: + low = 0; + high = (int) refcount->count-1; + if (create && ((refcount->count == 0) || + (ea_key > refcount->list[high].ea_key))) { + if (refcount->count >= refcount->size) + refcount_collapse(refcount); + + return insert_refcount_el(refcount, ea_key, + (unsigned) refcount->count); + } + if (refcount->count == 0) + return 0; + + if (refcount->cursor >= refcount->count) + refcount->cursor = 0; + if (ea_key == refcount->list[refcount->cursor].ea_key) + return &refcount->list[refcount->cursor++]; +#ifdef DEBUG + printf("Non-cursor get_refcount_el: %u\n", ea_key); +#endif + while (low <= high) { + mid = (low+high)/2; + if (ea_key == refcount->list[mid].ea_key) { + refcount->cursor = mid+1; + return &refcount->list[mid]; + } + if (ea_key < refcount->list[mid].ea_key) + 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, ea_key, low); + } + return 0; +} + +errcode_t ea_refcount_fetch(ext2_refcount_t refcount, ea_key_t ea_key, + ea_value_t *ret) +{ + struct ea_refcount_el *el; + + el = get_refcount_el(refcount, ea_key, 0); + if (!el) { + *ret = 0; + return 0; + } + *ret = el->ea_value; + return 0; +} + +errcode_t ea_refcount_increment(ext2_refcount_t refcount, ea_key_t ea_key, + ea_value_t *ret) +{ + struct ea_refcount_el *el; + + el = get_refcount_el(refcount, ea_key, 1); + if (!el) + return EXT2_ET_NO_MEMORY; + el->ea_value++; + + if (ret) + *ret = el->ea_value; + return 0; +} + +errcode_t ea_refcount_decrement(ext2_refcount_t refcount, ea_key_t ea_key, + ea_value_t *ret) +{ + struct ea_refcount_el *el; + + el = get_refcount_el(refcount, ea_key, 0); + if (!el || el->ea_value == 0) + return EXT2_ET_INVALID_ARGUMENT; + + el->ea_value--; + + if (ret) + *ret = el->ea_value; + return 0; +} + +errcode_t ea_refcount_store(ext2_refcount_t refcount, ea_key_t ea_key, + ea_value_t ea_value) +{ + struct ea_refcount_el *el; + + /* + * Get the refcount element + */ + el = get_refcount_el(refcount, ea_key, ea_value ? 1 : 0); + if (!el) + return ea_value ? EXT2_ET_NO_MEMORY : 0; + el->ea_value = ea_value; + return 0; +} + +size_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; +} + +ea_key_t ea_refcount_intr_next(ext2_refcount_t refcount, + ea_value_t *ret) +{ + struct ea_refcount_el *list; + + while (1) { + if (refcount->cursor >= refcount->count) + return 0; + list = refcount->list; + if (list[refcount->cursor].ea_value) { + if (ret) + *ret = list[refcount->cursor].ea_value; + return list[refcount->cursor++].ea_key; + } + 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_key >= refcount->list[i].ea_key) { + fprintf(out, + "%s: list[%d].ea_key=%llu, list[%d].ea_key=%llu\n", + bad, i-1, + (unsigned long long) refcount->list[i-1].ea_key, + i, + (unsigned long long) refcount->list[i].ea_key); + 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; + size_t size; + ea_key_t ea_key; + ea_value_t arg; + 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, + "while creating size %zu", size); + exit(1); + } else + printf("Creating refcount with size %zu\n", + size); + break; + case BCODE_FREE: + ea_refcount_free(refcount); + refcount = 0; + printf("Freeing refcount\n"); + break; + case BCODE_STORE: + ea_key = (size_t) bcode_program[i++]; + arg = bcode_program[i++]; + printf("Storing ea_key %llu with value %llu\n", + (unsigned long long) ea_key, + (unsigned long long) arg); + retval = ea_refcount_store(refcount, ea_key, arg); + if (retval) + com_err("ea_refcount_store", retval, + "while storing ea_key %llu", + (unsigned long long) ea_key); + break; + case BCODE_FETCH: + ea_key = (size_t) bcode_program[i++]; + retval = ea_refcount_fetch(refcount, ea_key, &arg); + if (retval) + com_err("ea_refcount_fetch", retval, + "while fetching ea_key %llu", + (unsigned long long) ea_key); + else + printf("bcode_fetch(%llu) returns %llu\n", + (unsigned long long) ea_key, + (unsigned long long) arg); + break; + case BCODE_INCR: + ea_key = (size_t) bcode_program[i++]; + retval = ea_refcount_increment(refcount, ea_key, &arg); + if (retval) + com_err("ea_refcount_increment", retval, + "while incrementing ea_key %llu", + (unsigned long long) ea_key); + else + printf("bcode_increment(%llu) returns %llu\n", + (unsigned long long) ea_key, + (unsigned long long) arg); + break; + case BCODE_DECR: + ea_key = (size_t) bcode_program[i++]; + retval = ea_refcount_decrement(refcount, ea_key, &arg); + if (retval) + com_err("ea_refcount_decrement", retval, + "while decrementing ea_key %llu", + (unsigned long long) ea_key); + else + printf("bcode_decrement(%llu) returns %llu\n", + (unsigned long long) ea_key, + (unsigned long long) arg); + break; + case BCODE_VALIDATE: + retval = ea_refcount_validate(refcount, stderr); + if (retval) + com_err("ea_refcount_validate", retval, + "while validating"); + else + printf("Refcount validation OK.\n"); + break; + case BCODE_LIST: + ea_refcount_intr_begin(refcount); + while (1) { + ea_key = ea_refcount_intr_next(refcount, &arg); + if (!ea_key) + break; + printf("\tea_key=%llu, count=%llu\n", + (unsigned long long) ea_key, + (unsigned long long) arg); + } + break; + case BCODE_COLLAPSE: + refcount_collapse(refcount); + break; + } + + } +} + +#endif diff --git a/e2fsck/ehandler.c b/e2fsck/ehandler.c new file mode 100644 index 0000000..71ca301 --- /dev/null +++ b/e2fsck/ehandler.c @@ -0,0 +1,133 @@ +/* + * 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 "config.h" +#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 (ctx->flags & E2F_FLAG_EXITING) + return 0; + /* + * 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_blk64(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); + + /* Don't rewrite a block past the end of the FS. */ + if (block >= ext2fs_blocks_count(fs->super)) + return 0; + + if (ask(ctx, _("Ignore error"), 1)) { + if (ask(ctx, _("Force rewrite"), 1)) + io_channel_write_blk64(channel, block, count, 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 (ctx->flags & E2F_FLAG_EXITING) + return 0; + + /* + * 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_blk64(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/e2fsck/emptydir.c b/e2fsck/emptydir.c new file mode 100644 index 0000000..7aea7b6 --- /dev/null +++ b/e2fsck/emptydir.c @@ -0,0 +1,194 @@ +/* + * emptydir.c --- clear empty directory blocks + * + * Copyright (C) 1998 Theodore Ts'o + * + * %Begin-Header% + * This file may be redistributed under the terms of the GNU Public + * License. + * %End-Header% + * + * This file has the necessary routines to search for empty directory + * blocks and get rid of them. + */ + +#include "config.h" +#include "e2fsck.h" +#include "problem.h" + +/* + * For e2fsck.h + */ +struct empty_dir_info_struct { + ext2_dblist empty_dblist; + ext2fs_block_bitmap empty_dir_blocks; + ext2fs_inode_bitmap dir_map; + char *block_buf; + ext2_ino_t ino; + struct ext2_inode inode; + blk64_t logblk; + blk64_t freed_blocks; +}; + +typedef struct empty_dir_info_struct *empty_dir_info; + +extern empty_dir_info init_empty_dir(e2fsck_t ctx); +extern void free_empty_dirblock(empty_dir_info edi); +extern void add_empty_dirblock(empty_dir_info edi, + struct ext2_db_entry2 *db); +extern void process_empty_dirblock(e2fsck_t ctx, empty_dir_info edi); + + +empty_dir_info init_empty_dir(e2fsck_t ctx) +{ + empty_dir_info edi; + errcode_t retval; + + edi = e2fsck_allocate_memzero(ctx, sizeof(struct empty_dir_info_struct), + "empty dir info"); + if (retval) + return NULL; + + retval = ext2fs_init_dblist(ctx->fs, &edi->empty_dblist); + if (retval) + goto errout; + + retval = ext2fs_allocate_block_bitmap(ctx->fs, _("empty dirblocks"), + &edi->empty_dir_blocks); + if (retval) + goto errout; + + retval = ext2fs_allocate_inode_bitmap(ctx->fs, _("empty dir map"), + &edi->dir_map); + if (retval) + goto errout; + + return (edi); + +errout: + free_empty_dirblock(edi); + return NULL; +} + +void free_empty_dirblock(empty_dir_info edi) +{ + if (!edi) + return; + if (edi->empty_dblist) + ext2fs_free_dblist(edi->empty_dblist); + if (edi->empty_dir_blocks) + ext2fs_free_block_bitmap(edi->empty_dir_blocks); + if (edi->dir_map) + ext2fs_free_inode_bitmap(edi->dir_map); + + memset(edi, 0, sizeof(struct empty_dir_info_struct)); + ext2fs_free_mem(&edi); +} + +void add_empty_dirblock(empty_dir_info edi, + struct ext2_db_entry2 *db) +{ + if (!edi || !db) + return; + + if (db->ino == 11) + return; /* Inode number 11 is usually lost+found */ + + printf(_("Empty directory block %u (#%d) in inode %u\n"), + db->blk, db->blockcnt, db->ino); + + ext2fs_mark_block_bitmap2(edi->empty_dir_blocks, db->blk); + if (ext2fs_test_inode_bitmap(edi->dir_map, db->ino)) + return; + ext2fs_mark_inode_bitmap(edi->dir_map, db->ino); + + ext2fs_add_dir_block2(edi->empty_dblist, db->ino, + db->blk, db->blockcnt); +} + +/* + * Helper function used by fix_directory. + * + * XXX need to finish this. General approach is to use bmap to + * iterate over all of the logical blocks using the bmap function, and + * copy the block reference as necessary. Big question --- what do + * about error recovery? + * + * Also question --- how to free the indirect blocks. + */ +int empty_pass1(ext2_filsys fs, blk64_t *block_nr, e2_blkcnt_t blockcnt, + blk64_t ref_block, int ref_offset, void *priv_data) +{ + empty_dir_info edi = (empty_dir_info) priv_data; + blk64_t block, new_block; + errcode_t retval; + + if (blockcnt < 0) + return 0; + block = *block_nr; + do { + retval = ext2fs_bmap2(fs, edi->ino, &edi->inode, + edi->block_buf, 0, edi->logblk, 0, + &new_block); + if (retval) + return DIRENT_ABORT; /* XXX what to do? */ + if (new_block == 0) + break; + edi->logblk++; + } while (ext2fs_test_block_bitmap2(edi->empty_dir_blocks, new_block)); + + if (new_block == block) + return 0; + if (new_block == 0) + edi->freed_blocks++; + *block_nr = new_block; + return BLOCK_CHANGED; +} + +static int fix_directory(ext2_filsys fs, + struct ext2_db_entry2 *db, + void *priv_data) +{ + errcode_t retval; + + empty_dir_info edi = (empty_dir_info) priv_data; + + edi->logblk = 0; + edi->freed_blocks = 0; + edi->ino = db->ino; + + retval = ext2fs_read_inode(fs, db->ino, &edi->inode); + if (retval) + return 0; + + retval = ext2fs_block_iterate3(fs, db->ino, 0, edi->block_buf, + empty_pass1, edi); + if (retval) + return 0; + + if (edi->freed_blocks) { + edi->inode.i_size -= edi->freed_blocks * fs->blocksize; + ext2fs_iblk_add_blocks(fs, &edi->inode, edi->freed_blocks); + retval = ext2fs_write_inode(fs, db->ino, &edi->inode); + if (retval) + return 0; + } + return 0; +} + +void process_empty_dirblock(e2fsck_t ctx, empty_dir_info edi) +{ + if (!edi) + return; + + retval = ext2f_get_mem(ctx, ctx->fs->blocksize * 3, + &edi->block_buf); + + if (edi->block_buf) { + (void) ext2fs_dblist_iterate2(edi->empty_dblist, + fix_directory, &edi); + } + ext2fs_free_mem(&edi->block_buf); + free_empty_dirblock(edi); +} + diff --git a/e2fsck/encrypted_files.c b/e2fsck/encrypted_files.c new file mode 100644 index 0000000..16be2d6 --- /dev/null +++ b/e2fsck/encrypted_files.c @@ -0,0 +1,458 @@ +/* + * encrypted_files.c --- save information about encrypted files + * + * Copyright 2019 Google LLC + * + * %Begin-Header% + * This file may be redistributed under the terms of the GNU Public + * License. + * %End-Header% + */ + +/* + * e2fsck pass 1 (inode table scan) creates a map from inode number to + * encryption policy for all encrypted inodes. But it's optimized so that the + * full xattrs aren't saved but rather only 32-bit "policy IDs", since usually + * many inodes share the same encryption policy. This requires also maintaining + * a second map, from policy to policy ID. See add_encrypted_file(). + * + * We also use run-length encoding to save memory when many adjacent inodes + * share the same encryption policy, which is often the case too. + * + * e2fsck pass 2 (directory structure check) uses the inode => policy ID map to + * verify that all regular files, directories, and symlinks in encrypted + * directories use the directory's encryption policy. + */ + +#include "config.h" + +#include "e2fsck.h" +#include "problem.h" +#include "ext2fs/rbtree.h" + +#define FSCRYPT_KEY_DESCRIPTOR_SIZE 8 +#define FSCRYPT_KEY_IDENTIFIER_SIZE 16 +#define FS_KEY_DERIVATION_NONCE_SIZE 16 + +struct fscrypt_context_v1 { + __u8 version; + __u8 contents_encryption_mode; + __u8 filenames_encryption_mode; + __u8 flags; + __u8 master_key_descriptor[FSCRYPT_KEY_DESCRIPTOR_SIZE]; + __u8 nonce[FS_KEY_DERIVATION_NONCE_SIZE]; +}; + +struct fscrypt_context_v2 { + __u8 version; + __u8 contents_encryption_mode; + __u8 filenames_encryption_mode; + __u8 flags; + __u8 __reserved[4]; + __u8 master_key_identifier[FSCRYPT_KEY_IDENTIFIER_SIZE]; + __u8 nonce[FS_KEY_DERIVATION_NONCE_SIZE]; +}; + +/* On-disk format of encryption xattr */ +union fscrypt_context { + __u8 version; + struct fscrypt_context_v1 v1; + struct fscrypt_context_v2 v2; +}; + +struct fscrypt_policy_v1 { + __u8 version; + __u8 contents_encryption_mode; + __u8 filenames_encryption_mode; + __u8 flags; + __u8 master_key_descriptor[FSCRYPT_KEY_DESCRIPTOR_SIZE]; +}; + +struct fscrypt_policy_v2 { + __u8 version; + __u8 contents_encryption_mode; + __u8 filenames_encryption_mode; + __u8 flags; + __u8 __reserved[4]; + __u8 master_key_identifier[FSCRYPT_KEY_IDENTIFIER_SIZE]; +}; + +/* The encryption "policy" is the fscrypt_context excluding the nonce. */ +union fscrypt_policy { + __u8 version; + struct fscrypt_policy_v1 v1; + struct fscrypt_policy_v2 v2; +}; + +/* A range of inodes which share the same encryption policy */ +struct encrypted_file_range { + ext2_ino_t first_ino; + ext2_ino_t last_ino; + __u32 policy_id; +}; + +/* Information about the encrypted files which have been seen so far */ +struct encrypted_file_info { + /* + * Map from inode number to encryption policy ID, implemented as a + * sorted array of inode ranges, each of which shares the same policy. + * Inodes are added in order of increasing inode number. + * + * Freed after pass 2. + */ + struct encrypted_file_range *file_ranges; + size_t file_ranges_count; + size_t file_ranges_capacity; + + /* + * Map from encryption policy to encryption policy ID, for the unique + * encryption policies that have been seen so far. next_policy_id is + * the next available ID, starting at 0. + * + * Freed after pass 1. + */ + struct rb_root policies; + __u32 next_policy_id; +}; + +/* Entry in encrypted_file_info::policies */ +struct policy_map_entry { + union fscrypt_policy policy; + __u32 policy_id; + struct rb_node node; +}; + +static int cmp_fscrypt_policies(e2fsck_t ctx, const union fscrypt_policy *a, + const union fscrypt_policy *b) +{ + if (a->version != b->version) + return (int)a->version - (int)b->version; + + switch (a->version) { + case 1: + return memcmp(a, b, sizeof(a->v1)); + case 2: + return memcmp(a, b, sizeof(a->v2)); + } + fatal_error(ctx, "Unhandled encryption policy version"); + return 0; +} + +/* Read an inode's encryption xattr. */ +static errcode_t read_encryption_xattr(e2fsck_t ctx, ext2_ino_t ino, + void **value, size_t *value_len) +{ + struct ext2_xattr_handle *h; + errcode_t retval; + + retval = ext2fs_xattrs_open(ctx->fs, ino, &h); + if (retval) + return retval; + + retval = ext2fs_xattrs_read(h); + if (retval == 0) + retval = ext2fs_xattr_get(h, "c", value, value_len); + + ext2fs_xattrs_close(&h); + return retval; +} + +/* + * Convert an fscrypt_context to an fscrypt_policy. Returns 0, + * CORRUPT_ENCRYPTION_POLICY, or UNRECOGNIZED_ENCRYPTION_POLICY. + */ +static __u32 fscrypt_context_to_policy(const void *xattr, size_t xattr_size, + union fscrypt_policy *policy_u) +{ + const union fscrypt_context *ctx_u = xattr; + + if (xattr_size < 1) + return CORRUPT_ENCRYPTION_POLICY; + switch (ctx_u->version) { + case 0: + return CORRUPT_ENCRYPTION_POLICY; + case 1: { + struct fscrypt_policy_v1 *policy = &policy_u->v1; + const struct fscrypt_context_v1 *ctx = &ctx_u->v1; + + if (xattr_size != sizeof(*ctx)) + return CORRUPT_ENCRYPTION_POLICY; + policy->version = ctx->version; + policy->contents_encryption_mode = + ctx->contents_encryption_mode; + policy->filenames_encryption_mode = + ctx->filenames_encryption_mode; + policy->flags = ctx->flags; + memcpy(policy->master_key_descriptor, + ctx->master_key_descriptor, + sizeof(policy->master_key_descriptor)); + return 0; + } + case 2: { + struct fscrypt_policy_v2 *policy = &policy_u->v2; + const struct fscrypt_context_v2 *ctx = &ctx_u->v2; + + if (xattr_size != sizeof(*ctx)) + return CORRUPT_ENCRYPTION_POLICY; + policy->version = ctx->version; + policy->contents_encryption_mode = + ctx->contents_encryption_mode; + policy->filenames_encryption_mode = + ctx->filenames_encryption_mode; + policy->flags = ctx->flags; + memcpy(policy->__reserved, ctx->__reserved, + sizeof(policy->__reserved)); + memcpy(policy->master_key_identifier, + ctx->master_key_identifier, + sizeof(policy->master_key_identifier)); + return 0; + } + } + return UNRECOGNIZED_ENCRYPTION_POLICY; +} + +/* + * Read an inode's encryption xattr and get/allocate its encryption policy ID, + * or alternatively use one of the special IDs NO_ENCRYPTION_POLICY, + * CORRUPT_ENCRYPTION_POLICY, or UNRECOGNIZED_ENCRYPTION_POLICY. + * + * Returns nonzero only if out of memory. + */ +static errcode_t get_encryption_policy_id(e2fsck_t ctx, ext2_ino_t ino, + __u32 *policy_id_ret) +{ + struct encrypted_file_info *info = ctx->encrypted_files; + struct rb_node **new = &info->policies.rb_node; + struct rb_node *parent = NULL; + void *xattr; + size_t xattr_size; + union fscrypt_policy policy; + __u32 policy_id; + struct policy_map_entry *entry; + errcode_t retval; + + retval = read_encryption_xattr(ctx, ino, &xattr, &xattr_size); + if (retval == EXT2_ET_NO_MEMORY) + return retval; + if (retval) { + *policy_id_ret = NO_ENCRYPTION_POLICY; + return 0; + } + + /* Translate the xattr to an fscrypt_policy, if possible. */ + policy_id = fscrypt_context_to_policy(xattr, xattr_size, &policy); + ext2fs_free_mem(&xattr); + if (policy_id != 0) + goto out; + + /* Check if the policy was already seen. */ + while (*new) { + int res; + + parent = *new; + entry = ext2fs_rb_entry(parent, struct policy_map_entry, node); + res = cmp_fscrypt_policies(ctx, &policy, &entry->policy); + if (res < 0) { + new = &parent->rb_left; + } else if (res > 0) { + new = &parent->rb_right; + } else { + /* Policy already seen. Use existing ID. */ + policy_id = entry->policy_id; + goto out; + } + } + + /* First time seeing this policy. Allocate a new policy ID. */ + retval = ext2fs_get_mem(sizeof(*entry), &entry); + if (retval) + goto out; + policy_id = info->next_policy_id++; + entry->policy_id = policy_id; + entry->policy = policy; + ext2fs_rb_link_node(&entry->node, parent, new); + ext2fs_rb_insert_color(&entry->node, &info->policies); +out: + *policy_id_ret = policy_id; + return retval; +} + +static int handle_nomem(e2fsck_t ctx, struct problem_context *pctx, + size_t size_needed) +{ + pctx->num = size_needed; + fix_problem(ctx, PR_1_ALLOCATE_ENCRYPTED_INODE_LIST, pctx); + /* Should never get here */ + ctx->flags |= E2F_FLAG_ABORT; + return 0; +} + +static int append_ino_and_policy_id(e2fsck_t ctx, struct problem_context *pctx, + ext2_ino_t ino, __u32 policy_id) +{ + struct encrypted_file_info *info = ctx->encrypted_files; + struct encrypted_file_range *range; + + /* See if we can just extend the last range. */ + if (info->file_ranges_count > 0) { + range = &info->file_ranges[info->file_ranges_count - 1]; + + if (ino <= range->last_ino) { + /* Should never get here */ + fatal_error(ctx, + "Encrypted inodes processed out of order"); + } + + if (ino == range->last_ino + 1 && + policy_id == range->policy_id) { + range->last_ino++; + return 0; + } + } + /* Nope, a new range is needed. */ + + if (info->file_ranges_count == info->file_ranges_capacity) { + /* Double the capacity by default. */ + size_t new_capacity = info->file_ranges_capacity * 2; + + /* ... but go from 0 to 128 right away. */ + if (new_capacity < 128) + new_capacity = 128; + + /* We won't need more than the filesystem's inode count. */ + if (new_capacity > ctx->fs->super->s_inodes_count) + new_capacity = ctx->fs->super->s_inodes_count; + + /* To be safe, ensure the capacity really increases. */ + if (new_capacity < info->file_ranges_capacity + 1) + new_capacity = info->file_ranges_capacity + 1; + + if (ext2fs_resize_mem(info->file_ranges_capacity * + sizeof(*range), + new_capacity * sizeof(*range), + &info->file_ranges) != 0) + return handle_nomem(ctx, pctx, + new_capacity * sizeof(*range)); + + info->file_ranges_capacity = new_capacity; + } + range = &info->file_ranges[info->file_ranges_count++]; + range->first_ino = ino; + range->last_ino = ino; + range->policy_id = policy_id; + return 0; +} + +/* + * Handle an inode that has EXT4_ENCRYPT_FL set during pass 1. Normally this + * just finds the unique ID that identifies the inode's encryption policy + * (allocating a new ID if needed), and adds the inode number and its policy ID + * to the encrypted_file_info so that it's available in pass 2. + * + * But this also handles: + * - If the inode doesn't have an encryption xattr at all, offer to clear the + * encrypt flag. + * - If the encryption xattr is clearly corrupt, tell the caller that the whole + * inode should be cleared. + * - To be future-proof: if the encryption xattr has an unrecognized version + * number, it *might* be valid, so we don't consider it invalid. But we can't + * do much with it, so give all such policies the same ID, + * UNRECOGNIZED_ENCRYPTION_POLICY. + * + * Returns -1 if the inode should be cleared, otherwise 0. + */ +int add_encrypted_file(e2fsck_t ctx, struct problem_context *pctx) +{ + struct encrypted_file_info *info = ctx->encrypted_files; + ext2_ino_t ino = pctx->ino; + __u32 policy_id; + + /* Allocate the encrypted_file_info if needed. */ + if (info == NULL) { + if (ext2fs_get_memzero(sizeof(*info), &info) != 0) + return handle_nomem(ctx, pctx, sizeof(*info)); + ctx->encrypted_files = info; + } + + /* Get a unique ID for this inode's encryption policy. */ + if (get_encryption_policy_id(ctx, ino, &policy_id) != 0) + return handle_nomem(ctx, pctx, 0 /* unknown size */); + if (policy_id == NO_ENCRYPTION_POLICY) { + if (fix_problem(ctx, PR_1_MISSING_ENCRYPTION_XATTR, pctx)) { + pctx->inode->i_flags &= ~EXT4_ENCRYPT_FL; + e2fsck_write_inode(ctx, ino, pctx->inode, "pass1"); + } + return 0; + } else if (policy_id == CORRUPT_ENCRYPTION_POLICY) { + if (fix_problem(ctx, PR_1_CORRUPT_ENCRYPTION_XATTR, pctx)) + return -1; + return 0; + } + + /* Store this ino => policy_id mapping in the encrypted_file_info. */ + return append_ino_and_policy_id(ctx, pctx, ino, policy_id); +} + +/* + * Find the ID of an inode's encryption policy, using the information saved + * earlier. + * + * If the inode is encrypted, returns the policy ID or + * UNRECOGNIZED_ENCRYPTION_POLICY. Else, returns NO_ENCRYPTION_POLICY. + */ +__u32 find_encryption_policy(e2fsck_t ctx, ext2_ino_t ino) +{ + const struct encrypted_file_info *info = ctx->encrypted_files; + size_t l, r; + + if (info == NULL) + return NO_ENCRYPTION_POLICY; + l = 0; + r = info->file_ranges_count; + while (l < r) { + size_t m = l + (r - l) / 2; + const struct encrypted_file_range *range = + &info->file_ranges[m]; + + if (ino < range->first_ino) + r = m; + else if (ino > range->last_ino) + l = m + 1; + else + return range->policy_id; + } + return NO_ENCRYPTION_POLICY; +} + +/* Destroy ctx->encrypted_files->policies */ +void destroy_encryption_policy_map(e2fsck_t ctx) +{ + struct encrypted_file_info *info = ctx->encrypted_files; + + if (info) { + struct rb_root *policies = &info->policies; + + while (!ext2fs_rb_empty_root(policies)) { + struct policy_map_entry *entry; + + entry = ext2fs_rb_entry(policies->rb_node, + struct policy_map_entry, node); + ext2fs_rb_erase(&entry->node, policies); + ext2fs_free_mem(&entry); + } + info->next_policy_id = 0; + } +} + +/* Destroy ctx->encrypted_files */ +void destroy_encrypted_file_info(e2fsck_t ctx) +{ + struct encrypted_file_info *info = ctx->encrypted_files; + + if (info) { + destroy_encryption_policy_map(ctx); + ext2fs_free_mem(&info->file_ranges); + ext2fs_free_mem(&info); + ctx->encrypted_files = NULL; + } +} diff --git a/e2fsck/extend.c b/e2fsck/extend.c new file mode 100644 index 0000000..9d17e44 --- /dev/null +++ b/e2fsck/extend.c @@ -0,0 +1,83 @@ +/* + * extend.c --- extend a file so that it has at least a specified + * number of blocks. + * + * Copyright (C) 1993, 1994, 1995 Theodore Ts'o. + * + * This file may be redistributed under the terms of the GNU Public + * License. + */ + +#include "config.h" +#include +#include +#include +#include +#include +#include +#include "../misc/nls-enable.h" + +static void usage(char *progname) +{ + fprintf(stderr, _("%s: %s filename nblocks blocksize\n"), + progname, progname); + exit(1); +} + + +int main(int argc, char **argv) +{ + char *filename; + int nblocks, blocksize; + int fd; + char *block; + errcode_t retval; + int ret; + + if (argc != 4) + usage(argv[0]); + + filename = argv[1]; + nblocks = strtoul(argv[2], 0, 0) - 1; + blocksize = strtoul(argv[3], 0, 0); + + if (nblocks < 0) { + fprintf(stderr, _("Illegal number of blocks!\n")); + exit(1); + } + + retval = ext2fs_get_memzero(blocksize, &block); + if (retval) { + fprintf(stderr, _("Couldn't allocate block buffer (size=%d)\n"), + blocksize); + exit(1); + } + + fd = open(filename, O_RDWR); + if (fd < 0) { + perror(filename); + exit(1); + } + ret = lseek(fd, nblocks*blocksize, SEEK_SET); + if (ret < 0) { + perror("lseek"); + exit(1); + } + ret = read(fd, block, blocksize); + if (ret < 0) { + perror("read"); + exit(1); + } + ret = lseek(fd, nblocks*blocksize, SEEK_SET); + if (ret < 0) { + perror("lseek #2"); + exit(1); + } + ret = write(fd, block, blocksize); + if (ret < 0) { + perror("read"); + exit(1); + } + ext2fs_free_mem(&block); + return(0); +} diff --git a/e2fsck/extents.c b/e2fsck/extents.c new file mode 100644 index 0000000..70798f3 --- /dev/null +++ b/e2fsck/extents.c @@ -0,0 +1,620 @@ +/* + * extents.c --- rebuild extent tree + * + * Copyright (C) 2014 Oracle. + * + * %Begin-Header% + * This file may be redistributed under the terms of the GNU Public + * License, version 2. + * %End-Header% + */ + +#include "config.h" +#include +#include +#include +#include "e2fsck.h" +#include "problem.h" + +#undef DEBUG +#undef DEBUG_SUMMARY +#undef DEBUG_FREE + +#define NUM_EXTENTS 341 /* about one ETB' worth of extents */ + +static errcode_t e2fsck_rebuild_extents(e2fsck_t ctx, ext2_ino_t ino); + +/* Schedule an inode to have its extent tree rebuilt during pass 1E. */ +errcode_t e2fsck_rebuild_extents_later(e2fsck_t ctx, ext2_ino_t ino) +{ + errcode_t retval = 0; + + if (!ext2fs_has_feature_extents(ctx->fs->super) || + (ctx->options & E2F_OPT_NO) || + (ino != EXT2_ROOT_INO && ino < ctx->fs->super->s_first_ino)) + return 0; + + if (ctx->flags & E2F_FLAG_ALLOC_OK) + return e2fsck_rebuild_extents(ctx, ino); + + if (!ctx->inodes_to_rebuild) + retval = e2fsck_allocate_inode_bitmap(ctx->fs, + _("extent rebuild inode map"), + EXT2FS_BMAP64_RBTREE, + "inodes_to_rebuild", + &ctx->inodes_to_rebuild); + if (retval) + return retval; + + ext2fs_mark_inode_bitmap2(ctx->inodes_to_rebuild, ino); + return 0; +} + +/* Ask if an inode will have its extents rebuilt during pass 1E. */ +int e2fsck_ino_will_be_rebuilt(e2fsck_t ctx, ext2_ino_t ino) +{ + if (!ctx->inodes_to_rebuild) + return 0; + return ext2fs_test_inode_bitmap2(ctx->inodes_to_rebuild, ino); +} + +static errcode_t load_extents(e2fsck_t ctx, struct extent_list *list) +{ + ext2_filsys fs = ctx->fs; + ext2_extent_handle_t handle; + struct ext2fs_extent extent; + errcode_t retval; + + retval = ext2fs_extent_open(fs, list->ino, &handle); + if (retval) + return retval; + + retval = ext2fs_extent_get(handle, EXT2_EXTENT_ROOT, &extent); + if (retval) + goto out; + + do { + if (extent.e_flags & EXT2_EXTENT_FLAGS_SECOND_VISIT) + goto next; + + /* Internal node; free it and we'll re-allocate it later */ + if (!(extent.e_flags & EXT2_EXTENT_FLAGS_LEAF)) { +#if defined(DEBUG) || defined(DEBUG_FREE) + printf("ino=%d free=%llu bf=%llu\n", list->ino, + extent.e_pblk, list->blocks_freed + 1); +#endif + list->blocks_freed++; + ext2fs_block_alloc_stats2(fs, extent.e_pblk, -1); + goto next; + } + + list->ext_read++; + /* Can we attach it to the previous extent? */ + if (list->count) { + struct ext2fs_extent *last = list->extents + + list->count - 1; + blk64_t end = last->e_len + extent.e_len; + + if (last->e_pblk + last->e_len == extent.e_pblk && + last->e_lblk + last->e_len == extent.e_lblk && + (last->e_flags & EXT2_EXTENT_FLAGS_UNINIT) == + (extent.e_flags & EXT2_EXTENT_FLAGS_UNINIT) && + end < (1ULL << 32)) { + last->e_len += extent.e_len; +#ifdef DEBUG + printf("R: ino=%d len=%u\n", list->ino, + last->e_len); +#endif + goto next; + } + } + + /* Do we need to expand? */ + if (list->count == list->size) { + unsigned int new_size = (list->size + NUM_EXTENTS) * + sizeof(struct ext2fs_extent); + retval = ext2fs_resize_mem(0, new_size, &list->extents); + if (retval) + goto out; + list->size += NUM_EXTENTS; + } + + /* Add a new extent */ + memcpy(list->extents + list->count, &extent, sizeof(extent)); +#ifdef DEBUG + printf("R: ino=%d pblk=%llu lblk=%llu len=%u\n", list->ino, + extent.e_pblk, extent.e_lblk, extent.e_len); +#endif + list->count++; +next: + retval = ext2fs_extent_get(handle, EXT2_EXTENT_NEXT, &extent); + } while (retval == 0); + +out: + /* Ok if we run off the end */ + if (retval == EXT2_ET_EXTENT_NO_NEXT) + retval = 0; + ext2fs_extent_free(handle); + return retval; +} + +static int find_blocks(ext2_filsys fs, blk64_t *blocknr, e2_blkcnt_t blockcnt, + blk64_t ref_blk EXT2FS_ATTR((unused)), + int ref_offset EXT2FS_ATTR((unused)), void *priv_data) +{ + struct extent_list *list = priv_data; + + /* Internal node? */ + if (blockcnt < 0) { +#if defined(DEBUG) || defined(DEBUG_FREE) + printf("ino=%d free=%llu bf=%llu\n", list->ino, *blocknr, + list->blocks_freed + 1); +#endif + list->blocks_freed++; + ext2fs_block_alloc_stats2(fs, *blocknr, -1); + return 0; + } + + /* Can we attach it to the previous extent? */ + if (list->count) { + struct ext2fs_extent *last = list->extents + + list->count - 1; + blk64_t end = last->e_len + 1; + + if (last->e_lblk + last->e_len == (__u64) blockcnt && + last->e_pblk + last->e_len == *blocknr && + end < (1ULL << 32)) { + last->e_len++; +#ifdef DEBUG + printf("R: ino=%d len=%u\n", list->ino, last->e_len); +#endif + return 0; + } + } + + /* Do we need to expand? */ + if (list->count == list->size) { + unsigned int new_size = (list->size + NUM_EXTENTS) * + sizeof(struct ext2fs_extent); + list->retval = ext2fs_resize_mem(0, new_size, &list->extents); + if (list->retval) + return BLOCK_ABORT; + list->size += NUM_EXTENTS; + } + + /* Add a new extent */ + list->extents[list->count].e_pblk = *blocknr; + list->extents[list->count].e_lblk = blockcnt; + list->extents[list->count].e_len = 1; + list->extents[list->count].e_flags = 0; +#ifdef DEBUG + printf("R: ino=%d pblk=%llu lblk=%llu len=%u\n", list->ino, *blocknr, + blockcnt, 1); +#endif + list->count++; + + return 0; +} + +static errcode_t rewrite_extent_replay(e2fsck_t ctx, struct extent_list *list, + struct ext2_inode_large *inode) +{ + errcode_t retval; + ext2_extent_handle_t handle; + unsigned int i, ext_written; + struct ext2fs_extent *ex, extent; + blk64_t start_val, delta; + + /* Reset extent tree */ + inode->i_flags &= ~EXT4_EXTENTS_FL; + memset(inode->i_block, 0, sizeof(inode->i_block)); + + /* Make a note of freed blocks */ + quota_data_sub(ctx->qctx, inode, list->ino, + list->blocks_freed * ctx->fs->blocksize); + retval = ext2fs_iblk_sub_blocks(ctx->fs, EXT2_INODE(inode), + list->blocks_freed); + if (retval) + return retval; + + /* Now stuff extents into the file */ + retval = ext2fs_extent_open2(ctx->fs, list->ino, EXT2_INODE(inode), + &handle); + if (retval) + return retval; + + ext_written = 0; + + start_val = ext2fs_get_stat_i_blocks(ctx->fs, EXT2_INODE(inode)); + + for (i = 0, ex = list->extents; i < list->count; i++, ex++) { + if (ex->e_len == 0) + continue; + memcpy(&extent, ex, sizeof(struct ext2fs_extent)); + extent.e_flags &= EXT2_EXTENT_FLAGS_UNINIT; + if (extent.e_flags & EXT2_EXTENT_FLAGS_UNINIT) { + if (extent.e_len > EXT_UNINIT_MAX_LEN) { + extent.e_len = EXT_UNINIT_MAX_LEN; + ex->e_pblk += EXT_UNINIT_MAX_LEN; + ex->e_lblk += EXT_UNINIT_MAX_LEN; + ex->e_len -= EXT_UNINIT_MAX_LEN; + ex--; + i--; + } + } else { + if (extent.e_len > EXT_INIT_MAX_LEN) { + extent.e_len = EXT_INIT_MAX_LEN; + ex->e_pblk += EXT_INIT_MAX_LEN; + ex->e_lblk += EXT_INIT_MAX_LEN; + ex->e_len -= EXT_INIT_MAX_LEN; + ex--; + i--; + } + } + +#ifdef DEBUG + printf("W: ino=%d pblk=%llu lblk=%llu len=%u\n", list->ino, + extent.e_pblk, extent.e_lblk, extent.e_len); +#endif + retval = ext2fs_extent_insert(handle, EXT2_EXTENT_INSERT_AFTER, + &extent); + if (retval) + goto err; + retval = ext2fs_extent_fix_parents(handle); + if (retval) + goto err; + ext_written++; + } + + delta = ext2fs_get_stat_i_blocks(ctx->fs, EXT2_INODE(inode)) - + start_val; + if (delta) + quota_data_add(ctx->qctx, inode, list->ino, delta << 9); + +#if defined(DEBUG) || defined(DEBUG_SUMMARY) + printf("rebuild: ino=%d extents=%d->%d\n", ino, list->ext_read, + ext_written); +#endif + e2fsck_write_inode(ctx, list->ino, EXT2_INODE(inode), + "rebuild_extents"); + +err: + ext2fs_extent_free(handle); + return retval; +} + +errcode_t e2fsck_rewrite_extent_tree(e2fsck_t ctx, struct extent_list *list) +{ + struct ext2_inode_large inode; + blk64_t blk_count; + errcode_t err; + + memset(&inode, 0, sizeof(inode)); + err = ext2fs_read_inode_full(ctx->fs, list->ino, EXT2_INODE(&inode), + sizeof(inode)); + if (err) + return err; + + /* Skip deleted inodes and inline data files */ + if (inode.i_flags & EXT4_INLINE_DATA_FL) + return 0; + + err = rewrite_extent_replay(ctx, list, &inode); + if (err) + return err; + + err = ext2fs_count_blocks(ctx->fs, list->ino, EXT2_INODE(&inode), + &blk_count); + if (err) + return err; + err = ext2fs_iblk_set(ctx->fs, EXT2_INODE(&inode), blk_count); + if (err) + return err; + return ext2fs_write_inode_full(ctx->fs, list->ino, EXT2_INODE(&inode), + sizeof(inode)); +} + +errcode_t e2fsck_read_extents(e2fsck_t ctx, struct extent_list *extents) +{ + struct ext2_inode_large inode; + errcode_t retval; + + extents->extents = NULL; + extents->count = 0; + extents->blocks_freed = 0; + extents->ext_read = 0; + extents->size = NUM_EXTENTS; + retval = ext2fs_get_array(NUM_EXTENTS, sizeof(struct ext2fs_extent), + &extents->extents); + if (retval) + return ENOMEM; + + retval = ext2fs_read_inode(ctx->fs, extents->ino, EXT2_INODE(&inode)); + if (retval) + goto err_out; + + retval = load_extents(ctx, extents); + if (!retval) + return 0; +err_out: + ext2fs_free_mem(&extents->extents); + extents->size = 0; + extents->count = 0; + return retval; +} + +static errcode_t rebuild_extent_tree(e2fsck_t ctx, struct extent_list *list, + ext2_ino_t ino) +{ + struct ext2_inode_large inode; + errcode_t retval; + + list->count = 0; + list->blocks_freed = 0; + list->ino = ino; + list->ext_read = 0; + e2fsck_read_inode_full(ctx, ino, EXT2_INODE(&inode), sizeof(inode), + "rebuild_extents"); + + /* Skip deleted inodes and inline data files */ + if (inode.i_links_count == 0 || + inode.i_flags & EXT4_INLINE_DATA_FL) + return 0; + + /* Collect lblk->pblk mappings */ + if (inode.i_flags & EXT4_EXTENTS_FL) { + retval = load_extents(ctx, list); + if (retval) + return retval; + return rewrite_extent_replay(ctx, list, &inode); + } + + retval = ext2fs_block_iterate3(ctx->fs, ino, BLOCK_FLAG_READ_ONLY, 0, + find_blocks, list); + + return retval || list->retval || + rewrite_extent_replay(ctx, list, &inode); +} + +/* Rebuild the extents immediately */ +static errcode_t e2fsck_rebuild_extents(e2fsck_t ctx, ext2_ino_t ino) +{ + struct extent_list list = { 0 }; + errcode_t err; + + if (!ext2fs_has_feature_extents(ctx->fs->super) || + (ctx->options & E2F_OPT_NO) || + (ino != EXT2_ROOT_INO && ino < ctx->fs->super->s_first_ino)) + return 0; + + e2fsck_read_bitmaps(ctx); + err = ext2fs_get_array(NUM_EXTENTS, sizeof(struct ext2fs_extent), + &list.extents); + if (err) + return err; + list.size = NUM_EXTENTS; + err = rebuild_extent_tree(ctx, &list, ino); + ext2fs_free_mem(&list.extents); + + return err; +} + +static void rebuild_extents(e2fsck_t ctx, const char *pass_name, int pr_header) +{ + struct problem_context pctx; +#ifdef RESOURCE_TRACK + struct resource_track rtrack; +#endif + struct extent_list list = { 0 }; + int first = 1; + ext2_ino_t ino = 0; + errcode_t retval; + + if (!ext2fs_has_feature_extents(ctx->fs->super) || + !ext2fs_test_valid(ctx->fs) || + ctx->invalid_bitmaps) { + if (ctx->inodes_to_rebuild) + ext2fs_free_inode_bitmap(ctx->inodes_to_rebuild); + ctx->inodes_to_rebuild = NULL; + } + + if (ctx->inodes_to_rebuild == NULL) + return; + + init_resource_track(&rtrack, ctx->fs->io); + clear_problem_context(&pctx); + e2fsck_read_bitmaps(ctx); + + list.size = NUM_EXTENTS; + retval = ext2fs_get_array(sizeof(struct ext2fs_extent), + list.size, &list.extents); + if (retval) + return; + while (1) { + retval = ext2fs_find_first_set_inode_bitmap2( + ctx->inodes_to_rebuild, ino + 1, + ctx->fs->super->s_inodes_count, &ino); + if (retval) + break; + pctx.ino = ino; + if (first) { + fix_problem(ctx, pr_header, &pctx); + first = 0; + } + pctx.errcode = rebuild_extent_tree(ctx, &list, ino); + if (pctx.errcode) { + end_problem_latch(ctx, PR_LATCH_OPTIMIZE_EXT); + fix_problem(ctx, PR_1E_OPTIMIZE_EXT_ERR, &pctx); + } + if (ctx->progress && !ctx->progress_fd) + e2fsck_simple_progress(ctx, "Rebuilding extents", + 100.0 * (float) ino / + (float) ctx->fs->super->s_inodes_count, + ino); + } + end_problem_latch(ctx, PR_LATCH_OPTIMIZE_EXT); + + ext2fs_free_inode_bitmap(ctx->inodes_to_rebuild); + ctx->inodes_to_rebuild = NULL; + ext2fs_free_mem(&list.extents); + + print_resource_track(ctx, pass_name, &rtrack, ctx->fs->io); +} + +/* Scan a file to see if we should rebuild its extent tree */ +errcode_t e2fsck_check_rebuild_extents(e2fsck_t ctx, ext2_ino_t ino, + struct ext2_inode *inode, + struct problem_context *pctx) +{ + struct extent_tree_info eti; + struct ext2_extent_info info, top_info; + struct ext2fs_extent extent; + ext2_extent_handle_t ehandle; + ext2_filsys fs = ctx->fs; + errcode_t retval; + + /* block map file and we want extent conversion */ + if (!(inode->i_flags & EXT4_EXTENTS_FL) && + !(inode->i_flags & EXT4_INLINE_DATA_FL) && + (ctx->options & E2F_OPT_CONVERT_BMAP)) { + return e2fsck_rebuild_extents_later(ctx, ino); + } + + if (!(inode->i_flags & EXT4_EXTENTS_FL)) + return 0; + memset(&eti, 0, sizeof(eti)); + eti.ino = ino; + + /* Otherwise, go scan the extent tree... */ + retval = ext2fs_extent_open2(fs, ino, inode, &ehandle); + if (retval) + return 0; + + retval = ext2fs_extent_get_info(ehandle, &top_info); + if (retval) + goto out; + + /* Check maximum extent depth */ + pctx->ino = ino; + pctx->blk = top_info.max_depth; + pctx->blk2 = ext2fs_max_extent_depth(ehandle); + if (pctx->blk2 < pctx->blk && + fix_problem(ctx, PR_1_EXTENT_BAD_MAX_DEPTH, pctx)) + eti.force_rebuild = 1; + + /* Can we collect extent tree level stats? */ + pctx->blk = MAX_EXTENT_DEPTH_COUNT; + if (pctx->blk2 > pctx->blk) + fix_problem(ctx, PR_1E_MAX_EXTENT_TREE_DEPTH, pctx); + + /* We need to fix tree depth problems, but the scan isn't a fix. */ + if (ctx->options & E2F_OPT_FIXES_ONLY) + goto out; + + retval = ext2fs_extent_get(ehandle, EXT2_EXTENT_ROOT, &extent); + if (retval) + goto out; + + do { + retval = ext2fs_extent_get_info(ehandle, &info); + if (retval) + break; + + /* + * If this is the first extent in an extent block that we + * haven't visited, collect stats on the block. + */ + if (info.curr_entry == 1 && + !(extent.e_flags & EXT2_EXTENT_FLAGS_SECOND_VISIT) && + !eti.force_rebuild && + info.curr_level < MAX_EXTENT_DEPTH_COUNT) { + struct extent_tree_level *etl; + + etl = eti.ext_info + info.curr_level; + etl->num_extents += info.num_entries; + etl->max_extents += info.max_entries; + /* + * Implementation wart: Splitting extent blocks when + * appending will leave the old block with one free + * entry. Therefore unless the node is totally full, + * pretend that a non-root extent block can hold one + * fewer entry than it actually does, so that we don't + * repeatedly rebuild the extent tree. + */ + if (info.curr_level && + info.num_entries < info.max_entries) + etl->max_extents--; + } + + /* Skip to the end of a block of leaf nodes */ + if (extent.e_flags & EXT2_EXTENT_FLAGS_LEAF) { + retval = ext2fs_extent_get(ehandle, + EXT2_EXTENT_LAST_SIB, + &extent); + if (retval) + break; + } + + retval = ext2fs_extent_get(ehandle, EXT2_EXTENT_NEXT, &extent); + } while (retval == 0); +out: + ext2fs_extent_free(ehandle); + return e2fsck_should_rebuild_extents(ctx, pctx, &eti, &top_info); +} + +/* Having scanned a file's extent tree, decide if we should rebuild it */ +errcode_t e2fsck_should_rebuild_extents(e2fsck_t ctx, + struct problem_context *pctx, + struct extent_tree_info *eti, + struct ext2_extent_info *info) +{ + struct extent_tree_level *ei; + int i, j, op; + unsigned int extents_per_block; + + if (eti->force_rebuild) + goto rebuild; + + if (ctx->options & E2F_OPT_NOOPT_EXTENTS) + return 0; + + extents_per_block = (ctx->fs->blocksize - + sizeof(struct ext3_extent_header)) / + sizeof(struct ext3_extent); + + /* If the extent tree is too deep, then rebuild it. */ + if (info->max_depth > MAX_EXTENT_DEPTH_COUNT-1) { + pctx->blk = info->max_depth; + op = PR_1E_CAN_COLLAPSE_EXTENT_TREE; + goto rebuild; + } + /* + * If we can consolidate a level or shorten the tree, schedule the + * extent tree to be rebuilt. + */ + for (i = 0, ei = eti->ext_info; i < info->max_depth + 1; i++, ei++) { + if (ei->max_extents - ei->num_extents > extents_per_block) { + pctx->blk = i; + op = PR_1E_CAN_NARROW_EXTENT_TREE; + goto rebuild; + } + for (j = 0; j < i; j++) { + if (ei->num_extents < eti->ext_info[j].max_extents) { + pctx->blk = i; + op = PR_1E_CAN_COLLAPSE_EXTENT_TREE; + goto rebuild; + } + } + } + return 0; + +rebuild: + if (eti->force_rebuild || fix_problem(ctx, op, pctx)) + return e2fsck_rebuild_extents_later(ctx, eti->ino); + return 0; +} + +void e2fsck_pass1e(e2fsck_t ctx) +{ + rebuild_extents(ctx, "Pass 1E", PR_1E_PASS_HEADER); +} diff --git a/e2fsck/flushb.c b/e2fsck/flushb.c new file mode 100644 index 0000000..6100fc6 --- /dev/null +++ b/e2fsck/flushb.c @@ -0,0 +1,67 @@ +/* + * flushb.c --- This routine flushes the disk buffers for a disk + * + * Copyright 1997, 2000, by Theodore Ts'o. + * + * WARNING: use of flushb on some older 2.2 kernels on a heavily loaded + * system will corrupt filesystems. This program is not really useful + * beyond for benchmarking scripts. + * + * %Begin-Header% + * This file may be redistributed under the terms of the GNU Public + * License. + * %End-Header% + */ + +#include "config.h" +#include +#include +#include +#include +#include +#include +#include +#include "../misc/nls-enable.h" + +/* For Linux, define BLKFLSBUF if necessary */ +#if (!defined(BLKFLSBUF) && defined(__linux__)) +#define BLKFLSBUF _IO(0x12,97) /* flush buffer cache */ +#endif + +const char *progname; + +static void usage(void) +{ + fprintf(stderr, _("Usage: %s disk\n"), progname); + exit(1); +} + +int main(int argc, char **argv) +{ + int fd; + + progname = argv[0]; + if (argc != 2) + usage(); + + fd = open(argv[1], O_RDONLY, 0); + if (fd < 0) { + perror("open"); + exit(1); + } + /* + * Note: to reread the partition table, use the ioctl + * BLKRRPART instead of BLKFSLBUF. + */ +#ifdef BLKFLSBUF + if (ioctl(fd, BLKFLSBUF, 0) < 0) { + perror("ioctl BLKFLSBUF"); + exit(1); + } + return 0; +#else + fprintf(stderr, + _("BLKFLSBUF ioctl not supported! Can't flush buffers.\n")); + return 1; +#endif +} diff --git a/e2fsck/iscan.c b/e2fsck/iscan.c new file mode 100644 index 0000000..33c6a4c --- /dev/null +++ b/e2fsck/iscan.c @@ -0,0 +1,265 @@ +/* + * Test to see how quickly we can scan the inode table (not doing + * anything else) + */ + +#include "config.h" +#include +#include +#include +#include +#include +#ifdef HAVE_GETOPT_H +#include +#endif +#include +#ifdef HAVE_ERRNO_H +#include +#endif +#include +#ifdef HAVE_MALLOC_H +#include +#endif +#include +#include + +#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 + +#include "et/com_err.h" +#include "../version.h" + +struct resource_track { + struct timeval time_start; + struct timeval user_start; + struct timeval system_start; + void *brk_start; + unsigned long long bytes_read; + unsigned long long bytes_written; +}; + +extern int isatty(int); + +const char * program_name = "iscan"; +const char * device_name = NULL; + +int yflag = 0; +int nflag = 0; +int preen = 0; +int inode_buffer_blocks = 0; +int invalid_bitmaps = 0; + +struct resource_track global_rtrack; + +void init_resource_track(struct resource_track *track, io_channel channel) +{ +#ifdef HAVE_GETRUSAGE + struct rusage r; +#endif + io_stats io_start = 0; + + 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 + track->bytes_read = 0; + track->bytes_written = 0; + if (channel && channel->manager && channel->manager->get_stats) + channel->manager->get_stats(channel, &io_start); + if (io_start) { + track->bytes_read = io_start->bytes_read; + track->bytes_written = io_start->bytes_written; + } +} + +static 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, io_channel channel) +{ +#ifdef HAVE_GETRUSAGE + struct rusage r; +#endif + struct timeval time_end; + + gettimeofday(&time_end, 0); + + if (desc) + printf("%s: ", desc); + +#define kbytes(x) (((unsigned long long)(x) + 1023) / 1024) +#ifdef HAVE_MALLINFO2 + if (1) { + struct mallinfo2 malloc_info = mallinfo2(); + + printf("Memory used: %lluk/%lluk (%lluk/%lluk), ", + kbytes(malloc_info.arena), kbytes(malloc_info.hblkhd), + kbytes(malloc_info.uordblks), + kbytes(malloc_info.fordblks)); + } else +#elif defined HAVE_MALLINFO + /* don't use mallinfo() if over 2GB used, since it returns "int" */ + if ((char *)sbrk(0) - (char *)track->brk_start < 2LL << 30) { + struct mallinfo malloc_info = mallinfo(); + + printf("Memory used: %lluk/%lluk (%lluk/%lluk), ", + kbytes(malloc_info.arena), kbytes(malloc_info.hblkhd), + kbytes(malloc_info.uordblks), + kbytes(malloc_info.fordblks)); + } else +#endif + printf("Memory used: %lluk, ", + kbytes(((char *)sbrk(0)) - ((char *)track->brk_start))); + +#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 +#define mbytes(x) (((x) + 1048575) / 1048576) + if (channel && channel->manager && channel->manager->get_stats) { + io_stats delta = 0; + unsigned long long bytes_read = 0; + unsigned long long bytes_written = 0; + + if (desc) + printf("%s: ", desc); + + channel->manager->get_stats(channel, &delta); + if (delta) { + bytes_read = delta->bytes_read - track->bytes_read; + bytes_written = delta->bytes_written - + track->bytes_written; + } + printf("I/O read: %lluMB, write: %lluMB, " + "rate: %.2fMB/s\n", + mbytes(bytes_read), mbytes(bytes_written), + (double)mbytes(bytes_read + bytes_written) / + timeval_subtract(&time_end, &track->time_start)); + } +} + +static void usage(void) +{ + fprintf(stderr, + "Usage: %s [-F] [-I inode_buffer_blocks] device\n", + program_name); + exit(1); +} + +static void PRS(int argc, char *argv[]) +{ + int flush = 0; + int c; +#ifdef MTRACE + extern void *mallwatch; +#endif + errcode_t retval; + + setbuf(stdout, NULL); + setbuf(stderr, NULL); + initialize_ext2_error_table(); + + if (argc && *argv) + program_name = *argv; + while ((c = getopt (argc, argv, "FI")) != EOF) + switch (c) { + case 'F': + flush = 1; + break; + case 'I': + inode_buffer_blocks = atoi(optarg); + break; + default: + usage (); + } + device_name = argv[optind]; + if (flush) { + int fd = open(device_name, O_RDONLY, 0); + + if (fd < 0) { + com_err("open", errno, + "while opening %s for flushing", device_name); + exit(1); + } + if ((retval = ext2fs_sync_device(fd, 1))) { + com_err("ext2fs_sync_device", retval, + "while trying to flush %s", device_name); + exit(1); + } + close(fd); + } +} + +int main (int argc, char *argv[]) +{ + errcode_t retval = 0; + int exit_value = 0; + ext2_filsys fs; + ext2_ino_t ino; + __u32 num_inodes = 0; + struct ext2_inode inode; + ext2_inode_scan scan; + + PRS(argc, argv); + + retval = ext2fs_open(device_name, 0, + 0, 0, unix_io_manager, &fs); + if (retval) { + com_err(program_name, retval, "while trying to open '%s'", + device_name); + exit(1); + } + + init_resource_track(&global_rtrack, fs->io); + + retval = ext2fs_open_inode_scan(fs, inode_buffer_blocks, &scan); + if (retval) { + com_err(program_name, retval, "while opening inode scan"); + exit(1); + } + + while (1) { + retval = ext2fs_get_next_inode(scan, &ino, &inode); + if (retval) { + com_err(program_name, retval, + "while getting next inode"); + exit(1); + } + if (ino == 0) + break; + num_inodes++; + } + + print_resource_track(NULL, &global_rtrack, fs->io); + printf("%u inodes scanned.\n", num_inodes); + + exit(0); +} diff --git a/e2fsck/jfs_user.h b/e2fsck/jfs_user.h new file mode 100644 index 0000000..5928a8a --- /dev/null +++ b/e2fsck/jfs_user.h @@ -0,0 +1,321 @@ +/* + * 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. + */ +#ifndef _JFS_USER_H +#define _JFS_USER_H + +#include "config.h" + +#ifdef DEBUGFS +#include +#include +#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 +#else +/* + * Pull in the definition of the e2fsck context structure + */ +#include "e2fsck.h" +#endif + +#if __STDC_VERSION__ < 199901L +# if __GNUC__ >= 2 || _MSC_VER >= 1300 +# define __func__ __FUNCTION__ +# else +# define __func__ "" +# endif +#endif + +struct buffer_head { +#ifdef DEBUGFS + ext2_filsys b_fs; +#else + e2fsck_t b_ctx; +#endif + io_channel b_io; + int b_size; + int b_err; + unsigned int b_dirty:1; + unsigned int b_uptodate:1; + unsigned long long b_blocknr; + char b_data[4096]; +}; + +struct inode { +#ifdef DEBUGFS + ext2_filsys i_fs; +#else + e2fsck_t i_ctx; +#endif + ext2_ino_t i_ino; + struct ext2_inode i_ext2; +}; + +struct kdev_s { +#ifdef DEBUGFS + ext2_filsys k_fs; +#else + e2fsck_t k_ctx; +#endif + int k_dev; +}; + +#define K_DEV_FS 1 +#define K_DEV_JOURNAL 2 + +#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) + +struct kmem_cache { + unsigned int object_size; +}; + +#define cond_resched() do { } while (0) + +#define __init + +/* + * Now pull in the real linux/jfs.h definitions. + */ +#include + +/* + * We use the standard libext2fs portability tricks for inline + * functions. + */ +#ifdef NO_INLINE_FUNCS +extern struct kmem_cache *kmem_cache_create(const char *name, + unsigned int size, + unsigned int align, + unsigned int flags, + void (*ctor)(void *)); +extern void kmem_cache_destroy(struct kmem_cache *s); +extern void *kmem_cache_alloc(struct kmem_cache *cachep, gfp_t flags); +extern void kmem_cache_free(struct kmem_cache *s, void *objp); +extern void *kmalloc(size_t size, gfp_t flags); +extern void kfree(const void *objp); +extern size_t journal_tag_bytes(journal_t *journal); +extern __u32 __hash_32(__u32 val); +extern __u32 hash_32(__u32 val, unsigned int bits); +extern __u32 hash_64(__u64 val, unsigned int bits); +extern void *kmalloc_array(unsigned n, unsigned size, int flags); +extern __u32 jbd2_chksum(journal_t *j, __u32 crc, const void *address, + unsigned int length); +extern void jbd2_descriptor_block_csum_set(journal_t *j, + struct buffer_head *bh); +#endif + +#if (defined(E2FSCK_INCLUDE_INLINE_FUNCS) || !defined(NO_INLINE_FUNCS)) +#ifdef E2FSCK_INCLUDE_INLINE_FUNCS +#if (__STDC_VERSION__ >= 199901L) +#define _INLINE_ extern inline +#else +#define _INLINE_ inline +#endif +#else /* !E2FSCK_INCLUDE_INLINE FUNCS */ +#if (__STDC_VERSION__ >= 199901L) +#define _INLINE_ inline +#else /* not C99 */ +#ifdef __GNUC__ +#define _INLINE_ extern __inline__ +#else /* For Watcom C */ +#define _INLINE_ extern inline +#endif /* __GNUC__ */ +#endif /* __STDC_VERSION__ >= 199901L */ +#endif /* E2FSCK_INCLUDE_INLINE_FUNCS */ + +_INLINE_ struct kmem_cache * +kmem_cache_create(const char *name EXT2FS_ATTR((unused)), + unsigned int size, + unsigned int align EXT2FS_ATTR((unused)), + unsigned int flags EXT2FS_ATTR((unused)), + void (*ctor)(void *) EXT2FS_ATTR((unused))) +{ + struct kmem_cache *new_cache; + + new_cache = malloc(sizeof(*new_cache)); + if (new_cache) + new_cache->object_size = size; + return new_cache; +} + +_INLINE_ void kmem_cache_destroy(struct kmem_cache *s) +{ + free(s); +} + +_INLINE_ void *kmem_cache_alloc(struct kmem_cache *cachep, + gfp_t flags EXT2FS_ATTR((unused))) +{ + return malloc(cachep->object_size); +} + +_INLINE_ void kmem_cache_free(struct kmem_cache *s EXT2FS_ATTR((unused)), + void *objp) +{ + free(objp); +} + +_INLINE_ void *kmalloc(size_t size, gfp_t flags EXT2FS_ATTR((unused))) +{ + return malloc(size); +} + +_INLINE_ void kfree(const void *objp) +{ +#ifdef HAVE_INTPTR_T + /* + * Work around a botch in the C standard, which triggers + * compiler warnings. For better or for worse, the kernel + * uses const void * for kfree, while the C standard mandates + * the use of void *. See: https://yarchive.net/comp/const.html + */ + free((void *)(intptr_t)objp); +#else + free((void *)objp); +#endif +} + +/* generic hashing taken from the Linux kernel */ +#define GOLDEN_RATIO_32 0x61C88647 +#define GOLDEN_RATIO_64 0x61C8864680B583EBull + +_INLINE_ __u32 __hash_32(__u32 val) +{ + return val * GOLDEN_RATIO_32; +} + +_INLINE_ __u32 hash_32(__u32 val, unsigned int bits) +{ + /* High bits are more random, so use them. */ + return __hash_32(val) >> (32 - bits); +} + +_INLINE_ __u32 hash_64(__u64 val, unsigned int bits) +{ + if (sizeof(long) >= 8) { + /* 64x64-bit multiply is efficient on all 64-bit processors */ + return val * GOLDEN_RATIO_64 >> (64 - bits); + } else { + /* Hash 64 bits using only 32x32-bit multiply. */ + return hash_32((__u32)val ^ __hash_32(val >> 32), bits); + } +} + +_INLINE_ void *kmalloc_array(unsigned n, unsigned size, + int flags EXT2FS_ATTR((unused))) +{ + if (n && (~0U)/n < size) + return NULL; + return malloc(n * size); +} + +_INLINE_ __u32 jbd2_chksum(journal_t *j EXT2FS_ATTR((unused)), + __u32 crc, const void *address, + unsigned int length) +{ + return ext2fs_crc32c_le(crc, address, length); +} + +_INLINE_ void jbd2_descriptor_block_csum_set(journal_t *j, + struct buffer_head *bh) +{ + struct jbd2_journal_block_tail *tail; + __u32 csum; + + if (!jbd2_journal_has_csum_v2or3(j)) + return; + + tail = (struct jbd2_journal_block_tail *)(bh->b_data + j->j_blocksize - + sizeof(struct jbd2_journal_block_tail)); + tail->t_checksum = 0; + csum = jbd2_chksum(j, j->j_csum_seed, bh->b_data, j->j_blocksize); + tail->t_checksum = cpu_to_be32(csum); +} +#undef _INLINE_ +#endif + +/* + * Kernel compatibility functions are defined in journal.c + */ +int jbd2_journal_bmap(journal_t *journal, unsigned long block, + unsigned long long *phys); +struct buffer_head *getblk(kdev_t ctx, unsigned long long blocknr, + int blocksize); +int sync_blockdev(kdev_t kdev); +void ll_rw_block(int rw, int op_flags, int nr, 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) + +#ifdef DEBUGFS +#include +#undef J_ASSERT +#define J_ASSERT(x) assert(x) + +#define JSB_HAS_INCOMPAT_FEATURE(jsb, mask) \ + ((jsb)->s_header.h_blocktype == ext2fs_cpu_to_be32(JBD2_SUPERBLOCK_V2) && \ + ((jsb)->s_feature_incompat & ext2fs_cpu_to_be32((mask)))) +#else /* !DEBUGFS */ + +extern e2fsck_t e2fsck_global_ctx; /* Try your very best not to use this! */ + +#define J_ASSERT(assert) \ + do { if (!(assert)) { \ + printf ("Assertion failure in %s() at %s line %d: " \ + "\"%s\"\n", \ + __func__, __FILE__, __LINE__, # assert); \ + fatal_error(e2fsck_global_ctx, 0); \ + } } while (0) + +#endif /* DEBUGFS */ + +#ifndef EFSBADCRC +#define EFSBADCRC EXT2_ET_BAD_CRC +#endif +#ifndef EFSCORRUPTED +#define EFSCORRUPTED EXT2_ET_FILESYSTEM_CORRUPTED +#endif + +/* recovery.c */ +extern int jbd2_journal_recover (journal_t *journal); +extern int jbd2_journal_skip_recovery (journal_t *); + +/* revoke.c */ +extern int jbd2_journal_init_revoke(journal_t *, int); +extern void jbd2_journal_destroy_revoke(journal_t *); +extern void jbd2_journal_destroy_revoke_record_cache(void); +extern void jbd2_journal_destroy_revoke_table_cache(void); +extern int jbd2_journal_init_revoke_record_cache(void); +extern int jbd2_journal_init_revoke_table_cache(void); + + +extern int jbd2_journal_set_revoke(journal_t *, unsigned long long, tid_t); +extern int jbd2_journal_test_revoke(journal_t *, unsigned long long, tid_t); +extern void jbd2_journal_clear_revoke(journal_t *); + +#endif /* _JFS_USER_H */ diff --git a/e2fsck/journal.c b/e2fsck/journal.c new file mode 100644 index 0000000..c7868d8 --- /dev/null +++ b/e2fsck/journal.c @@ -0,0 +1,1900 @@ +/* + * 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. + */ + +#include "config.h" +#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" + +static int bh_count = 0; + +/* + * 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 + +/* Checksumming functions */ +static int e2fsck_journal_verify_csum_type(journal_t *j, + journal_superblock_t *jsb) +{ + if (!jbd2_journal_has_csum_v2or3(j)) + return 1; + + return jsb->s_checksum_type == JBD2_CRC32C_CHKSUM; +} + +static __u32 e2fsck_journal_sb_csum(journal_superblock_t *jsb) +{ + __u32 crc, old_crc; + + old_crc = jsb->s_checksum; + jsb->s_checksum = 0; + crc = ext2fs_crc32c_le(~0, (unsigned char *)jsb, + sizeof(journal_superblock_t)); + jsb->s_checksum = old_crc; + + return crc; +} + +static int e2fsck_journal_sb_csum_verify(journal_t *j, + journal_superblock_t *jsb) +{ + __u32 provided, calculated; + + if (!jbd2_journal_has_csum_v2or3(j)) + return 1; + + provided = ext2fs_be32_to_cpu(jsb->s_checksum); + calculated = e2fsck_journal_sb_csum(jsb); + + return provided == calculated; +} + +static errcode_t e2fsck_journal_sb_csum_set(journal_t *j, + journal_superblock_t *jsb) +{ + __u32 crc; + + if (!jbd2_journal_has_csum_v2or3(j)) + return 0; + + crc = e2fsck_journal_sb_csum(jsb); + jsb->s_checksum = ext2fs_cpu_to_be32(crc); + return 0; +} + +/* 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 jbd2_journal_bmap(journal_t *journal, unsigned long block, + unsigned long long *phys) +{ +#ifdef USE_INODE_IO + *phys = block; + return 0; +#else + struct inode *inode = journal->j_inode; + errcode_t retval; + blk64_t pblk; + + if (!inode) { + *phys = block; + return 0; + } + + retval= ext2fs_bmap2(inode->i_ctx->fs, inode->i_ino, + &inode->i_ext2, NULL, 0, (blk64_t) block, + 0, &pblk); + *phys = pblk; + return -1 * ((int) retval); +#endif +} + +struct buffer_head *getblk(kdev_t kdev, unsigned long long blocknr, + int blocksize) +{ + struct buffer_head *bh; + int bufsize = sizeof(*bh) + kdev->k_ctx->fs->blocksize - + sizeof(bh->b_data); + + bh = e2fsck_allocate_memory(kdev->k_ctx, bufsize, "block buffer"); + if (!bh) + return NULL; + + if (journal_enable_debug >= 3) + bh_count++; + jfs_debug(4, "getblk for block %llu (%d bytes)(total %d)\n", + 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; +} + +int 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; + + return io_channel_flush(io) ? -EIO : 0; +} + +void ll_rw_block(int rw, int op_flags EXT2FS_ATTR((unused)), int nr, + struct buffer_head *bhp[]) +{ + errcode_t retval; + struct buffer_head *bh; + + for (; nr > 0; --nr) { + bh = *bhp++; + if (rw == REQ_OP_READ && !bh->b_uptodate) { + jfs_debug(3, "reading block %llu/%p\n", + bh->b_blocknr, (void *) bh); + retval = io_channel_read_blk64(bh->b_io, + bh->b_blocknr, + 1, bh->b_data); + if (retval) { + com_err(bh->b_ctx->device_name, retval, + "while reading block %llu\n", + bh->b_blocknr); + bh->b_err = (int) retval; + continue; + } + bh->b_uptodate = 1; + } else if (rw == REQ_OP_WRITE && bh->b_dirty) { + jfs_debug(3, "writing block %llu/%p\n", + bh->b_blocknr, + (void *) bh); + retval = io_channel_write_blk64(bh->b_io, + bh->b_blocknr, + 1, bh->b_data); + if (retval) { + com_err(bh->b_ctx->device_name, retval, + "while writing block %llu\n", + bh->b_blocknr); + bh->b_err = (int) retval; + continue; + } + bh->b_dirty = 0; + bh->b_uptodate = 1; + } else { + jfs_debug(3, "no-op %s for block %llu\n", + rw == REQ_OP_READ ? "read" : "write", + 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(REQ_OP_WRITE, 0, 1, &bh); + jfs_debug(3, "freeing block %llu/%p (total %d)\n", + 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(REQ_OP_READ, 0, 1, &bh); +} + + +static void e2fsck_clear_recover(e2fsck_t ctx, int error) +{ + ext2fs_clear_feature_journal_needs_recovery(ctx->fs->super); + + /* 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); +} + +/* + * This is a helper function to check the validity of the journal. + */ +struct process_block_struct { + e2_blkcnt_t last_block; +}; + +static int process_journal_block(ext2_filsys fs, + blk64_t *block_nr, + e2_blkcnt_t blockcnt, + blk64_t ref_block EXT2FS_ATTR((unused)), + int ref_offset EXT2FS_ATTR((unused)), + void *priv_data) +{ + struct process_block_struct *p; + blk64_t blk = *block_nr; + + p = (struct process_block_struct *) priv_data; + + if (!blk || blk < fs->super->s_first_data_block || + blk >= ext2fs_blocks_count(fs->super)) + return BLOCK_ABORT; + + if (blockcnt >= 0) + p->last_block = blockcnt; + return 0; +} + +static int ext4_fc_replay_scan(journal_t *j, struct buffer_head *bh, + int off, tid_t expected_tid) +{ + e2fsck_t ctx = j->j_fs_dev->k_ctx; + struct e2fsck_fc_replay_state *state; + int ret = JBD2_FC_REPLAY_CONTINUE; + struct ext4_fc_add_range ext; + struct ext4_fc_tl tl; + struct ext4_fc_tail tail; + __u8 *start, *cur, *end, *val; + struct ext4_fc_head head; + struct ext2fs_extent ext2fs_ex = {0}; + + state = &ctx->fc_replay_state; + + start = (__u8 *)bh->b_data; + end = (__u8 *)bh->b_data + j->j_blocksize - 1; + + jbd_debug(1, "Scan phase starting, expected %d", expected_tid); + if (state->fc_replay_expected_off == 0) { + memset(state, 0, sizeof(*state)); + /* Check if we can stop early */ + if (le16_to_cpu(((struct ext4_fc_tl *)start)->fc_tag) + != EXT4_FC_TAG_HEAD) { + jbd_debug(1, "Ending early!, not a head tag"); + return 0; + } + } + + if (off != state->fc_replay_expected_off) { + ret = -EFSCORRUPTED; + goto out_err; + } + + state->fc_replay_expected_off++; + for (cur = start; cur < end; cur = cur + le16_to_cpu(tl.fc_len) + sizeof(tl)) { + memcpy(&tl, cur, sizeof(tl)); + val = cur + sizeof(tl); + + jbd_debug(3, "Scan phase, tag:%s, blk %lld\n", + tag2str(le16_to_cpu(tl.fc_tag)), bh->b_blocknr); + switch (le16_to_cpu(tl.fc_tag)) { + case EXT4_FC_TAG_ADD_RANGE: + memcpy(&ext, val, sizeof(ext)); + ret = ext2fs_decode_extent(&ext2fs_ex, + (void *)&ext.fc_ex, + sizeof(ext.fc_ex)); + if (ret) + ret = JBD2_FC_REPLAY_STOP; + else + ret = JBD2_FC_REPLAY_CONTINUE; + /* fallthrough */ + case EXT4_FC_TAG_DEL_RANGE: + case EXT4_FC_TAG_LINK: + case EXT4_FC_TAG_UNLINK: + case EXT4_FC_TAG_CREAT: + case EXT4_FC_TAG_INODE: + case EXT4_FC_TAG_PAD: + state->fc_cur_tag++; + state->fc_crc = jbd2_chksum(j, state->fc_crc, cur, + sizeof(tl) + ext4_fc_tag_len(&tl)); + break; + case EXT4_FC_TAG_TAIL: + state->fc_cur_tag++; + memcpy(&tail, val, sizeof(tail)); + state->fc_crc = jbd2_chksum(j, state->fc_crc, cur, + sizeof(tl) + + offsetof(struct ext4_fc_tail, + fc_crc)); + jbd_debug(1, "tail tid %d, expected %d\n", + le32_to_cpu(tail.fc_tid), expected_tid); + if (le32_to_cpu(tail.fc_tid) == expected_tid && + le32_to_cpu(tail.fc_crc) == state->fc_crc) { + state->fc_replay_num_tags = state->fc_cur_tag; + } else { + ret = state->fc_replay_num_tags ? + JBD2_FC_REPLAY_STOP : -EFSBADCRC; + } + state->fc_crc = 0; + break; + case EXT4_FC_TAG_HEAD: + memcpy(&head, val, sizeof(head)); + if (le32_to_cpu(head.fc_features) & + ~EXT4_FC_SUPPORTED_FEATURES) { + ret = -EOPNOTSUPP; + break; + } + if (le32_to_cpu(head.fc_tid) != expected_tid) { + ret = -EINVAL; + break; + } + state->fc_cur_tag++; + state->fc_crc = jbd2_chksum(j, state->fc_crc, cur, + sizeof(tl) + ext4_fc_tag_len(&tl)); + break; + default: + ret = state->fc_replay_num_tags ? + JBD2_FC_REPLAY_STOP : -ECANCELED; + } + if (ret < 0 || ret == JBD2_FC_REPLAY_STOP) + break; + } + +out_err: + return ret; +} + +static int __errcode_to_errno(errcode_t err, const char *func, int line) +{ + if (err == 0) + return 0; + fprintf(stderr, "Error \"%s\" encountered in function %s at line %d\n", + error_message(err), func, line); + if (err <= 256) + return -err; + return -EFAULT; +} + +#define errcode_to_errno(err) __errcode_to_errno(err, __func__, __LINE__) + +#define ex_end(__ex) ((__ex)->e_lblk + (__ex)->e_len - 1) +#define ex_pend(__ex) ((__ex)->e_pblk + (__ex)->e_len - 1) + +static int make_room(struct extent_list *list, int i) +{ + int ret; + + if (list->count == list->size) { + unsigned int new_size = (list->size + 341) * + sizeof(struct ext2fs_extent); + ret = errcode_to_errno(ext2fs_resize_mem(0, new_size, &list->extents)); + if (ret) + return ret; + list->size += 341; + } + + memmove(&list->extents[i + 1], &list->extents[i], + sizeof(list->extents[0]) * (list->count - i)); + list->count++; + return 0; +} + +static int ex_compar(const void *arg1, const void *arg2) +{ + const struct ext2fs_extent *ex1 = (const struct ext2fs_extent *)arg1; + const struct ext2fs_extent *ex2 = (const struct ext2fs_extent *)arg2; + + if (ex1->e_lblk < ex2->e_lblk) + return -1; + if (ex1->e_lblk > ex2->e_lblk) + return 1; + return ex1->e_len - ex2->e_len; +} + +static int ex_len_compar(const void *arg1, const void *arg2) +{ + const struct ext2fs_extent *ex1 = (const struct ext2fs_extent *)arg1; + const struct ext2fs_extent *ex2 = (const struct ext2fs_extent *)arg2; + + if (ex1->e_len < ex2->e_len) + return 1; + + if (ex1->e_lblk > ex2->e_lblk) + return -1; + + return 0; +} + +static void ex_sort_and_merge(struct extent_list *list) +{ + unsigned int i, j; + + if (list->count < 2) + return; + + /* + * Reverse sort by length, that way we strip off all the 0 length + * extents + */ + qsort(list->extents, list->count, sizeof(struct ext2fs_extent), + ex_len_compar); + + for (i = 0; i < list->count; i++) { + if (list->extents[i].e_len == 0) { + list->count = i; + break; + } + } + + if (list->count == 0) + return; + + /* Now sort by logical offset */ + qsort(list->extents, list->count, sizeof(list->extents[0]), + ex_compar); + + /* Merge adjacent extents if they are logically and physically contiguous */ + i = 0; + while (i < list->count - 1) { + if (ex_end(&list->extents[i]) + 1 != list->extents[i + 1].e_lblk || + ex_pend(&list->extents[i]) + 1 != list->extents[i + 1].e_pblk || + (list->extents[i].e_flags & EXT2_EXTENT_FLAGS_UNINIT) != + (list->extents[i + 1].e_flags & EXT2_EXTENT_FLAGS_UNINIT)) { + i++; + continue; + } + + list->extents[i].e_len += list->extents[i + 1].e_len; + for (j = i + 1; j < list->count - 1; j++) + list->extents[j] = list->extents[j + 1]; + list->count--; + } +} + +/* must free blocks that are released */ +static int ext4_modify_extent_list(e2fsck_t ctx, struct extent_list *list, + struct ext2fs_extent *ex, int del) +{ + int ret, offset; + unsigned int i; + struct ext2fs_extent add_ex = *ex; + + /* First let's create a hole from ex->e_lblk of length ex->e_len */ + for (i = 0; i < list->count; i++) { + if (ex_end(&list->extents[i]) < add_ex.e_lblk) + continue; + + /* Case 1: No overlap */ + if (list->extents[i].e_lblk > ex_end(&add_ex)) + break; + /* + * Unmark all the blocks in bb now. All the blocks get marked + * before we exit this function. + */ + ext2fs_unmark_block_bitmap_range2(ctx->fs->block_map, + list->extents[i].e_pblk, list->extents[i].e_len); + /* Case 2: Split */ + if (list->extents[i].e_lblk < add_ex.e_lblk && + ex_end(&list->extents[i]) > ex_end(&add_ex)) { + ret = make_room(list, i + 1); + if (ret) + return ret; + list->extents[i + 1] = list->extents[i]; + offset = ex_end(&add_ex) + 1 - list->extents[i].e_lblk; + list->extents[i + 1].e_lblk += offset; + list->extents[i + 1].e_pblk += offset; + list->extents[i + 1].e_len -= offset; + list->extents[i].e_len = + add_ex.e_lblk - list->extents[i].e_lblk; + break; + } + + /* Case 3: Exact overlap */ + if (add_ex.e_lblk <= list->extents[i].e_lblk && + ex_end(&list->extents[i]) <= ex_end(&add_ex)) { + + list->extents[i].e_len = 0; + continue; + } + + /* Case 4: Partial overlap */ + if (ex_end(&list->extents[i]) > ex_end(&add_ex)) { + offset = ex_end(&add_ex) + 1 - list->extents[i].e_lblk; + list->extents[i].e_lblk += offset; + list->extents[i].e_pblk += offset; + list->extents[i].e_len -= offset; + break; + } + + if (ex_end(&add_ex) >= ex_end(&list->extents[i])) + list->extents[i].e_len = + add_ex.e_lblk > list->extents[i].e_lblk ? + add_ex.e_lblk - list->extents[i].e_lblk : 0; + } + + if (add_ex.e_len && !del) { + make_room(list, list->count); + list->extents[list->count - 1] = add_ex; + } + + ex_sort_and_merge(list); + + /* Mark all occupied blocks allocated */ + for (i = 0; i < list->count; i++) + ext2fs_mark_block_bitmap_range2(ctx->fs->block_map, + list->extents[i].e_pblk, list->extents[i].e_len); + ext2fs_mark_bb_dirty(ctx->fs); + + return 0; +} + +static int ext4_add_extent_to_list(e2fsck_t ctx, struct extent_list *list, + struct ext2fs_extent *ex) +{ + return ext4_modify_extent_list(ctx, list, ex, 0 /* add */); +} + +static int ext4_del_extent_from_list(e2fsck_t ctx, struct extent_list *list, + struct ext2fs_extent *ex) +{ + return ext4_modify_extent_list(ctx, list, ex, 1 /* delete */); +} + +static int ext4_fc_read_extents(e2fsck_t ctx, ext2_ino_t ino) +{ + struct extent_list *extent_list = &ctx->fc_replay_state.fc_extent_list; + + if (extent_list->ino == ino) + return 0; + + extent_list->ino = ino; + return errcode_to_errno(e2fsck_read_extents(ctx, extent_list)); +} + +/* + * Flush extents in replay state on disk. @ino is the inode that is going + * to be processed next. So, we hold back flushing of the extent list + * if the next inode that's going to be processed is same as the one with + * cached extents in our replay state. That allows us to gather multiple extents + * for the inode so that we can flush all of them at once and it also saves us + * from continuously growing and shrinking the extent tree. + */ +static void ext4_fc_flush_extents(e2fsck_t ctx, ext2_ino_t ino) +{ + struct extent_list *extent_list = &ctx->fc_replay_state.fc_extent_list; + + if (extent_list->ino == ino || extent_list->ino == 0) + return; + e2fsck_rewrite_extent_tree(ctx, extent_list); + ext2fs_free_mem(&extent_list->extents); + memset(extent_list, 0, sizeof(*extent_list)); +} + +/* Helper struct for dentry replay routines */ +struct dentry_info_args { + ext2_ino_t parent_ino; + ext2_ino_t ino; + int dname_len; + char *dname; +}; + +static inline int tl_to_darg(struct dentry_info_args *darg, + struct ext4_fc_tl *tl, __u8 *val) +{ + struct ext4_fc_dentry_info fcd; + + memcpy(&fcd, val, sizeof(fcd)); + + darg->parent_ino = le32_to_cpu(fcd.fc_parent_ino); + darg->ino = le32_to_cpu(fcd.fc_ino); + darg->dname_len = ext4_fc_tag_len(tl) - + sizeof(struct ext4_fc_dentry_info); + darg->dname = malloc(darg->dname_len + 1); + if (!darg->dname) + return -ENOMEM; + memcpy(darg->dname, + val + sizeof(struct ext4_fc_dentry_info), + darg->dname_len); + darg->dname[darg->dname_len] = 0; + jbd_debug(1, "%s: %s, ino %u, parent %u\n", + le16_to_cpu(tl->fc_tag) == EXT4_FC_TAG_CREAT ? "create" : + (le16_to_cpu(tl->fc_tag) == EXT4_FC_TAG_LINK ? "link" : + (le16_to_cpu(tl->fc_tag) == EXT4_FC_TAG_UNLINK ? "unlink" : + "error")), darg->dname, darg->ino, darg->parent_ino); + return 0; +} + +static int ext4_fc_handle_unlink(e2fsck_t ctx, struct ext4_fc_tl *tl, __u8 *val) +{ + struct dentry_info_args darg; + int ret; + + ret = tl_to_darg(&darg, tl, val); + if (ret) + return ret; + ext4_fc_flush_extents(ctx, darg.ino); + ret = errcode_to_errno(ext2fs_unlink(ctx->fs, darg.parent_ino, + darg.dname, darg.ino, 0)); + /* It's okay if the above call fails */ + free(darg.dname); + + return ret; +} + +static int ext4_fc_handle_link_and_create(e2fsck_t ctx, struct ext4_fc_tl *tl, __u8 *val) +{ + struct dentry_info_args darg; + ext2_filsys fs = ctx->fs; + struct ext2_inode_large inode_large; + int ret, filetype, mode; + + ret = tl_to_darg(&darg, tl, val); + if (ret) + return ret; + ext4_fc_flush_extents(ctx, 0); + ret = errcode_to_errno(ext2fs_read_inode(fs, darg.ino, + (struct ext2_inode *)&inode_large)); + if (ret) + goto out; + + mode = inode_large.i_mode; + + if (LINUX_S_ISREG(mode)) + filetype = EXT2_FT_REG_FILE; + else if (LINUX_S_ISDIR(mode)) + filetype = EXT2_FT_DIR; + else if (LINUX_S_ISCHR(mode)) + filetype = EXT2_FT_CHRDEV; + else if (LINUX_S_ISBLK(mode)) + filetype = EXT2_FT_BLKDEV; + else if (LINUX_S_ISLNK(mode)) + return EXT2_FT_SYMLINK; + else if (LINUX_S_ISFIFO(mode)) + filetype = EXT2_FT_FIFO; + else if (LINUX_S_ISSOCK(mode)) + filetype = EXT2_FT_SOCK; + else { + ret = -EINVAL; + goto out; + } + + /* + * Forcefully unlink if the same name is present and ignore the error + * if any, since this dirent might not exist + */ + ext2fs_unlink(fs, darg.parent_ino, darg.dname, darg.ino, + EXT2FS_UNLINK_FORCE); + + ret = errcode_to_errno( + ext2fs_link(fs, darg.parent_ino, darg.dname, darg.ino, + filetype)); +out: + free(darg.dname); + return ret; + +} + +/* This function fixes the i_blocks field in the replayed indoe */ +static void ext4_fc_replay_fixup_iblocks(struct ext2_inode_large *ondisk_inode, + struct ext2_inode_large *fc_inode) +{ + if (ondisk_inode->i_flags & EXT4_EXTENTS_FL) { + struct ext3_extent_header *eh; + + eh = (struct ext3_extent_header *)(&ondisk_inode->i_block[0]); + if (le16_to_cpu(eh->eh_magic) != EXT3_EXT_MAGIC) { + memset(eh, 0, sizeof(*eh)); + eh->eh_magic = cpu_to_le16(EXT3_EXT_MAGIC); + eh->eh_max = cpu_to_le16( + (sizeof(ondisk_inode->i_block) - + sizeof(struct ext3_extent_header)) / + sizeof(struct ext3_extent)); + } + } else if (ondisk_inode->i_flags & EXT4_INLINE_DATA_FL) { + memcpy(ondisk_inode->i_block, fc_inode->i_block, + sizeof(fc_inode->i_block)); + } +} + +static int ext4_fc_handle_inode(e2fsck_t ctx, __u8 *val) +{ + int ino, inode_len = EXT2_GOOD_OLD_INODE_SIZE; + struct ext2_inode_large *inode = NULL, *fc_inode = NULL; + __le32 fc_ino; + __u8 *fc_raw_inode; + errcode_t err; + blk64_t blks; + + memcpy(&fc_ino, val, sizeof(fc_ino)); + fc_raw_inode = val + sizeof(fc_ino); + ino = le32_to_cpu(fc_ino); + + if (EXT2_INODE_SIZE(ctx->fs->super) > EXT2_GOOD_OLD_INODE_SIZE) { + __u16 extra_isize = ext2fs_le16_to_cpu( + ((struct ext2_inode_large *)fc_raw_inode)->i_extra_isize); + + if ((extra_isize < (sizeof(inode->i_extra_isize) + + sizeof(inode->i_checksum_hi))) || + (extra_isize > (EXT2_INODE_SIZE(ctx->fs->super) - + EXT2_GOOD_OLD_INODE_SIZE))) { + err = EFSCORRUPTED; + goto out; + } + inode_len += extra_isize; + } + err = ext2fs_get_mem(inode_len, &inode); + if (err) + goto out; + err = ext2fs_get_mem(inode_len, &fc_inode); + if (err) + goto out; + ext4_fc_flush_extents(ctx, ino); + + err = ext2fs_read_inode_full(ctx->fs, ino, (struct ext2_inode *)inode, + inode_len); + if (err) + goto out; + memcpy(fc_inode, fc_raw_inode, inode_len); +#ifdef WORDS_BIGENDIAN + ext2fs_swap_inode_full(ctx->fs, fc_inode, fc_inode, 0, inode_len); +#endif + memcpy(inode, fc_inode, offsetof(struct ext2_inode_large, i_block)); + memcpy(&inode->i_generation, &fc_inode->i_generation, + inode_len - offsetof(struct ext2_inode_large, i_generation)); + ext4_fc_replay_fixup_iblocks(inode, fc_inode); + err = ext2fs_count_blocks(ctx->fs, ino, EXT2_INODE(inode), &blks); + if (err) + goto out; + ext2fs_iblk_set(ctx->fs, EXT2_INODE(inode), blks); + ext2fs_inode_csum_set(ctx->fs, ino, inode); + + err = ext2fs_write_inode_full(ctx->fs, ino, (struct ext2_inode *)inode, + inode_len); + if (err) + goto out; + if (inode->i_links_count) + ext2fs_mark_inode_bitmap2(ctx->fs->inode_map, ino); + else + ext2fs_unmark_inode_bitmap2(ctx->fs->inode_map, ino); + ext2fs_mark_ib_dirty(ctx->fs); + +out: + ext2fs_free_mem(&inode); + ext2fs_free_mem(&fc_inode); + return errcode_to_errno(err); +} + +/* + * Handle add extent replay tag. + */ +static int ext4_fc_handle_add_extent(e2fsck_t ctx, __u8 *val) +{ + struct ext2fs_extent extent; + struct ext4_fc_add_range add_range; + ext2_ino_t ino; + int ret = 0; + + memcpy(&add_range, val, sizeof(add_range)); + ino = le32_to_cpu(add_range.fc_ino); + ext4_fc_flush_extents(ctx, ino); + + ret = ext4_fc_read_extents(ctx, ino); + if (ret) + return ret; + memset(&extent, 0, sizeof(extent)); + ret = errcode_to_errno(ext2fs_decode_extent( + &extent, (void *)add_range.fc_ex, + sizeof(add_range.fc_ex))); + if (ret) + return ret; + return ext4_add_extent_to_list(ctx, + &ctx->fc_replay_state.fc_extent_list, &extent); +} + +/* + * Handle delete logical range replay tag. + */ +static int ext4_fc_handle_del_range(e2fsck_t ctx, __u8 *val) +{ + struct ext2fs_extent extent; + struct ext4_fc_del_range del_range; + int ret, ino; + + memcpy(&del_range, val, sizeof(del_range)); + ino = le32_to_cpu(del_range.fc_ino); + ext4_fc_flush_extents(ctx, ino); + + memset(&extent, 0, sizeof(extent)); + extent.e_lblk = le32_to_cpu(del_range.fc_lblk); + extent.e_len = le32_to_cpu(del_range.fc_len); + ret = ext4_fc_read_extents(ctx, ino); + if (ret) + return ret; + return ext4_del_extent_from_list(ctx, + &ctx->fc_replay_state.fc_extent_list, &extent); +} + +/* + * Main recovery path entry point. This function returns JBD2_FC_REPLAY_CONTINUE + * to indicate that it is expecting more fast commit blocks. It returns + * JBD2_FC_REPLAY_STOP to indicate that replay is done. + */ +static int ext4_fc_replay(journal_t *journal, struct buffer_head *bh, + enum passtype pass, int off, tid_t expected_tid) +{ + e2fsck_t ctx = journal->j_fs_dev->k_ctx; + struct e2fsck_fc_replay_state *state = &ctx->fc_replay_state; + int ret = JBD2_FC_REPLAY_CONTINUE; + struct ext4_fc_tl tl; + __u8 *start, *end, *cur, *val; + + if (pass == PASS_SCAN) { + state->fc_current_pass = PASS_SCAN; + return ext4_fc_replay_scan(journal, bh, off, expected_tid); + } + + if (state->fc_replay_num_tags == 0) + goto replay_done; + + if (state->fc_current_pass != pass) { + /* Starting replay phase */ + state->fc_current_pass = pass; + /* We will reset checksums */ + ctx->fs->flags |= EXT2_FLAG_IGNORE_CSUM_ERRORS; + ret = errcode_to_errno(ext2fs_read_bitmaps(ctx->fs)); + if (ret) { + jbd_debug(1, "Error %d while reading bitmaps\n", ret); + return ret; + } + state->fc_super_state = ctx->fs->super->s_state; + /* + * Mark the file system to indicate it contains errors. That's + * because the updates performed by fast commit replay code are + * not atomic and may result in inconsistent file system if it + * crashes before the replay is complete. + */ + ctx->fs->super->s_state |= EXT2_ERROR_FS; + ctx->fs->super->s_state |= EXT4_FC_REPLAY; + ext2fs_mark_super_dirty(ctx->fs); + ext2fs_flush(ctx->fs); + } + + start = (__u8 *)bh->b_data; + end = (__u8 *)bh->b_data + journal->j_blocksize - 1; + + for (cur = start; cur < end; cur = cur + le16_to_cpu(tl.fc_len) + sizeof(tl)) { + memcpy(&tl, cur, sizeof(tl)); + val = cur + sizeof(tl); + + if (state->fc_replay_num_tags == 0) + goto replay_done; + jbd_debug(3, "Replay phase processing %s tag\n", + tag2str(le16_to_cpu(tl.fc_tag))); + state->fc_replay_num_tags--; + switch (le16_to_cpu(tl.fc_tag)) { + case EXT4_FC_TAG_CREAT: + case EXT4_FC_TAG_LINK: + ret = ext4_fc_handle_link_and_create(ctx, &tl, val); + break; + case EXT4_FC_TAG_UNLINK: + ret = ext4_fc_handle_unlink(ctx, &tl, val); + break; + case EXT4_FC_TAG_ADD_RANGE: + ret = ext4_fc_handle_add_extent(ctx, val); + break; + case EXT4_FC_TAG_DEL_RANGE: + ret = ext4_fc_handle_del_range(ctx, val); + break; + case EXT4_FC_TAG_INODE: + ret = ext4_fc_handle_inode(ctx, val); + break; + case EXT4_FC_TAG_TAIL: + ext4_fc_flush_extents(ctx, 0); + case EXT4_FC_TAG_PAD: + case EXT4_FC_TAG_HEAD: + break; + default: + ret = -ECANCELED; + break; + } + if (ret < 0) + break; + ret = JBD2_FC_REPLAY_CONTINUE; + } + return ret; +replay_done: + jbd_debug(1, "End of fast commit replay\n"); + if (state->fc_current_pass != pass) + return JBD2_FC_REPLAY_STOP; + + ext2fs_calculate_summary_stats(ctx->fs, 0 /* update bg also */); + ext2fs_write_block_bitmap(ctx->fs); + ext2fs_write_inode_bitmap(ctx->fs); + ext2fs_mark_super_dirty(ctx->fs); + ext2fs_set_gdt_csum(ctx->fs); + ctx->fs->super->s_state = state->fc_super_state; + ext2fs_flush(ctx->fs); + + return JBD2_FC_REPLAY_STOP; +} + +static errcode_t e2fsck_get_journal(e2fsck_t ctx, journal_t **ret_journal) +{ + struct process_block_struct pb; + 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 long start = 0; + int ret; + int ext_journal = 0; + int tried_backup_jnl = 0; + + 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)) { + /* + * The full set of superblock sanity checks haven't + * been performed yet, so we need to do some basic + * checks here to avoid potential array overruns. + */ + if (!sb->s_journal_inum || + (sb->s_journal_inum > + (ctx->fs->group_desc_count * sb->s_inodes_per_group))) { + retval = EXT2_ET_BAD_INODE_NUM; + goto errout; + } + 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_high = sb->s_jnl_blocks[15]; + 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; + e2fsck_use_inode_shortcuts(ctx, 1); + ctx->stashed_ino = j_inode->i_ino; + ctx->stashed_inode = &j_inode->i_ext2; + tried_backup_jnl++; + } + if (!j_inode->i_ext2.i_links_count || + !LINUX_S_ISREG(j_inode->i_ext2.i_mode) || + (j_inode->i_ext2.i_flags & EXT4_ENCRYPT_FL)) { + retval = EXT2_ET_NO_JOURNAL; + goto try_backup_journal; + } + if (EXT2_I_SIZE(&j_inode->i_ext2) / journal->j_blocksize < + JBD2_MIN_JOURNAL_BLOCKS) { + retval = EXT2_ET_JOURNAL_TOO_SMALL; + goto try_backup_journal; + } + pb.last_block = -1; + retval = ext2fs_block_iterate3(ctx->fs, j_inode->i_ino, + BLOCK_FLAG_HOLE, 0, + process_journal_block, &pb); + if ((pb.last_block + 1) * ctx->fs->blocksize < + (int) EXT2_I_SIZE(&j_inode->i_ext2)) { + retval = EXT2_ET_JOURNAL_TOO_SMALL; + goto try_backup_journal; + } + if (tried_backup_jnl && !(ctx->options & E2F_OPT_READONLY)) { + retval = ext2fs_write_inode(ctx->fs, sb->s_journal_inum, + &j_inode->i_ext2); + if (retval) + goto errout; + } + + journal->j_total_len = EXT2_I_SIZE(&j_inode->i_ext2) / + 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 ((ret = jbd2_journal_bmap(journal, 0, &start)) != 0) { + retval = (errcode_t) (-1 * ret); + 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); + retval = EXT2_ET_LOAD_EXT_JOURNAL; + goto errout; + } + + 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 + { + int flags = IO_FLAG_RW; + if (!(ctx->mount_flags & EXT2_MF_ISROOT && + ctx->mount_flags & EXT2_MF_READONLY)) + flags |= IO_FLAG_EXCLUSIVE; + if ((ctx->mount_flags & EXT2_MF_READONLY) && + (ctx->options & E2F_OPT_FORCE)) + flags &= ~IO_FLAG_EXCLUSIVE; + + + retval = io_ptr->open(journal_name, flags, + &ctx->journal_io); + } + if (retval) + goto errout; + + io_channel_set_blksize(ctx->journal_io, ctx->fs->blocksize); + + if (ext_journal) { + blk64_t maxlen; + + start = ext2fs_journal_sb_start(ctx->fs->blocksize) - 1; + bh = getblk(dev_journal, start, ctx->fs->blocksize); + if (!bh) { + retval = EXT2_ET_NO_MEMORY; + goto errout; + } + ll_rw_block(REQ_OP_READ, 0, 1, &bh); + if ((retval = bh->b_err) != 0) { + brelse(bh); + goto errout; + } + memcpy(&jsuper, start ? bh->b_data : bh->b_data + SUPERBLOCK_OFFSET, + sizeof(jsuper)); +#ifdef WORDS_BIGENDIAN + if (jsuper.s_magic == ext2fs_swab16(EXT2_SUPER_MAGIC)) + ext2fs_swap_super(&jsuper); +#endif + if (jsuper.s_magic != EXT2_SUPER_MAGIC || + !ext2fs_has_feature_journal_dev(&jsuper)) { + fix_problem(ctx, PR_0_EXT_JOURNAL_BAD_SUPER, &pctx); + retval = EXT2_ET_LOAD_EXT_JOURNAL; + brelse(bh); + 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; + brelse(bh); + goto errout; + } + + /* Check the superblock checksum */ + if (ext2fs_has_feature_metadata_csum(&jsuper)) { + struct struct_ext2_filsys fsx; + struct ext2_super_block superx; + void *p; + + p = start ? bh->b_data : bh->b_data + SUPERBLOCK_OFFSET; + memcpy(&fsx, ctx->fs, sizeof(fsx)); + memcpy(&superx, ctx->fs->super, sizeof(superx)); + fsx.super = &superx; + ext2fs_set_feature_metadata_csum(fsx.super); + if (!ext2fs_superblock_csum_verify(&fsx, p) && + fix_problem(ctx, PR_0_EXT_JOURNAL_SUPER_CSUM_INVALID, + &pctx)) { + ext2fs_superblock_csum_set(&fsx, p); + mark_buffer_dirty(bh); + } + } + brelse(bh); + + maxlen = ext2fs_blocks_count(&jsuper); + journal->j_total_len = (maxlen < 1ULL << 32) ? maxlen : (1ULL << 32) - 1; + 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; + if (ext2fs_has_feature_fast_commit(ctx->fs->super)) + journal->j_fc_replay_callback = ext4_fc_replay; + else + journal->j_fc_replay_callback = NULL; + +#ifdef USE_INODE_IO + if (j_inode) + ext2fs_free_mem(&j_inode); +#endif + + *ret_journal = journal; + e2fsck_use_inode_shortcuts(ctx, 0); + return 0; + +errout: + e2fsck_use_inode_shortcuts(ctx, 0); + 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 = ext2fs_has_feature_journal_needs_recovery(ctx->fs->super); + int has_journal = ext2fs_has_feature_journal(ctx->fs->super); + + 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("*** journal has been deleted ***\n\n"); + ext2fs_clear_feature_journal(sb); + sb->s_journal_inum = 0; + memset(sb->s_jnl_blocks, 0, sizeof(sb->s_jnl_blocks)); + ctx->flags |= E2F_FLAG_JOURNAL_INODE; + ctx->fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY; + e2fsck_clear_recover(ctx, 1); + return 0; + } + return EXT2_ET_CORRUPT_JOURNAL_SB; + } 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; + + ctx->flags |= E2F_FLAG_PROBLEMS_FIXED; + 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(REQ_OP_READ, 0, 1, &jbh); + if (jbh->b_err) { + com_err(ctx->device_name, jbh->b_err, "%s", + _("reading journal superblock\n")); + return jbh->b_err; + } + + jsb = journal->j_superblock; + /* If we don't even have JBD2_MAGIC, we probably have a wrong inode */ + if (jsb->s_header.h_magic != htonl(JBD2_MAGIC_NUMBER)) + return e2fsck_journal_fix_bad_inode(ctx, &pctx); + + switch (ntohl(jsb->s_header.h_blocktype)) { + case JBD2_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 JBD2_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 JBD2_DESCRIPTOR_BLOCK: + case JBD2_COMMIT_BLOCK: + case JBD2_REVOKE_BLOCK: + return EXT2_ET_CORRUPT_JOURNAL_SB; + + /* 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 (JBD2_HAS_INCOMPAT_FEATURE(journal, ~JBD2_KNOWN_INCOMPAT_FEATURES)) + return EXT2_ET_UNSUPP_FEATURE; + + if (JBD2_HAS_RO_COMPAT_FEATURE(journal, ~JBD2_KNOWN_ROCOMPAT_FEATURES)) + return EXT2_ET_RO_UNSUPP_FEATURE; + + /* Checksum v1-3 are mutually exclusive features. */ + if (jbd2_has_feature_csum2(journal) && jbd2_has_feature_csum3(journal)) + return EXT2_ET_CORRUPT_JOURNAL_SB; + + if (jbd2_journal_has_csum_v2or3(journal) && + jbd2_has_feature_checksum(journal)) + return EXT2_ET_CORRUPT_JOURNAL_SB; + + if (!e2fsck_journal_verify_csum_type(journal, jsb) || + !e2fsck_journal_sb_csum_verify(journal, jsb)) + return EXT2_ET_CORRUPT_JOURNAL_SB; + + if (jbd2_journal_has_csum_v2or3(journal)) + journal->j_csum_seed = jbd2_chksum(journal, ~0, jsb->s_uuid, + sizeof(jsb->s_uuid)); + + /* 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_JOURNAL_SB, + _("%s: no valid journal superblock found\n"), + ctx->device_name); + return EXT2_ET_CORRUPT_JOURNAL_SB; + } + + if (ntohl(jsb->s_maxlen) < journal->j_total_len) + journal->j_total_len = ntohl(jsb->s_maxlen); + else if (ntohl(jsb->s_maxlen) > journal->j_total_len) { + com_err(ctx->program_name, EXT2_ET_CORRUPT_JOURNAL_SB, + _("%s: journal too short\n"), + ctx->device_name); + return EXT2_ET_CORRUPT_JOURNAL_SB; + } + + 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); + if (jbd2_has_feature_fast_commit(journal)) { + if (ntohl(jsb->s_maxlen) - jbd2_journal_get_num_fc_blks(jsb) + < JBD2_MIN_JOURNAL_BLOCKS) { + com_err(ctx->program_name, EXT2_ET_CORRUPT_JOURNAL_SB, + _("%s: incorrect fast commit blocks\n"), + ctx->device_name); + return EXT2_ET_CORRUPT_JOURNAL_SB; + } + journal->j_fc_last = ntohl(jsb->s_maxlen); + journal->j_last = journal->j_fc_last - + jbd2_journal_get_num_fc_blks(jsb); + journal->j_fc_first = journal->j_last + 1; + } else { + 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(JBD2_MAGIC_NUMBER) || + jsb->s_header.h_blocktype != htonl(JBD2_SUPERBLOCK_V1)) { + jsb->s_header.h_magic = htonl(JBD2_MAGIC_NUMBER); + jsb->s_header.h_blocktype = htonl(JBD2_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_total_len); + 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); + e2fsck_journal_sb_csum_set(journal, jsb); + + mark_buffer_dirty(journal->j_sb_buffer); + ll_rw_block(REQ_OP_WRITE, 0, 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 = ext2fs_has_feature_journal_needs_recovery(ctx->fs->super); + + if (ext2fs_has_feature_journal(sb)) { + 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_JOURNAL_SB; + } else if (e2fsck_journal_fix_bad_inode(ctx, pctx)) + return EXT2_ET_CORRUPT_JOURNAL_SB; + + 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_tail_sequence); + if (reset) + jsb->s_start = 0; /* this marks the journal as empty */ + e2fsck_journal_sb_csum_set(journal, jsb); + 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. + */ +errcode_t e2fsck_check_ext3_journal(e2fsck_t ctx) +{ + struct ext2_super_block *sb = ctx->fs->super; + journal_t *journal; + int recover = ext2fs_has_feature_journal_needs_recovery(ctx->fs->super); + struct problem_context pctx; + problem_t problem; + int reset = 0, force_fsck = 0; + errcode_t retval; + + /* If we don't have any journal features, don't do anything more */ + if (!ext2fs_has_feature_journal(sb) && + !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_JOURNAL_SB) || + ((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 (!ext2fs_has_feature_journal(sb)) { + recover = ext2fs_has_feature_journal_needs_recovery(sb); + 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)) { + ext2fs_set_feature_journal(sb); + ctx->fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY; + ext2fs_mark_super_dirty(ctx->fs); + } + } + + if (ext2fs_has_feature_journal(sb) && + !ext2fs_has_feature_journal_needs_recovery(sb) && + 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; + ext2fs_set_feature_journal_needs_recovery(sb); + 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? + */ + } + + /* + * If we don't need to do replay the journal, check to see if + * the journal's errno is set; if so, we need to mark the file + * system as being corrupt and clear the journal's s_errno. + */ + if (!ext2fs_has_feature_journal_needs_recovery(sb) && + 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; + e2fsck_journal_sb_csum_set(journal, journal->j_superblock); + mark_buffer_dirty(journal->j_sb_buffer); + } + + e2fsck_journal_release(ctx, journal, reset, 0); + return retval; +} + +static errcode_t recover_ext3_journal(e2fsck_t ctx) +{ + struct problem_context pctx; + journal_t *journal; + errcode_t retval; + + clear_problem_context(&pctx); + + retval = jbd2_journal_init_revoke_record_cache(); + if (retval) + return retval; + + retval = jbd2_journal_init_revoke_table_cache(); + if (retval) + return retval; + + retval = e2fsck_get_journal(ctx, &journal); + if (retval) + return retval; + + retval = e2fsck_journal_load(journal); + if (retval) + goto errout; + + retval = jbd2_journal_init_revoke(journal, 1024); + if (retval) + goto errout; + + retval = -jbd2_journal_recover(journal); + if (retval) + goto errout; + + if (journal->j_failed_commit) { + pctx.ino = journal->j_failed_commit; + fix_problem(ctx, PR_0_JNL_TXN_CORRUPT, &pctx); + journal->j_superblock->s_errno = -EINVAL; + mark_buffer_dirty(journal->j_sb_buffer); + } + + journal->j_tail_sequence = journal->j_transaction_sequence; + +errout: + jbd2_journal_destroy_revoke(journal); + jbd2_journal_destroy_revoke_record_cache(); + jbd2_journal_destroy_revoke_table_cache(); + e2fsck_journal_release(ctx, journal, 1, 0); + return retval; +} + +errcode_t 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; + io_stats stats = 0; + unsigned long long kbytes_written = 0; + + 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. + */ + if (ctx->fs->super->s_kbytes_written && + ctx->fs->io->manager->get_stats) + ctx->fs->io->manager->get_stats(ctx->fs->io, &stats); + if (stats && stats->bytes_written) + kbytes_written = stats->bytes_written >> 10; + + ext2fs_mmp_stop(ctx->fs); + ext2fs_free(ctx->fs); + retval = ext2fs_open(ctx->filesystem_name, ctx->openfs_flags, + 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; + ctx->fs->now = ctx->now; + ctx->fs->flags |= EXT2_FLAG_MASTER_SB_ONLY; + ctx->fs->super->s_kbytes_written += kbytes_written; + + /* Set the superblock flags */ + e2fsck_clear_recover(ctx, recover_retval != 0); + + /* + * Do one last sanity check, and propagate journal->s_errno to + * the EXT2_ERROR_FS flag in the fs superblock if needed. + */ + retval = e2fsck_check_ext3_journal(ctx); + return retval ? retval : 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; + dgrp_t group; + int 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) || + !ext2fs_has_feature_journal(sb)) + 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[15] = inode.i_size_high; + 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 = ctx->now; + if ((retval = ext2fs_write_inode(fs, ino, &inode)) != 0) + goto err_out; + + group = ext2fs_group_of_ino(fs, ino); + ext2fs_unmark_inode_bitmap2(fs->inode_map, ino); + ext2fs_mark_ib_dirty(fs); + ext2fs_bg_free_inodes_count_set(fs, group, ext2fs_bg_free_inodes_count(fs, group) + 1); + ext2fs_group_desc_csum_set(fs, group); + 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; +} + +/* + * This function makes sure the superblock hint for the external + * journal is correct. + */ +int e2fsck_fix_ext3_journal_hint(e2fsck_t ctx) +{ + struct ext2_super_block *sb = ctx->fs->super; + struct problem_context pctx; + char uuid[37], *journal_name; + struct stat st; + + if (!ext2fs_has_feature_journal(sb) || + uuid_is_null(sb->s_journal_uuid)) + return 0; + + uuid_unparse(sb->s_journal_uuid, uuid); + journal_name = blkid_get_devname(ctx->blkid, "UUID", uuid); + if (!journal_name) + return 0; + + if (stat(journal_name, &st) < 0) { + free(journal_name); + return 0; + } + + if (st.st_rdev != sb->s_journal_dev) { + clear_problem_context(&pctx); + pctx.num = st.st_rdev; + if (fix_problem(ctx, PR_0_EXTERNAL_JOURNAL_HINT, &pctx)) { + sb->s_journal_dev = st.st_rdev; + ext2fs_mark_super_dirty(ctx->fs); + } + } + + free(journal_name); + return 0; +} diff --git a/e2fsck/logfile.c b/e2fsck/logfile.c new file mode 100644 index 0000000..9d79eed --- /dev/null +++ b/e2fsck/logfile.c @@ -0,0 +1,411 @@ +/* + * logfile.c --- set up e2fsck log files + * + * 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 "config.h" +#ifdef HAVE_ERRNO_H +#include +#endif +#include +#include +#include + +#include "e2fsck.h" +#include + +extern e2fsck_t e2fsck_global_ctx; /* Try your very best not to use this! */ + +struct string { + char *s; + int len; + int end; +}; + +static void alloc_string(struct string *s, int len) +{ + s->s = malloc(len); +/* e2fsck_allocate_memory(ctx, len, "logfile name"); */ + s->len = s->s ? len : 0; + s->end = 0; +} + +static void append_string(struct string *s, const char *a, int len) +{ + int needlen; + + if (!len) + len = strlen(a); + + needlen = s->end + len + 1; + if (needlen > s->len) { + char *n; + + if (s->len * 2 > needlen) + needlen = s->len * 2; + n = realloc(s->s, needlen); + + if (n) { + s->s = n; + s->len = needlen; + } else { + /* Don't append if we ran out of memory */ + return; + } + } + memcpy(s->s + s->end, a, len); + s->end += len; + s->s[s->end] = 0; +} + +#define FLAG_UTC 0x0001 + +static void expand_percent_expression(e2fsck_t ctx, char ch, + struct string *s, int *flags) +{ + struct tm *tm = NULL, tm_struct; + struct passwd *pw = NULL, pw_struct; + char *cp; + char buf[256]; + + if ((ch == 'D') || (ch == 'd') || (ch == 'm') || (ch == 'y') || + (ch == 'Y') || + (ch == 'T') || (ch == 'H') || (ch == 'M') || (ch == 'S')) { + tzset(); + tm = (*flags & FLAG_UTC) ? gmtime_r(&ctx->now, &tm_struct) : + localtime_r(&ctx->now, &tm_struct); + } + + switch (ch) { + case '%': + append_string(s, "%", 1); + return; + case 'd': + sprintf(buf, "%02d", tm->tm_mday); + break; + case 'D': + sprintf(buf, "%d%02d%02d", tm->tm_year + 1900, tm->tm_mon + 1, + tm->tm_mday); + break; + case 'h': +#ifdef TEST_PROGRAM + strcpy(buf, "server"); +#else + buf[0] = 0; + gethostname(buf, sizeof(buf)); + buf[sizeof(buf)-1] = 0; +#endif + break; + case 'H': + sprintf(buf, "%02d", tm->tm_hour); + break; + case 'm': + sprintf(buf, "%02d", tm->tm_mon + 1); + break; + case 'M': + sprintf(buf, "%02d", tm->tm_min); + break; + case 'N': /* block device name */ + cp = strrchr(ctx->filesystem_name, '/'); + if (cp) + cp++; + else + cp = ctx->filesystem_name; + append_string(s, cp, 0); + return; + case 'p': + sprintf(buf, "%lu", (unsigned long) getpid()); + break; + case 's': + sprintf(buf, "%lu", (unsigned long) ctx->now); + break; + case 'S': + sprintf(buf, "%02d", tm->tm_sec); + break; + case 'T': + sprintf(buf, "%02d%02d%02d", tm->tm_hour, tm->tm_min, + tm->tm_sec); + break; + case 'u': +#ifdef TEST_PROGRAM + strcpy(buf, "tytso"); + break; +#else +#ifdef HAVE_GETPWUID_R + getpwuid_r(getuid(), &pw_struct, buf, sizeof(buf), &pw); +#else + pw = getpwuid(getuid()); +#endif + if (pw) + append_string(s, pw->pw_name, 0); + return; +#endif + case 'U': + *flags |= FLAG_UTC; + return; + case 'y': + sprintf(buf, "%02d", tm->tm_year % 100); + break; + case 'Y': + sprintf(buf, "%d", tm->tm_year + 1900); + break; + default: + sprintf(buf, "%%%c", ch); + break; + } + append_string(s, buf, 0); +} + +static void expand_logfn(e2fsck_t ctx, const char *log_fn, struct string *s) +{ + const char *cp; + int i; + int flags = 0; + + alloc_string(s, 100); + for (cp = log_fn; *cp; cp++) { + if (cp[0] == '%') { + cp++; + expand_percent_expression(ctx, *cp, s, &flags); + continue; + } + for (i = 0; cp[i]; i++) + if (cp[i] == '%') + break; + append_string(s, cp, i); + cp += i-1; + } +} + +static int outbufsize; +static void *outbuf; + +static int do_read(int fd) +{ + int c; + char *n; + char buffer[4096]; + + c = read(fd, buffer, sizeof(buffer)-1); + if (c <= 0) + return c; + + n = realloc(outbuf, outbufsize + c); + if (n) { + outbuf = n; + memcpy(((char *)outbuf)+outbufsize, buffer, c); + outbufsize += c; + } + return c; +} + +/* + * Fork a child process to save the output of the logfile until the + * appropriate file system is mounted read/write. + */ +static FILE *save_output(const char *s0, const char *s1, const char *s2) +{ + int c, fd, fds[2]; + char *cp; + pid_t pid; + FILE *ret; + + if (s0 && *s0 == 0) + s0 = 0; + if (s1 && *s1 == 0) + s1 = 0; + if (s2 && *s2 == 0) + s2 = 0; + + /* At least one potential output file name is valid */ + if (!s0 && !s1 && !s2) + return NULL; + if (pipe(fds) < 0) { + perror("pipe"); + exit(1); + } + + pid = fork(); + if (pid < 0) { + perror("fork"); + exit(1); + } + + if (pid == 0) { + if (e2fsck_global_ctx && e2fsck_global_ctx->progress_fd) + close(e2fsck_global_ctx->progress_fd); + if (daemon(0, 0) < 0) { + perror("daemon"); + exit(1); + } + /* + * Grab the output from our parent + */ + close(fds[1]); + while (do_read(fds[0]) > 0) + ; + close(fds[0]); + + /* OK, now let's try to open the output file */ + fd = -1; + while (1) { + if (fd < 0 && s0) + fd = open(s0, O_WRONLY|O_CREAT|O_TRUNC, 0644); + if (fd < 0 && s1) + fd = open(s1, O_WRONLY|O_CREAT|O_TRUNC, 0644); + if (fd < 0 && s2) + fd = open(s2, O_WRONLY|O_CREAT|O_TRUNC, 0644); + if (fd >= 0) + break; + sleep(1); + } + + cp = outbuf; + while (outbufsize > 0) { + c = write(fd, cp, outbufsize); + if (c < 0) { + if ((errno == EAGAIN) || (errno == EINTR)) + continue; + break; + } + outbufsize -= c; + cp += c; + } + exit(0); + } + + close(fds[0]); + ret = fdopen(fds[1], "w"); + if (!ret) + close(fds[1]); + return ret; +} + +#ifndef TEST_PROGRAM +static FILE *set_up_log_file(e2fsck_t ctx, const char *key, const char *fn) +{ + FILE *f = NULL; + struct string s, s1, s2; + char *s0 = 0, *log_dir = 0, *log_fn = 0; + int log_dir_wait = 0; + + s.s = s1.s = s2.s = 0; + + profile_get_boolean(ctx->profile, "options", "log_dir_wait", 0, 0, + &log_dir_wait); + if (fn) + log_fn = string_copy(ctx, fn, 0); + else + profile_get_string(ctx->profile, "options", key, + 0, 0, &log_fn); + profile_get_string(ctx->profile, "options", "log_dir", 0, 0, &log_dir); + + if (!log_fn || !log_fn[0]) + goto out; + + expand_logfn(ctx, log_fn, &s); + if ((log_fn[0] == '/') || !log_dir || !log_dir[0]) + s0 = s.s; + + if (log_dir && log_dir[0]) { + alloc_string(&s1, strlen(log_dir) + strlen(s.s) + 2); + append_string(&s1, log_dir, 0); + append_string(&s1, "/", 1); + append_string(&s1, s.s, 0); + } + + free(log_dir); + profile_get_string(ctx->profile, "options", "log_dir_fallback", 0, 0, + &log_dir); + if (log_dir && log_dir[0]) { + alloc_string(&s2, strlen(log_dir) + strlen(s.s) + 2); + append_string(&s2, log_dir, 0); + append_string(&s2, "/", 1); + append_string(&s2, s.s, 0); + printf("%s\n", s2.s); + } + + if (s0) + f = fopen(s0, "w"); + if (!f && s1.s) + f = fopen(s1.s, "w"); + if (!f && s2.s) + f = fopen(s2.s, "w"); + if (!f && log_dir_wait) + f = save_output(s0, s1.s, s2.s); + +out: + free(s.s); + free(s1.s); + free(s2.s); + free(log_fn); + free(log_dir); + return f; +} + +void set_up_logging(e2fsck_t ctx) +{ + ctx->logf = set_up_log_file(ctx, "log_filename", ctx->log_fn); + ctx->problem_logf = set_up_log_file(ctx, "problem_log_filename", + ctx->problem_log_fn); +} +#else +void *e2fsck_allocate_memory(e2fsck_t ctx, unsigned long size, + const char *description) +{ + void *ret; + char buf[256]; + + ret = malloc(size); + if (!ret) { + sprintf(buf, "Can't allocate %s\n", description); + exit(1); + } + memset(ret, 0, size); + return ret; +} + +errcode_t e2fsck_allocate_context(e2fsck_t *ret) +{ + e2fsck_t context; + errcode_t retval; + char *time_env; + + context = malloc(sizeof(struct e2fsck_struct)); + if (!context) + return ENOMEM; + + memset(context, 0, sizeof(struct e2fsck_struct)); + + context->now = 1332006474; + + context->filesystem_name = "/dev/sda3"; + context->device_name = "fslabel"; + + *ret = context; + return 0; +} + +int main(int argc, char **argv) +{ + e2fsck_t ctx; + struct string s; + + putenv("TZ=EST+5:00"); + e2fsck_allocate_context(&ctx); + expand_logfn(ctx, "e2fsck-%N.%h.%u.%D-%T", &s); + printf("%s\n", s.s); + free(s.s); + expand_logfn(ctx, "e2fsck-%N.%h.%u.%Y%m%d-%H%M%S", &s); + printf("%s\n", s.s); + free(s.s); + + return 0; +} +#endif diff --git a/e2fsck/message.c b/e2fsck/message.c new file mode 100644 index 0000000..ba38038 --- /dev/null +++ b/e2fsck/message.c @@ -0,0 +1,556 @@ +/* + * 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 interpret blkcount as blkcount + * %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_size_high + * %Iu -> i_uid + * %Ig -> i_gid + * %It + * %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. + * %r interpret blkcount as refcount + * %s miscellaneous string + * %t time (in ) + * %T current time + * %U quota type (in ) + * %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 + * @m multiply-claimed + * @n invalid + * @o orphaned + * @p problem in + * @q quota + * @r root inode + * @s should be + * @S superblock + * @u unattached + * @v device + * @x extent + * @z zero-length + */ + +#include "config.h" +#include +#include +#include +#include +#include +#include "support/quotaio.h" + +#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_("ddirectory"), + N_("Ddeleted"), + N_("eentry"), + N_("E@e '%Dn' in %p (%i)"), + N_("ffilesystem"), + N_("Ffor @i %i (%Q) is"), + N_("ggroup"), + N_("hHTREE @d @i"), + N_("iinode"), + N_("Iillegal"), + N_("jjournal"), + N_("llost+found"), + N_("Lis a link"), + N_("mmultiply-claimed"), + N_("ninvalid"), + N_("oorphaned"), + N_("pproblem in"), + N_("qquota"), + N_("rroot @i"), + N_("sshould be"), + N_("Ssuper@b"), + N_("uunattached"), + N_("vdevice"), + N_("xextent"), + 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(FILE *f, const char *cp, int len) +{ + unsigned char ch; + + if (len < 0) + len = strlen(cp); + + while (len--) { + ch = *cp++; + if (ch > 128) { + fputs("M-", f); + ch -= 128; + } + if ((ch < 32) || (ch == 0x7f)) { + fputc('^', f); + ch ^= 0x40; /* ^@, ^A, ^B; ^? for DEL */ + } + fputc(ch, f); + } +} + + +/* + * This function prints a pathname, using the ext2fs_get_pathname + * function + */ +static void print_pathname(FILE *f, ext2_filsys fs, ext2_ino_t dir, + ext2_ino_t ino) +{ + errcode_t retval = 0; + char *path; + + if (!dir && (ino < num_special_inodes)) { + fputs(_(special_inode_name[ino]), f); + return; + } + + if (fs) + retval = ext2fs_get_pathname(fs, dir, ino, &path); + if (!fs || retval) + fputs("???", f); + else { + safe_print(f, path, -1); + ext2fs_free_mem(&path); + } +} + +static void print_time(FILE *f, time_t t) +{ + const char * time_str; + static int do_gmt = -1; + +#ifdef __dietlibc__ + /* The diet libc doesn't respect the TZ environment variable */ + if (do_gmt == -1) { + time_str = getenv("TZ"); + if (!time_str) + time_str = ""; + do_gmt = !strcmp(time_str, "GMT") || + !strcmp(time_str, "GMT0"); + } +#endif + time_str = asctime((do_gmt > 0) ? gmtime(&t) : localtime(&t)); + fprintf(f, "%.24s", time_str); +} + +/* + * This function handles the '@' expansion. We allow recursive + * expansion; an @ expression can contain further '@' and '%' + * expressions. + */ +static _INLINE_ void expand_at_expression(FILE *f, e2fsck_t ctx, char ch, + struct problem_context *pctx, + int *first, int recurse) +{ + const char **cpp, *str; + + /* Search for the abbreviation */ + for (cpp = abbrevs; *cpp; cpp++) { + if (ch == *cpp[0]) + break; + } + if (*cpp && recurse < 10) { + str = _(*cpp) + 1; + if (*first && islower(*str)) { + *first = 0; + fputc(toupper(*str++), f); + } + print_e2fsck_message(f, ctx, str, pctx, *first, recurse+1); + } else + fprintf(f, "@%c", ch); +} + +/* + * This function expands '%IX' expressions + */ +static _INLINE_ void expand_inode_expression(FILE *f, ext2_filsys fs, char ch, + struct problem_context *ctx) +{ + struct ext2_inode *inode; + struct ext2_inode_large *large_inode; + + if (!ctx || !ctx->inode) + goto no_inode; + + inode = ctx->inode; + large_inode = (struct ext2_inode_large *) inode; + + switch (ch) { + case 's': + fprintf(f, "%llu", (unsigned long long) EXT2_I_SIZE(inode)); + break; + case 'S': + fprintf(f, "%u", large_inode->i_extra_isize); + break; + case 'b': + if (ext2fs_has_feature_huge_file(fs->super)) + fprintf(f, "%llu", inode->i_blocks + + (((long long) inode->osd2.linux2.l_i_blocks_hi) + << 32)); + else + fprintf(f, "%u", inode->i_blocks); + break; + case 'l': + fprintf(f, "%d", inode->i_links_count); + break; + case 'm': + fprintf(f, "0%o", inode->i_mode); + break; + case 'M': + print_time(f, inode->i_mtime); + break; + case 'F': + fprintf(f, "%u", inode->i_faddr); + break; + case 'f': + fprintf(f, "%llu", + (unsigned long long) ext2fs_file_acl_block(fs, inode)); + break; + case 'd': + fprintf(f, "%u", (LINUX_S_ISDIR(inode->i_mode) ? + inode->i_size_high : 0)); + break; + case 'u': + fprintf(f, "%d", inode_uid(*inode)); + break; + case 'g': + fprintf(f, "%d", inode_gid(*inode)); + break; + case 't': + if (LINUX_S_ISREG(inode->i_mode)) + fputs(_("regular file"), f); + else if (LINUX_S_ISDIR(inode->i_mode)) + fputs(_("directory"), f); + else if (LINUX_S_ISCHR(inode->i_mode)) + fputs(_("character device"), f); + else if (LINUX_S_ISBLK(inode->i_mode)) + fputs(_("block device"), f); + else if (LINUX_S_ISFIFO(inode->i_mode)) + fputs(_("named pipe"), f); + else if (LINUX_S_ISLNK(inode->i_mode)) + fputs(_("symbolic link"), f); + else if (LINUX_S_ISSOCK(inode->i_mode)) + fputs(_("socket"), f); + else + fprintf(f, _("unknown file type with mode 0%o"), + inode->i_mode); + break; + default: + no_inode: + fprintf(f, "%%I%c", ch); + break; + } +} + +/* + * This function expands '%dX' expressions + */ +static _INLINE_ void expand_dirent_expression(FILE *f, ext2_filsys fs, char ch, + struct problem_context *ctx) +{ + struct ext2_dir_entry *dirent; + unsigned int rec_len, len; + + if (!ctx || !ctx->dirent) + goto no_dirent; + + dirent = ctx->dirent; + + switch (ch) { + case 'i': + fprintf(f, "%u", dirent->inode); + break; + case 'n': + len = ext2fs_dirent_name_len(dirent); + if ((ext2fs_get_rec_len(fs, dirent, &rec_len) == 0) && + (len > rec_len)) + len = rec_len; + safe_print(f, dirent->name, len); + break; + case 'r': + (void) ext2fs_get_rec_len(fs, dirent, &rec_len); + fprintf(f, "%u", rec_len); + break; + case 'l': + fprintf(f, "%u", ext2fs_dirent_name_len(dirent)); + break; + case 't': + fprintf(f, "%u", ext2fs_dirent_file_type(dirent)); + break; + default: + no_dirent: + fprintf(f, "%%D%c", ch); + break; + } +} + +static _INLINE_ void expand_percent_expression(FILE *f, ext2_filsys fs, + char ch, int width, int *first, + struct problem_context *ctx) +{ + e2fsck_t e2fsck_ctx = fs ? (e2fsck_t) fs->priv_data : NULL; + const char *m; + + if (!ctx) + goto no_context; + + switch (ch) { + case '%': + fputc('%', f); + break; + case 'b': + fprintf(f, "%*llu", width, (unsigned long long) ctx->blk); + break; + case 'B': + if (ctx->blkcount == BLOCK_COUNT_IND) + m = _("indirect block"); + else if (ctx->blkcount == BLOCK_COUNT_DIND) + m = _("double indirect block"); + else if (ctx->blkcount == BLOCK_COUNT_TIND) + m = _("triple indirect block"); + else if (ctx->blkcount == BLOCK_COUNT_TRANSLATOR) + m = _("translator block"); + else + m = _("block #"); + if (*first && islower(m[0])) + fputc(toupper(*m++), f); + fputs(m, f); + if (ctx->blkcount >= 0) + fprintf(f, "%lld", (long long) ctx->blkcount); + break; + case 'c': + fprintf(f, "%*llu", width, (unsigned long long) ctx->blk2); + break; + case 'd': + fprintf(f, "%*u", width, ctx->dir); + break; + case 'g': + fprintf(f, "%*u", width, ctx->group); + break; + case 'i': + fprintf(f, "%*u", width, ctx->ino); + break; + case 'j': + fprintf(f, "%*u", width, ctx->ino2); + break; + case 'm': + fprintf(f, "%*s", width, error_message(ctx->errcode)); + break; + case 'N': + fprintf(f, "%*llu", width, (long long)ctx->num); + break; + case 'n': + fprintf(f, "%*llu", width, (long long)ctx->num2); + break; + case 'p': + print_pathname(f, fs, ctx->ino, 0); + break; + case 'P': + print_pathname(f, fs, ctx->ino2, + ctx->dirent ? ctx->dirent->inode : 0); + break; + case 'q': + print_pathname(f, fs, ctx->dir, 0); + break; + case 'Q': + print_pathname(f, fs, ctx->dir, ctx->ino); + break; + case 'r': + fprintf(f, "%*lld", width, (long long) ctx->blkcount); + break; + case 'S': + fprintf(f, "%llu", + (unsigned long long) get_backup_sb(NULL, fs, + NULL, NULL)); + break; + case 's': + fprintf(f, "%*s", width, ctx->str ? ctx->str : "NULL"); + break; + case 't': + print_time(f, (time_t) ctx->num); + break; + case 'T': + print_time(f, e2fsck_ctx ? e2fsck_ctx->now : time(0)); + break; + case 'U': + switch (ctx->num) { + case USRQUOTA: + m = _("user"); + break; + case GRPQUOTA: + m = _("group"); + break; + case PRJQUOTA: + m = _("project"); + break; + default: + m = _("unknown quota type"); + break; + } + if (*first && islower(m[0])) + fputc(toupper(*m++), f); + fputs(m, f); + if (ctx->num > PRJQUOTA) + fprintf(f, " %d", (int) ctx->num); + break; + case 'x': + fprintf(f, "0x%0*x", width, ctx->csum1); + break; + case 'X': + fprintf(f, "0x%0*llx", width, (long long)ctx->num); + break; + case 'y': + fprintf(f, "0x%0*x", width, ctx->csum2); + break; + default: + no_context: + fprintf(f, "%%%c", ch); + break; + } +} + +void print_e2fsck_message(FILE *f, e2fsck_t ctx, const char *msg, + struct problem_context *pctx, int first, + int recurse) +{ + ext2_filsys fs = ctx->fs; + const char * cp; + int i, width; + + e2fsck_clear_progbar(ctx); + for (cp = msg; *cp; cp++) { + if (cp[0] == '@') { + cp++; + expand_at_expression(f, ctx, *cp, pctx, &first, + recurse); + } else if (cp[0] == '%') { + cp++; + width = 0; + while (isdigit(cp[0])) { + width = (width * 10) + cp[0] - '0'; + cp++; + } + if (cp[0] == 'I') { + cp++; + expand_inode_expression(f, fs, *cp, pctx); + } else if (cp[0] == 'D') { + cp++; + expand_dirent_expression(f, fs, *cp, pctx); + } else { + expand_percent_expression(f, fs, *cp, width, + &first, pctx); + } + } else { + for (i=0; cp[i]; i++) + if ((cp[i] == '@') || cp[i] == '%') + break; + fprintf(f, "%.*s", i, cp); + cp += i-1; + } + first = 0; + } +} diff --git a/e2fsck/mtrace.awk b/e2fsck/mtrace.awk new file mode 100644 index 0000000..7e96b8a --- /dev/null +++ b/e2fsck/mtrace.awk @@ -0,0 +1,37 @@ +#!/usr/bin/awk -f +# +# Awk program to analyze mtrace.c output. +# +$1 == "+" { if (allocated[$2] != "") + print "+", $2, "Alloc", NR, "duplicate:", allocated[$2]; + else + allocated[$2] = $3; + } +$1 == "-" { if (allocated[$2] != "") { + allocated[$2] = ""; + if (allocated[$2] != "") + print "DELETE FAILED", $2, allocated[$2]; + } else + print "-", $2, "Free", NR, "was never alloc'd"; + } +$1 == "<" { if (allocated[$2] != "") + allocated[$2] = ""; + else + print "-", $2, "Realloc", NR, "was never alloc'd"; + } +$1 == ">" { if (allocated[$2] != "") + print "+", $2, "Realloc", NR, "duplicate:", allocated[$2]; + else + allocated[$2] = $3; + } + +# Ignore "= Start" +$1 == "=" { } +# Ignore failed realloc attempts for now +$1 == "!" { } + + +END { for (x in allocated) + if (allocated[x] != "") + print "+", x, allocated[x]; + } diff --git a/e2fsck/mtrace.c b/e2fsck/mtrace.c new file mode 100644 index 0000000..2b7b34a --- /dev/null +++ b/e2fsck/mtrace.c @@ -0,0 +1,160 @@ +/* More debugging hooks for `malloc'. + Copyright (C) 1991, 1992 Free Software Foundation, Inc. + Written April 2, 1991 by John Gilmore of Cygnus Support. + Based on mcheck.c by Mike Haertel. + +This library is free software; you can redistribute it and/or +modify it under the terms of the GNU Library General Public License as +published by the Free Software Foundation; either version 2 of the +License, or (at your option) any later version. + +This library is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +Library General Public License for more details. + +You should have received a copy of the GNU Library General Public +License along with this library; see the file COPYING.LIB. If +not, write to the Free Software Foundation, Inc., 675 Mass Ave, +Cambridge, MA 02139, USA. + + The author may be reached (Email) at the address mike@ai.mit.edu, + or (US mail) as Mike Haertel c/o Free Software Foundation. */ + +#include "config.h" + +#ifndef _MALLOC_INTERNAL +#define _MALLOC_INTERNAL +#include "./mtrace.h" +#endif + +#include + +#ifndef __GNU_LIBRARY__ +extern char *getenv (); +#else +#include +#endif + +static FILE *mallstream; +static char mallenv[]= "MALLOC_TRACE"; +static char mallbuf[BUFSIZ]; /* Buffer for the output. */ + +/* Address to breakpoint on accesses to... */ +__ptr_t mallwatch; + +/* Old hook values. */ +static void (*tr_old_free_hook) __P ((__ptr_t ptr)); +static __ptr_t (*tr_old_malloc_hook) __P ((size_t size)); +static __ptr_t (*tr_old_realloc_hook) __P ((__ptr_t ptr, size_t size)); + +/* + * Added by TYT, 10/10/93 --- so that we can print + */ +FILE *malloc_get_mallstream() +{ + return mallstream; +} + +/* This function is called when the block being alloc'd, realloc'd, or + freed has an address matching the variable "mallwatch". In a debugger, + set "mallwatch" to the address of interest, then put a breakpoint on + tr_break. */ + +void tr_break __P ((void)); +void +tr_break () +{ +} + +static void tr_freehook __P ((__ptr_t)); +static void +tr_freehook (ptr) + __ptr_t ptr; +{ + fprintf (mallstream, "- %p\n", ptr); /* Be sure to print it first. */ + if (ptr == mallwatch) + tr_break (); + __free_hook = tr_old_free_hook; + free (ptr); + __free_hook = tr_freehook; +} + +static __ptr_t tr_mallochook __P ((size_t)); +static __ptr_t +tr_mallochook (size) + size_t size; +{ + __ptr_t hdr; + + __malloc_hook = tr_old_malloc_hook; + hdr = (__ptr_t) malloc (size); + __malloc_hook = tr_mallochook; + + /* We could be printing a NULL here; that's OK. */ + fprintf (mallstream, "+ %p %d\n", hdr, size); + + if (hdr == mallwatch) + tr_break (); + + return hdr; +} + +static __ptr_t tr_reallochook __P ((__ptr_t, size_t)); +static __ptr_t +tr_reallochook (ptr, size) + __ptr_t ptr; + size_t size; +{ + __ptr_t hdr; + + if (ptr == mallwatch) + tr_break (); + + __free_hook = tr_old_free_hook; + __malloc_hook = tr_old_malloc_hook; + __realloc_hook = tr_old_realloc_hook; + hdr = (__ptr_t) realloc (ptr, size); + __free_hook = tr_freehook; + __malloc_hook = tr_mallochook; + __realloc_hook = tr_reallochook; + if (hdr == NULL) + /* Failed realloc. */ + fprintf (mallstream, "! %p %d\n", ptr, size); + else + fprintf (mallstream, "< %p\n> %p %d\n", ptr, hdr, size); + + if (hdr == mallwatch) + tr_break (); + + return hdr; +} + +/* We enable tracing if either the environment variable MALLOC_TRACE + is set, or if the variable mallwatch has been patched to an address + that the debugging user wants us to stop on. When patching mallwatch, + don't forget to set a breakpoint on tr_break! */ + +void +mtrace () +{ + char *mallfile; + + mallfile = getenv (mallenv); + if (mallfile != NULL || mallwatch != NULL) + { + mallstream = fopen (mallfile != NULL ? mallfile : "/dev/null", "w"); + if (mallstream != NULL) + { + /* Be sure it doesn't malloc its buffer! */ + setbuf (mallstream, mallbuf); + fprintf (mallstream, "= Start\n"); + tr_old_free_hook = __free_hook; + __free_hook = tr_freehook; + tr_old_malloc_hook = __malloc_hook; + __malloc_hook = tr_mallochook; + tr_old_realloc_hook = __realloc_hook; + __realloc_hook = tr_reallochook; + } + } +} diff --git a/e2fsck/mtrace.h b/e2fsck/mtrace.h new file mode 100644 index 0000000..2ed20eb --- /dev/null +++ b/e2fsck/mtrace.h @@ -0,0 +1,231 @@ +/* Declarations for `malloc' and friends. + Copyright 1990, 1991, 1992 Free Software Foundation, Inc. + Written May 1989 by Mike Haertel. + +This library is free software; you can redistribute it and/or +modify it under the terms of the GNU Library General Public License as +published by the Free Software Foundation; either version 2 of the +License, or (at your option) any later version. + +This library is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +Library General Public License for more details. + +You should have received a copy of the GNU Library General Public +License along with this library; see the file COPYING.LIB. If +not, write to the Free Software Foundation, Inc., 675 Mass Ave, +Cambridge, MA 02139, USA. + + The author may be reached (Email) at the address mike@ai.mit.edu, + or (US mail) as Mike Haertel c/o Free Software Foundation. */ + +#ifndef _MTRACE_H + +#define _MTRACE_H 1 + +#ifdef __cplusplus +extern "C" +{ +#endif + +#if defined (__cplusplus) || (defined (__STDC__) && __STDC__) +#undef __P +#define __P(args) args +#undef __ptr_t +#define __ptr_t void * +#else /* Not C++ or ANSI C. */ +#undef __P +#define __P(args) () +#undef const +#define const +#undef __ptr_t +#define __ptr_t char * +#endif /* C++ or ANSI C. */ + +#ifndef NULL +#define NULL 0 +#endif + +#ifdef __STDC__ +#include +#else +#undef size_t +#define size_t unsigned int +#undef ptrdiff_t +#define ptrdiff_t int +#endif + + +/* Allocate SIZE bytes of memory. */ +extern __ptr_t malloc __P ((size_t __size)); +/* Re-allocate the previously allocated block + in __ptr_t, making the new block SIZE bytes long. */ +extern __ptr_t realloc __P ((__ptr_t __ptr, size_t __size)); +/* Allocate NMEMB elements of SIZE bytes each, all initialized to 0. */ +extern __ptr_t calloc __P ((size_t __nmemb, size_t __size)); +/* Free a block allocated by `malloc', `realloc' or `calloc'. */ +extern void free __P ((__ptr_t __ptr)); + +/* Allocate SIZE bytes allocated to ALIGNMENT bytes. */ +extern __ptr_t memalign __P ((size_t __alignment, size_t __size)); + +/* Allocate SIZE bytes on a page boundary. */ +extern __ptr_t valloc __P ((size_t __size)); + + +#ifdef _MALLOC_INTERNAL + +#include /* Harmless, gets __GNU_LIBRARY__ defined. */ + +#if defined(__GNU_LIBRARY__) || defined(STDC_HEADERS) || defined(USG) +#include +#else +#ifndef memset +#define memset(s, zero, n) bzero ((s), (n)) +#endif +#ifndef memcpy +#define memcpy(d, s, n) bcopy ((s), (d), (n)) +#endif +#endif + + +#if defined(__GNU_LIBRARY__) || defined(__STDC__) +#include +#else +#define CHAR_BIT 8 +#endif + +/* The allocator divides the heap into blocks of fixed size; large + requests receive one or more whole blocks, and small requests + receive a fragment of a block. Fragment sizes are powers of two, + and all fragments of a block are the same size. When all the + fragments in a block have been freed, the block itself is freed. */ +#define INT_BIT (CHAR_BIT * sizeof(int)) +#define BLOCKLOG (INT_BIT > 16 ? 12 : 9) +#define BLOCKSIZE (1 << BLOCKLOG) +#define BLOCKIFY(SIZE) (((SIZE) + BLOCKSIZE - 1) / BLOCKSIZE) + +/* Determine the amount of memory spanned by the initial heap table + (not an absolute limit). */ +#define HEAP (INT_BIT > 16 ? 4194304 : 65536) + +/* Number of contiguous free blocks allowed to build up at the end of + memory before they will be returned to the system. */ +#define FINAL_FREE_BLOCKS 8 + +/* Data structure giving per-block information. */ +typedef union + { + /* Heap information for a busy block. */ + struct + { + /* Zero for a large block, or positive giving the + logarithm to the base two of the fragment size. */ + int type; + union + { + struct + { + size_t nfree; /* Free fragments in a fragmented block. */ + size_t first; /* First free fragment of the block. */ + } frag; + /* Size (in blocks) of a large cluster. */ + size_t size; + } info; + } busy; + /* Heap information for a free block + (that may be the first of a free cluster). */ + struct + { + size_t size; /* Size (in blocks) of a free cluster. */ + size_t next; /* Index of next free cluster. */ + size_t prev; /* Index of previous free cluster. */ + } free; + } malloc_info; + +/* Pointer to first block of the heap. */ +extern char *_heapbase; + +/* Table indexed by block number giving per-block information. */ +extern malloc_info *_heapinfo; + +/* Address to block number and vice versa. */ +#define BLOCK(A) (((char *) (A) - _heapbase) / BLOCKSIZE + 1) +#define ADDRESS(B) ((__ptr_t) (((B) - 1) * BLOCKSIZE + _heapbase)) + +/* Current search index for the heap table. */ +extern size_t _heapindex; + +/* Limit of valid info table indices. */ +extern size_t _heaplimit; + +/* Doubly linked lists of free fragments. */ +struct list + { + struct list *next; + struct list *prev; + }; + +/* Free list headers for each fragment size. */ +extern struct list _fraghead[]; + +/* List of blocks allocated with `memalign' (or `valloc'). */ +struct alignlist + { + struct alignlist *next; + __ptr_t aligned; /* The address that memaligned returned. */ + __ptr_t exact; /* The address that malloc returned. */ + }; +extern struct alignlist *_aligned_blocks; + +/* Instrumentation. */ +extern size_t _chunks_used; +extern size_t _bytes_used; +extern size_t _chunks_free; +extern size_t _bytes_free; + +/* Internal version of `free' used in `morecore' (malloc.c). */ +extern void _free_internal __P ((__ptr_t __ptr)); + +#endif /* _MALLOC_INTERNAL. */ + +/* Underlying allocation function; successive calls should + return contiguous pieces of memory. */ +extern __ptr_t (*__morecore) __P ((ptrdiff_t __size)); + +/* Default value of `__morecore'. */ +extern __ptr_t __default_morecore __P ((ptrdiff_t __size)); + +/* Nonzero if `malloc' has been called and done its initialization. */ +extern int __malloc_initialized; + +/* Hooks for debugging versions. */ +extern void (*__free_hook) __P ((__ptr_t __ptr)); +extern __ptr_t (*__malloc_hook) __P ((size_t __size)); +extern __ptr_t (*__realloc_hook) __P ((__ptr_t __ptr, size_t __size)); + +/* Activate a standard collection of debugging hooks. */ +extern void mcheck __P ((void (*__func) __P ((void)))); + +/* Activate a standard collection of tracing hooks. */ +extern void mtrace __P ((void)); + +/* Statistics available to the user. */ +struct mstats + { + size_t bytes_total; /* Total size of the heap. */ + size_t chunks_used; /* Chunks allocated by the user. */ + size_t bytes_used; /* Byte total of user-allocated chunks. */ + size_t chunks_free; /* Chunks in the free list. */ + size_t bytes_free; /* Byte total of chunks in the free list. */ + }; + +/* Pick up the current statistics. */ +extern struct mstats mstats __P ((void)); + +#ifdef __cplusplus +} +#endif + +#endif /* mtrace.h */ diff --git a/e2fsck/pass1.c b/e2fsck/pass1.c new file mode 100644 index 0000000..a341c72 --- /dev/null +++ b/e2fsck/pass1.c @@ -0,0 +1,4466 @@ +/* + * 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 inodes are casefolded. (inode_casefold_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) + * - Ref counts for ea_inodes. (ea_inode_refs) + * - The encryption policy ID of each encrypted inode. (encrypted_files) + * + * 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. (Although 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 "config.h" +#include +#include +#ifdef HAVE_ERRNO_H +#include +#endif + +#include "e2fsck.h" +#include +#include + +#include "problem.h" + +#ifdef NO_INLINE_FUNCS +#define _INLINE_ +#else +#define _INLINE_ inline +#endif + +#undef DEBUG + +struct ea_quota { + blk64_t blocks; + __u64 inodes; +}; + +static int process_block(ext2_filsys fs, blk64_t *blocknr, + e2_blkcnt_t blockcnt, blk64_t ref_blk, + int ref_offset, void *priv_data); +static int process_bad_block(ext2_filsys fs, blk64_t *block_nr, + e2_blkcnt_t blockcnt, blk64_t ref_blk, + int ref_offset, void *priv_data); +static void check_blocks(e2fsck_t ctx, struct problem_context *pctx, + char *block_buf, + const struct ea_quota *ea_ibody_quota); +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, ext2_ino_t ino); +static void add_casefolded_dir(e2fsck_t ctx, ext2_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, blk64_t block); */ + +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, + inode_modified:1; + blk64_t num_blocks; + blk64_t max_blocks; + blk64_t last_block; + e2_blkcnt_t last_init_lblock; + e2_blkcnt_t last_db_block; + int num_illegal_blocks; + blk64_t previous_block; + struct ext2_inode *inode; + struct problem_context *pctx; + ext2fs_block_bitmap fs_meta_blocks; + e2fsck_t ctx; + blk64_t next_lblock; + struct extent_tree_info eti; +}; + +struct process_inode_block { + ext2_ino_t ino; + struct ea_quota ea_ibody_quota; + struct ext2_inode_large 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]; + +/* + * 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 EXT2FS_ATTR((unused)), + struct ext2_inode *inode) +{ + int i; + + /* + * If the index or extents flag is set, then this is a bogus + * device/fifo/socket + */ + if (inode->i_flags & (EXT2_INDEX_FL | EXT4_EXTENTS_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, ext2_ino_t ino, + struct ext2_inode *inode, char *buf) +{ + unsigned int buflen; + unsigned int len; + + if ((inode->i_size_high || inode->i_size == 0) || + (inode->i_flags & EXT2_INDEX_FL)) + return 0; + + if (inode->i_flags & EXT4_INLINE_DATA_FL) { + size_t inline_size; + + if (inode->i_flags & EXT4_EXTENTS_FL) + return 0; + if (ext2fs_inline_data_size(fs, ino, &inline_size)) + return 0; + if (inode->i_size != inline_size) + return 0; + + return 1; + } + + if (ext2fs_is_fast_symlink(inode)) { + if (inode->i_flags & EXT4_EXTENTS_FL) + return 0; + buf = (char *)inode->i_block; + buflen = sizeof(inode->i_block); + } else { + ext2_extent_handle_t handle; + struct ext2_extent_info info; + struct ext2fs_extent extent; + blk64_t blk; + int i; + + if (inode->i_flags & EXT4_EXTENTS_FL) { + if (ext2fs_extent_open2(fs, ino, inode, &handle)) + return 0; + if (ext2fs_extent_get_info(handle, &info) || + (info.num_entries != 1) || + (info.max_depth != 0)) { + ext2fs_extent_free(handle); + return 0; + } + if (ext2fs_extent_get(handle, EXT2_EXTENT_ROOT, + &extent) || + (extent.e_lblk != 0) || + (extent.e_len != 1)) { + ext2fs_extent_free(handle); + return 0; + } + blk = extent.e_pblk; + ext2fs_extent_free(handle); + } else { + blk = inode->i_block[0]; + + for (i = 1; i < EXT2_N_BLOCKS; i++) + if (inode->i_block[i]) + return 0; + } + + if (blk < fs->super->s_first_data_block || + blk >= ext2fs_blocks_count(fs->super)) + return 0; + + if (io_channel_read_blk64(fs->io, blk, 1, buf)) + return 0; + + buflen = fs->blocksize; + } + + if (inode->i_flags & EXT4_ENCRYPT_FL) + len = ext2fs_le16_to_cpu(*(__u16 *)buf) + 2; + else + len = strnlen(buf, buflen); + + if (len >= buflen) + return 0; + + if (len != inode->i_size) + return 0; + return 1; +} + +/* + * If the extents or inlinedata flags are set on the inode, offer to clear 'em. + */ +#define BAD_SPECIAL_FLAGS (EXT4_EXTENTS_FL | EXT4_INLINE_DATA_FL) +static void check_extents_inlinedata(e2fsck_t ctx, + struct problem_context *pctx) +{ + if (!(pctx->inode->i_flags & BAD_SPECIAL_FLAGS)) + return; + + if (!fix_problem(ctx, PR_1_SPECIAL_EXTENTS_IDATA, pctx)) + return; + + pctx->inode->i_flags &= ~BAD_SPECIAL_FLAGS; + e2fsck_write_inode(ctx, pctx->ino, pctx->inode, "pass1"); +} +#undef BAD_SPECIAL_FLAGS + +/* + * 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 (EXT2_I_SIZE(inode) == 0) + return; + + if (!fix_problem(ctx, PR_1_SET_NONZSIZE, pctx)) + return; + + ext2fs_inode_size_set(ctx->fs, inode, 0); + e2fsck_write_inode(ctx, pctx->ino, pctx->inode, "pass1"); +} + +/* + * For a given size, calculate how many blocks would be charged towards quota. + */ +static blk64_t size_to_quota_blocks(ext2_filsys fs, size_t size) +{ + blk64_t clusters; + + clusters = DIV_ROUND_UP(size, fs->blocksize << fs->cluster_ratio_bits); + return EXT2FS_C2B(fs, clusters); +} + +/* + * Check validity of EA inode. Return 0 if EA inode is valid, otherwise return + * the problem code. + */ +static problem_t check_large_ea_inode(e2fsck_t ctx, + struct ext2_ext_attr_entry *entry, + struct problem_context *pctx, + blk64_t *quota_blocks) +{ + struct ext2_inode inode; + __u32 hash, signed_hash; + errcode_t retval; + + /* Check if inode is within valid range */ + if ((entry->e_value_inum < EXT2_FIRST_INODE(ctx->fs->super)) || + (entry->e_value_inum > ctx->fs->super->s_inodes_count)) { + pctx->num = entry->e_value_inum; + return PR_1_ATTR_VALUE_EA_INODE; + } + + e2fsck_read_inode(ctx, entry->e_value_inum, &inode, "pass1"); + + retval = ext2fs_ext_attr_hash_entry3(ctx->fs, entry, NULL, &hash, + &signed_hash); + if (retval) { + com_err("check_large_ea_inode", retval, + _("while hashing entry with e_value_inum = %u"), + entry->e_value_inum); + fatal_error(ctx, 0); + } + + if ((hash == entry->e_hash) || (signed_hash == entry->e_hash)) { + *quota_blocks = size_to_quota_blocks(ctx->fs, + entry->e_value_size); + } else { + /* This might be an old Lustre-style ea_inode reference. */ + if (inode.i_mtime == pctx->ino && + inode.i_generation == pctx->inode->i_generation) { + *quota_blocks = 0; + } else { + /* If target inode is also missing EA_INODE flag, + * this is likely to be a bad reference. + */ + if (!(inode.i_flags & EXT4_EA_INODE_FL)) { + pctx->num = entry->e_value_inum; + return PR_1_ATTR_VALUE_EA_INODE; + } else { + pctx->num = entry->e_hash; + return PR_1_ATTR_HASH; + } + } + } + + if (!(inode.i_flags & EXT4_EA_INODE_FL)) { + pctx->num = entry->e_value_inum; + if (fix_problem(ctx, PR_1_ATTR_SET_EA_INODE_FL, pctx)) { + inode.i_flags |= EXT4_EA_INODE_FL; + ext2fs_write_inode(ctx->fs, entry->e_value_inum, + &inode); + } else { + return PR_1_ATTR_NO_EA_INODE_FL; + } + } + return 0; +} + +static void inc_ea_inode_refs(e2fsck_t ctx, struct problem_context *pctx, + struct ext2_ext_attr_entry *first, void *end) +{ + struct ext2_ext_attr_entry *entry = first; + struct ext2_ext_attr_entry *np = EXT2_EXT_ATTR_NEXT(entry); + + while ((void *) entry < end && (void *) np < end && + !EXT2_EXT_IS_LAST_ENTRY(entry)) { + if (!entry->e_value_inum) + goto next; + if (!ctx->ea_inode_refs) { + pctx->errcode = ea_refcount_create(0, + &ctx->ea_inode_refs); + if (pctx->errcode) { + pctx->num = 4; + fix_problem(ctx, PR_1_ALLOCATE_REFCOUNT, pctx); + ctx->flags |= E2F_FLAG_ABORT; + return; + } + } + ea_refcount_increment(ctx->ea_inode_refs, entry->e_value_inum, + 0); + next: + entry = np; + np = EXT2_EXT_ATTR_NEXT(entry); + } +} + +static void check_ea_in_inode(e2fsck_t ctx, struct problem_context *pctx, + struct ea_quota *ea_ibody_quota) +{ + struct ext2_super_block *sb = ctx->fs->super; + struct ext2_inode_large *inode; + struct ext2_ext_attr_entry *entry; + char *start, *header, *end; + unsigned int storage_size, remain; + problem_t problem = 0; + region_t region = 0; + + ea_ibody_quota->blocks = 0; + ea_ibody_quota->inodes = 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; + header = ((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE + + inode->i_extra_isize; + end = header + storage_size; + start = header + sizeof(__u32); + entry = (struct ext2_ext_attr_entry *) start; + + /* scan all entry's headers first */ + + /* take finish entry 0UL into account */ + remain = storage_size - sizeof(__u32); + + region = region_create(0, storage_size); + if (!region) { + fix_problem(ctx, PR_1_EA_ALLOC_REGION_ABORT, pctx); + problem = 0; + ctx->flags |= E2F_FLAG_ABORT; + return; + } + if (region_allocate(region, 0, sizeof(__u32))) { + problem = PR_1_INODE_EA_ALLOC_COLLISION; + goto fix; + } + + while (remain >= sizeof(struct ext2_ext_attr_entry) && + !EXT2_EXT_IS_LAST_ENTRY(entry)) { + __u32 hash; + + if (region_allocate(region, (char *)entry - (char *)header, + EXT2_EXT_ATTR_LEN(entry->e_name_len))) { + problem = PR_1_INODE_EA_ALLOC_COLLISION; + goto fix; + } + + /* 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); + + if (entry->e_value_inum == 0) { + /* check value size */ + if (entry->e_value_size > remain) { + pctx->num = entry->e_value_size; + problem = PR_1_ATTR_VALUE_SIZE; + goto fix; + } + + if (entry->e_value_size && + region_allocate(region, + sizeof(__u32) + entry->e_value_offs, + EXT2_EXT_ATTR_SIZE( + entry->e_value_size))) { + problem = PR_1_INODE_EA_ALLOC_COLLISION; + goto fix; + } + + hash = ext2fs_ext_attr_hash_entry(entry, + start + entry->e_value_offs); + if (entry->e_hash != 0 && entry->e_hash != hash) + hash = ext2fs_ext_attr_hash_entry_signed(entry, + start + entry->e_value_offs); + + /* e_hash may be 0 in older inode's ea */ + if (entry->e_hash != 0 && entry->e_hash != hash) { + pctx->num = entry->e_hash; + problem = PR_1_ATTR_HASH; + goto fix; + } + } else { + blk64_t quota_blocks; + + problem = check_large_ea_inode(ctx, entry, pctx, + "a_blocks); + if (problem != 0) + goto fix; + + ea_ibody_quota->blocks += quota_blocks; + ea_ibody_quota->inodes++; + } + + /* If EA value is stored in external inode then it does not + * consume space here */ + if (entry->e_value_inum == 0) + remain -= entry->e_value_size; + + entry = EXT2_EXT_ATTR_NEXT(entry); + } + + if (region_allocate(region, (char *)entry - (char *)header, + sizeof(__u32))) { + problem = PR_1_INODE_EA_ALLOC_COLLISION; + goto fix; + } +fix: + if (region) + region_free(region); + /* + * it seems like a corruption. it's very unlikely we could repair + * EA(s) in automatic fashion -bzzz + */ + if (problem == 0 || !fix_problem(ctx, problem, pctx)) { + inc_ea_inode_refs(ctx, pctx, + (struct ext2_ext_attr_entry *)start, end); + return; + } + + /* simply remove all possible EA(s) */ + *((__u32 *)header) = 0UL; + e2fsck_write_inode_full(ctx, pctx->ino, pctx->inode, + EXT2_INODE_SIZE(sb), "pass1"); + ea_ibody_quota->blocks = 0; + ea_ibody_quota->inodes = 0; +} + +static int check_inode_extra_negative_epoch(__u32 xtime, __u32 extra) { + return (xtime & (1U << 31)) != 0 && + (extra & EXT4_EPOCH_MASK) == EXT4_EPOCH_MASK; +} + +#define CHECK_INODE_EXTRA_NEGATIVE_EPOCH(inode, xtime) \ + check_inode_extra_negative_epoch(inode->i_##xtime, \ + inode->i_##xtime##_extra) + +/* When today's date is earlier than 2242, we assume that atimes, + * ctimes, crtimes, and mtimes with years in the range 2310..2378 are + * actually pre-1970 dates mis-encoded. + */ +#define EXT4_EXTRA_NEGATIVE_DATE_CUTOFF 2 * (1LL << 32) + +static void check_inode_extra_space(e2fsck_t ctx, struct problem_context *pctx, + struct ea_quota *ea_ibody_quota) +{ + struct ext2_super_block *sb = ctx->fs->super; + struct ext2_inode_large *inode; + __u32 *eamagic; + int min, max; + + ea_ibody_quota->blocks = 0; + ea_ibody_quota->inodes = 0; + + 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_checksum_hi at least */ + min = sizeof(inode->i_extra_isize) + sizeof(inode->i_checksum_hi); + 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 || + inode->i_extra_isize & 3)) { + if (!fix_problem(ctx, PR_1_EXTRA_ISIZE, pctx)) + return; + if (inode->i_extra_isize < min || inode->i_extra_isize > max) + inode->i_extra_isize = sb->s_want_extra_isize; + else + inode->i_extra_isize = (inode->i_extra_isize + 3) & ~3; + e2fsck_write_inode_full(ctx, pctx->ino, pctx->inode, + EXT2_INODE_SIZE(sb), "pass1"); + } + + /* check if there is no place for an EA header */ + if (inode->i_extra_isize >= max - sizeof(__u32)) + 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, ea_ibody_quota); + } + + /* + * If the inode's extended atime (ctime, crtime, mtime) is stored in + * the old, invalid format, repair it. + */ + if (((sizeof(time_t) <= 4) || + (((sizeof(time_t) > 4) && + ctx->now < EXT4_EXTRA_NEGATIVE_DATE_CUTOFF))) && + (CHECK_INODE_EXTRA_NEGATIVE_EPOCH(inode, atime) || + CHECK_INODE_EXTRA_NEGATIVE_EPOCH(inode, ctime) || + CHECK_INODE_EXTRA_NEGATIVE_EPOCH(inode, crtime) || + CHECK_INODE_EXTRA_NEGATIVE_EPOCH(inode, mtime))) { + + if (!fix_problem(ctx, PR_1_EA_TIME_OUT_OF_RANGE, pctx)) + return; + + if (CHECK_INODE_EXTRA_NEGATIVE_EPOCH(inode, atime)) + inode->i_atime_extra &= ~EXT4_EPOCH_MASK; + if (CHECK_INODE_EXTRA_NEGATIVE_EPOCH(inode, ctime)) + inode->i_ctime_extra &= ~EXT4_EPOCH_MASK; + if (CHECK_INODE_EXTRA_NEGATIVE_EPOCH(inode, crtime)) + inode->i_crtime_extra &= ~EXT4_EPOCH_MASK; + if (CHECK_INODE_EXTRA_NEGATIVE_EPOCH(inode, mtime)) + inode->i_mtime_extra &= ~EXT4_EPOCH_MASK; + e2fsck_write_inode_full(ctx, pctx->ino, pctx->inode, + EXT2_INODE_SIZE(sb), "pass1"); + } + +} + +/* + * Check to see if the inode might really be a directory, despite i_mode + * + * This is a lot of complexity for something for which I'm not really + * convinced happens frequently in the wild. If for any reason this + * causes any problems, take this code out. + * [tytso:20070331.0827EDT] + */ +static void check_is_really_dir(e2fsck_t ctx, struct problem_context *pctx, + char *buf) +{ + struct ext2_inode *inode = pctx->inode; + struct ext2_dir_entry *dirent; + errcode_t retval; + blk64_t blk; + unsigned int i, rec_len, not_device = 0; + int extent_fs; + int inlinedata_fs; + + /* + * If the mode looks OK, we believe it. If the first block in + * the i_block array is 0, this cannot be a directory. If the + * inode is extent-mapped, it is still the case that the latter + * cannot be 0 - the magic number in the extent header would make + * it nonzero. + */ + if (LINUX_S_ISDIR(inode->i_mode) || LINUX_S_ISREG(inode->i_mode) || + LINUX_S_ISLNK(inode->i_mode) || inode->i_block[0] == 0) + return; + + /* + * Check the block numbers in the i_block array for validity: + * zero blocks are skipped (but the first one cannot be zero - + * see above), other blocks are checked against the first and + * max data blocks (from the the superblock) and against the + * block bitmap. Any invalid block found means this cannot be + * a directory. + * + * If there are non-zero blocks past the fourth entry, then + * this cannot be a device file: we remember that for the next + * check. + * + * For extent mapped files, we don't do any sanity checking: + * just try to get the phys block of logical block 0 and run + * with it. + * + * For inline data files, we just try to get the size of inline + * data. If it's true, we will treat it as a directory. + */ + + extent_fs = ext2fs_has_feature_extents(ctx->fs->super); + inlinedata_fs = ext2fs_has_feature_inline_data(ctx->fs->super); + if (inlinedata_fs && (inode->i_flags & EXT4_INLINE_DATA_FL)) { + size_t size; + __u32 dotdot; + unsigned int rec_len2; + struct ext2_dir_entry de; + + if (ext2fs_inline_data_size(ctx->fs, pctx->ino, &size)) + return; + /* + * If the size isn't a multiple of 4, it's probably not a + * directory?? + */ + if (size & 3) + return; + /* + * If the first 10 bytes don't look like a directory entry, + * it's probably not a directory. + */ + memcpy(&dotdot, inode->i_block, sizeof(dotdot)); + memcpy(&de, ((char *)inode->i_block) + EXT4_INLINE_DATA_DOTDOT_SIZE, + EXT2_DIR_REC_LEN(0)); + dotdot = ext2fs_le32_to_cpu(dotdot); + de.inode = ext2fs_le32_to_cpu(de.inode); + de.rec_len = ext2fs_le16_to_cpu(de.rec_len); + ext2fs_get_rec_len(ctx->fs, &de, &rec_len2); + if (dotdot >= ctx->fs->super->s_inodes_count || + (dotdot < EXT2_FIRST_INO(ctx->fs->super) && + dotdot != EXT2_ROOT_INO) || + de.inode >= ctx->fs->super->s_inodes_count || + (de.inode < EXT2_FIRST_INO(ctx->fs->super) && + de.inode != 0) || + rec_len2 > EXT4_MIN_INLINE_DATA_SIZE - + EXT4_INLINE_DATA_DOTDOT_SIZE) + return; + /* device files never have a "system.data" entry */ + goto isdir; + } else if (extent_fs && (inode->i_flags & EXT4_EXTENTS_FL)) { + /* extent mapped */ + if (ext2fs_bmap2(ctx->fs, pctx->ino, inode, 0, 0, 0, 0, + &blk)) + return; + /* device files are never extent mapped */ + not_device++; + } else { + for (i=0; i < EXT2_N_BLOCKS; i++) { + blk = inode->i_block[i]; + if (!blk) + continue; + if (i >= 4) + not_device++; + + if (blk < ctx->fs->super->s_first_data_block || + blk >= ext2fs_blocks_count(ctx->fs->super) || + ext2fs_fast_test_block_bitmap2(ctx->block_found_map, + blk)) + return; /* Invalid block, can't be dir */ + } + blk = inode->i_block[0]; + } + + /* + * If the mode says this is a device file and the i_links_count field + * is sane and we have not ruled it out as a device file previously, + * we declare it a device file, not a directory. + */ + if ((LINUX_S_ISCHR(inode->i_mode) || LINUX_S_ISBLK(inode->i_mode)) && + (inode->i_links_count == 1) && !not_device) + return; + + /* read the first block */ + ehandler_operation(_("reading directory block")); + retval = ext2fs_read_dir_block4(ctx->fs, blk, buf, 0, pctx->ino); + ehandler_operation(0); + if (retval) + return; + + dirent = (struct ext2_dir_entry *) buf; + retval = ext2fs_get_rec_len(ctx->fs, dirent, &rec_len); + if (retval) + return; + if ((ext2fs_dirent_name_len(dirent) != 1) || + (dirent->name[0] != '.') || + (dirent->inode != pctx->ino) || + (rec_len < 12) || + (rec_len % 4) || + (rec_len >= ctx->fs->blocksize - 12)) + return; + + dirent = (struct ext2_dir_entry *) (buf + rec_len); + retval = ext2fs_get_rec_len(ctx->fs, dirent, &rec_len); + if (retval) + return; + if ((ext2fs_dirent_name_len(dirent) != 2) || + (dirent->name[0] != '.') || + (dirent->name[1] != '.') || + (rec_len < 12) || + (rec_len % 4)) + return; + +isdir: + if (fix_problem(ctx, PR_1_TREAT_AS_DIRECTORY, pctx)) { + inode->i_mode = (inode->i_mode & 07777) | LINUX_S_IFDIR; + e2fsck_write_inode_full(ctx, pctx->ino, inode, + EXT2_INODE_SIZE(ctx->fs->super), + "check_is_really_dir"); + } +} + +extern errcode_t e2fsck_setup_icount(e2fsck_t ctx, const char *icount_name, + int flags, ext2_icount_t hint, + ext2_icount_t *ret) +{ + unsigned int threshold; + unsigned int save_type; + ext2_ino_t num_dirs; + errcode_t retval; + char *tdb_dir; + int enable; + + *ret = 0; + + profile_get_string(ctx->profile, "scratch_files", "directory", 0, 0, + &tdb_dir); + profile_get_uint(ctx->profile, "scratch_files", + "numdirs_threshold", 0, 0, &threshold); + profile_get_boolean(ctx->profile, "scratch_files", + "icount", 0, 1, &enable); + + retval = ext2fs_get_num_dirs(ctx->fs, &num_dirs); + if (retval) + num_dirs = 1024; /* Guess */ + + if (enable && tdb_dir && !access(tdb_dir, W_OK) && + (!threshold || num_dirs > threshold)) { + retval = ext2fs_create_icount_tdb(ctx->fs, tdb_dir, + flags, ret); + if (retval == 0) + return 0; + } + e2fsck_set_bitmap_type(ctx->fs, EXT2FS_BMAP64_RBTREE, icount_name, + &save_type); + if (ctx->options & E2F_OPT_ICOUNT_FULLMAP) + flags |= EXT2_ICOUNT_OPT_FULLMAP; + retval = ext2fs_create_icount2(ctx->fs, flags, 0, hint, ret); + ctx->fs->default_bitmap_type = save_type; + return retval; +} + +static errcode_t recheck_bad_inode_checksum(ext2_filsys fs, ext2_ino_t ino, + e2fsck_t ctx, + struct problem_context *pctx) +{ + errcode_t retval; + struct ext2_inode_large inode; + + /* + * Reread inode. If we don't see checksum error, then this inode + * has been fixed elsewhere. + */ + ctx->stashed_ino = 0; + retval = ext2fs_read_inode_full(fs, ino, (struct ext2_inode *)&inode, + sizeof(inode)); + if (retval && retval != EXT2_ET_INODE_CSUM_INVALID) + return retval; + if (!retval) + return 0; + + /* + * Checksum still doesn't match. That implies that the inode passes + * all the sanity checks, so maybe the checksum is simply corrupt. + * See if the user will go for fixing that. + */ + if (!fix_problem(ctx, PR_1_INODE_ONLY_CSUM_INVALID, pctx)) + return 0; + + retval = ext2fs_write_inode_full(fs, ino, (struct ext2_inode *)&inode, + sizeof(inode)); + return retval; +} + +static void reserve_block_for_root_repair(e2fsck_t ctx) +{ + blk64_t blk = 0; + errcode_t err; + ext2_filsys fs = ctx->fs; + + ctx->root_repair_block = 0; + if (ext2fs_test_inode_bitmap2(ctx->inode_used_map, EXT2_ROOT_INO)) + return; + + err = ext2fs_new_block2(fs, 0, ctx->block_found_map, &blk); + if (err) + return; + ext2fs_mark_block_bitmap2(ctx->block_found_map, blk); + ctx->root_repair_block = blk; +} + +static void reserve_block_for_lnf_repair(e2fsck_t ctx) +{ + blk64_t blk = 0; + errcode_t err; + ext2_filsys fs = ctx->fs; + static const char name[] = "lost+found"; + ext2_ino_t ino; + + ctx->lnf_repair_block = 0; + if (!ext2fs_lookup(fs, EXT2_ROOT_INO, name, sizeof(name)-1, 0, &ino)) + return; + + err = ext2fs_new_block2(fs, 0, ctx->block_found_map, &blk); + if (err) + return; + ext2fs_mark_block_bitmap2(ctx->block_found_map, blk); + ctx->lnf_repair_block = blk; +} + +static errcode_t get_inline_data_ea_size(ext2_filsys fs, ext2_ino_t ino, + struct ext2_inode *inode, + size_t *sz) +{ + void *p; + struct ext2_xattr_handle *handle; + errcode_t retval; + + retval = ext2fs_xattrs_open(fs, ino, &handle); + if (retval) + return retval; + + retval = ext2fs_xattrs_read_inode(handle, + (struct ext2_inode_large *)inode); + if (retval) + goto err; + + retval = ext2fs_xattr_get(handle, "system.data", &p, sz); + if (retval) + goto err; + ext2fs_free_mem(&p); +err: + (void) ext2fs_xattrs_close(&handle); + return retval; +} + +static void finish_processing_inode(e2fsck_t ctx, ext2_ino_t ino, + struct problem_context *pctx, + int failed_csum) +{ + if (!failed_csum) + return; + + /* + * If the inode failed the checksum and the user didn't + * clear the inode, test the checksum again -- if it still + * fails, ask the user if the checksum should be corrected. + */ + pctx->errcode = recheck_bad_inode_checksum(ctx->fs, ino, ctx, pctx); + if (pctx->errcode) + ctx->flags |= E2F_FLAG_ABORT; +} +#define FINISH_INODE_LOOP(ctx, ino, pctx, failed_csum) \ + do { \ + finish_processing_inode((ctx), (ino), (pctx), (failed_csum)); \ + if ((ctx)->flags & E2F_FLAG_ABORT) \ + return; \ + } while (0) + +static int could_be_block_map(ext2_filsys fs, struct ext2_inode *inode) +{ + __u32 x; + int i; + + for (i = 0; i < EXT2_N_BLOCKS; i++) { + x = inode->i_block[i]; +#ifdef WORDS_BIGENDIAN + x = ext2fs_swab32(x); +#endif + if (x >= ext2fs_blocks_count(fs->super)) + return 0; + } + + return 1; +} + +/* + * Figure out what to do with an inode that has both extents and inline data + * inode flags set. Returns -1 if we decide to erase the inode, 0 otherwise. + */ +static int fix_inline_data_extents_file(e2fsck_t ctx, + ext2_ino_t ino, + struct ext2_inode *inode, + int inode_size, + struct problem_context *pctx) +{ + size_t max_inline_ea_size; + ext2_filsys fs = ctx->fs; + int dirty = 0; + + /* Both feature flags not set? Just run the regular checks */ + if (!ext2fs_has_feature_extents(fs->super) && + !ext2fs_has_feature_inline_data(fs->super)) + return 0; + + /* Clear both flags if it's a special file */ + if (LINUX_S_ISCHR(inode->i_mode) || + LINUX_S_ISBLK(inode->i_mode) || + LINUX_S_ISFIFO(inode->i_mode) || + LINUX_S_ISSOCK(inode->i_mode)) { + check_extents_inlinedata(ctx, pctx); + return 0; + } + + /* If it looks like an extent tree, try to clear inlinedata */ + if (ext2fs_extent_header_verify(inode->i_block, + sizeof(inode->i_block)) == 0 && + fix_problem(ctx, PR_1_CLEAR_INLINE_DATA_FOR_EXTENT, pctx)) { + inode->i_flags &= ~EXT4_INLINE_DATA_FL; + dirty = 1; + goto out; + } + + /* If it looks short enough to be inline data, try to clear extents */ + if (inode_size > EXT2_GOOD_OLD_INODE_SIZE) + max_inline_ea_size = inode_size - + (EXT2_GOOD_OLD_INODE_SIZE + + ((struct ext2_inode_large *)inode)->i_extra_isize); + else + max_inline_ea_size = 0; + if (EXT2_I_SIZE(inode) < + EXT4_MIN_INLINE_DATA_SIZE + max_inline_ea_size && + fix_problem(ctx, PR_1_CLEAR_EXTENT_FOR_INLINE_DATA, pctx)) { + inode->i_flags &= ~EXT4_EXTENTS_FL; + dirty = 1; + goto out; + } + + /* + * Too big for inline data, but no evidence of extent tree - + * maybe it's a block map file? If the mappings all look valid? + */ + if (could_be_block_map(fs, inode) && + fix_problem(ctx, PR_1_CLEAR_EXTENT_INLINE_DATA_FLAGS, pctx)) { +#ifdef WORDS_BIGENDIAN + int i; + + for (i = 0; i < EXT2_N_BLOCKS; i++) + inode->i_block[i] = ext2fs_swab32(inode->i_block[i]); +#endif + + inode->i_flags &= ~(EXT4_EXTENTS_FL | EXT4_INLINE_DATA_FL); + dirty = 1; + goto out; + } + + /* Oh well, just clear the busted inode. */ + if (fix_problem(ctx, PR_1_CLEAR_EXTENT_INLINE_DATA_INODE, pctx)) { + e2fsck_clear_inode(ctx, ino, inode, 0, "pass1"); + return -1; + } + +out: + if (dirty) + e2fsck_write_inode(ctx, ino, inode, "pass1"); + + return 0; +} + +static void pass1_readahead(e2fsck_t ctx, dgrp_t *group, ext2_ino_t *next_ino) +{ + ext2_ino_t inodes_in_group = 0, inodes_per_block, inodes_per_buffer; + dgrp_t start = *group, grp; + blk64_t blocks_to_read = 0; + errcode_t err = EXT2_ET_INVALID_ARGUMENT; + + if (ctx->readahead_kb == 0) + goto out; + + /* Keep iterating groups until we have enough to readahead */ + inodes_per_block = EXT2_INODES_PER_BLOCK(ctx->fs->super); + for (grp = start; grp < ctx->fs->group_desc_count; grp++) { + if (ext2fs_bg_flags_test(ctx->fs, grp, EXT2_BG_INODE_UNINIT)) + continue; + inodes_in_group = ctx->fs->super->s_inodes_per_group - + ext2fs_bg_itable_unused(ctx->fs, grp); + blocks_to_read += (inodes_in_group + inodes_per_block - 1) / + inodes_per_block; + if (blocks_to_read * ctx->fs->blocksize > + ctx->readahead_kb * 1024) + break; + } + + err = e2fsck_readahead(ctx->fs, E2FSCK_READA_ITABLE, start, + grp - start + 1); + if (err == EAGAIN) { + ctx->readahead_kb /= 2; + err = 0; + } + +out: + if (err) { + /* Error; disable itable readahead */ + *group = ctx->fs->group_desc_count; + *next_ino = ctx->fs->super->s_inodes_count; + } else { + /* + * Don't do more readahead until we've reached the first inode + * of the last inode scan buffer block for the last group. + */ + *group = grp + 1; + inodes_per_buffer = (ctx->inode_buffer_blocks ? + ctx->inode_buffer_blocks : + EXT2_INODE_SCAN_DEFAULT_BUFFER_BLOCKS) * + ctx->fs->blocksize / + EXT2_INODE_SIZE(ctx->fs->super); + inodes_in_group--; + *next_ino = inodes_in_group - + (inodes_in_group % inodes_per_buffer) + 1 + + (grp * ctx->fs->super->s_inodes_per_group); + } +} + +/* + * Check if the passed ino is one of the used superblock quota inodes. + * + * Before the quota inodes were journaled, older superblock quota inodes + * were just regular files in the filesystem and not reserved inodes. This + * checks if the passed ino is one of the s_*_quota_inum superblock fields, + * which may not always be the same as the EXT4_*_QUOTA_INO fields. + */ +static int quota_inum_is_super(struct ext2_super_block *sb, ext2_ino_t ino) +{ + enum quota_type qtype; + + for (qtype = 0; qtype < MAXQUOTAS; qtype++) + if (*quota_sb_inump(sb, qtype) == ino) + return 1; + + return 0; +} + +/* + * Check if the passed ino is one of the reserved quota inodes. + * This checks if the inode number is one of the reserved EXT4_*_QUOTA_INO + * inodes. These inodes may or may not be in use by the quota feature. + */ +static int quota_inum_is_reserved(ext2_filsys fs, ext2_ino_t ino) +{ + enum quota_type qtype; + + for (qtype = 0; qtype < MAXQUOTAS; qtype++) + if (quota_type2inum(qtype, fs->super) == ino) + return 1; + + return 0; +} + +void e2fsck_pass1(e2fsck_t ctx) +{ + int i; + __u64 max_sizes; + ext2_filsys fs = ctx->fs; + ext2_ino_t ino = 0; + struct ext2_inode *inode = NULL; + ext2_inode_scan scan = NULL; + char *block_buf = NULL; +#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; + const char *old_op; + const char *eop_next_inode = _("getting next inode from scan"); + int imagic_fs, extent_fs, inlinedata_fs, casefold_fs; + int low_dtime_check = 1; + unsigned int inode_size = EXT2_INODE_SIZE(fs->super); + unsigned int bufsize; + int failed_csum = 0; + ext2_ino_t ino_threshold = 0; + dgrp_t ra_group = 0; + struct ea_quota ea_ibody_quota; + + init_resource_track(&rtrack, ctx->fs->io); + clear_problem_context(&pctx); + + /* If we can do readahead, figure out how many groups to pull in. */ + if (!e2fsck_can_readahead(ctx->fs)) + ctx->readahead_kb = 0; + else if (ctx->readahead_kb == ~0ULL) + ctx->readahead_kb = e2fsck_guess_readahead(ctx->fs); + pass1_readahead(ctx, &ra_group, &ino_threshold); + + if (!(ctx->options & E2F_OPT_PREEN)) + fix_problem(ctx, PR_1_PASS_HEADER, &pctx); + + if (ext2fs_has_feature_dir_index(fs->super) && + !(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)); + ext2_max_sizes[i - EXT2_MIN_BLOCK_LOG_SIZE] = max_sizes; + } +#undef EXT2_BPP + + imagic_fs = ext2fs_has_feature_imagic_inodes(sb); + extent_fs = ext2fs_has_feature_extents(sb); + inlinedata_fs = ext2fs_has_feature_inline_data(sb); + casefold_fs = ext2fs_has_feature_casefold(sb); + + /* + * Allocate bitmaps structures + */ + pctx.errcode = e2fsck_allocate_inode_bitmap(fs, _("in-use inode map"), + EXT2FS_BMAP64_RBTREE, + "inode_used_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 = e2fsck_allocate_inode_bitmap(fs, + _("directory inode map"), + EXT2FS_BMAP64_AUTODIR, + "inode_dir_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 = e2fsck_allocate_inode_bitmap(fs, + _("regular file inode map"), EXT2FS_BMAP64_RBTREE, + "inode_reg_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 = e2fsck_allocate_subcluster_bitmap(fs, + _("in-use block map"), EXT2FS_BMAP64_RBTREE, + "block_found_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 = e2fsck_allocate_block_bitmap(fs, + _("metadata block map"), EXT2FS_BMAP64_RBTREE, + "block_metadata_map", &ctx->block_metadata_map); + if (pctx.errcode) { + pctx.num = 1; + fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, &pctx); + ctx->flags |= E2F_FLAG_ABORT; + return; + } + if (casefold_fs) { + pctx.errcode = + e2fsck_allocate_inode_bitmap(fs, + _("inode casefold map"), + EXT2FS_BMAP64_RBTREE, + "inode_casefold_map", + &ctx->inode_casefold_map); + if (pctx.errcode) { + pctx.num = 1; + fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx); + ctx->flags |= E2F_FLAG_ABORT; + return; + } + } + pctx.errcode = e2fsck_setup_icount(ctx, "inode_link_info", 0, NULL, + &ctx->inode_link_info); + if (pctx.errcode) { + fix_problem(ctx, PR_1_ALLOCATE_ICOUNT, &pctx); + ctx->flags |= E2F_FLAG_ABORT; + return; + } + bufsize = inode_size; + if (bufsize < sizeof(struct ext2_inode_large)) + bufsize = sizeof(struct ext2_inode_large); + inode = (struct ext2_inode *) + e2fsck_allocate_memory(ctx, bufsize, "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; + goto endit; + } + + /* + * 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); + pctx.errcode = ext2fs_convert_subcluster_bitmap(fs, + &ctx->block_found_map); + if (pctx.errcode) { + fix_problem(ctx, PR_1_CONVERT_SUBCLUSTER, &pctx); + ctx->flags |= E2F_FLAG_ABORT; + goto endit; + } + block_buf = (char *) e2fsck_allocate_memory(ctx, fs->blocksize * 3, + "block iterate buffer"); + if (EXT2_INODE_SIZE(fs->super) == EXT2_GOOD_OLD_INODE_SIZE) + e2fsck_use_inode_shortcuts(ctx, 1); + e2fsck_intercept_block_allocations(ctx); + old_op = ehandler_operation(_("opening inode scan")); + pctx.errcode = ext2fs_open_inode_scan(fs, ctx->inode_buffer_blocks, + &scan); + ehandler_operation(old_op); + if (pctx.errcode) { + fix_problem(ctx, PR_1_ISCAN_ERROR, &pctx); + ctx->flags |= E2F_FLAG_ABORT; + goto endit; + } + ext2fs_inode_scan_flags(scan, EXT2_SF_SKIP_MISSING_ITABLE | + EXT2_SF_WARN_GARBAGE_INODES, 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 && ((ctx->progress)(ctx, 1, 0, + ctx->fs->group_desc_count))) + goto endit; + if ((fs->super->s_wtime && + fs->super->s_wtime < fs->super->s_inodes_count) || + (fs->super->s_mtime && + fs->super->s_mtime < fs->super->s_inodes_count) || + (fs->super->s_mkfs_time && + fs->super->s_mkfs_time < fs->super->s_inodes_count)) + low_dtime_check = 0; + + if (ext2fs_has_feature_mmp(fs->super) && + fs->super->s_mmp_block > fs->super->s_first_data_block && + fs->super->s_mmp_block < ext2fs_blocks_count(fs->super)) + ext2fs_mark_block_bitmap2(ctx->block_found_map, + fs->super->s_mmp_block); + + /* Set up ctx->lost_and_found if possible */ + (void) e2fsck_get_lost_and_found(ctx, 0); + + while (1) { + if (ino % (fs->super->s_inodes_per_group * 4) == 1) { + if (e2fsck_mmp_update(fs)) + fatal_error(ctx, 0); + } + old_op = ehandler_operation(eop_next_inode); + pctx.errcode = ext2fs_get_next_inode_full(scan, &ino, + inode, inode_size); + if (ino > ino_threshold) + pass1_readahead(ctx, &ra_group, &ino_threshold); + ehandler_operation(old_op); + if (ctx->flags & E2F_FLAG_SIGNAL_MASK) + goto endit; + if (pctx.errcode == EXT2_ET_BAD_BLOCK_IN_INODE_TABLE) { + /* + * If badblocks says badblocks is bad, offer to clear + * the list, update the in-core bb list, and restart + * the inode scan. + */ + if (ino == EXT2_BAD_INO && + fix_problem(ctx, PR_1_BADBLOCKS_IN_BADBLOCKS, + &pctx)) { + errcode_t err; + + e2fsck_clear_inode(ctx, ino, inode, 0, "pass1"); + ext2fs_badblocks_list_free(ctx->fs->badblocks); + ctx->fs->badblocks = NULL; + err = ext2fs_read_bb_inode(ctx->fs, + &ctx->fs->badblocks); + if (err) { + fix_problem(ctx, PR_1_ISCAN_ERROR, + &pctx); + ctx->flags |= E2F_FLAG_ABORT; + } else + ctx->flags |= E2F_FLAG_RESTART; + goto endit; + } + if (!ctx->inode_bb_map) + alloc_bb_map(ctx); + ext2fs_mark_inode_bitmap2(ctx->inode_bb_map, ino); + ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino); + continue; + } + if (pctx.errcode && + pctx.errcode != EXT2_ET_INODE_CSUM_INVALID && + pctx.errcode != EXT2_ET_INODE_IS_GARBAGE) { + fix_problem(ctx, PR_1_ISCAN_ERROR, &pctx); + ctx->flags |= E2F_FLAG_ABORT; + goto endit; + } + if (!ino) + break; + pctx.ino = ino; + pctx.inode = inode; + ctx->stashed_ino = ino; + + /* Clear trashed inode? */ + if (pctx.errcode == EXT2_ET_INODE_IS_GARBAGE && + inode->i_links_count > 0 && + fix_problem(ctx, PR_1_INODE_IS_GARBAGE, &pctx)) { + pctx.errcode = 0; + e2fsck_clear_inode(ctx, ino, inode, 0, "pass1"); + } + failed_csum = pctx.errcode != 0; + + /* + * 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 && low_dtime_check && + 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 : ctx->now; + e2fsck_write_inode(ctx, ino, inode, + "pass1"); + failed_csum = 0; + } + } + + 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; + goto endit; + } + } else if ((ino >= EXT2_FIRST_INODE(fs->super)) && + !quota_inum_is_reserved(fs, ino)) { + if (!inode->i_dtime && inode->i_mode) { + if (fix_problem(ctx, + PR_1_ZERO_DTIME, &pctx)) { + inode->i_dtime = ctx->now; + e2fsck_write_inode(ctx, ino, inode, + "pass1"); + failed_csum = 0; + } + } + FINISH_INODE_LOOP(ctx, ino, &pctx, failed_csum); + continue; + } + + if ((inode->i_flags & EXT4_CASEFOLD_FL) && + ((!LINUX_S_ISDIR(inode->i_mode) && + fix_problem(ctx, PR_1_CASEFOLD_NONDIR, &pctx)) || + (!casefold_fs && + fix_problem(ctx, PR_1_CASEFOLD_FEATURE, &pctx)))) { + inode->i_flags &= ~EXT4_CASEFOLD_FL; + e2fsck_write_inode(ctx, ino, inode, "pass1"); + } + + /* Conflicting inlinedata/extents inode flags? */ + if ((inode->i_flags & EXT4_INLINE_DATA_FL) && + (inode->i_flags & EXT4_EXTENTS_FL)) { + int res = fix_inline_data_extents_file(ctx, ino, inode, + inode_size, + &pctx); + if (res < 0) { + /* skip FINISH_INODE_LOOP */ + continue; + } + } + + /* Test for incorrect inline_data flags settings. */ + if ((inode->i_flags & EXT4_INLINE_DATA_FL) && !inlinedata_fs && + (ino >= EXT2_FIRST_INODE(fs->super))) { + size_t size = 0; + + pctx.errcode = get_inline_data_ea_size(fs, ino, inode, + &size); + if (!pctx.errcode && + fix_problem(ctx, PR_1_INLINE_DATA_FEATURE, &pctx)) { + ext2fs_set_feature_inline_data(sb); + ext2fs_mark_super_dirty(fs); + inlinedata_fs = 1; + } else if (fix_problem(ctx, PR_1_INLINE_DATA_SET, &pctx)) { + e2fsck_clear_inode(ctx, ino, inode, 0, "pass1"); + /* skip FINISH_INODE_LOOP */ + continue; + } + } + + /* Test for inline data flag but no attr */ + if ((inode->i_flags & EXT4_INLINE_DATA_FL) && inlinedata_fs && + (ino >= EXT2_FIRST_INODE(fs->super))) { + size_t size = 0; + errcode_t err; + int flags; + + flags = fs->flags; + if (failed_csum) + fs->flags |= EXT2_FLAG_IGNORE_CSUM_ERRORS; + err = get_inline_data_ea_size(fs, ino, inode, &size); + fs->flags = (flags & EXT2_FLAG_IGNORE_CSUM_ERRORS) | + (fs->flags & ~EXT2_FLAG_IGNORE_CSUM_ERRORS); + + switch (err) { + case 0: + /* Everything is awesome... */ + break; + case EXT2_ET_BAD_EA_BLOCK_NUM: + case EXT2_ET_BAD_EA_HASH: + case EXT2_ET_BAD_EA_HEADER: + case EXT2_ET_EA_BAD_NAME_LEN: + case EXT2_ET_EA_BAD_VALUE_SIZE: + case EXT2_ET_EA_KEY_NOT_FOUND: + case EXT2_ET_EA_NO_SPACE: + case EXT2_ET_MISSING_EA_FEATURE: + case EXT2_ET_INLINE_DATA_CANT_ITERATE: + case EXT2_ET_INLINE_DATA_NO_BLOCK: + case EXT2_ET_INLINE_DATA_NO_SPACE: + case EXT2_ET_NO_INLINE_DATA: + case EXT2_ET_EXT_ATTR_CSUM_INVALID: + case EXT2_ET_EA_BAD_VALUE_OFFSET: + case EXT2_ET_EA_INODE_CORRUPTED: + /* broken EA or no system.data EA; truncate */ + if (fix_problem(ctx, PR_1_INLINE_DATA_NO_ATTR, + &pctx)) { + err = ext2fs_inode_size_set(fs, inode, 0); + if (err) { + pctx.errcode = err; + ctx->flags |= E2F_FLAG_ABORT; + goto endit; + } + inode->i_flags &= ~EXT4_INLINE_DATA_FL; + memset(&inode->i_block, 0, + sizeof(inode->i_block)); + e2fsck_write_inode(ctx, ino, inode, + "pass1"); + failed_csum = 0; + } + break; + default: + /* Some other kind of non-xattr error? */ + pctx.errcode = err; + ctx->flags |= E2F_FLAG_ABORT; + goto endit; + } + } + + /* + * Test for incorrect extent flag settings. + * + * On big-endian machines we must be careful: + * When the inode is read, the i_block array is not swapped + * if the extent flag is set. Therefore if we are testing + * for or fixing a wrongly-set flag, we must potentially + * (un)swap before testing, or after fixing. + */ + + /* + * In this case the extents flag was set when read, so + * extent_header_verify is ok. If the inode is cleared, + * no need to swap... so no extra swapping here. + */ + if ((inode->i_flags & EXT4_EXTENTS_FL) && !extent_fs && + (inode->i_links_count || (ino == EXT2_BAD_INO) || + (ino == EXT2_ROOT_INO) || (ino == EXT2_JOURNAL_INO))) { + if ((ext2fs_extent_header_verify(inode->i_block, + sizeof(inode->i_block)) == 0) && + fix_problem(ctx, PR_1_EXTENT_FEATURE, &pctx)) { + ext2fs_set_feature_extents(sb); + ext2fs_mark_super_dirty(fs); + extent_fs = 1; + } else if (fix_problem(ctx, PR_1_EXTENTS_SET, &pctx)) { + clear_inode: + e2fsck_clear_inode(ctx, ino, inode, 0, "pass1"); + if (ino == EXT2_BAD_INO) + ext2fs_mark_inode_bitmap2(ctx->inode_used_map, + ino); + /* skip FINISH_INODE_LOOP */ + continue; + } + } + + /* + * For big-endian machines: + * If the inode didn't have the extents flag set when it + * was read, then the i_blocks array was swapped. To test + * as an extents header, we must swap it back first. + * IF we then set the extents flag, the entire i_block + * array must be un/re-swapped to make it proper extents data. + */ + if (extent_fs && !(inode->i_flags & EXT4_EXTENTS_FL) && + (inode->i_links_count || (ino == EXT2_BAD_INO) || + (ino == EXT2_ROOT_INO) || (ino == EXT2_JOURNAL_INO)) && + (LINUX_S_ISREG(inode->i_mode) || + LINUX_S_ISDIR(inode->i_mode))) { + void *ehp; +#ifdef WORDS_BIGENDIAN + __u32 tmp_block[EXT2_N_BLOCKS]; + + for (i = 0; i < EXT2_N_BLOCKS; i++) + tmp_block[i] = ext2fs_swab32(inode->i_block[i]); + ehp = tmp_block; +#else + ehp = inode->i_block; +#endif + if ((ext2fs_extent_header_verify(ehp, + sizeof(inode->i_block)) == 0) && + (fix_problem(ctx, PR_1_UNSET_EXTENT_FL, &pctx))) { + inode->i_flags |= EXT4_EXTENTS_FL; +#ifdef WORDS_BIGENDIAN + memcpy(inode->i_block, tmp_block, + sizeof(inode->i_block)); +#endif + e2fsck_write_inode(ctx, ino, inode, "pass1"); + failed_csum = 0; + } + } + + if (ino == EXT2_BAD_INO) { + struct process_block_struct pb; + + if ((failed_csum || inode->i_mode || inode->i_uid || + inode->i_gid || inode->i_links_count || + (inode->i_flags & EXT4_INLINE_DATA_FL) || + inode->i_file_acl) && + fix_problem(ctx, PR_1_INVALID_BAD_INODE, &pctx)) { + memset(inode, 0, sizeof(struct ext2_inode)); + e2fsck_write_inode(ctx, ino, inode, + "clear bad inode"); + failed_csum = 0; + } + + 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; + goto endit; + } + pb.ino = EXT2_BAD_INO; + pb.num_blocks = pb.last_block = 0; + pb.last_db_block = -1; + 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_iterate3(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; + goto endit; + } + if (pb.bbcheck) + if (!fix_problem(ctx, PR_1_BBINODE_BAD_METABLOCK_PROMPT, &pctx)) { + ctx->flags |= E2F_FLAG_ABORT; + goto endit; + } + ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino); + clear_problem_context(&pctx); + FINISH_INODE_LOOP(ctx, ino, &pctx, failed_csum); + continue; + } else if (ino == EXT2_ROOT_INO) { + /* + * Make sure the root inode is a directory; if + * not, offer to clear it. It will be + * regenerated in pass #3. + */ + if (!LINUX_S_ISDIR(inode->i_mode)) { + if (fix_problem(ctx, PR_1_ROOT_NO_DIR, &pctx)) + goto clear_inode; + } + /* + * 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"); + failed_csum = 0; + } + } + } else if (ino == EXT2_JOURNAL_INO) { + ext2fs_mark_inode_bitmap2(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"); + failed_csum = 0; + } + check_blocks(ctx, &pctx, block_buf, NULL); + FINISH_INODE_LOOP(ctx, ino, &pctx, failed_csum); + continue; + } + if ((inode->i_links_count || + 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"); + failed_csum = 0; + } + } else if (quota_inum_is_reserved(fs, ino)) { + ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino); + if (ext2fs_has_feature_quota(fs->super) && + quota_inum_is_super(fs->super, ino)) { + if (!LINUX_S_ISREG(inode->i_mode) && + fix_problem(ctx, PR_1_QUOTA_BAD_MODE, + &pctx)) { + inode->i_mode = LINUX_S_IFREG; + e2fsck_write_inode(ctx, ino, inode, + "pass1"); + failed_csum = 0; + } + check_blocks(ctx, &pctx, block_buf, NULL); + FINISH_INODE_LOOP(ctx, ino, &pctx, failed_csum); + continue; + } + if ((inode->i_links_count || + inode->i_blocks || inode->i_block[0]) && + fix_problem(ctx, PR_1_QUOTA_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"); + failed_csum = 0; + } + } else if (ino == fs->super->s_orphan_file_inum) { + ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino); + if (ext2fs_has_feature_orphan_file(fs->super)) { + if (!LINUX_S_ISREG(inode->i_mode) && + fix_problem(ctx, PR_1_ORPHAN_FILE_BAD_MODE, + &pctx)) { + inode->i_mode = LINUX_S_IFREG; + e2fsck_write_inode(ctx, ino, inode, + "pass1"); + failed_csum = 0; + } + check_blocks(ctx, &pctx, block_buf, NULL); + FINISH_INODE_LOOP(ctx, ino, &pctx, failed_csum); + continue; + } + if ((inode->i_links_count || + inode->i_blocks || inode->i_block[0]) && + fix_problem(ctx, PR_1_ORPHAN_FILE_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"); + failed_csum = 0; + } + } else if (ino < EXT2_FIRST_INODE(fs->super)) { + problem_t problem = 0; + + ext2fs_mark_inode_bitmap2(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"); + failed_csum = 0; + } + } + check_blocks(ctx, &pctx, block_buf, NULL); + FINISH_INODE_LOOP(ctx, ino, &pctx, failed_csum); + continue; + } + + if (!inode->i_links_count) { + FINISH_INODE_LOOP(ctx, ino, &pctx, failed_csum); + 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"); + failed_csum = 0; + } + } + + ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino); + switch (fs->super->s_creator_os) { + case EXT2_OS_HURD: + frag = inode->osd2.hurd2.h_i_frag; + fsize = inode->osd2.hurd2.h_i_fsize; + break; + default: + frag = fsize = 0; + } + + if (inode->i_faddr || frag || fsize || + (!ext2fs_has_feature_largedir(fs->super) && + (LINUX_S_ISDIR(inode->i_mode) && inode->i_size_high))) + mark_inode_bad(ctx, ino); + if ((fs->super->s_creator_os != EXT2_OS_HURD) && + !ext2fs_has_feature_64bit(fs->super) && + inode->osd2.linux2.l_i_file_acl_high != 0) + mark_inode_bad(ctx, ino); + if ((fs->super->s_creator_os != EXT2_OS_HURD) && + !ext2fs_has_feature_huge_file(fs->super) && + (inode->osd2.linux2.l_i_blocks_hi != 0)) + 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_bitmap2(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"); + failed_csum = 0; + } + } + } + + check_inode_extra_space(ctx, &pctx, &ea_ibody_quota); + check_is_really_dir(ctx, &pctx, block_buf); + + /* + * ext2fs_inode_has_valid_blocks2 does not actually look + * at i_block[] values, so not endian-sensitive here. + */ + if (extent_fs && (inode->i_flags & EXT4_EXTENTS_FL) && + LINUX_S_ISLNK(inode->i_mode) && + !ext2fs_inode_has_valid_blocks2(fs, inode) && + fix_problem(ctx, PR_1_FAST_SYMLINK_EXTENT_FL, &pctx)) { + inode->i_flags &= ~EXT4_EXTENTS_FL; + e2fsck_write_inode(ctx, ino, inode, "pass1"); + failed_csum = 0; + } + + if ((inode->i_flags & EXT4_ENCRYPT_FL) && + add_encrypted_file(ctx, &pctx) < 0) + goto clear_inode; + + if (casefold_fs && inode->i_flags & EXT4_CASEFOLD_FL) + ext2fs_mark_inode_bitmap2(ctx->inode_casefold_map, ino); + + if (LINUX_S_ISDIR(inode->i_mode)) { + ext2fs_mark_inode_bitmap2(ctx->inode_dir_map, ino); + e2fsck_add_dir_info(ctx, ino, 0); + ctx->fs_directory_count++; + if (inode->i_flags & EXT4_CASEFOLD_FL) + add_casefolded_dir(ctx, ino); + } else if (LINUX_S_ISREG (inode->i_mode)) { + ext2fs_mark_inode_bitmap2(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_extents_inlinedata(ctx, &pctx); + 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_extents_inlinedata(ctx, &pctx); + 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, ino, inode, + block_buf)) { + check_immutable(ctx, &pctx); + ctx->fs_symlinks_count++; + if (inode->i_flags & EXT4_INLINE_DATA_FL) { + FINISH_INODE_LOOP(ctx, ino, &pctx, failed_csum); + continue; + } else if (ext2fs_is_fast_symlink(inode)) { + ctx->fs_fast_symlinks_count++; + check_blocks(ctx, &pctx, block_buf, + &ea_ibody_quota); + FINISH_INODE_LOOP(ctx, ino, &pctx, failed_csum); + continue; + } + } + else if (LINUX_S_ISFIFO (inode->i_mode) && + e2fsck_pass1_check_device_inode(fs, inode)) { + check_extents_inlinedata(ctx, &pctx); + 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_extents_inlinedata(ctx, &pctx); + check_immutable(ctx, &pctx); + check_size(ctx, &pctx); + ctx->fs_sockets_count++; + } else + mark_inode_bad(ctx, ino); + if (!(inode->i_flags & EXT4_EXTENTS_FL) && + !(inode->i_flags & EXT4_INLINE_DATA_FL)) { + 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_flags & EXT4_EXTENTS_FL) && + !(inode->i_flags & EXT4_INLINE_DATA_FL) && + (inode->i_block[EXT2_IND_BLOCK] || + inode->i_block[EXT2_DIND_BLOCK] || + inode->i_block[EXT2_TIND_BLOCK] || + ext2fs_file_acl_block(fs, inode))) { + struct process_inode_block *itp; + + itp = &inodes_to_process[process_inode_count]; + itp->ino = ino; + itp->ea_ibody_quota = ea_ibody_quota; + if (inode_size < sizeof(struct ext2_inode_large)) + memcpy(&itp->inode, inode, inode_size); + else + memcpy(&itp->inode, inode, sizeof(itp->inode)); + process_inode_count++; + } else + check_blocks(ctx, &pctx, block_buf, &ea_ibody_quota); + + FINISH_INODE_LOOP(ctx, ino, &pctx, failed_csum); + + if (ctx->flags & E2F_FLAG_SIGNAL_MASK) + goto endit; + + if (process_inode_count >= ctx->process_inode_size) { + process_inodes(ctx, block_buf); + + if (ctx->flags & E2F_FLAG_SIGNAL_MASK) + goto endit; + } + } + process_inodes(ctx, block_buf); + ext2fs_close_inode_scan(scan); + scan = NULL; + + reserve_block_for_root_repair(ctx); + reserve_block_for_lnf_repair(ctx); + + /* + * 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->ea_block_quota_blocks) { + ea_refcount_free(ctx->ea_block_quota_blocks); + ctx->ea_block_quota_blocks = 0; + } + + if (ctx->ea_block_quota_inodes) { + ea_refcount_free(ctx->ea_block_quota_inodes); + ctx->ea_block_quota_inodes = 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; + } + + /* We don't need the encryption policy => ID map any more */ + destroy_encryption_policy_map(ctx); + + if (ctx->flags & E2F_FLAG_RESIZE_INODE) { + clear_problem_context(&pctx); + pctx.errcode = ext2fs_create_resize_inode(fs); + if (pctx.errcode) { + if (!fix_problem(ctx, PR_1_RESIZE_INODE_CREATE, + &pctx)) { + ctx->flags |= E2F_FLAG_ABORT; + goto endit; + } + pctx.errcode = 0; + } + if (!pctx.errcode) { + e2fsck_read_inode(ctx, EXT2_RESIZE_INO, inode, + "recreate inode"); + inode->i_mtime = ctx->now; + e2fsck_write_inode(ctx, EXT2_RESIZE_INO, inode, + "recreate inode"); + } + 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; + goto endit; + } + + if (ctx->large_dirs && !ext2fs_has_feature_largedir(fs->super)) { + if (fix_problem(ctx, PR_2_FEATURE_LARGE_DIRS, &pctx)) { + ext2fs_set_feature_largedir(fs->super); + fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY; + ext2fs_mark_super_dirty(fs); + } + if (fs->super->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); + } + } + + 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); + } + ctx->flags |= E2F_FLAG_ALLOC_OK; +endit: + e2fsck_use_inode_shortcuts(ctx, 0); + ext2fs_free_mem(&inodes_to_process); + inodes_to_process = 0; + + if (scan) + ext2fs_close_inode_scan(scan); + if (block_buf) + ext2fs_free_mem(&block_buf); + if (inode) + ext2fs_free_mem(&inode); + + /* + * The l+f inode may have been cleared, so zap it now and + * later passes will recalculate it if necessary + */ + ctx->lost_and_found = 0; + + if ((ctx->flags & E2F_FLAG_SIGNAL_MASK) == 0) + print_resource_track(ctx, _("Pass 1"), &rtrack, ctx->fs->io); + else + ctx->invalid_bitmaps++; +} +#undef FINISH_INODE_LOOP + +/* + * 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 = + (struct ext2_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, + &inodes_to_process[i].ea_ibody_quota); + 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) + /* + * We only call process_inodes() for non-extent + * inodes, so it's OK to pass NULL to + * ext2fs_file_acl_block() here. + */ + ret = ext2fs_file_acl_block(0, ext2fs_const_inode(&ib_a->inode)) - + ext2fs_file_acl_block(0, ext2fs_const_inode(&ib_b->inode)); + if (ret == 0) + ret = ib_a->ino - ib_b->ino; + return ret; +} + +/* + * Mark an inode as being bad in some what + */ +static void mark_inode_bad(e2fsck_t ctx, ext2_ino_t ino) +{ + struct problem_context pctx; + + if (!ctx->inode_bad_map) { + clear_problem_context(&pctx); + + pctx.errcode = e2fsck_allocate_inode_bitmap(ctx->fs, + _("bad inode map"), EXT2FS_BMAP64_RBTREE, + "inode_bad_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_bitmap2(ctx->inode_bad_map, ino); +} + +static void add_casefolded_dir(e2fsck_t ctx, ext2_ino_t ino) +{ + struct problem_context pctx; + + if (!ctx->casefolded_dirs) { + pctx.errcode = ext2fs_u32_list_create(&ctx->casefolded_dirs, 0); + if (pctx.errcode) + goto error; + } + pctx.errcode = ext2fs_u32_list_add(ctx->casefolded_dirs, ino); + if (pctx.errcode == 0) + return; +error: + fix_problem(ctx, PR_1_ALLOCATE_CASEFOLDED_DIRLIST, &pctx); + /* Should never get here */ + ctx->flags |= E2F_FLAG_ABORT; +} + +/* + * 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 = e2fsck_allocate_inode_bitmap(ctx->fs, + _("inode in bad block map"), EXT2FS_BMAP64_RBTREE, + "inode_bb_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 = e2fsck_allocate_inode_bitmap(ctx->fs, + _("imagic inode map"), EXT2FS_BMAP64_RBTREE, + "inode_imagic_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, blk64_t block) +{ + struct problem_context pctx; + + clear_problem_context(&pctx); + + if (ext2fs_fast_test_block_bitmap2(ctx->block_found_map, block)) { + if (ext2fs_has_feature_shared_blocks(ctx->fs->super) && + !(ctx->options & E2F_OPT_UNSHARE_BLOCKS)) { + return; + } + if (!ctx->block_dup_map) { + pctx.errcode = e2fsck_allocate_block_bitmap(ctx->fs, + _("multiply claimed block map"), + EXT2FS_BMAP64_RBTREE, "block_dup_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_bitmap2(ctx->block_dup_map, block); + } else { + ext2fs_fast_mark_block_bitmap2(ctx->block_found_map, block); + } +} + +/* + * When cluster size is greater than one block, it is caller's responsibility + * to make sure block parameter starts at a cluster boundary. + */ +static _INLINE_ void mark_blocks_used(e2fsck_t ctx, blk64_t block, + unsigned int num) +{ + if (ext2fs_test_block_bitmap_range2(ctx->block_found_map, block, num)) + ext2fs_mark_block_bitmap_range2(ctx->block_found_map, block, num); + else { + unsigned int i; + + for (i = 0; i < num; i += EXT2FS_CLUSTER_RATIO(ctx->fs)) + mark_block_used(ctx, block + i); + } +} + +/* + * 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; + blk64_t blk; + __u32 should_be; + ea_value_t 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_attr3(fs, blk, block_buf, + pctx.ino); + 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 * (int)count; + pctx.num = should_be; + if (fix_problem(ctx, PR_1_EXTATTR_REFCOUNT, &pctx)) { + header->h_refcount = should_be; + pctx.errcode = ext2fs_write_ext_attr3(fs, blk, + block_buf, + pctx.ino); + if (pctx.errcode) { + fix_problem(ctx, PR_1_EXTATTR_WRITE_ABORT, + &pctx); + continue; + } + } + } +} + +/* + * Handle processing the extended attribute blocks + */ +static int check_ext_attr(e2fsck_t ctx, struct problem_context *pctx, + char *block_buf, struct ea_quota *ea_block_quota) +{ + ext2_filsys fs = ctx->fs; + ext2_ino_t ino = pctx->ino; + struct ext2_inode *inode = pctx->inode; + blk64_t blk; + char * end; + struct ext2_ext_attr_header *header; + struct ext2_ext_attr_entry *first, *entry; + blk64_t quota_blocks = EXT2FS_C2B(fs, 1); + __u64 quota_inodes = 0; + region_t region = 0; + int failed_csum = 0; + + ea_block_quota->blocks = 0; + ea_block_quota->inodes = 0; + + blk = ext2fs_file_acl_block(fs, inode); + 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 (!ext2fs_has_feature_xattr(fs->super) || + (blk < fs->super->s_first_data_block) || + (blk >= ext2fs_blocks_count(fs->super))) { + mark_inode_bad(ctx, ino); + return 0; + } + + /* If ea bitmap hasn't been allocated, create it */ + if (!ctx->block_ea_map) { + pctx->errcode = e2fsck_allocate_block_bitmap(fs, + _("ext attr block map"), + EXT2FS_BMAP64_RBTREE, "block_ea_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_bitmap2(ctx->block_ea_map, blk)) { + ea_block_quota->blocks = EXT2FS_C2B(fs, 1); + ea_block_quota->inodes = 0; + + if (ctx->ea_block_quota_blocks) { + ea_refcount_fetch(ctx->ea_block_quota_blocks, blk, + "a_blocks); + if (quota_blocks) + ea_block_quota->blocks = quota_blocks; + } + + if (ctx->ea_block_quota_inodes) + ea_refcount_fetch(ctx->ea_block_quota_inodes, blk, + &ea_block_quota->inodes); + + 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_attr3(fs, blk, block_buf, pctx->ino); + if (pctx->errcode == EXT2_ET_EXT_ATTR_CSUM_INVALID) { + pctx->errcode = 0; + failed_csum = 1; + } else if (pctx->errcode == EXT2_ET_BAD_EA_HEADER) + pctx->errcode = 0; + + if (pctx->errcode && + fix_problem(ctx, PR_1_READ_EA_BLOCK, pctx)) { + pctx->errcode = 0; + goto clear_extattr; + } + header = (struct ext2_ext_attr_header *) block_buf; + pctx->blk = ext2fs_file_acl_block(fs, inode); + 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; + } + + if (pctx->errcode && fix_problem(ctx, PR_1_READ_EA_BLOCK, pctx)) + goto clear_extattr; + + region = region_create(0, fs->blocksize); + if (!region) { + fix_problem(ctx, PR_1_EA_ALLOC_REGION_ABORT, 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; + } + + first = (struct ext2_ext_attr_entry *)(header+1); + end = block_buf + fs->blocksize; + entry = first; + while ((char *)entry < end && *(__u32 *)entry) { + __u32 hash; + + 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; + break; + } + 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; + break; + } + if (entry->e_value_inum == 0) { + if (entry->e_value_size > EXT2_XATTR_SIZE_MAX || + (entry->e_value_offs + entry->e_value_size > + fs->blocksize)) { + if (fix_problem(ctx, PR_1_EA_BAD_VALUE, pctx)) + goto clear_extattr; + break; + } + 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; + } + + hash = ext2fs_ext_attr_hash_entry(entry, block_buf + + entry->e_value_offs); + if (entry->e_hash != hash) + hash = ext2fs_ext_attr_hash_entry_signed(entry, + block_buf + entry->e_value_offs); + + if (entry->e_hash != hash) { + pctx->num = entry->e_hash; + if (fix_problem(ctx, PR_1_ATTR_HASH, pctx)) + goto clear_extattr; + entry->e_hash = hash; + } + } else { + problem_t problem; + blk64_t entry_quota_blocks; + + problem = check_large_ea_inode(ctx, entry, pctx, + &entry_quota_blocks); + if (problem && fix_problem(ctx, problem, pctx)) + goto clear_extattr; + + quota_blocks += entry_quota_blocks; + quota_inodes++; + } + + 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); + + /* + * We only get here if there was no other errors that were fixed. + * If there was a checksum fail, ask to correct it. + */ + if (failed_csum && + fix_problem(ctx, PR_1_EA_BLOCK_ONLY_CSUM_INVALID, pctx)) { + pctx->errcode = ext2fs_write_ext_attr3(fs, blk, block_buf, + pctx->ino); + if (pctx->errcode) + return 0; + } + + if (quota_blocks != EXT2FS_C2B(fs, 1U)) { + if (!ctx->ea_block_quota_blocks) { + pctx->errcode = ea_refcount_create(0, + &ctx->ea_block_quota_blocks); + if (pctx->errcode) { + pctx->num = 3; + goto refcount_fail; + } + } + ea_refcount_store(ctx->ea_block_quota_blocks, blk, + quota_blocks); + } + + if (quota_inodes) { + if (!ctx->ea_block_quota_inodes) { + pctx->errcode = ea_refcount_create(0, + &ctx->ea_block_quota_inodes); + if (pctx->errcode) { + pctx->num = 4; +refcount_fail: + fix_problem(ctx, PR_1_ALLOCATE_REFCOUNT, pctx); + ctx->flags |= E2F_FLAG_ABORT; + return 0; + } + } + + ea_refcount_store(ctx->ea_block_quota_inodes, blk, + quota_inodes); + } + ea_block_quota->blocks = quota_blocks; + ea_block_quota->inodes = quota_inodes; + + inc_ea_inode_refs(ctx, pctx, first, end); + ea_refcount_store(ctx->refcount, blk, header->h_refcount - 1); + mark_block_used(ctx, blk); + ext2fs_fast_mark_block_bitmap2(ctx->block_ea_map, blk); + return 1; + +clear_extattr: + if (region) + region_free(region); + ext2fs_file_acl_block_set(fs, inode, 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, struct ext2_inode *inode, + char *block_buf) +{ + struct ext2_dx_root_info *root; + ext2_filsys fs = ctx->fs; + errcode_t retval; + blk64_t blk; + + if ((!LINUX_S_ISDIR(inode->i_mode) && + fix_problem(ctx, PR_1_HTREE_NODIR, pctx)) || + (!ext2fs_has_feature_dir_index(fs->super) && + fix_problem(ctx, PR_1_HTREE_SET, pctx))) + return 1; + + pctx->errcode = ext2fs_bmap2(fs, ino, inode, 0, 0, 0, 0, &blk); + + if ((pctx->errcode) || + (blk == 0) || + (blk < fs->super->s_first_data_block) || + (blk >= ext2fs_blocks_count(fs->super))) { + if (fix_problem(ctx, PR_1_HTREE_BADROOT, pctx)) + return 1; + else + return 0; + } + + retval = io_channel_read_blk64(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) && + (root->hash_version != EXT2_HASH_SIPHASH) && + fix_problem(ctx, PR_1_HTREE_HASHV, pctx)) + return 1; + + if (ext4_hash_in_dirent(inode)) { + if (root->hash_version != EXT2_HASH_SIPHASH && + fix_problem(ctx, PR_1_HTREE_NEEDS_SIPHASH, pctx)) + return 1; + } else { + if (root->hash_version == EXT2_HASH_SIPHASH && + fix_problem(ctx, PR_1_HTREE_CANNOT_SIPHASH, 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 htree level is clearly too high, consider it to be broken */ + if (root->indirect_levels > EXT4_HTREE_LEVEL && + fix_problem(ctx, PR_1_HTREE_DEPTH, pctx)) + return 1; + + /* if level is only maybe too high, LARGE_DIR feature could be unset */ + if (root->indirect_levels > ext2_dir_htree_level(fs) && + !ext2fs_has_feature_largedir(fs->super)) { + int blockbits = EXT2_BLOCK_SIZE_BITS(fs->super) + 10; + unsigned idx_pb = 1 << (blockbits - 3); + + /* compare inode size/blocks vs. max-sized 2-level htree */ + if (EXT2_I_SIZE(pctx->inode) < + (idx_pb - 1) * (idx_pb - 2) << blockbits && + pctx->inode->i_blocks < + (idx_pb - 1) * (idx_pb - 2) << (blockbits - 9) && + fix_problem(ctx, PR_1_HTREE_DEPTH, pctx)) + return 1; + } + + if (root->indirect_levels > EXT4_HTREE_LEVEL_COMPAT || + ext2fs_needs_large_file_feature(EXT2_I_SIZE(inode))) + ctx->large_dirs++; + + return 0; +} + +void e2fsck_clear_inode(e2fsck_t ctx, ext2_ino_t ino, + struct ext2_inode *inode, int restart_flag, + const char *source) +{ + inode->i_flags = 0; + inode->i_links_count = 0; + ext2fs_icount_store(ctx->inode_link_info, ino, 0); + inode->i_dtime = ctx->now; + + /* + * If a special inode has such rotten block mappings that we + * want to clear the whole inode, be sure to actually zap + * the block maps because i_links_count isn't checked for + * special inodes, and we'll end up right back here the next + * time we run fsck. + */ + if (ino < EXT2_FIRST_INODE(ctx->fs->super)) + memset(inode->i_block, 0, sizeof(inode->i_block)); + + ext2fs_unmark_inode_bitmap2(ctx->inode_dir_map, ino); + ext2fs_unmark_inode_bitmap2(ctx->inode_used_map, ino); + if (ctx->inode_reg_map) + ext2fs_unmark_inode_bitmap2(ctx->inode_reg_map, ino); + if (ctx->inode_bad_map) + ext2fs_unmark_inode_bitmap2(ctx->inode_bad_map, ino); + + /* + * If the inode was partially accounted for before processing + * was aborted, we need to restart the pass 1 scan. + */ + ctx->flags |= restart_flag; + + if (ino == EXT2_BAD_INO) + memset(inode, 0, sizeof(struct ext2_inode)); + + e2fsck_write_inode(ctx, ino, inode, source); +} + +/* + * Use the multiple-blocks reclamation code to fix alignment problems in + * a bigalloc filesystem. We want a logical cluster to map to *only* one + * physical cluster, and we want the block offsets within that cluster to + * line up. + */ +static int has_unaligned_cluster_map(e2fsck_t ctx, + blk64_t last_pblk, blk64_t last_lblk, + blk64_t pblk, blk64_t lblk) +{ + blk64_t cluster_mask; + + if (!ctx->fs->cluster_ratio_bits) + return 0; + cluster_mask = EXT2FS_CLUSTER_MASK(ctx->fs); + + /* + * If the block in the logical cluster doesn't align with the block in + * the physical cluster... + */ + if ((lblk & cluster_mask) != (pblk & cluster_mask)) + return 1; + + /* + * If we cross a physical cluster boundary within a logical cluster... + */ + if (last_pblk && (lblk & cluster_mask) != 0 && + EXT2FS_B2C(ctx->fs, lblk) == EXT2FS_B2C(ctx->fs, last_lblk) && + EXT2FS_B2C(ctx->fs, pblk) != EXT2FS_B2C(ctx->fs, last_pblk)) + return 1; + + return 0; +} + +static void scan_extent_node(e2fsck_t ctx, struct problem_context *pctx, + struct process_block_struct *pb, + blk64_t start_block, blk64_t end_block, + blk64_t eof_block, + ext2_extent_handle_t ehandle, + int try_repairs) +{ + struct ext2fs_extent extent; + blk64_t blk, last_lblk; + unsigned int i, n; + int is_dir, is_leaf; + problem_t problem; + struct ext2_extent_info info; + int failed_csum = 0; + + if (pctx->errcode == EXT2_ET_EXTENT_CSUM_INVALID) + failed_csum = 1; + + pctx->errcode = ext2fs_extent_get_info(ehandle, &info); + if (pctx->errcode) + return; + if (!(ctx->options & E2F_OPT_FIXES_ONLY) && + !pb->eti.force_rebuild && + info.curr_level < MAX_EXTENT_DEPTH_COUNT) { + struct extent_tree_level *etl; + + etl = pb->eti.ext_info + info.curr_level; + etl->num_extents += info.num_entries; + etl->max_extents += info.max_entries; + /* + * Implementation wart: Splitting extent blocks when appending + * will leave the old block with one free entry. Therefore + * unless the node is totally full, pretend that a non-root + * extent block can hold one fewer entry than it actually does, + * so that we don't repeatedly rebuild the extent tree. + */ + if (info.curr_level && info.num_entries < info.max_entries) + etl->max_extents--; + } + + pctx->errcode = ext2fs_extent_get(ehandle, EXT2_EXTENT_FIRST_SIB, + &extent); + while ((pctx->errcode == 0 || + pctx->errcode == EXT2_ET_EXTENT_CSUM_INVALID) && + info.num_entries-- > 0) { + is_leaf = extent.e_flags & EXT2_EXTENT_FLAGS_LEAF; + is_dir = LINUX_S_ISDIR(pctx->inode->i_mode); + last_lblk = extent.e_lblk + extent.e_len - 1; + + problem = 0; + pctx->blk = extent.e_pblk; + pctx->blk2 = extent.e_lblk; + pctx->num = extent.e_len; + pctx->blkcount = extent.e_lblk + extent.e_len; + + if (extent.e_pblk == 0 || + extent.e_pblk < ctx->fs->super->s_first_data_block || + extent.e_pblk >= ext2fs_blocks_count(ctx->fs->super)) + problem = PR_1_EXTENT_BAD_START_BLK; + else if (extent.e_lblk < start_block) + problem = PR_1_OUT_OF_ORDER_EXTENTS; + else if ((end_block && last_lblk > end_block) && + !(last_lblk > eof_block && + ((extent.e_flags & EXT2_EXTENT_FLAGS_UNINIT) || + (pctx->inode->i_flags & EXT4_VERITY_FL)))) + problem = PR_1_EXTENT_END_OUT_OF_BOUNDS; + else if (is_leaf && extent.e_len == 0) + problem = PR_1_EXTENT_LENGTH_ZERO; + else if (is_leaf && + (extent.e_pblk + extent.e_len) > + ext2fs_blocks_count(ctx->fs->super)) + problem = PR_1_EXTENT_ENDS_BEYOND; + else if (is_leaf && is_dir && !pctx->inode->i_size_high && + !ext2fs_has_feature_largedir(ctx->fs->super) && + ((extent.e_lblk + extent.e_len) > + (1U << (21 - ctx->fs->super->s_log_block_size)))) + problem = PR_1_TOOBIG_DIR; + + if (is_leaf && problem == 0 && extent.e_len > 0) { +#if 0 + printf("extent_region(ino=%u, expect=%llu, " + "lblk=%llu, len=%u)\n", pb->ino, + (unsigned long long) pb->next_lblock, + (unsigned long long) extent.e_lblk, + extent.e_len); +#endif + if (extent.e_lblk < pb->next_lblock) + problem = PR_1_EXTENT_COLLISION; + else if (extent.e_lblk + extent.e_len > pb->next_lblock) + pb->next_lblock = extent.e_lblk + extent.e_len; + } + + /* + * Uninitialized blocks in a directory? Clear the flag and + * we'll interpret the blocks later. + */ + if (try_repairs && is_dir && problem == 0 && + (extent.e_flags & EXT2_EXTENT_FLAGS_UNINIT) && + fix_problem(ctx, PR_1_UNINIT_DBLOCK, pctx)) { + extent.e_flags &= ~EXT2_EXTENT_FLAGS_UNINIT; + pb->inode_modified = 1; + pctx->errcode = ext2fs_extent_replace(ehandle, 0, + &extent); + if (pctx->errcode) + return; + failed_csum = 0; + } +#ifdef CONFIG_DEVELOPER_FEATURES + if (try_repairs && !is_dir && problem == 0 && + (ctx->options & E2F_OPT_CLEAR_UNINIT) && + (extent.e_flags & EXT2_EXTENT_FLAGS_UNINIT) && + fix_problem(ctx, PR_1_CLEAR_UNINIT_EXTENT, pctx)) { + extent.e_flags &= ~EXT2_EXTENT_FLAGS_UNINIT; + pb->inode_modified = 1; + pctx->errcode = ext2fs_extent_replace(ehandle, 0, + &extent); + if (pctx->errcode) + return; + failed_csum = 0; + } +#endif + if (try_repairs && problem) { +report_problem: + if (fix_problem(ctx, problem, pctx)) { + if (ctx->invalid_bitmaps) { + /* + * If fsck knows the bitmaps are bad, + * skip to the next extent and + * try to clear this extent again + * after fixing the bitmaps, by + * restarting fsck. + */ + pctx->errcode = ext2fs_extent_get( + ehandle, + EXT2_EXTENT_NEXT_SIB, + &extent); + ctx->flags |= E2F_FLAG_RESTART_LATER; + if (pctx->errcode == + EXT2_ET_NO_CURRENT_NODE) { + pctx->errcode = 0; + break; + } + continue; + } + e2fsck_read_bitmaps(ctx); + pb->inode_modified = 1; + pctx->errcode = + ext2fs_extent_delete(ehandle, 0); + if (pctx->errcode) { + pctx->str = "ext2fs_extent_delete"; + return; + } + pctx->errcode = ext2fs_extent_fix_parents(ehandle); + if (pctx->errcode && + pctx->errcode != EXT2_ET_NO_CURRENT_NODE) { + pctx->str = "ext2fs_extent_fix_parents"; + return; + } + pctx->errcode = ext2fs_extent_get(ehandle, + EXT2_EXTENT_CURRENT, + &extent); + if (pctx->errcode == EXT2_ET_NO_CURRENT_NODE) { + pctx->errcode = 0; + break; + } + failed_csum = 0; + continue; + } + goto next; + } + + if (!is_leaf) { + blk64_t lblk = extent.e_lblk; + int next_try_repairs = 1; + + blk = extent.e_pblk; + + /* + * If this lower extent block collides with critical + * metadata, don't try to repair the damage. Pass 1b + * will reallocate the block; then we can try again. + */ + if (pb->ino != EXT2_RESIZE_INO && + extent.e_pblk < ctx->fs->super->s_blocks_count && + ext2fs_test_block_bitmap2(ctx->block_metadata_map, + extent.e_pblk)) { + next_try_repairs = 0; + pctx->blk = blk; + fix_problem(ctx, + PR_1_CRITICAL_METADATA_COLLISION, + pctx); + if ((ctx->options & E2F_OPT_NO) == 0) + ctx->flags |= E2F_FLAG_RESTART_LATER; + } + pctx->errcode = ext2fs_extent_get(ehandle, + EXT2_EXTENT_DOWN, &extent); + if (pctx->errcode && + pctx->errcode != EXT2_ET_EXTENT_CSUM_INVALID) { + pctx->str = "EXT2_EXTENT_DOWN"; + problem = PR_1_EXTENT_HEADER_INVALID; + if (!next_try_repairs) + return; + if (pctx->errcode == EXT2_ET_EXTENT_HEADER_BAD) + goto report_problem; + return; + } + /* The next extent should match this index's logical start */ + if (extent.e_lblk != lblk) { + struct ext2_extent_info e_info; + + pctx->errcode = ext2fs_extent_get_info(ehandle, + &e_info); + if (pctx->errcode) { + pctx->str = "ext2fs_extent_get_info"; + return; + } + pctx->blk = lblk; + pctx->blk2 = extent.e_lblk; + pctx->num = e_info.curr_level - 1; + problem = PR_1_EXTENT_INDEX_START_INVALID; + if (fix_problem(ctx, problem, pctx)) { + pb->inode_modified = 1; + pctx->errcode = + ext2fs_extent_fix_parents(ehandle); + if (pctx->errcode) { + pctx->str = "ext2fs_extent_fix_parents"; + return; + } + } + } + scan_extent_node(ctx, pctx, pb, extent.e_lblk, + last_lblk, eof_block, ehandle, + next_try_repairs); + if (pctx->errcode) + return; + pctx->errcode = ext2fs_extent_get(ehandle, + EXT2_EXTENT_UP, &extent); + if (pctx->errcode) { + pctx->str = "EXT2_EXTENT_UP"; + return; + } + mark_block_used(ctx, blk); + pb->num_blocks++; + goto next; + } + + if ((pb->previous_block != 0) && + (pb->previous_block+1 != extent.e_pblk)) { + if (ctx->options & E2F_OPT_FRAGCHECK) { + char type = '?'; + + if (pb->is_dir) + type = 'd'; + else if (pb->is_reg) + type = 'f'; + + printf(("%6lu(%c): expecting %6lu " + "actual extent " + "phys %6lu log %lu len %lu\n"), + (unsigned long) pctx->ino, type, + (unsigned long) pb->previous_block+1, + (unsigned long) extent.e_pblk, + (unsigned long) extent.e_lblk, + (unsigned long) extent.e_len); + } + pb->fragmented = 1; + } + /* + * If we notice a gap in the logical block mappings of an + * extent-mapped directory, offer to close the hole by + * moving the logical block down, otherwise we'll go mad in + * pass 3 allocating empty directory blocks to fill the hole. + */ + if (try_repairs && is_dir && + pb->last_block + 1 < extent.e_lblk) { + blk64_t new_lblk; + + new_lblk = pb->last_block + 1; + if (EXT2FS_CLUSTER_RATIO(ctx->fs) > 1) + new_lblk = ((new_lblk + + EXT2FS_CLUSTER_RATIO(ctx->fs) - 1) & + ~EXT2FS_CLUSTER_MASK(ctx->fs)) | + (extent.e_pblk & + EXT2FS_CLUSTER_MASK(ctx->fs)); + pctx->blk = extent.e_lblk; + pctx->blk2 = new_lblk; + if (fix_problem(ctx, PR_1_COLLAPSE_DBLOCK, pctx)) { + extent.e_lblk = new_lblk; + pb->inode_modified = 1; + pctx->errcode = ext2fs_extent_replace(ehandle, + 0, &extent); + if (pctx->errcode) { + pctx->errcode = 0; + goto alloc_later; + } + pctx->errcode = ext2fs_extent_fix_parents(ehandle); + if (pctx->errcode) + goto failed_add_dir_block; + pctx->errcode = ext2fs_extent_goto(ehandle, + extent.e_lblk); + if (pctx->errcode) + goto failed_add_dir_block; + last_lblk = extent.e_lblk + extent.e_len - 1; + failed_csum = 0; + } + } +alloc_later: + if (is_dir) { + while (++pb->last_db_block < + (e2_blkcnt_t) extent.e_lblk) { + pctx->errcode = ext2fs_add_dir_block2( + ctx->fs->dblist, + pb->ino, 0, + pb->last_db_block); + if (pctx->errcode) { + pctx->blk = 0; + pctx->num = pb->last_db_block; + goto failed_add_dir_block; + } + } + + for (i = 0; i < extent.e_len; i++) { + pctx->errcode = ext2fs_add_dir_block2( + ctx->fs->dblist, + pctx->ino, + extent.e_pblk + i, + extent.e_lblk + i); + if (pctx->errcode) { + pctx->blk = extent.e_pblk + i; + pctx->num = extent.e_lblk + i; + failed_add_dir_block: + fix_problem(ctx, PR_1_ADD_DBLOCK, pctx); + /* Should never get here */ + ctx->flags |= E2F_FLAG_ABORT; + return; + } + } + if (extent.e_len > 0) + pb->last_db_block = extent.e_lblk + extent.e_len - 1; + } + if (has_unaligned_cluster_map(ctx, pb->previous_block, + pb->last_block, + extent.e_pblk, + extent.e_lblk)) { + for (i = 0; i < extent.e_len; i++) { + pctx->blk = extent.e_lblk + i; + pctx->blk2 = extent.e_pblk + i; + fix_problem(ctx, PR_1_MISALIGNED_CLUSTER, pctx); + mark_block_used(ctx, extent.e_pblk + i); + mark_block_used(ctx, extent.e_pblk + i); + } + } + + /* + * Check whether first cluster got marked in previous iteration. + */ + if (ctx->fs->cluster_ratio_bits && + pb->previous_block && + (EXT2FS_B2C(ctx->fs, extent.e_pblk) == + EXT2FS_B2C(ctx->fs, pb->previous_block))) + /* Set blk to the beginning of next cluster. */ + blk = EXT2FS_C2B( + ctx->fs, + EXT2FS_B2C(ctx->fs, extent.e_pblk) + 1); + else + /* Set blk to the beginning of current cluster. */ + blk = EXT2FS_C2B(ctx->fs, + EXT2FS_B2C(ctx->fs, extent.e_pblk)); + + if (blk < extent.e_pblk + extent.e_len) { + mark_blocks_used(ctx, blk, + extent.e_pblk + extent.e_len - blk); + n = DIV_ROUND_UP(extent.e_pblk + extent.e_len - blk, + EXT2FS_CLUSTER_RATIO(ctx->fs)); + pb->num_blocks += n; + } + pb->last_block = extent.e_lblk + extent.e_len - 1; + pb->previous_block = extent.e_pblk + extent.e_len - 1; + start_block = pb->last_block = last_lblk; + if (is_leaf && !is_dir && + !(extent.e_flags & EXT2_EXTENT_FLAGS_UNINIT)) + pb->last_init_lblock = last_lblk; + next: + pctx->errcode = ext2fs_extent_get(ehandle, + EXT2_EXTENT_NEXT_SIB, + &extent); + } + + /* Failed csum but passes checks? Ask to fix checksum. */ + if (failed_csum && + fix_problem(ctx, PR_1_EXTENT_ONLY_CSUM_INVALID, pctx)) { + pb->inode_modified = 1; + pctx->errcode = ext2fs_extent_replace(ehandle, 0, &extent); + if (pctx->errcode) + return; + } + + if (pctx->errcode == EXT2_ET_EXTENT_NO_NEXT) + pctx->errcode = 0; +} + +static void check_blocks_extents(e2fsck_t ctx, struct problem_context *pctx, + struct process_block_struct *pb) +{ + struct ext2_extent_info info; + struct ext2_inode *inode = pctx->inode; + ext2_extent_handle_t ehandle; + ext2_filsys fs = ctx->fs; + ext2_ino_t ino = pctx->ino; + errcode_t retval; + blk64_t eof_lblk; + struct ext3_extent_header *eh; + + /* Check for a proper extent header... */ + eh = (struct ext3_extent_header *) &inode->i_block[0]; + retval = ext2fs_extent_header_verify(eh, sizeof(inode->i_block)); + if (retval) { + if (fix_problem(ctx, PR_1_MISSING_EXTENT_HEADER, pctx)) + e2fsck_clear_inode(ctx, ino, inode, 0, + "check_blocks_extents"); + pctx->errcode = 0; + return; + } + + /* ...since this function doesn't fail if i_block is zeroed. */ + pctx->errcode = ext2fs_extent_open2(fs, ino, inode, &ehandle); + if (pctx->errcode) { + if (fix_problem(ctx, PR_1_READ_EXTENT, pctx)) + e2fsck_clear_inode(ctx, ino, inode, 0, + "check_blocks_extents"); + pctx->errcode = 0; + return; + } + + retval = ext2fs_extent_get_info(ehandle, &info); + if (retval == 0) { + int max_depth = info.max_depth; + + if (max_depth >= MAX_EXTENT_DEPTH_COUNT) + max_depth = MAX_EXTENT_DEPTH_COUNT-1; + ctx->extent_depth_count[max_depth]++; + } + + /* Check maximum extent depth */ + pctx->blk = info.max_depth; + pctx->blk2 = ext2fs_max_extent_depth(ehandle); + if (pctx->blk2 < pctx->blk && + fix_problem(ctx, PR_1_EXTENT_BAD_MAX_DEPTH, pctx)) + pb->eti.force_rebuild = 1; + + /* Can we collect extent tree level stats? */ + pctx->blk = MAX_EXTENT_DEPTH_COUNT; + if (pctx->blk2 > pctx->blk) + fix_problem(ctx, PR_1E_MAX_EXTENT_TREE_DEPTH, pctx); + memset(pb->eti.ext_info, 0, sizeof(pb->eti.ext_info)); + pb->eti.ino = pb->ino; + + pb->next_lblock = 0; + + eof_lblk = ((EXT2_I_SIZE(inode) + fs->blocksize - 1) >> + EXT2_BLOCK_SIZE_BITS(fs->super)) - 1; + scan_extent_node(ctx, pctx, pb, 0, 0, eof_lblk, ehandle, 1); + if (pctx->errcode && + fix_problem(ctx, PR_1_EXTENT_ITERATE_FAILURE, pctx)) { + pb->num_blocks = 0; + inode->i_blocks = 0; + e2fsck_clear_inode(ctx, ino, inode, E2F_FLAG_RESTART, + "check_blocks_extents"); + pctx->errcode = 0; + } + ext2fs_extent_free(ehandle); + + /* Rebuild unless it's a dir and we're rehashing it */ + if (LINUX_S_ISDIR(inode->i_mode) && + e2fsck_dir_will_be_rehashed(ctx, ino)) + return; + + if (ctx->options & E2F_OPT_CONVERT_BMAP) + e2fsck_rebuild_extents_later(ctx, ino); + else + e2fsck_should_rebuild_extents(ctx, pctx, &pb->eti, &info); +} + +/* + * In fact we don't need to check blocks for an inode with inline data + * because this inode doesn't have any blocks. In this function all + * we need to do is add this inode into dblist when it is a directory. + */ +static void check_blocks_inline_data(e2fsck_t ctx, struct problem_context *pctx, + struct process_block_struct *pb) +{ + int flags; + size_t inline_data_size = 0; + + if (!pb->is_dir) { + pctx->errcode = 0; + return; + } + + /* Process the dirents in i_block[] as the "first" block. */ + pctx->errcode = ext2fs_add_dir_block2(ctx->fs->dblist, pb->ino, 0, 0); + if (pctx->errcode) + goto err; + + /* Process the dirents in the EA as a "second" block. */ + flags = ctx->fs->flags; + ctx->fs->flags |= EXT2_FLAG_IGNORE_CSUM_ERRORS; + pctx->errcode = ext2fs_inline_data_size(ctx->fs, pb->ino, + &inline_data_size); + ctx->fs->flags = (flags & EXT2_FLAG_IGNORE_CSUM_ERRORS) | + (ctx->fs->flags & ~EXT2_FLAG_IGNORE_CSUM_ERRORS); + if (pctx->errcode) { + pctx->errcode = 0; + return; + } + + if (inline_data_size <= EXT4_MIN_INLINE_DATA_SIZE) + return; + + pctx->errcode = ext2fs_add_dir_block2(ctx->fs->dblist, pb->ino, 0, 1); + if (pctx->errcode) + goto err; + + return; +err: + pctx->blk = 0; + pctx->num = 0; + fix_problem(ctx, PR_1_ADD_DBLOCK, pctx); + ctx->flags |= E2F_FLAG_ABORT; +} + +/* + * 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, const struct ea_quota *ea_ibody_quota) +{ + ext2_filsys fs = ctx->fs; + struct process_block_struct pb; + ext2_ino_t ino = pctx->ino; + struct ext2_inode *inode = pctx->inode; + unsigned bad_size = 0; + int dirty_inode = 0; + int extent_fs; + int inlinedata_fs; + __u64 size; + struct ea_quota ea_block_quota; + + pb.ino = ino; + pb.num_blocks = EXT2FS_B2C(ctx->fs, + ea_ibody_quota ? ea_ibody_quota->blocks : 0); + pb.last_block = ~0; + pb.last_init_lblock = -1; + pb.last_db_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 = 1U << (31 - fs->super->s_log_block_size); + pb.inode = inode; + pb.pctx = pctx; + pb.ctx = ctx; + pb.inode_modified = 0; + pb.eti.force_rebuild = 0; + pctx->ino = ino; + pctx->errcode = 0; + + extent_fs = ext2fs_has_feature_extents(ctx->fs->super); + inlinedata_fs = ext2fs_has_feature_inline_data(ctx->fs->super); + + if (check_ext_attr(ctx, pctx, block_buf, &ea_block_quota)) { + if (ctx->flags & E2F_FLAG_SIGNAL_MASK) + goto out; + pb.num_blocks += EXT2FS_B2C(ctx->fs, ea_block_quota.blocks); + } + + if (inlinedata_fs && (inode->i_flags & EXT4_INLINE_DATA_FL)) + check_blocks_inline_data(ctx, pctx, &pb); + else if (ext2fs_inode_has_valid_blocks2(fs, inode)) { + if (extent_fs && (inode->i_flags & EXT4_EXTENTS_FL)) + check_blocks_extents(ctx, pctx, &pb); + else { + int flags; + /* + * If we've modified the inode, write it out before + * iterate() tries to use it. + */ + if (dirty_inode) { + e2fsck_write_inode(ctx, ino, inode, + "check_blocks"); + dirty_inode = 0; + } + flags = fs->flags; + fs->flags |= EXT2_FLAG_IGNORE_CSUM_ERRORS; + pctx->errcode = ext2fs_block_iterate3(fs, ino, + pb.is_dir ? BLOCK_FLAG_HOLE : 0, + block_buf, process_block, &pb); + /* + * We do not have uninitialized extents in non extent + * files. + */ + pb.last_init_lblock = pb.last_block; + /* + * If iterate() changed a block mapping, we have to + * re-read the inode. If we decide to clear the + * inode after clearing some stuff, we'll re-write the + * bad mappings into the inode! + */ + if (pb.inode_modified) + e2fsck_read_inode(ctx, ino, inode, + "check_blocks"); + fs->flags = (flags & EXT2_FLAG_IGNORE_CSUM_ERRORS) | + (fs->flags & ~EXT2_FLAG_IGNORE_CSUM_ERRORS); + + if (ctx->options & E2F_OPT_CONVERT_BMAP) { +#ifdef DEBUG + printf("bmap rebuild ino=%d\n", ino); +#endif + if (!LINUX_S_ISDIR(inode->i_mode) || + !e2fsck_dir_will_be_rehashed(ctx, ino)) + e2fsck_rebuild_extents_later(ctx, ino); + } + } + } + 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) { + if (LINUX_S_ISDIR(inode->i_mode)) + ctx->fs_fragmented_dir++; + else + ctx->fs_fragmented++; + } + + if (pb.clear) { + e2fsck_clear_inode(ctx, ino, inode, E2F_FLAG_RESTART, + "check_blocks"); + return; + } + + 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 { + e2fsck_add_dx_dir(ctx, ino, inode, pb.last_block+1); + } + } + + if (!pb.num_blocks && pb.is_dir && + !(inode->i_flags & EXT4_INLINE_DATA_FL)) { + if (fix_problem(ctx, PR_1_ZERO_LENGTH_DIR, pctx)) { + e2fsck_clear_inode(ctx, ino, inode, 0, "check_blocks"); + ctx->fs_directory_count--; + return; + } + } + + if (ino != quota_type2inum(PRJQUOTA, fs->super) && + ino != fs->super->s_orphan_file_inum && + (ino == EXT2_ROOT_INO || ino >= EXT2_FIRST_INODE(ctx->fs->super)) && + !(inode->i_flags & EXT4_EA_INODE_FL)) { + quota_data_add(ctx->qctx, (struct ext2_inode_large *) inode, + ino, + pb.num_blocks * EXT2_CLUSTER_SIZE(fs->super)); + quota_data_inodes(ctx->qctx, (struct ext2_inode_large *) inode, + ino, (ea_ibody_quota ? + ea_ibody_quota->inodes : 0) + + ea_block_quota.inodes + 1); + } + + if (!ext2fs_has_feature_huge_file(fs->super) || + !(inode->i_flags & EXT4_HUGE_FILE_FL)) + pb.num_blocks *= (fs->blocksize / 512); + pb.num_blocks *= EXT2FS_CLUSTER_RATIO(fs); +#if 0 + printf("inode %u, i_size = %u, last_block = %llu, i_blocks=%llu, num_blocks = %llu\n", + ino, inode->i_size, (unsigned long long) pb.last_block, + (unsigned long long) ext2fs_inode_i_blocks(fs, inode), + (unsigned long long) pb.num_blocks); +#endif + size = EXT2_I_SIZE(inode); + if (pb.is_dir) { + unsigned nblock = size >> EXT2_BLOCK_SIZE_BITS(fs->super); + if (inode->i_flags & EXT4_INLINE_DATA_FL) { + int flags; + size_t sz = 0; + errcode_t err; + + flags = ctx->fs->flags; + ctx->fs->flags |= EXT2_FLAG_IGNORE_CSUM_ERRORS; + err = ext2fs_inline_data_size(ctx->fs, pctx->ino, + &sz); + ctx->fs->flags = (flags & + EXT2_FLAG_IGNORE_CSUM_ERRORS) | + (ctx->fs->flags & + ~EXT2_FLAG_IGNORE_CSUM_ERRORS); + if (err || sz != size) { + bad_size = 7; + pctx->num = sz; + } + } else if (size & (fs->blocksize - 1)) + bad_size = 5; + else 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 { + if ((pb.last_init_lblock >= 0) && + /* Do not allow initialized allocated blocks past i_size*/ + (size < (__u64)pb.last_init_lblock * fs->blocksize) && + !(inode->i_flags & EXT4_VERITY_FL)) + bad_size = 3; + else if (!(extent_fs && (inode->i_flags & EXT4_EXTENTS_FL)) && + size > ext2_max_sizes[fs->super->s_log_block_size]) + /* too big for a direct/indirect-mapped file */ + bad_size = 4; + else if ((extent_fs && (inode->i_flags & EXT4_EXTENTS_FL)) && + size > + ((1ULL << (32 + EXT2_BLOCK_SIZE_BITS(fs->super))) - 1)) + /* too big for an extent-based file - 32bit ee_block */ + bad_size = 6; + } + /* i_size for symlinks is checked elsewhere */ + if (bad_size && !LINUX_S_ISLNK(inode->i_mode)) { + /* Did inline_data set pctx->num earlier? */ + if (bad_size != 7) + pctx->num = (pb.last_block + 1) * fs->blocksize; + pctx->group = bad_size; + if (fix_problem(ctx, PR_1_BAD_I_SIZE, pctx)) { + ext2fs_inode_size_set(fs, inode, pctx->num); + if (EXT2_I_SIZE(inode) == 0 && + (inode->i_flags & EXT4_INLINE_DATA_FL)) { + memset(inode->i_block, 0, + sizeof(inode->i_block)); + inode->i_flags &= ~EXT4_INLINE_DATA_FL; + } + dirty_inode++; + } + pctx->num = 0; + } + if (LINUX_S_ISREG(inode->i_mode) && + ext2fs_needs_large_file_feature(EXT2_I_SIZE(inode))) + ctx->large_files++; + if ((fs->super->s_creator_os != EXT2_OS_HURD) && + ((pb.num_blocks != ext2fs_inode_i_blocks(fs, inode)) || + (ext2fs_has_feature_huge_file(fs->super) && + (inode->i_flags & EXT4_HUGE_FILE_FL) && + (inode->osd2.linux2.l_i_blocks_hi != 0)))) { + pctx->num = pb.num_blocks; + if (fix_problem(ctx, PR_1_BAD_I_BLOCKS, pctx)) { + inode->i_blocks = pb.num_blocks; + inode->osd2.linux2.l_i_blocks_hi = pb.num_blocks >> 32; + dirty_inode++; + } + pctx->num = 0; + } + + /* + * The kernel gets mad if we ask it to allocate bigalloc clusters to + * a block mapped file, so rebuild it as an extent file. We can skip + * symlinks because they're never rewritten. + */ + if (ext2fs_has_feature_bigalloc(fs->super) && + (LINUX_S_ISREG(inode->i_mode) || LINUX_S_ISDIR(inode->i_mode)) && + ext2fs_inode_data_blocks2(fs, inode) > 0 && + (ino == EXT2_ROOT_INO || ino >= EXT2_FIRST_INO(fs->super)) && + !(inode->i_flags & (EXT4_EXTENTS_FL | EXT4_INLINE_DATA_FL)) && + fix_problem(ctx, PR_1_NO_BIGALLOC_BLOCKMAP_FILES, pctx)) { + pctx->errcode = e2fsck_rebuild_extents_later(ctx, ino); + if (pctx->errcode) + goto out; + } + + if (ctx->dirs_to_hash && pb.is_dir && + !(ctx->lost_and_found && ctx->lost_and_found == ino) && + !(inode->i_flags & EXT2_INDEX_FL) && + ((inode->i_size / fs->blocksize) >= 3)) + e2fsck_rehash_dir_later(ctx, ino); + +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, blk64_t block) +{ + blk64_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 >= ext2fs_blocks_count(fs->super)) { + sprintf(problem, "> BLOCKS (%u)", ext2fs_blocks_count(fs->super)); + 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 == ext2fs_block_bitmap_loc(fs, i)) { + sprintf(problem, "is the block bitmap of group %d", i); + break; + } + if (block == ext2fs_inode_bitmap_loc(fs, i)) { + sprintf(problem, "is the inode bitmap of group %d", i); + break; + } + if (block >= ext2fs_inode_table_loc(fs, i) && + (block < ext2fs_inode_table_loc(fs, i) + + 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, + blk64_t *block_nr, + e2_blkcnt_t blockcnt, + blk64_t ref_block EXT2FS_ATTR((unused)), + int ref_offset EXT2FS_ATTR((unused)), + void *priv_data) +{ + struct process_block_struct *p; + struct problem_context *pctx; + blk64_t blk = *block_nr; + int ret_code = 0; + problem_t problem = 0; + e2fsck_t ctx; + + p = (struct process_block_struct *) priv_data; + pctx = p->pctx; + ctx = p->ctx; + + /* + * For a directory, add logical block zero for processing even if it's + * not mapped or we'll be perennially stuck with broken "." and ".." + * entries. + */ + if (p->is_dir && blockcnt == 0 && blk == 0) { + pctx->errcode = ext2fs_add_dir_block2(fs->dblist, p->ino, 0, 0); + if (pctx->errcode) { + pctx->blk = blk; + pctx->num = blockcnt; + goto failed_add_dir_block; + } + p->last_db_block++; + } + + if (blk == 0) + 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 (p->previous_block && p->ino != EXT2_RESIZE_INO) { + if (p->previous_block+1 != blk) { + if (ctx->options & E2F_OPT_FRAGCHECK) { + char type = '?'; + + if (p->is_dir) + type = 'd'; + else if (p->is_reg) + type = 'f'; + + printf(_("%6lu(%c): expecting %6lu " + "got phys %6lu (blkcnt %lld)\n"), + (unsigned long) pctx->ino, type, + (unsigned long) p->previous_block+1, + (unsigned long) blk, + (long long) blockcnt); + } + p->fragmented = 1; + } + } + + if (p->is_dir && !ext2fs_has_feature_largedir(fs->super) && + !pctx->inode->i_size_high && + blockcnt > (1 << (21 - fs->super->s_log_block_size))) + problem = PR_1_TOOBIG_DIR; + if (p->is_dir && p->num_blocks + 1 >= p->max_blocks) + 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 >= ext2fs_blocks_count(fs->super)) + problem = PR_1_ILLEGAL_BLOCK_NUM; + + /* + * If this IND/DIND/TIND block is squatting atop some critical metadata + * (group descriptors, superblock, bitmap, inode table), any write to + * "fix" mapping problems will destroy the metadata. We'll let pass 1b + * fix that and restart fsck. + */ + if (blockcnt < 0 && + p->ino != EXT2_RESIZE_INO && + blk < ctx->fs->super->s_blocks_count && + ext2fs_test_block_bitmap2(ctx->block_metadata_map, blk)) { + pctx->blk = blk; + fix_problem(ctx, PR_1_CRITICAL_METADATA_COLLISION, pctx); + if ((ctx->options & E2F_OPT_NO) == 0) + ctx->flags |= E2F_FLAG_RESTART_LATER; + } + + if (problem) { + p->num_illegal_blocks++; + /* + * A bit of subterfuge here -- we're trying to fix a block + * mapping, but the IND/DIND/TIND block could have collided + * with some critical metadata. So, fix the in-core mapping so + * iterate won't go insane, but return 0 instead of + * BLOCK_CHANGED so that it won't write the remapping out to + * our multiply linked block. + * + * Even if we previously determined that an *IND block + * conflicts with critical metadata, we must still try to + * iterate the *IND block as if it is an *IND block to find and + * mark the blocks it points to. Better to be overly cautious + * with the used_blocks map so that we don't move the *IND + * block to a block that's really in use! + */ + if (p->ino != EXT2_RESIZE_INO && + ref_block != 0 && + ext2fs_test_block_bitmap2(ctx->block_metadata_map, + ref_block)) { + *block_nr = 0; + return 0; + } + 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; + p->inode_modified = 1; + /* + * If the directory block is too big and is beyond the + * end of the FS, don't bother trying to add it for + * processing -- the kernel would never have created a + * directory this large, and we risk an ENOMEM abort. + * In any case, the toobig handler for extent-based + * directories also doesn't feed toobig blocks to + * pass 2. + */ + if (problem == PR_1_TOOBIG_DIR) + return ret_code; + 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); + p->num_blocks++; + } else if (!(ctx->fs->cluster_ratio_bits && + p->previous_block && + (EXT2FS_B2C(ctx->fs, blk) == + EXT2FS_B2C(ctx->fs, p->previous_block)) && + (blk & EXT2FS_CLUSTER_MASK(ctx->fs)) == + ((unsigned) blockcnt & EXT2FS_CLUSTER_MASK(ctx->fs)))) { + mark_block_used(ctx, blk); + p->num_blocks++; + } else if (has_unaligned_cluster_map(ctx, p->previous_block, + p->last_block, blk, blockcnt)) { + pctx->blk = blockcnt; + pctx->blk2 = blk; + fix_problem(ctx, PR_1_MISALIGNED_CLUSTER, pctx); + mark_block_used(ctx, blk); + mark_block_used(ctx, blk); + } + if (blockcnt >= 0) + p->last_block = blockcnt; + p->previous_block = blk; +mark_dir: + if (p->is_dir && (blockcnt >= 0)) { + while (++p->last_db_block < blockcnt) { + pctx->errcode = ext2fs_add_dir_block2(fs->dblist, + p->ino, 0, + p->last_db_block); + if (pctx->errcode) { + pctx->blk = 0; + pctx->num = p->last_db_block; + goto failed_add_dir_block; + } + } + pctx->errcode = ext2fs_add_dir_block2(fs->dblist, p->ino, + blk, blockcnt); + if (pctx->errcode) { + pctx->blk = blk; + pctx->num = blockcnt; + failed_add_dir_block: + 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, + blk64_t *block_nr, + e2_blkcnt_t blockcnt, + blk64_t ref_block EXT2FS_ATTR((unused)), + int ref_offset EXT2FS_ATTR((unused)), + void *priv_data) +{ + struct process_block_struct *p; + blk64_t blk = *block_nr; + blk64_t first_block; + dgrp_t i; + struct problem_context *pctx; + e2fsck_t ctx; + + 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 >= ext2fs_blocks_count(fs->super))) { + 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_bitmap2(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_bitmap2(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_bitmap2(ctx->block_found_map, blk)) { + ext2fs_mark_block_bitmap2(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 == ext2fs_block_bitmap_loc(fs, i)) { + if (fix_problem(ctx, PR_1_BB_BAD_BLOCK, pctx)) { + ctx->invalid_block_bitmap_flag[i]++; + ctx->invalid_bitmaps++; + } + return 0; + } + if (blk == ext2fs_inode_bitmap_loc(fs, i)) { + if (fix_problem(ctx, PR_1_IB_BAD_BLOCK, pctx)) { + ctx->invalid_inode_bitmap_flag[i]++; + ctx->invalid_bitmaps++; + } + return 0; + } + if ((blk >= ext2fs_inode_table_loc(fs, i)) && + (blk < (ext2fs_inode_table_loc(fs, i) + + 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, blk64_t first_block, dgrp_t group, + const char *name, int num, blk64_t *new_block) +{ + ext2_filsys fs = ctx->fs; + dgrp_t last_grp; + blk64_t old_block = *new_block; + blk64_t last_block; + dgrp_t flexbg; + unsigned flexbg_size; + int i, is_flexbg; + char *buf; + struct problem_context pctx; + + clear_problem_context(&pctx); + + pctx.group = group; + pctx.blk = old_block; + pctx.str = name; + + /* + * For flex_bg filesystems, first try to allocate the metadata + * within the flex_bg, and if that fails then try finding the + * space anywhere in the filesystem. + */ + is_flexbg = ext2fs_has_feature_flex_bg(fs->super); + if (is_flexbg) { + flexbg_size = 1U << fs->super->s_log_groups_per_flex; + flexbg = group / flexbg_size; + first_block = ext2fs_group_first_block2(fs, + flexbg_size * flexbg); + last_grp = group | (flexbg_size - 1); + if (last_grp >= fs->group_desc_count) + last_grp = fs->group_desc_count - 1; + last_block = ext2fs_group_last_block2(fs, last_grp); + } else + last_block = ext2fs_group_last_block2(fs, group); + pctx.errcode = ext2fs_get_free_blocks2(fs, first_block, last_block, + num, ctx->block_found_map, + new_block); + if (is_flexbg && (pctx.errcode == EXT2_ET_BLOCK_ALLOC_FAIL)) + pctx.errcode = ext2fs_get_free_blocks2(fs, + fs->super->s_first_data_block, + ext2fs_blocks_count(fs->super), + 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); + ctx->flags |= E2F_FLAG_ABORT; + 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); + ctx->flags |= E2F_FLAG_ABORT; + 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_bitmap2(ctx->block_found_map, (*new_block)+i); + if (old_block) { + pctx.errcode = io_channel_read_blk64(fs->io, + old_block + i, 1, buf); + if (pctx.errcode) + fix_problem(ctx, PR_1_RELOC_READ_ERR, &pctx); + pctx.blk = (*new_block) + i; + pctx.errcode = io_channel_write_blk64(fs->io, pctx.blk, + 1, buf); + } else { + pctx.blk = (*new_block) + i; + pctx.errcode = ext2fs_zero_blocks2(fs, pctx.blk, 1, + NULL, NULL); + } + + 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; + blk64_t first_block; + blk64_t new_blk; + + for (i = 0; i < fs->group_desc_count; i++) { + first_block = ext2fs_group_first_block2(fs, i); + + if (ctx->invalid_block_bitmap_flag[i]) { + new_blk = ext2fs_block_bitmap_loc(fs, i); + new_table_block(ctx, first_block, i, _("block bitmap"), + 1, &new_blk); + ext2fs_block_bitmap_loc_set(fs, i, new_blk); + } + if (ctx->invalid_inode_bitmap_flag[i]) { + new_blk = ext2fs_inode_bitmap_loc(fs, i); + new_table_block(ctx, first_block, i, _("inode bitmap"), + 1, &new_blk); + ext2fs_inode_bitmap_loc_set(fs, i, new_blk); + } + if (ctx->invalid_inode_table_flag[i]) { + new_blk = ext2fs_inode_table_loc(fs, i); + new_table_block(ctx, first_block, i, _("inode table"), + fs->inode_blocks_per_group, + &new_blk); + ext2fs_inode_table_loc_set(fs, i, new_blk); + ctx->flags |= E2F_FLAG_RESTART; + } + } + 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; + blk64_t b; + dgrp_t i; + unsigned int j; + struct problem_context pctx; + + clear_problem_context(&pctx); + + for (i = 0; i < fs->group_desc_count; i++) { + pctx.group = i; + + ext2fs_reserve_super_and_bgd(fs, i, ctx->block_found_map); + ext2fs_reserve_super_and_bgd(fs, i, ctx->block_metadata_map); + + /* + * Mark the blocks used for the inode table + */ + if (ext2fs_inode_table_loc(fs, i)) { + for (j = 0, b = ext2fs_inode_table_loc(fs, i); + j < fs->inode_blocks_per_group; + j++, b++) { + if (ext2fs_test_block_bitmap2(ctx->block_found_map, + b)) { + pctx.blk = b; + if (!ctx->invalid_inode_table_flag[i] && + fix_problem(ctx, + PR_1_ITABLE_CONFLICT, &pctx)) { + ctx->invalid_inode_table_flag[i]++; + ctx->invalid_bitmaps++; + } + } else { + ext2fs_mark_block_bitmap2( + ctx->block_found_map, b); + ext2fs_mark_block_bitmap2( + ctx->block_metadata_map, b); + } + } + } + + /* + * Mark block used for the block bitmap + */ + if (ext2fs_block_bitmap_loc(fs, i)) { + if (ext2fs_test_block_bitmap2(ctx->block_found_map, + ext2fs_block_bitmap_loc(fs, i))) { + pctx.blk = ext2fs_block_bitmap_loc(fs, i); + if (fix_problem(ctx, PR_1_BB_CONFLICT, &pctx)) { + ctx->invalid_block_bitmap_flag[i]++; + ctx->invalid_bitmaps++; + } + } else { + ext2fs_mark_block_bitmap2(ctx->block_found_map, + ext2fs_block_bitmap_loc(fs, i)); + ext2fs_mark_block_bitmap2(ctx->block_metadata_map, + ext2fs_block_bitmap_loc(fs, i)); + } + } + /* + * Mark block used for the inode bitmap + */ + if (ext2fs_inode_bitmap_loc(fs, i)) { + if (ext2fs_test_block_bitmap2(ctx->block_found_map, + ext2fs_inode_bitmap_loc(fs, i))) { + pctx.blk = ext2fs_inode_bitmap_loc(fs, i); + if (fix_problem(ctx, PR_1_IB_CONFLICT, &pctx)) { + ctx->invalid_inode_bitmap_flag[i]++; + ctx->invalid_bitmaps++; + } + } else { + ext2fs_mark_block_bitmap2(ctx->block_metadata_map, + ext2fs_inode_bitmap_loc(fs, i)); + ext2fs_mark_block_bitmap2(ctx->block_found_map, + ext2fs_inode_bitmap_loc(fs, i)); + } + } + } +} + +/* + * These 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 && + (inode != 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; +} + +static errcode_t e2fsck_get_alloc_block(ext2_filsys fs, blk64_t goal, + blk64_t *ret) +{ + e2fsck_t ctx = (e2fsck_t) fs->priv_data; + errcode_t retval; + blk64_t new_block; + + if (ctx->block_found_map) { + retval = ext2fs_new_block2(fs, goal, ctx->block_found_map, + &new_block); + if (retval) + return retval; + if (fs->block_map) { + ext2fs_mark_block_bitmap2(fs->block_map, new_block); + ext2fs_mark_bb_dirty(fs); + } + } else { + if (!fs->block_map) { + retval = ext2fs_read_block_bitmap(fs); + if (retval) + return retval; + } + + retval = ext2fs_new_block2(fs, goal, fs->block_map, &new_block); + if (retval) + return retval; + } + + *ret = new_block; + return (0); +} + +static errcode_t e2fsck_new_range(ext2_filsys fs, int flags, blk64_t goal, + blk64_t len, blk64_t *pblk, blk64_t *plen) +{ + e2fsck_t ctx = (e2fsck_t) fs->priv_data; + errcode_t retval; + + if (ctx->block_found_map) + return ext2fs_new_range(fs, flags, goal, len, + ctx->block_found_map, pblk, plen); + + if (!fs->block_map) { + retval = ext2fs_read_block_bitmap(fs); + if (retval) + return retval; + } + + return ext2fs_new_range(fs, flags, goal, len, fs->block_map, + pblk, plen); +} + +static void e2fsck_block_alloc_stats(ext2_filsys fs, blk64_t blk, int inuse) +{ + e2fsck_t ctx = (e2fsck_t) fs->priv_data; + + /* Never free a critical metadata block */ + if (ctx->block_found_map && + ctx->block_metadata_map && + inuse < 0 && + ext2fs_test_block_bitmap2(ctx->block_metadata_map, blk)) + return; + + if (ctx->block_found_map) { + if (inuse > 0) + ext2fs_mark_block_bitmap2(ctx->block_found_map, blk); + else + ext2fs_unmark_block_bitmap2(ctx->block_found_map, blk); + } +} + +static void e2fsck_block_alloc_stats_range(ext2_filsys fs, blk64_t blk, + blk_t num, int inuse) +{ + e2fsck_t ctx = (e2fsck_t) fs->priv_data; + + /* Never free a critical metadata block */ + if (ctx->block_found_map && + ctx->block_metadata_map && + inuse < 0 && + ext2fs_test_block_bitmap_range2(ctx->block_metadata_map, blk, num)) + return; + + if (ctx->block_found_map) { + if (inuse > 0) + ext2fs_mark_block_bitmap_range2(ctx->block_found_map, + blk, num); + else + ext2fs_unmark_block_bitmap_range2(ctx->block_found_map, + blk, num); + } +} + +void e2fsck_use_inode_shortcuts(e2fsck_t ctx, int use_shortcuts) +{ + ext2_filsys fs = ctx->fs; + + if (use_shortcuts) { + 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; + } +} + +void e2fsck_intercept_block_allocations(e2fsck_t ctx) +{ + ext2fs_set_alloc_block_callback(ctx->fs, e2fsck_get_alloc_block, 0); + ext2fs_set_block_alloc_stats_callback(ctx->fs, + e2fsck_block_alloc_stats, 0); + ext2fs_set_new_range_callback(ctx->fs, e2fsck_new_range, NULL); + ext2fs_set_block_alloc_stats_range_callback(ctx->fs, + e2fsck_block_alloc_stats_range, NULL); +} diff --git a/e2fsck/pass1b.c b/e2fsck/pass1b.c new file mode 100644 index 0000000..950af5b --- /dev/null +++ b/e2fsck/pass1b.c @@ -0,0 +1,1046 @@ +/* + * 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 "config.h" +#include +#ifdef HAVE_ERRNO_H +#include +#endif + +#ifdef HAVE_INTTYPES_H +#include +#endif + +#ifndef HAVE_INTPTR_T +typedef long intptr_t; +#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 +#include "e2fsck.h" + +#include "problem.h" +#include "support/dict.h" + +/* Define an extension to the ext2 library's block count information */ +#define BLOCK_COUNT_EXTATTR (-5) + +struct cluster_el { + blk64_t cluster; + struct cluster_el *next; +}; + +struct inode_el { + ext2_ino_t inode; + struct inode_el *next; +}; + +struct dup_cluster { + 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_large inode; + struct cluster_el *cluster_list; +}; + +static int process_pass1b_block(ext2_filsys fs, blk64_t *blocknr, + e2_blkcnt_t blockcnt, blk64_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 errcode_t 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, blk64_t block); +static int check_if_fs_cluster(e2fsck_t ctx, blk64_t cluster); + +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 int dup_inode_founddir = 0; + +static dict_t clstr_dict, ino_dict; + +static ext2fs_inode_bitmap inode_dup_map; + +static int dict_int_cmp(const void *cmp_ctx EXT2FS_ATTR((unused)), + 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, blk64_t cluster, + struct ext2_inode_large *inode) +{ + dnode_t *n; + struct dup_cluster *db; + struct dup_inode *di; + struct cluster_el *cluster_el; + struct inode_el *ino_el; + + n = dict_lookup(&clstr_dict, INT_TO_VOIDPTR(cluster)); + if (n) + db = (struct dup_cluster *) dnode_get(n); + else { + db = (struct dup_cluster *) e2fsck_allocate_memory(ctx, + sizeof(struct dup_cluster), "duplicate cluster header"); + db->num_bad = 0; + db->inode_list = 0; + dict_alloc_insert(&clstr_dict, INT_TO_VOIDPTR(cluster), 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"); + if (ino == EXT2_ROOT_INO) { + di->dir = EXT2_ROOT_INO; + dup_inode_founddir++; + } else + di->dir = 0; + + di->num_dupblocks = 0; + di->cluster_list = 0; + di->inode = *inode; + dict_alloc_insert(&ino_dict, INT_TO_VOIDPTR(ino), di); + } + cluster_el = (struct cluster_el *) e2fsck_allocate_memory(ctx, + sizeof(struct cluster_el), "cluster element"); + cluster_el->cluster = cluster; + cluster_el->next = di->cluster_list; + di->cluster_list = cluster_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 cluster_el *p, *next; + + di = (struct dup_inode *) dnode_get(node); + for (p = di->cluster_list; p; p = next) { + next = p->next; + ext2fs_free_mem(&p); + } + ext2fs_free_mem(&di); + ext2fs_free_mem(&node); +} + +/* + * Free a duplicate cluster record + */ +static void cluster_dnode_free(dnode_t *node, + void *context EXT2FS_ATTR((unused))) +{ + struct dup_cluster *dc; + struct inode_el *p, *next; + + dc = (struct dup_cluster *) dnode_get(node); + for (p = dc->inode_list; p; p = next) { + next = p->next; + ext2fs_free_mem(&p); + } + ext2fs_free_mem(&dc); + ext2fs_free_mem(&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; +#ifdef RESOURCE_TRACK + struct resource_track rtrack; +#endif + + clear_problem_context(&pctx); + + pctx.errcode = e2fsck_allocate_inode_bitmap(fs, + _("multiply claimed inode map"), + EXT2FS_BMAP64_RBTREE, "inode_dup_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(&clstr_dict, DICTCOUNT_T_MAX, dict_int_cmp); + dict_set_allocator(&ino_dict, NULL, inode_dnode_free, NULL); + dict_set_allocator(&clstr_dict, NULL, cluster_dnode_free, NULL); + + init_resource_track(&rtrack, ctx->fs->io); + pass1b(ctx, block_buf); + print_resource_track(ctx, "Pass 1b", &rtrack, ctx->fs->io); + + init_resource_track(&rtrack, ctx->fs->io); + pass1c(ctx, block_buf); + print_resource_track(ctx, "Pass 1c", &rtrack, ctx->fs->io); + + init_resource_track(&rtrack, ctx->fs->io); + pass1d(ctx, block_buf); + print_resource_track(ctx, "Pass 1d", &rtrack, ctx->fs->io); + + if (ext2fs_has_feature_shared_blocks(ctx->fs->super) && + (ctx->options & E2F_OPT_UNSHARE_BLOCKS)) { + /* + * If we successfully managed to unshare all blocks, unset the + * shared block feature. + */ + blk64_t next; + int result = ext2fs_find_first_set_block_bitmap2( + ctx->block_dup_map, + ctx->fs->super->s_first_data_block, + ext2fs_blocks_count(ctx->fs->super) - 1, + &next); + if (result == ENOENT && !(ctx->options & E2F_OPT_NO)) { + ext2fs_clear_feature_shared_blocks(ctx->fs->super); + ext2fs_mark_super_dirty(ctx->fs); + } + } + + /* + * Time to free all of the accumulated data structures that we + * don't need anymore. + */ + dict_free_nodes(&ino_dict); + dict_free_nodes(&clstr_dict); + ext2fs_free_inode_bitmap(inode_dup_map); +} + +/* + * Scan the inodes looking for inodes that contain duplicate blocks. + */ +struct process_block_struct { + e2fsck_t ctx; + ext2_ino_t ino; + int dup_blocks; + blk64_t cur_cluster, phys_cluster; + blk64_t last_blk; + struct ext2_inode_large *inode; + struct problem_context *pctx; +}; + +static void pass1b(e2fsck_t ctx, char *block_buf) +{ + ext2_filsys fs = ctx->fs; + ext2_ino_t ino = 0; + struct ext2_inode_large inode; + ext2_inode_scan scan; + struct process_block_struct pb; + struct problem_context pctx; + problem_t op; + + 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 = EXT2_INODE(&inode); + pb.ctx = ctx; + pb.pctx = &pctx; + pctx.str = "pass1b"; + while (1) { + if (ino % (fs->super->s_inodes_per_group * 4) == 1) { + if (e2fsck_mmp_update(fs)) + fatal_error(ctx, 0); + } + pctx.errcode = ext2fs_get_next_inode_full(scan, &ino, + EXT2_INODE(&inode), sizeof(inode)); + if (pctx.errcode == EXT2_ET_BAD_BLOCK_IN_INODE_TABLE) + continue; + if (pctx.errcode) { + pctx.ino = ino; + 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_bitmap2(ctx->inode_used_map, ino)) + continue; + + pb.ino = ino; + pb.dup_blocks = 0; + pb.inode = &inode; + pb.cur_cluster = ~0; + pb.phys_cluster = ~0; + pb.last_blk = 0; + pb.pctx->blk = pb.pctx->blk2 = 0; + + if (ext2fs_inode_has_valid_blocks2(fs, EXT2_INODE(&inode)) || + (ino == EXT2_BAD_INO)) + pctx.errcode = ext2fs_block_iterate3(fs, ino, + BLOCK_FLAG_READ_ONLY, block_buf, + process_pass1b_block, &pb); + /* If the feature is not set, attrs will be cleared later anyway */ + if (ext2fs_has_feature_xattr(fs->super) && + ext2fs_file_acl_block(fs, EXT2_INODE(&inode))) { + blk64_t blk = ext2fs_file_acl_block(fs, EXT2_INODE(&inode)); + process_pass1b_block(fs, &blk, + BLOCK_COUNT_EXTATTR, 0, 0, &pb); + ext2fs_file_acl_block_set(fs, EXT2_INODE(&inode), blk); + } + if (pb.dup_blocks) { + if (ino != EXT2_BAD_INO) { + op = pctx.blk == pctx.blk2 ? + PR_1B_DUP_BLOCK : PR_1B_DUP_RANGE; + fix_problem(ctx, op, pb.pctx); + } + 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)), + blk64_t *block_nr, + e2_blkcnt_t blockcnt, + blk64_t ref_blk EXT2FS_ATTR((unused)), + int ref_offset EXT2FS_ATTR((unused)), + void *priv_data) +{ + struct process_block_struct *p; + e2fsck_t ctx; + blk64_t lc, pc; + problem_t op; + + if (*block_nr == 0) + return 0; + p = (struct process_block_struct *) priv_data; + ctx = p->ctx; + lc = EXT2FS_B2C(fs, blockcnt); + pc = EXT2FS_B2C(fs, *block_nr); + + if (!ext2fs_test_block_bitmap2(ctx->block_dup_map, *block_nr)) + goto finish; + + /* OK, this is a duplicate block */ + if (p->ino != EXT2_BAD_INO) { + if (p->last_blk + 1 != *block_nr) { + if (p->last_blk) { + op = p->pctx->blk == p->pctx->blk2 ? + PR_1B_DUP_BLOCK : + PR_1B_DUP_RANGE; + fix_problem(ctx, op, p->pctx); + } + p->pctx->blk = *block_nr; + } + p->pctx->blk2 = *block_nr; + p->last_blk = *block_nr; + } + p->dup_blocks++; + ext2fs_mark_inode_bitmap2(inode_dup_map, p->ino); + + /* + * Qualifications for submitting a block for duplicate processing: + * It's an extent/indirect block (and has a negative logical offset); + * we've crossed a logical cluster boundary; or the physical cluster + * suddenly changed, which indicates that blocks in a logical cluster + * are mapped to multiple physical clusters. + */ + if (blockcnt < 0 || lc != p->cur_cluster || pc != p->phys_cluster) + add_dupe(ctx, p->ino, EXT2FS_B2C(fs, *block_nr), p->inode); + +finish: + p->cur_cluster = lc; + p->phys_cluster = pc; + 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_bitmap2(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); + if (!p->dir) { + 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 - dup_inode_founddir; + 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_cluster *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 cluster_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 || ino == EXT2_RESIZE_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->cluster_list; s; s = s->next) { + m = dict_lookup(&clstr_dict, + INT_TO_VOIDPTR(s->cluster)); + if (!m) + continue; /* Should never happen... */ + q = (struct dup_cluster *) dnode_get(m); + if (q->num_bad > 1) + file_ok = 0; + if (check_if_fs_cluster(ctx, s->cluster)) { + 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 = EXT2_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 = EXT2_INODE(&t->inode); + pctx.ino = shared[i]; + pctx.dir = t->dir; + fix_problem(ctx, PR_1D_DUP_FILE_LIST, &pctx); + } + /* + * Even if the file shares blocks with itself, we still need to + * clone the blocks. + */ + if (file_ok && (meta_data ? shared_len+1 : shared_len) != 0) { + fix_problem(ctx, PR_1D_DUP_BLOCKS_DEALT, &pctx); + continue; + } + if ((ctx->options & E2F_OPT_UNSHARE_BLOCKS) || + 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; + } + /* + * Note: When unsharing blocks, we don't prompt to delete + * files. If the clone operation fails than the unshare + * operation should fail too. + */ + if (!(ctx->options & E2F_OPT_UNSHARE_BLOCKS) && + 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, blk64_t block, + struct dup_cluster *p) +{ + p->num_bad--; + if (p->num_bad <= 0 || + (p->num_bad == 1 && !check_if_fs_block(ctx, block))) { + if (check_if_fs_cluster(ctx, EXT2FS_B2C(ctx->fs, block))) + return; + ext2fs_unmark_block_bitmap2(ctx->block_dup_map, block); + } +} + +static int delete_file_block(ext2_filsys fs, + blk64_t *block_nr, + e2_blkcnt_t blockcnt, + blk64_t ref_block EXT2FS_ATTR((unused)), + int ref_offset EXT2FS_ATTR((unused)), + void *priv_data) +{ + struct process_block_struct *pb; + struct dup_cluster *p; + dnode_t *n; + e2fsck_t ctx; + blk64_t c, lc; + + pb = (struct process_block_struct *) priv_data; + ctx = pb->ctx; + + if (*block_nr == 0) + return 0; + + c = EXT2FS_B2C(fs, *block_nr); + lc = EXT2FS_B2C(fs, blockcnt); + if (ext2fs_test_block_bitmap2(ctx->block_dup_map, *block_nr)) { + n = dict_lookup(&clstr_dict, INT_TO_VOIDPTR(c)); + if (n) { + if (lc != pb->cur_cluster) { + p = (struct dup_cluster *) dnode_get(n); + decrement_badcount(ctx, *block_nr, p); + pb->dup_blocks++; + } + } else + com_err("delete_file_block", 0, + _("internal error: can't find dup_blk for %llu\n"), + (unsigned long long) *block_nr); + } else { + if ((*block_nr % EXT2FS_CLUSTER_RATIO(ctx->fs)) == 0) + ext2fs_block_alloc_stats2(fs, *block_nr, -1); + pb->dup_blocks++; + } + pb->cur_cluster = lc; + + 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 problem_context pctx; + unsigned int count; + + clear_problem_context(&pctx); + pctx.ino = pb.ino = ino; + pb.dup_blocks = 0; + pb.ctx = ctx; + pctx.str = "delete_file"; + pb.cur_cluster = ~0; + + if (ext2fs_inode_has_valid_blocks2(fs, EXT2_INODE(&dp->inode))) + pctx.errcode = ext2fs_block_iterate3(fs, ino, + BLOCK_FLAG_READ_ONLY, + block_buf, + delete_file_block, &pb); + if (pctx.errcode) + fix_problem(ctx, PR_1B_BLOCK_ITERATE, &pctx); + if (ctx->inode_bad_map) + ext2fs_unmark_inode_bitmap2(ctx->inode_bad_map, ino); + if (ctx->inode_reg_map) + ext2fs_unmark_inode_bitmap2(ctx->inode_reg_map, ino); + ext2fs_unmark_inode_bitmap2(ctx->inode_dir_map, ino); + ext2fs_unmark_inode_bitmap2(ctx->inode_used_map, ino); + ext2fs_inode_alloc_stats2(fs, ino, -1, LINUX_S_ISDIR(dp->inode.i_mode)); + quota_data_sub(ctx->qctx, &dp->inode, ino, + pb.dup_blocks * fs->blocksize); + quota_data_inodes(ctx->qctx, &dp->inode, ino, -1); + + /* Inode may have changed by block_iterate, so reread it */ + e2fsck_read_inode_full(ctx, ino, EXT2_INODE(&dp->inode), + sizeof(dp->inode), "delete_file"); + e2fsck_clear_inode(ctx, ino, EXT2_INODE(&dp->inode), 0, "delete_file"); + if (ext2fs_file_acl_block(fs, EXT2_INODE(&dp->inode)) && + ext2fs_has_feature_xattr(fs->super)) { + blk64_t file_acl_block = ext2fs_file_acl_block(fs, + EXT2_INODE(&dp->inode)); + + count = 1; + pctx.errcode = ext2fs_adjust_ea_refcount3(fs, file_acl_block, + block_buf, -1, &count, ino); + if (pctx.errcode == EXT2_ET_BAD_EA_BLOCK_NUM) { + pctx.errcode = 0; + count = 1; + } + if (pctx.errcode) { + pctx.blk = file_acl_block; + 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_bitmap2(ctx->block_dup_map, + file_acl_block)) { + delete_file_block(fs, &file_acl_block, + BLOCK_COUNT_EXTATTR, 0, 0, &pb); + ext2fs_file_acl_block_set(fs, EXT2_INODE(&dp->inode), + file_acl_block); + quota_data_sub(ctx->qctx, &dp->inode, ino, + fs->blocksize); + } + } +} + +struct clone_struct { + errcode_t errcode; + blk64_t dup_cluster; + blk64_t alloc_block; + ext2_ino_t dir, ino; + char *buf; + e2fsck_t ctx; + struct ext2_inode_large *inode; + + struct dup_cluster *save_dup_cluster; + blk64_t save_blocknr; +}; + +/* + * Decrement the bad count *after* we've shown that (a) we can allocate a + * replacement block and (b) remap the file blocks. Unfortunately, there's no + * way to find out if the remap succeeded until either the next + * clone_file_block() call (an error when remapping the block after returning + * BLOCK_CHANGED will halt the iteration) or after block_iterate() returns. + * Otherwise, it's possible that we decrease the badcount once in preparation + * to remap, then the remap fails (either we can't find a replacement block or + * we have to split the extent tree and can't find a new extent block), so we + * delete the file, which decreases the badcount again. + */ +static void deferred_dec_badcount(struct clone_struct *cs) +{ + if (!cs->save_dup_cluster) + return; + decrement_badcount(cs->ctx, cs->save_blocknr, cs->save_dup_cluster); + cs->save_dup_cluster = NULL; +} + +static int clone_file_block(ext2_filsys fs, + blk64_t *block_nr, + e2_blkcnt_t blockcnt, + blk64_t ref_block EXT2FS_ATTR((unused)), + int ref_offset EXT2FS_ATTR((unused)), + void *priv_data) +{ + struct dup_cluster *p = NULL; + blk64_t new_block; + errcode_t retval; + struct clone_struct *cs = (struct clone_struct *) priv_data; + dnode_t *n; + e2fsck_t ctx; + blk64_t c; + int is_meta = 0; + int should_write = 1; + + ctx = cs->ctx; + deferred_dec_badcount(cs); + + if (*block_nr == 0) + return 0; + + if (ext2fs_has_feature_shared_blocks(ctx->fs->super) && + (ctx->options & E2F_OPT_UNSHARE_BLOCKS) && + (ctx->options & E2F_OPT_NO)) + should_write = 0; + + c = EXT2FS_B2C(fs, blockcnt); + + if (c == cs->dup_cluster && cs->alloc_block) { + new_block = cs->alloc_block; + goto got_block; + } + + if (ext2fs_test_block_bitmap2(ctx->block_dup_map, *block_nr)) { + n = dict_lookup(&clstr_dict, + INT_TO_VOIDPTR(EXT2FS_B2C(fs, *block_nr))); + if (!n) { + com_err("clone_file_block", 0, + _("internal error: can't find dup_blk for %llu\n"), + (unsigned long long) *block_nr); + return 0; + } + + p = (struct dup_cluster *) dnode_get(n); + + cs->dup_cluster = c; + /* + * Let's try an implied cluster allocation. If we get the same + * cluster back, then we need to find a new block; otherwise, + * we're merely fixing the problem of one logical cluster being + * mapped to multiple physical clusters. + */ + new_block = 0; + retval = ext2fs_map_cluster_block(fs, cs->ino, + EXT2_INODE(cs->inode), + blockcnt, &new_block); + if (retval == 0 && new_block != 0 && + EXT2FS_B2C(ctx->fs, new_block) != + EXT2FS_B2C(ctx->fs, *block_nr)) + goto cluster_alloc_ok; + retval = ext2fs_new_block2(fs, 0, ctx->block_found_map, + &new_block); + if (retval) { + cs->errcode = retval; + return BLOCK_ABORT; + } + if (ext2fs_has_feature_shared_blocks(fs->super)) { + /* + * Update the block stats so we don't get a prompt to fix block + * counts in the final pass. + */ + ext2fs_block_alloc_stats2(fs, new_block, +1); + } +cluster_alloc_ok: + cs->alloc_block = new_block; + + got_block: + new_block &= ~EXT2FS_CLUSTER_MASK(fs); + new_block += EXT2FS_CLUSTER_MASK(fs) & blockcnt; + if (cs->dir && (blockcnt >= 0)) { + retval = ext2fs_set_dir_block2(fs->dblist, + cs->dir, new_block, blockcnt); + if (retval) { + cs->errcode = retval; + return BLOCK_ABORT; + } + } +#if 0 + printf("Cloning block #%lld from %llu to %llu\n", + blockcnt, (unsigned long long) *block_nr, + (unsigned long long) new_block); +#endif + retval = io_channel_read_blk64(fs->io, *block_nr, 1, cs->buf); + if (retval) { + cs->errcode = retval; + return BLOCK_ABORT; + } + if (should_write) { + retval = io_channel_write_blk64(fs->io, new_block, 1, cs->buf); + if (retval) { + cs->errcode = retval; + return BLOCK_ABORT; + } + } + if (check_if_fs_cluster(ctx, EXT2FS_B2C(fs, *block_nr))) + is_meta = 1; + cs->save_dup_cluster = (is_meta ? NULL : p); + cs->save_blocknr = *block_nr; + *block_nr = new_block; + ext2fs_mark_block_bitmap2(ctx->block_found_map, new_block); + ext2fs_mark_block_bitmap2(fs->block_map, new_block); + + if (!should_write) { + /* Don't try to change extent information; we want e2fsck to + * return success. + */ + return 0; + } + return BLOCK_CHANGED; + } + return 0; +} + +static errcode_t 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; + blk64_t blk, new_blk; + dnode_t *n; + struct inode_el *ino_el; + struct dup_cluster *dc; + struct dup_inode *di; + + clear_problem_context(&pctx); + cs.errcode = 0; + cs.dir = 0; + cs.dup_cluster = ~0; + cs.alloc_block = 0; + cs.ctx = ctx; + cs.ino = ino; + cs.inode = &dp->inode; + cs.save_dup_cluster = NULL; + cs.save_blocknr = 0; + retval = ext2fs_get_mem(fs->blocksize, &cs.buf); + if (retval) + return retval; + + if (ext2fs_test_inode_bitmap2(ctx->inode_dir_map, ino)) + cs.dir = ino; + + pctx.ino = ino; + pctx.str = "clone_file"; + if (ext2fs_inode_has_valid_blocks2(fs, EXT2_INODE(&dp->inode))) + pctx.errcode = ext2fs_block_iterate3(fs, ino, 0, block_buf, + clone_file_block, &cs); + deferred_dec_badcount(&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, "%s", + _("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_full(ctx, ino, EXT2_INODE(&dp->inode), + sizeof(dp->inode), "clone file EA"); + blk = ext2fs_file_acl_block(fs, EXT2_INODE(&dp->inode)); + new_blk = blk; + if (blk && (clone_file_block(fs, &new_blk, + BLOCK_COUNT_EXTATTR, 0, 0, &cs) == + BLOCK_CHANGED)) { + ext2fs_file_acl_block_set(fs, EXT2_INODE(&dp->inode), new_blk); + e2fsck_write_inode_full(ctx, ino, EXT2_INODE(&dp->inode), + sizeof(dp->inode), "clone file EA"); + /* + * If we cloned the EA block, find all other inodes + * which referred to that EA block, and modify + * them to point to the new EA block. + */ + n = dict_lookup(&clstr_dict, + INT_TO_VOIDPTR(EXT2FS_B2C(fs, blk))); + if (!n) { + com_err("clone_file", 0, + _("internal error: couldn't lookup EA " + "block record for %llu"), + (unsigned long long) blk); + retval = 0; /* OK to stumble on... */ + goto errout; + } + dc = (struct dup_cluster *) dnode_get(n); + for (ino_el = dc->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)); + if (!n) { + com_err("clone_file", 0, + _("internal error: couldn't lookup EA " + "inode record for %u"), + ino_el->inode); + retval = 0; /* OK to stumble on... */ + goto errout; + } + di = (struct dup_inode *) dnode_get(n); + if (ext2fs_file_acl_block(fs, + EXT2_INODE(&di->inode)) == blk) { + ext2fs_file_acl_block_set(fs, + EXT2_INODE(&di->inode), + ext2fs_file_acl_block(fs, EXT2_INODE(&dp->inode))); + e2fsck_write_inode_full(ctx, ino_el->inode, + EXT2_INODE(&di->inode), + sizeof(di->inode), "clone file EA"); + decrement_badcount(ctx, blk, dc); + } + } + } + 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, blk64_t block) +{ + return ext2fs_test_block_bitmap2(ctx->block_metadata_map, block); +} + +/* + * This routine returns 1 if a cluster overlaps with one of the superblocks, + * group descriptors, inode bitmaps, or block bitmaps. + */ +static int check_if_fs_cluster(e2fsck_t ctx, blk64_t cluster) +{ + ext2_filsys fs = ctx->fs; + blk64_t block = EXT2FS_C2B(fs, cluster); + int i; + + for (i = 0; i < EXT2FS_CLUSTER_RATIO(fs); i++) { + if (ext2fs_test_block_bitmap2(ctx->block_metadata_map, + block + i)) + return 1; + } + + return 0; +} diff --git a/e2fsck/pass2.c b/e2fsck/pass2.c new file mode 100644 index 0000000..410edd1 --- /dev/null +++ b/e2fsck/pass2.c @@ -0,0 +1,2171 @@ +/* + * 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 + * - The encrypted_file_info + * - The inode_casefold_map bitmap + * + * Pass 2 frees the following data structures + * - The inode_bad_map bitmap + * - The inode_reg_map bitmap + * - The encrypted_file_info + * - The inode_casefold_map bitmap + */ + +#define _GNU_SOURCE 1 /* get strnlen() */ +#include "config.h" +#include + +#include "e2fsck.h" +#include "problem.h" +#include "support/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_block2(ext2_filsys fs, + struct ext2_db_entry2 *dir_blocks_info, + void *priv_data); +static int check_dir_block(ext2_filsys fs, + struct ext2_db_entry2 *dir_blocks_info, + void *priv_data); +static int allocate_dir_block(e2fsck_t ctx, + struct ext2_db_entry2 *dir_blocks_info, + char *buf, struct problem_context *pctx); +static void clear_htree(e2fsck_t ctx, ext2_ino_t ino); +static short 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; + unsigned long long list_offset; + unsigned long long ra_entries; + unsigned long long next_ra_off; +}; + +static void update_parents(struct dx_dir_info *dx_dir, int type) +{ + struct dx_dirblock_info *dx_db, *dx_parent, *dx_previous; + blk_t b; + + for (b = 0, dx_db = dx_dir->dx_block; + b < dx_dir->numblocks; + b++, dx_db++) { + dx_parent = &dx_dir->dx_block[dx_db->parent]; + if (dx_db->type != type) + continue; + + /* + * 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; + if (dx_parent->previous) { + dx_previous = + &dx_dir->dx_block[dx_parent->previous]; + dx_previous->node_max_hash = + dx_parent->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; + } + } +} + +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 = NULL; +#ifdef RESOURCE_TRACK + struct resource_track rtrack; +#endif + struct check_dir_struct cd; + struct dx_dir_info *dx_dir; + struct dx_dirblock_info *dx_db; + blk_t b; + ext2_ino_t i; + short depth; + problem_t code; + int bad_dir; + int (*check_dir_func)(ext2_filsys fs, + struct ext2_db_entry2 *dir_blocks_info, + void *priv_data); + + init_resource_track(&rtrack, ctx->fs->io); + clear_problem_context(&cd.pctx); + +#ifdef MTRACE + mtrace_print("Pass 2"); +#endif + + fs->flags |= EXT2_FLAG_IGNORE_SWAP_DIRENT; + if (!(ctx->options & E2F_OPT_PREEN)) + fix_problem(ctx, PR_2_PASS_HEADER, &cd.pctx); + + cd.pctx.errcode = e2fsck_setup_icount(ctx, "inode_count", + EXT2_ICOUNT_OPT_INCREMENT, + 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; + goto cleanup; + } + 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.) + */ + (void) e2fsck_dir_info_set_parent(ctx, EXT2_ROOT_INO, EXT2_ROOT_INO); + + cd.buf = buf; + cd.ctx = ctx; + cd.count = 1; + cd.max = ext2fs_dblist_count2(fs->dblist); + cd.list_offset = 0; + cd.ra_entries = ctx->readahead_kb * 1024 / ctx->fs->blocksize; + cd.next_ra_off = 0; + + if (ctx->progress) + (void) (ctx->progress)(ctx, 2, 0, cd.max); + + if (ext2fs_has_feature_dir_index(fs->super)) + ext2fs_dblist_sort2(fs->dblist, special_dir_block_cmp); + + check_dir_func = cd.ra_entries ? check_dir_block2 : check_dir_block; + cd.pctx.errcode = ext2fs_dblist_iterate2(fs->dblist, check_dir_func, + &cd); + if (ctx->flags & E2F_FLAG_RESTART_LATER) { + ctx->flags |= E2F_FLAG_RESTART; + ctx->flags &= ~E2F_FLAG_RESTART_LATER; + } + + if (ctx->flags & E2F_FLAG_RUN_RETURN) + goto cleanup; + + if (cd.pctx.errcode) { + fix_problem(ctx, PR_2_DBLIST_ITERATE, &cd.pctx); + ctx->flags |= E2F_FLAG_ABORT; + goto cleanup; + } + + for (i=0; (dx_dir = e2fsck_dx_dir_info_iter(ctx, &i)) != 0;) { + if (ctx->flags & E2F_FLAG_SIGNAL_MASK) + goto cleanup; + if (e2fsck_dir_will_be_rehashed(ctx, dx_dir->ino) || + 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 + */ + update_parents(dx_dir, DX_DIRBLOCK_LEAF); + + /* for 3 level htree: update 2 level parent's min + * and max hash values */ + update_parents(dx_dir, DX_DIRBLOCK_NODE); + + 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) { + pctx.num = 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 (bad_dir && fix_problem(ctx, PR_2_HTREE_CLEAR, &pctx)) { + clear_htree(ctx, dx_dir->ino); + dx_dir->numblocks = 0; + } + } + e2fsck_free_dx_dir_info(ctx); + + 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; + } + if (ctx->inode_casefold_map) { + ext2fs_free_inode_bitmap(ctx->inode_casefold_map); + ctx->inode_casefold_map = 0; + } + destroy_encrypted_file_info(ctx); + if (ctx->casefolded_dirs) { + ext2fs_u32_list_free(ctx->casefolded_dirs); + ctx->casefolded_dirs = 0; + } + + clear_problem_context(&pctx); + if (ctx->large_files) { + if (!ext2fs_has_feature_large_file(sb) && + fix_problem(ctx, PR_2_FEATURE_LARGE_FILES, &pctx)) { + ext2fs_set_feature_large_file(sb); + fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY; + 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); + } + } + + print_resource_track(ctx, _("Pass 2"), &rtrack, fs->io); +cleanup: + ext2fs_free_mem(&buf); + fs->flags &= ~EXT2_FLAG_IGNORE_SWAP_DIRENT; +} + +#define MAX_DEPTH 32000 +static short htree_depth(struct dx_dir_info *dx_dir, + struct dx_dirblock_info *dx_db) +{ + short 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 *cmp_ctx EXT2FS_ATTR((unused)), + 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 = ext2fs_dirent_name_len(de_a); + de_b = (const struct ext2_dir_entry *) b; + b_len = ext2fs_dirent_name_len(de_b); + + if (a_len != b_len) + return (a_len - b_len); + + return memcmp(de_a->name, de_b->name, a_len); +} + +static int dict_de_cf_cmp(const void *cmp_ctx, const void *a, const void *b) +{ + const struct ext2fs_nls_table *tbl = cmp_ctx; + const struct ext2_dir_entry *de_a, *de_b; + int a_len, b_len; + + de_a = (const struct ext2_dir_entry *) a; + a_len = ext2fs_dirent_name_len(de_a); + de_b = (const struct ext2_dir_entry *) b; + b_len = ext2fs_dirent_name_len(de_b); + + return ext2fs_casefold_cmp(tbl, + (const unsigned char *) de_a->name, a_len, + (const unsigned char *) de_b->name, b_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_entry2 *db_a = + (const struct ext2_db_entry2 *) a; + const struct ext2_db_entry2 *db_b = + (const struct ext2_db_entry2 *) 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; + unsigned int rec_len, new_len; + int status = 0; + int created = 0; + problem_t problem = 0; + int ftype = EXT2_FT_DIR; + + if (!dirent->inode) + problem = PR_2_MISSING_DOT; + else if ((ext2fs_dirent_name_len(dirent) != 1) || + (dirent->name[0] != '.')) + problem = PR_2_1ST_NOT_DOT; + else if (dirent->name[1] != '\0') + problem = PR_2_DOT_NULL_TERM; + + (void) ext2fs_get_rec_len(ctx->fs, dirent, &rec_len); + if (problem) { + if (!ext2fs_has_feature_filetype(ctx->fs->super)) + ftype = EXT2_FT_UNKNOWN; + if (fix_problem(ctx, problem, pctx)) { + if (rec_len < 12) + rec_len = dirent->rec_len = 12; + dirent->inode = ino; + ext2fs_dirent_set_name_len(dirent, 1); + ext2fs_dirent_set_file_type(dirent, ftype); + 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 (rec_len > 12) { + new_len = 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; + /* if the next entry looks like "..", leave it + * and let check_dotdot() verify the dirent, + * otherwise zap the following entry. */ + if (strncmp(nextdir->name, "..", 3) != 0) { + (void)ext2fs_set_rec_len(ctx->fs, + new_len, + nextdir); + nextdir->inode = 0; + ext2fs_dirent_set_name_len(nextdir, 0); + ext2fs_dirent_set_file_type(nextdir, + ftype); +#ifdef WORDS_BIGENDIAN + } else { + (void) ext2fs_dirent_swab_in2(ctx->fs, + (char *) nextdir, + ctx->fs->blocksize - 12, 0); +#endif + } + 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, + ext2_ino_t ino, struct problem_context *pctx) +{ + problem_t problem = 0; + unsigned int rec_len; + int ftype = EXT2_FT_DIR; + + if (!dirent->inode) + problem = PR_2_MISSING_DOT_DOT; + else if ((ext2fs_dirent_name_len(dirent) != 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; + + (void) ext2fs_get_rec_len(ctx->fs, dirent, &rec_len); + if (problem) { + if (!ext2fs_has_feature_filetype(ctx->fs->super)) + ftype = EXT2_FT_UNKNOWN; + if (fix_problem(ctx, problem, pctx)) { + if (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; + ext2fs_dirent_set_name_len(dirent, 2); + ext2fs_dirent_set_file_type(dirent, ftype); + dirent->name[0] = '.'; + dirent->name[1] = '.'; + dirent->name[2] = '\0'; + return 1; + } + return 0; + } + if (e2fsck_dir_info_set_dotdot(ctx, ino, dirent->inode)) { + fix_problem(ctx, PR_2_NO_DIRINFO, pctx); + return -1; + } + 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, + struct problem_context *pctx) +{ + int i; + int fixup = -1; + int ret = 0; + + for ( i = 0; i < ext2fs_dirent_name_len(dirent); i++) { + if (dirent->name[i] != '/' && dirent->name[i] != '\0') + continue; + if (fixup < 0) + fixup = fix_problem(ctx, PR_2_BAD_NAME, pctx); + if (fixup == 0) + return 0; + dirent->name[i] = '.'; + ret = 1; + } + return ret; +} + +static int encrypted_check_name(e2fsck_t ctx, + const struct ext2_dir_entry *dirent, + struct problem_context *pctx) +{ + if (ext2fs_dirent_name_len(dirent) < EXT4_CRYPTO_BLOCK_SIZE) { + if (fix_problem(ctx, PR_2_BAD_ENCRYPTED_NAME, pctx)) + return 1; + ext2fs_unmark_valid(ctx->fs); + } + return 0; +} + +static int encoded_check_name(e2fsck_t ctx, + struct ext2_dir_entry *dirent, + struct problem_context *pctx) +{ + const struct ext2fs_nls_table *tbl = ctx->fs->encoding; + int ret; + int len = ext2fs_dirent_name_len(dirent); + char *pos, *end; + + ret = ext2fs_check_encoded_name(tbl, dirent->name, len, &pos); + if (ret < 0) { + fatal_error(ctx, _("NLS is broken.")); + } else if(ret > 0) { + ret = fix_problem(ctx, PR_2_BAD_ENCODED_NAME, pctx); + if (ret) { + end = &dirent->name[len]; + for (; *pos && pos != end; pos++) + *pos = '.'; + } + } + + return (ret || check_name(ctx, dirent, pctx)); +} + +/* + * 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 = ext2fs_dirent_file_type(dirent); + int should_be = EXT2_FT_UNKNOWN; + struct ext2_inode inode; + + if (!ext2fs_has_feature_filetype(ctx->fs->super)) { + if (filetype == 0 || + !fix_problem(ctx, PR_2_CLEAR_FILETYPE, pctx)) + return 0; + ext2fs_dirent_set_file_type(dirent, EXT2_FT_UNKNOWN); + return 1; + } + + if (ext2fs_test_inode_bitmap2(ctx->inode_dir_map, dirent->inode)) { + should_be = EXT2_FT_DIR; + } else if (ext2fs_test_inode_bitmap2(ctx->inode_reg_map, + dirent->inode)) { + should_be = EXT2_FT_REG_FILE; + } else if (ctx->inode_bad_map && + ext2fs_test_inode_bitmap2(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; + + ext2fs_dirent_set_file_type(dirent, should_be); + return 1; +} + +static void parse_int_node(ext2_filsys fs, + struct ext2_db_entry2 *db, + struct check_dir_struct *cd, + struct dx_dir_info *dx_dir, + char *block_buf, int failed_csum) +{ + 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; + int csum_size = 0; + + 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: %u\n", root->reserved_zero); + printf("\t Hash Version: %u\n", root->hash_version); + printf("\t Info length: %u\n", root->info_length); + printf("\t Indirect levels: %u\n", root->indirect_levels); + printf("\t Flags: %x\n", root->unused_flags); +#endif + + ent = (struct ext2_dx_entry *) (block_buf + 24 + root->info_length); + + if (failed_csum && + (e2fsck_dir_will_be_rehashed(cd->ctx, cd->pctx.ino) || + fix_problem(cd->ctx, PR_2_HTREE_ROOT_CSUM_INVALID, + &cd->pctx))) + goto clear_and_exit; + } else { + ent = (struct ext2_dx_entry *) (block_buf+8); + + if (failed_csum && + (e2fsck_dir_will_be_rehashed(cd->ctx, cd->pctx.ino) || + fix_problem(cd->ctx, PR_2_HTREE_NODE_CSUM_INVALID, + &cd->pctx))) + goto clear_and_exit; + } + + 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); + if (ext2fs_has_feature_metadata_csum(fs->super)) + csum_size = sizeof(struct ext2_dx_tail); + expect_limit = (fs->blocksize - + (csum_size + ((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 %u\n", i, + hash, ext2fs_le32_to_cpu(ent[i].block)); +#endif + blk = ext2fs_le32_to_cpu(ent[i].block) & EXT4_DX_BLOCK_MASK; + /* Check to make sure the block is valid */ + if (blk >= dx_dir->numblocks) { + cd->pctx.blk = blk; + if (fix_problem(cd->ctx, PR_2_HTREE_BADBLK, + &cd->pctx)) + goto clear_and_exit; + continue; + } + 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; + } + + dx_db->previous = + i ? (ext2fs_le32_to_cpu(ent[i-1].block) & + EXT4_DX_BLOCK_MASK) : 0; + + 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; + e2fsck_rehash_dir_later(cd->ctx, cd->pctx.ino); +} + +/* + * 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, + unsigned int block_len, + int hash_in_dirent) +{ + char *cp = (char *) dirent; + int left; + unsigned int rec_len, prev_rec_len; + unsigned int name_len; + + /* + * If the space left for the entry is too small to be an entry, + * we can't access dirent's fields, so plumb in the values needed + * so that the previous entry absorbs this one. + */ + if (block_len - *offset < EXT2_DIR_ENTRY_HEADER_LEN) { + name_len = 0; + rec_len = block_len - *offset; + } else { + name_len = ext2fs_dirent_name_len(dirent); + (void) ext2fs_get_rec_len(fs, dirent, &rec_len); + } + left = block_len - *offset - rec_len; + + /* + * 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 >= (int) ext2fs_dir_rec_len(1, hash_in_dirent)) && + (rec_len == EXT2_DIR_ENTRY_HEADER_LEN)) { + memmove(cp, cp+EXT2_DIR_ENTRY_HEADER_LEN, left); + memset(cp + left, 0, EXT2_DIR_ENTRY_HEADER_LEN); + 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) && + ((int) rec_len + left > EXT2_DIR_ENTRY_HEADER_LEN) && + ((int) ext2fs_dir_rec_len(name_len, hash_in_dirent) <= (int) rec_len + left) && + dirent->inode <= fs->super->s_inodes_count && + strnlen(dirent->name, name_len) == name_len) { + (void) ext2fs_set_rec_len(fs, (int) rec_len + left, dirent); + return; + } + /* + * If the record length of the directory entry is a multiple + * of four, and not too big, such that it is valid, let the + * previous directory entry absorb the invalid one. + */ + if (prev && rec_len && (rec_len % 4) == 0 && + (*offset + rec_len <= block_len)) { + (void) ext2fs_get_rec_len(fs, prev, &prev_rec_len); + prev_rec_len += rec_len; + (void) ext2fs_set_rec_len(fs, prev_rec_len, prev); + *offset += 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) { + (void) ext2fs_get_rec_len(fs, prev, &prev_rec_len); + prev_rec_len += block_len - *offset; + (void) ext2fs_set_rec_len(fs, prev_rec_len, prev); + *offset = fs->blocksize; + } else { + rec_len = block_len - *offset; + (void) ext2fs_set_rec_len(fs, rec_len, dirent); + ext2fs_dirent_set_name_len(dirent, 0); + ext2fs_dirent_set_file_type(dirent, EXT2_FT_UNKNOWN); + dirent->inode = 0; + } +} + +#define NEXT_DIRENT(d) ((void *)((char *)(d) + (d)->rec_len)) +static errcode_t insert_dirent_tail(ext2_filsys fs, void *dirbuf) +{ + struct ext2_dir_entry *d; + void *top; + struct ext2_dir_entry_tail *t; + + d = dirbuf; + top = EXT2_DIRENT_TAIL(dirbuf, fs->blocksize); + + while (d->rec_len && !(d->rec_len & 0x3) && NEXT_DIRENT(d) <= top) + d = NEXT_DIRENT(d); + + if (d != top) { + unsigned int min_size = EXT2_DIR_REC_LEN( + ext2fs_dirent_name_len(dirbuf)); + if (min_size > (char *)top - (char *)d) + return EXT2_ET_DIR_NO_SPACE_FOR_CSUM; + d->rec_len = (char *)top - (char *)d; + } + + t = (struct ext2_dir_entry_tail *)top; + if (t->det_reserved_zero1 || + t->det_rec_len != sizeof(struct ext2_dir_entry_tail) || + t->det_reserved_name_len != EXT2_DIR_NAME_LEN_CSUM) + ext2fs_initialize_dirent_tail(fs, t); + + return 0; +} +#undef NEXT_DIRENT + +static errcode_t fix_inline_dir_size(e2fsck_t ctx, ext2_ino_t ino, + size_t *inline_data_size, + struct problem_context *pctx, + char *buf) +{ + ext2_filsys fs = ctx->fs; + struct ext2_inode inode; + size_t new_size, old_size; + errcode_t retval; + + old_size = *inline_data_size; + /* + * If there's not enough bytes to start the "second" dir block + * (in the EA space) then truncate everything to the first block. + */ + if (old_size > EXT4_MIN_INLINE_DATA_SIZE && + old_size < EXT4_MIN_INLINE_DATA_SIZE + + EXT2_DIR_REC_LEN(1)) { + old_size = EXT4_MIN_INLINE_DATA_SIZE; + new_size = old_size; + } else + /* Increase to the next four-byte boundary for salvaging */ + new_size = old_size + (4 - (old_size & 3)); + memset(buf + old_size, 0, new_size - old_size); + retval = ext2fs_inline_data_set(fs, ino, 0, buf, new_size); + if (retval == EXT2_ET_INLINE_DATA_NO_SPACE) { + /* Or we can't, so truncate. */ + new_size -= 4; + retval = ext2fs_inline_data_set(fs, ino, 0, buf, new_size); + if (retval) { + if (fix_problem(ctx, PR_2_FIX_INLINE_DIR_FAILED, + pctx)) { + new_size = 0; + goto write_inode; + } + goto err; + } + } else if (retval) { + if (fix_problem(ctx, PR_2_FIX_INLINE_DIR_FAILED, + pctx)) { + new_size = 0; + goto write_inode; + } + goto err; + } + +write_inode: + retval = ext2fs_read_inode(fs, ino, &inode); + if (retval) + goto err; + + retval = ext2fs_inode_size_set(fs, &inode, new_size); + if (retval) + goto err; + if (new_size == 0) + inode.i_flags &= ~EXT4_INLINE_DATA_FL; + retval = ext2fs_write_inode(fs, ino, &inode); + if (retval) + goto err; + *inline_data_size = new_size; + +err: + return retval; +} + +/* Return true if this type of file needs encryption */ +static int needs_encryption(e2fsck_t ctx, const struct ext2_dir_entry *dirent) +{ + int filetype = ext2fs_dirent_file_type(dirent); + ext2_ino_t ino = dirent->inode; + struct ext2_inode inode; + + if (filetype != EXT2_FT_UNKNOWN) + return filetype == EXT2_FT_REG_FILE || + filetype == EXT2_FT_DIR || + filetype == EXT2_FT_SYMLINK; + + if (ext2fs_test_inode_bitmap2(ctx->inode_reg_map, ino) || + ext2fs_test_inode_bitmap2(ctx->inode_dir_map, ino)) + return 1; + + e2fsck_read_inode(ctx, ino, &inode, "check_encryption_policy"); + return LINUX_S_ISREG(inode.i_mode) || + LINUX_S_ISDIR(inode.i_mode) || + LINUX_S_ISLNK(inode.i_mode); +} + +/* + * All regular files, directories, and symlinks in encrypted directories must be + * encrypted using the same encryption policy as their directory. + * + * Returns 1 if the dirent should be cleared, otherwise 0. + */ +static int check_encryption_policy(e2fsck_t ctx, + const struct ext2_dir_entry *dirent, + __u32 dir_encpolicy_id, + struct problem_context *pctx) +{ + __u32 file_encpolicy_id = find_encryption_policy(ctx, dirent->inode); + + /* Same policy or both UNRECOGNIZED_ENCRYPTION_POLICY? */ + if (file_encpolicy_id == dir_encpolicy_id) + return 0; + + if (file_encpolicy_id == NO_ENCRYPTION_POLICY) { + if (!needs_encryption(ctx, dirent)) + return 0; + return fix_problem(ctx, PR_2_UNENCRYPTED_FILE, pctx); + } + + return fix_problem(ctx, PR_2_INCONSISTENT_ENCRYPTION_POLICY, pctx); +} + +/* + * Check an encrypted directory entry. + * + * Returns 1 if the dirent should be cleared, otherwise 0. + */ +static int check_encrypted_dirent(e2fsck_t ctx, + const struct ext2_dir_entry *dirent, + __u32 dir_encpolicy_id, + struct problem_context *pctx) +{ + if (encrypted_check_name(ctx, dirent, pctx)) + return 1; + if (check_encryption_policy(ctx, dirent, dir_encpolicy_id, pctx)) + return 1; + return 0; +} + +static int check_dir_block2(ext2_filsys fs, + struct ext2_db_entry2 *db, + void *priv_data) +{ + int err; + struct check_dir_struct *cd = priv_data; + + if (cd->ra_entries && cd->list_offset >= cd->next_ra_off) { + err = e2fsck_readahead_dblist(fs, + E2FSCK_RA_DBLIST_IGNORE_BLOCKCNT, + fs->dblist, + cd->list_offset + cd->ra_entries / 8, + cd->ra_entries); + if (err) + cd->ra_entries = 0; + cd->next_ra_off = cd->list_offset + (cd->ra_entries * 7 / 8); + } + + err = check_dir_block(fs, db, priv_data); + cd->list_offset++; + return err; +} + +static int check_dir_block(ext2_filsys fs, + struct ext2_db_entry2 *db, + void *priv_data) +{ + struct dx_dir_info *dx_dir; + struct dx_dirblock_info *dx_db = 0; + struct ext2_dir_entry *dirent, *prev, dot, dotdot; + ext2_dirhash_t hash; + unsigned int offset = 0; + int dir_modified = 0; + int dot_state; + unsigned int rec_len; + blk64_t block_nr = db->blk; + ext2_ino_t ino = db->ino; + ext2_ino_t subdir_parent; + __u16 links; + struct check_dir_struct *cd; + char *buf, *ibuf; + e2fsck_t ctx; + problem_t 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; + int ret; + int dx_csum_size = 0, de_csum_size = 0; + int failed_csum = 0; + int is_leaf = 1; + size_t inline_data_size = 0; + int filetype = 0; + __u32 dir_encpolicy_id = NO_ENCRYPTION_POLICY; + int hash_in_dirent = 0; + int casefolded = 0; + size_t max_block_size; + int hash_flags = 0; + static char *eop_read_dirblock = NULL; + int cf_dir = 0; + + cd = (struct check_dir_struct *) priv_data; + ibuf = buf = cd->buf; + ctx = cd->ctx; + + /* We only want filename encoding verification on strict + * mode or if explicitly requested by user. */ + if (ext2fs_test_inode_bitmap2(ctx->inode_casefold_map, ino) && + ((ctx->fs->super->s_encoding_flags & EXT4_ENC_STRICT_MODE_FL) || + (ctx->options & E2F_OPT_CHECK_ENCODING))) + cf_dir = 1; + + if (ctx->flags & E2F_FLAG_RUN_RETURN) + return DIRENT_ABORT; + + if (ctx->progress && (ctx->progress)(ctx, 2, cd->count++, cd->max)) + return DIRENT_ABORT; + + if (ext2fs_has_feature_metadata_csum(fs->super)) { + dx_csum_size = sizeof(struct ext2_dx_tail); + de_csum_size = sizeof(struct ext2_dir_entry_tail); + } + + if (ext2fs_has_feature_filetype(fs->super)) + filetype = EXT2_FT_DIR << 8; + + /* + * Make sure the inode is still in use (could have been + * deleted in the duplicate/bad blocks pass. + */ + if (!(ext2fs_test_inode_bitmap2(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 (ext2fs_has_feature_inline_data(fs->super)) { + errcode_t ec; + + ec = ext2fs_inline_data_size(fs, ino, &inline_data_size); + if (ec && ec != EXT2_ET_NO_INLINE_DATA) + return DIRENT_ABORT; + } + + /* This will allow (at some point in the future) to punch out empty + * directory blocks and reduce the space used by a directory that grows + * very large and then the files are deleted. For now, all that is + * needed is to avoid e2fsck filling in these holes as part of + * feature flag. */ + if (db->blk == 0 && ext2fs_has_feature_largedir(fs->super) && + !ext2fs_has_feature_inline_data(fs->super)) + return 0; + + if (db->blk == 0 && !inline_data_size) { + 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 + + if (!eop_read_dirblock) + eop_read_dirblock = (char *) _("reading directory block"); + ehandler_operation(eop_read_dirblock); + if (inline_data_size) { + memset(buf, 0, fs->blocksize - inline_data_size); + cd->pctx.errcode = ext2fs_inline_data_get(fs, ino, 0, buf, 0); + if (cd->pctx.errcode) + goto inline_read_fail; +#ifdef WORDS_BIGENDIAN + if (db->blockcnt) + goto skip_first_read_swab; + *((__u32 *)buf) = ext2fs_le32_to_cpu(*((__u32 *)buf)); + cd->pctx.errcode = ext2fs_dirent_swab_in2(fs, + buf + EXT4_INLINE_DATA_DOTDOT_SIZE, + EXT4_MIN_INLINE_DATA_SIZE - EXT4_INLINE_DATA_DOTDOT_SIZE, + 0); + if (cd->pctx.errcode) + goto inline_read_fail; +skip_first_read_swab: + if (inline_data_size <= EXT4_MIN_INLINE_DATA_SIZE || + !db->blockcnt) + goto inline_read_fail; + cd->pctx.errcode = ext2fs_dirent_swab_in2(fs, + buf + EXT4_MIN_INLINE_DATA_SIZE, + inline_data_size - EXT4_MIN_INLINE_DATA_SIZE, + 0); +#endif + } else + cd->pctx.errcode = ext2fs_read_dir_block4(fs, block_nr, + buf, 0, ino); +inline_read_fail: + pctx.ino = ino; + pctx.num = inline_data_size; + if (((inline_data_size & 3) || + (inline_data_size > EXT4_MIN_INLINE_DATA_SIZE && + inline_data_size < EXT4_MIN_INLINE_DATA_SIZE + + EXT2_DIR_REC_LEN(1))) && + fix_problem(ctx, PR_2_BAD_INLINE_DIR_SIZE, &pctx)) { + errcode_t err = fix_inline_dir_size(ctx, ino, + &inline_data_size, &pctx, + buf); + if (err) + return DIRENT_ABORT; + + } + ehandler_operation(0); + if (cd->pctx.errcode == EXT2_ET_DIR_CORRUPTED) + cd->pctx.errcode = 0; /* We'll handle this ourselves */ + else if (cd->pctx.errcode == EXT2_ET_DIR_CSUM_INVALID) { + cd->pctx.errcode = 0; /* We'll handle this ourselves */ + failed_csum = 1; + } + if (cd->pctx.errcode) { + char *buf2; + if (!fix_problem(ctx, PR_2_READ_DIRBLOCK, &cd->pctx)) { + ctx->flags |= E2F_FLAG_ABORT; + return DIRENT_ABORT; + } + ext2fs_new_dir_block(fs, db->blockcnt == 0 ? ino : 0, + EXT2_ROOT_INO, &buf2); + memcpy(buf, buf2, fs->blocksize); + ext2fs_free_mem(&buf2); + } + dx_dir = e2fsck_get_dx_dir_info(ctx, ino); + if (dx_dir && dx_dir->numblocks) { + if (db->blockcnt >= dx_dir->numblocks) { + pctx.dir = ino; + if (fix_problem(ctx, PR_2_UNEXPECTED_HTREE_BLOCK, + &pctx)) { + clear_htree(ctx, ino); + dx_dir->numblocks = 0; + dx_db = 0; + goto out_htree; + } + fatal_error(ctx, _("Can not continue.")); + } + 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; + (void) ext2fs_get_rec_len(fs, dirent, &rec_len); + 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; + + /* large_dir was set in pass1 if large dirs were found, + * so ext2_dir_htree_level() should now be correct */ + if ((root->reserved_zero || + root->info_length < 8 || + root->indirect_levels >= + ext2_dir_htree_level(fs)) && + fix_problem(ctx, PR_2_HTREE_BAD_ROOT, &cd->pctx)) { + clear_htree(ctx, ino); + dx_dir->numblocks = 0; + dx_db = NULL; + } + dx_dir->hashversion = root->hash_version; + if ((dx_dir->hashversion <= EXT2_HASH_TEA) && + (fs->super->s_flags & EXT2_FLAGS_UNSIGNED_HASH)) + dx_dir->hashversion += 3; + dx_dir->depth = root->indirect_levels + 1; + } else if ((dirent->inode == 0) && + (rec_len == fs->blocksize) && + (ext2fs_dirent_name_len(dirent) == 0) && + (ext2fs_le16_to_cpu(limit->limit) == + ((fs->blocksize - (8 + dx_csum_size)) / + sizeof(struct ext2_dx_entry)))) { + dx_db->type = DX_DIRBLOCK_NODE; + } + is_leaf = dx_db ? (dx_db->type == DX_DIRBLOCK_LEAF) : 0; + } +out_htree: + + /* Leaf node with no space for csum? Rebuild dirs in pass 3A. */ + if (is_leaf && !inline_data_size && failed_csum && + !ext2fs_dirent_has_tail(fs, (struct ext2_dir_entry *)buf)) { + de_csum_size = 0; + if (e2fsck_dir_will_be_rehashed(ctx, ino)) { + failed_csum = 0; + goto skip_checksum; + } + if (!fix_problem(cd->ctx, PR_2_LEAF_NODE_MISSING_CSUM, + &cd->pctx)) + goto skip_checksum; + e2fsck_rehash_dir_later(ctx, ino); + failed_csum = 0; + goto skip_checksum; + } + /* htree nodes don't use fake dirents to store checksums */ + if (!is_leaf) + de_csum_size = 0; + +skip_checksum: + if (inline_data_size) { + if (db->blockcnt) { + buf += EXT4_MIN_INLINE_DATA_SIZE; + max_block_size = inline_data_size - EXT4_MIN_INLINE_DATA_SIZE; + /* Zero-length second block, just exit */ + if (max_block_size == 0) + return 0; + } else { + max_block_size = EXT4_MIN_INLINE_DATA_SIZE; + } + } else + max_block_size = fs->blocksize - de_csum_size; + + dir_encpolicy_id = find_encryption_policy(ctx, ino); + + if (cf_dir) { + dict_init(&de_dict, DICTCOUNT_T_MAX, dict_de_cf_cmp); + dict_set_cmp_context(&de_dict, (const void *)ctx->fs->encoding); + } else { + dict_init(&de_dict, DICTCOUNT_T_MAX, dict_de_cmp); + } + if (ctx->casefolded_dirs) + casefolded = ext2fs_u32_list_test(ctx->casefolded_dirs, ino); + hash_in_dirent = (casefolded && + (dir_encpolicy_id != NO_ENCRYPTION_POLICY)); + + prev = 0; + do { + dgrp_t group; + ext2_ino_t first_unused_inode; + unsigned int name_len; + /* csum entry is not checked here, so don't worry about it */ + int extended = (dot_state > 1) && hash_in_dirent; + unsigned int min_dir_len = ext2fs_dir_rec_len(1, extended); + + problem = 0; + if (!inline_data_size || dot_state > 1) { + dirent = (struct ext2_dir_entry *) (buf + offset); + /* + * If there's not even space for the entry header, + * force salvaging this dir. + */ + if (max_block_size - offset < EXT2_DIR_ENTRY_HEADER_LEN) + rec_len = ext2fs_dir_rec_len(1, extended); + else + (void) ext2fs_get_rec_len(fs, dirent, &rec_len); + cd->pctx.dirent = dirent; + cd->pctx.num = offset; + if ((offset + rec_len > max_block_size) || + (rec_len < min_dir_len) || + ((rec_len % 4) != 0) || + ((ext2fs_dir_rec_len(ext2fs_dirent_name_len(dirent), + extended)) > rec_len)) { + if (fix_problem(ctx, PR_2_DIR_CORRUPTED, + &cd->pctx)) { +#ifdef WORDS_BIGENDIAN + /* + * On big-endian systems, if the dirent + * swap routine finds a rec_len that it + * doesn't like, it continues + * processing the block as if rec_len + * == EXT2_DIR_ENTRY_HEADER_LEN. This means that the name + * field gets byte swapped, which means + * that salvage will not detect the + * correct name length (unless the name + * has a length that's an exact + * multiple of four bytes), and it'll + * discard the entry (unnecessarily) + * and the rest of the dirent block. + * Therefore, swap the rest of the + * block back to disk order, run + * salvage, and re-swap anything after + * the salvaged dirent. + */ + int need_reswab = 0; + if (rec_len < EXT2_DIR_ENTRY_HEADER_LEN || rec_len % 4) { + need_reswab = 1; + ext2fs_dirent_swab_in2(fs, + ((char *)dirent) + EXT2_DIR_ENTRY_HEADER_LEN, + max_block_size - offset - EXT2_DIR_ENTRY_HEADER_LEN, + 0); + } +#endif + salvage_directory(fs, dirent, prev, + &offset, + max_block_size, + hash_in_dirent); +#ifdef WORDS_BIGENDIAN + if (need_reswab) { + unsigned int len; + + (void) ext2fs_get_rec_len(fs, + dirent, &len); + len += offset; + if (max_block_size > len) + ext2fs_dirent_swab_in2(fs, + ((char *)dirent) + len, max_block_size - len, 0); + } +#endif + dir_modified++; + continue; + } else + goto abort_free_dict; + } + } else { + if (dot_state == 0) { + memset(&dot, 0, sizeof(dot)); + dirent = ˙ + dirent->inode = ino; + dirent->rec_len = EXT2_DIR_REC_LEN(1); + dirent->name_len = 1 | filetype; + dirent->name[0] = '.'; + } else if (dot_state == 1) { + memset(&dotdot, 0, sizeof(dotdot)); + dirent = &dotdot; + dirent->inode = + ((struct ext2_dir_entry *)buf)->inode; + dirent->rec_len = EXT2_DIR_REC_LEN(2); + dirent->name_len = 2 | filetype; + dirent->name[0] = '.'; + dirent->name[1] = '.'; + } else { + fatal_error(ctx, _("Can not continue.")); + } + cd->pctx.dirent = dirent; + cd->pctx.num = offset; + } + + if (dot_state == 0) { + if (check_dot(ctx, dirent, ino, &cd->pctx)) + dir_modified++; + } else if (dot_state == 1) { + ret = check_dotdot(ctx, dirent, ino, &cd->pctx); + if (ret < 0) + goto abort_free_dict; + if (ret) + 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. + */ + name_len = ext2fs_dirent_name_len(dirent); + if (((dirent->inode != EXT2_ROOT_INO) && + (dirent->inode < EXT2_FIRST_INODE(fs->super))) || + (dirent->inode > fs->super->s_inodes_count) || + (dirent->inode == fs->super->s_usr_quota_inum) || + (dirent->inode == fs->super->s_grp_quota_inum) || + (dirent->inode == fs->super->s_prj_quota_inum) || + (dirent->inode == fs->super->s_orphan_file_inum)) { + problem = PR_2_BAD_INO; + } else if (ctx->inode_bb_map && + (ext2fs_test_inode_bitmap2(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) && (name_len == 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) && (name_len == 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) && (name_len == 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_bitmap2(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; + } + + group = ext2fs_group_of_ino(fs, dirent->inode); + first_unused_inode = group * fs->super->s_inodes_per_group + + 1 + fs->super->s_inodes_per_group - + ext2fs_bg_itable_unused(fs, group); + cd->pctx.group = group; + + /* + * Check if the inode was missed out because + * _INODE_UNINIT flag was set or bg_itable_unused was + * incorrect. If so, clear the _INODE_UNINIT flag and + * restart e2fsck. In the future it would be nice if + * we could call a function in pass1.c that checks the + * newly visible inodes. + */ + if (ext2fs_bg_flags_test(fs, group, EXT2_BG_INODE_UNINIT)) { + pctx.num = dirent->inode; + if (fix_problem(ctx, PR_2_INOREF_BG_INO_UNINIT, + &cd->pctx)){ + ext2fs_bg_flags_clear(fs, group, + EXT2_BG_INODE_UNINIT); + ext2fs_group_desc_csum_set(fs, group); + ext2fs_mark_super_dirty(fs); + ctx->flags |= E2F_FLAG_RESTART_LATER; + } else { + ext2fs_unmark_valid(fs); + if (problem == PR_2_BAD_INO) + goto next; + } + } else if (dirent->inode >= first_unused_inode) { + pctx.num = dirent->inode; + if (fix_problem(ctx, PR_2_INOREF_IN_UNUSED, &cd->pctx)){ + ext2fs_bg_itable_unused_set(fs, group, 0); + ext2fs_group_desc_csum_set(fs, group); + ext2fs_mark_super_dirty(fs); + ctx->flags |= E2F_FLAG_RESTART_LATER; + } else { + ext2fs_unmark_valid(fs); + if (problem == PR_2_BAD_INO) + goto next; + } + } + + /* + * Offer to clear unused inodes; if we are going to be + * restarting the scan due to bg_itable_unused being + * wrong, then don't clear any inodes to avoid zapping + * inodes that were skipped during pass1 due to an + * incorrect bg_itable_unused; we'll get any real + * problems after we restart. + */ + if (!(ctx->flags & E2F_FLAG_RESTART_LATER) && + !(ext2fs_test_inode_bitmap2(ctx->inode_used_map, + dirent->inode))) + problem = PR_2_UNUSED_INODE; + + 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 (check_filetype(ctx, dirent, ino, &cd->pctx)) + dir_modified++; + + if (dir_encpolicy_id != NO_ENCRYPTION_POLICY) { + /* Encrypted directory */ + if (dot_state > 1 && + check_encrypted_dirent(ctx, dirent, + dir_encpolicy_id, + &cd->pctx)) { + dirent->inode = 0; + dir_modified++; + goto next; + } + } else if (cf_dir) { + /* Casefolded directory */ + if (encoded_check_name(ctx, dirent, &cd->pctx)) + dir_modified++; + } else { + /* Unencrypted and uncasefolded directory */ + if (check_name(ctx, dirent, &cd->pctx)) + dir_modified++; + } + + if (dx_db) { + if (dx_dir->casefolded_hash) + hash_flags = EXT4_CASEFOLD_FL; + + if (dx_dir->hashversion == EXT2_HASH_SIPHASH) { + if (dot_state > 1) + hash = EXT2_DIRENT_HASH(dirent); + } else { + ext2fs_dirhash2(dx_dir->hashversion, + dirent->name, + ext2fs_dirent_name_len(dirent), + fs->encoding, hash_flags, + 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; + } + + /* + * 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_bitmap2(ctx->inode_dir_map, + dirent->inode))) { + if (e2fsck_dir_info_get_parent(ctx, dirent->inode, + &subdir_parent)) { + 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 { + (void) e2fsck_dir_info_set_parent(ctx, + dirent->inode, 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); + e2fsck_rehash_dir_later(ctx, 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; + if (dir_modified) + (void) ext2fs_get_rec_len(fs, dirent, &rec_len); + if (!inline_data_size || dot_state > 1) { + offset += rec_len; + } else { + if (dot_state == 1) { + offset = 4; + /* + * If we get here, we're checking an inline + * directory and we've just checked a (fake) + * dotdot entry that we created on the stack. + * Therefore set 'prev' to NULL so that if we + * call salvage_directory on the next entry, + * it won't try to absorb the next entry into + * the on-stack dotdot entry. + */ + prev = NULL; + } + } + dot_state++; + } while (offset < max_block_size); +#if 0 + printf("\n"); +#endif + 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, failed_csum); + } + + if (offset != max_block_size) { + cd->pctx.num = rec_len + offset - max_block_size; + if (fix_problem(ctx, PR_2_FINAL_RECLEN, &cd->pctx)) { + dirent->rec_len = cd->pctx.num; + dir_modified++; + } + } + if (dir_modified) { + int flags, will_rehash; + /* leaf block with no tail? Rehash dirs later. */ + if (ext2fs_has_feature_metadata_csum(fs->super) && + is_leaf && + !inline_data_size && + !ext2fs_dirent_has_tail(fs, (struct ext2_dir_entry *)buf)) { + if (insert_dirent_tail(fs, buf) == 0) + goto write_and_fix; + e2fsck_rehash_dir_later(ctx, ino); + } + +write_and_fix: + will_rehash = e2fsck_dir_will_be_rehashed(ctx, ino); + if (will_rehash) { + flags = ctx->fs->flags; + ctx->fs->flags |= EXT2_FLAG_IGNORE_CSUM_ERRORS; + } + if (inline_data_size) { + buf = ibuf; +#ifdef WORDS_BIGENDIAN + if (db->blockcnt) + goto skip_first_write_swab; + *((__u32 *)buf) = ext2fs_le32_to_cpu(*((__u32 *)buf)); + cd->pctx.errcode = ext2fs_dirent_swab_out2(fs, + buf + EXT4_INLINE_DATA_DOTDOT_SIZE, + EXT4_MIN_INLINE_DATA_SIZE - + EXT4_INLINE_DATA_DOTDOT_SIZE, + 0); + if (cd->pctx.errcode) + goto skip_second_write_swab; +skip_first_write_swab: + if (inline_data_size <= EXT4_MIN_INLINE_DATA_SIZE || + !db->blockcnt) + goto skip_second_write_swab; + cd->pctx.errcode = ext2fs_dirent_swab_out2(fs, + buf + EXT4_MIN_INLINE_DATA_SIZE, + inline_data_size - + EXT4_MIN_INLINE_DATA_SIZE, + 0); +skip_second_write_swab: + if (cd->pctx.errcode && + !fix_problem(ctx, PR_2_WRITE_DIRBLOCK, &cd->pctx)) + goto abort_free_dict; +#endif + cd->pctx.errcode = + ext2fs_inline_data_set(fs, ino, 0, buf, + inline_data_size); + } else + cd->pctx.errcode = ext2fs_write_dir_block4(fs, block_nr, + buf, 0, ino); + if (will_rehash) + ctx->fs->flags = (flags & + EXT2_FLAG_IGNORE_CSUM_ERRORS) | + (ctx->fs->flags & + ~EXT2_FLAG_IGNORE_CSUM_ERRORS); + if (cd->pctx.errcode) { + if (!fix_problem(ctx, PR_2_WRITE_DIRBLOCK, + &cd->pctx)) + goto abort_free_dict; + } + ext2fs_mark_changed(fs); + } else if (is_leaf && failed_csum && !dir_modified) { + /* + * If a leaf node that fails csum makes it this far without + * alteration, ask the user if the checksum should be fixed. + */ + if (fix_problem(ctx, PR_2_LEAF_NODE_ONLY_CSUM_INVALID, + &cd->pctx)) + goto write_and_fix; + } + dict_free_nodes(&de_dict); + return 0; +abort_free_dict: + ctx->flags |= E2F_FLAG_ABORT; + dict_free_nodes(&de_dict); + return DIRENT_ABORT; +} + +struct del_block { + e2fsck_t ctx; + e2_blkcnt_t num; + blk64_t last_cluster; +}; + +/* + * This function is called to deallocate a block, and is an iterator + * functioned called by deallocate inode via ext2fs_iterate_block(). + */ +static int deallocate_inode_block(ext2_filsys fs, + blk64_t *block_nr, + e2_blkcnt_t blockcnt EXT2FS_ATTR((unused)), + blk64_t ref_block EXT2FS_ATTR((unused)), + int ref_offset EXT2FS_ATTR((unused)), + void *priv_data) +{ + struct del_block *p = priv_data; + blk64_t cluster = EXT2FS_B2C(fs, *block_nr); + + if (*block_nr == 0) + return 0; + + if (cluster == p->last_cluster) + return 0; + + p->last_cluster = cluster; + if ((*block_nr < fs->super->s_first_data_block) || + (*block_nr >= ext2fs_blocks_count(fs->super))) + return 0; + + ext2fs_block_alloc_stats2(fs, *block_nr, -1); + p->num++; + return 0; +} + +/* + * This function 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; + struct del_block del_block; + + e2fsck_read_inode(ctx, ino, &inode, "deallocate_inode"); + clear_problem_context(&pctx); + pctx.ino = ino; + + /* + * Fix up the bitmaps... + */ + e2fsck_read_bitmaps(ctx); + ext2fs_inode_alloc_stats2(fs, ino, -1, LINUX_S_ISDIR(inode.i_mode)); + + if (ext2fs_file_acl_block(fs, &inode) && + ext2fs_has_feature_xattr(fs->super)) { + pctx.errcode = ext2fs_adjust_ea_refcount3(fs, + ext2fs_file_acl_block(fs, &inode), + block_buf, -1, &count, ino); + if (pctx.errcode == EXT2_ET_BAD_EA_BLOCK_NUM) { + pctx.errcode = 0; + count = 1; + } + if (pctx.errcode) { + pctx.blk = ext2fs_file_acl_block(fs, &inode); + fix_problem(ctx, PR_2_ADJ_EA_REFCOUNT, &pctx); + ctx->flags |= E2F_FLAG_ABORT; + return; + } + if (count == 0) { + ext2fs_block_alloc_stats2(fs, + ext2fs_file_acl_block(fs, &inode), -1); + } + ext2fs_file_acl_block_set(fs, &inode, 0); + } + + if (!ext2fs_inode_has_valid_blocks2(fs, &inode)) + goto clear_inode; + + /* Inline data inodes don't have blocks to iterate */ + if (inode.i_flags & EXT4_INLINE_DATA_FL) + goto clear_inode; + + if (ext2fs_needs_large_file_feature(EXT2_I_SIZE(&inode))) { + if (LINUX_S_ISREG(inode.i_mode)) + ctx->large_files--; + else if (LINUX_S_ISDIR(inode.i_mode)) + ctx->large_dirs--; + } + + del_block.ctx = ctx; + del_block.num = 0; + del_block.last_cluster = 0; + pctx.errcode = ext2fs_block_iterate3(fs, ino, 0, block_buf, + deallocate_inode_block, + &del_block); + if (pctx.errcode) { + fix_problem(ctx, PR_2_DEALLOC_INODE, &pctx); + ctx->flags |= E2F_FLAG_ABORT; + return; + } +clear_inode: + /* Inode may have changed by block_iterate, so reread it */ + e2fsck_read_inode(ctx, ino, &inode, "deallocate_inode"); + e2fsck_clear_inode(ctx, ino, &inode, 0, "deallocate_inode"); +} + +/* + * This function 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); +} + + +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; + problem_t 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 (ext2fs_file_acl_block(fs, &inode) && + !ext2fs_has_feature_xattr(fs->super)) { + if (fix_problem(ctx, PR_2_FILE_ACL_ZERO, &pctx)) { + ext2fs_file_acl_block_set(fs, &inode, 0); + 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, ino, &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_HURD: + frag = &inode.osd2.hurd2.h_i_frag; + fsize = &inode.osd2.hurd2.h_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 ((fs->super->s_creator_os == EXT2_OS_LINUX) && + !ext2fs_has_feature_huge_file(fs->super) && + (inode.osd2.linux2.l_i_blocks_hi != 0)) { + pctx.num = inode.osd2.linux2.l_i_blocks_hi; + if (fix_problem(ctx, PR_2_BLOCKS_HI_ZERO, &pctx)) { + inode.osd2.linux2.l_i_blocks_hi = 0; + inode_modified++; + } + } + + if ((fs->super->s_creator_os == EXT2_OS_LINUX) && + !ext2fs_has_feature_64bit(fs->super) && + inode.osd2.linux2.l_i_file_acl_high != 0) { + pctx.num = inode.osd2.linux2.l_i_file_acl_high; + if (fix_problem(ctx, PR_2_I_FILE_ACL_HI_ZERO, &pctx)) { + inode.osd2.linux2.l_i_file_acl_high = 0; + inode_modified++; + } else + not_fixed++; + } + + if (ext2fs_file_acl_block(fs, &inode) && + ((ext2fs_file_acl_block(fs, &inode) < fs->super->s_first_data_block) || + (ext2fs_file_acl_block(fs, &inode) >= ext2fs_blocks_count(fs->super)))) { + if (fix_problem(ctx, PR_2_FILE_ACL_BAD, &pctx)) { + ext2fs_file_acl_block_set(fs, &inode, 0); + inode_modified++; + } else + not_fixed++; + } + if (inode.i_size_high && !ext2fs_has_feature_largedir(fs->super) && + inode.i_blocks < 1ULL << (29 - EXT2_BLOCK_SIZE_BITS(fs->super)) && + LINUX_S_ISDIR(inode.i_mode)) { + if (fix_problem(ctx, PR_2_DIR_SIZE_HIGH_ZERO, &pctx)) { + inode.i_size_high = 0; + inode_modified++; + } else + not_fixed++; + } + + if (inode_modified) + e2fsck_write_inode(ctx, ino, &inode, "process_bad_inode"); + if (!not_fixed && ctx->inode_bad_map) + ext2fs_unmark_inode_bitmap2(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_entry2 *db, + char *buf EXT2FS_ATTR((unused)), + struct problem_context *pctx) +{ + ext2_filsys fs = ctx->fs; + blk64_t blk = 0; + 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 + */ + e2fsck_read_inode(ctx, db->ino, &inode, "allocate_dir_block"); + pctx->errcode = ext2fs_map_cluster_block(fs, db->ino, &inode, + db->blockcnt, &blk); + if (pctx->errcode || blk == 0) { + blk = ext2fs_find_inode_goal(fs, db->ino, &inode, db->blockcnt); + pctx->errcode = ext2fs_new_block2(fs, blk, + 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_bitmap2(ctx->block_found_map, blk); + ext2fs_mark_block_bitmap2(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_block4(fs, blk, block, 0, db->ino); + 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 + */ + ext2fs_iblk_add_blocks(fs, &inode, 1); + if (EXT2_I_SIZE(&inode) < ((__u64) db->blockcnt+1) * fs->blocksize) { + pctx->errcode = ext2fs_inode_size_set(fs, &inode, + (db->blockcnt+1) * fs->blocksize); + if (pctx->errcode) { + pctx->str = "ext2fs_inode_size_set"; + fix_problem(ctx, PR_2_ALLOC_DIRBOCK, pctx); + return 1; + } + } + e2fsck_write_inode(ctx, db->ino, &inode, "allocate_dir_block"); + + /* + * Finally, update the block pointers for the inode + */ + db->blk = blk; + pctx->errcode = ext2fs_bmap2(fs, db->ino, &inode, 0, BMAP_SET, + db->blockcnt, 0, &blk); + if (pctx->errcode) { + pctx->str = "ext2fs_block_iterate"; + fix_problem(ctx, PR_2_ALLOC_DIRBOCK, pctx); + return 1; + } + + return 0; +} diff --git a/e2fsck/pass3.c b/e2fsck/pass3.c new file mode 100644 index 0000000..16d243f --- /dev/null +++ b/e2fsck/pass3.c @@ -0,0 +1,921 @@ +/* + * 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 iterates 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 order 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. + */ + +#include "config.h" +#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, ext2_ino_t ino, + struct problem_context *pctx); +static void fix_dotdot(e2fsck_t ctx, ext2_ino_t ino, 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; + struct dir_info_iter *iter = NULL; +#ifdef RESOURCE_TRACK + struct resource_track rtrack; +#endif + struct problem_context pctx; + struct dir_info *dir; + unsigned long maxdirs, count; + + init_resource_track(&rtrack, ctx->fs->io); + 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 = e2fsck_allocate_inode_bitmap(fs, _("inode done bitmap"), + EXT2FS_BMAP64_AUTODIR, + "inode_done_map", &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; + } + print_resource_track(ctx, _("Peak memory"), &ctx->global_rtrack, NULL); + + check_root(ctx); + if (ctx->flags & E2F_FLAG_SIGNAL_MASK) + goto abort_exit; + + ext2fs_mark_inode_bitmap2(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; + + iter = e2fsck_dir_info_iter_begin(ctx); + while ((dir = e2fsck_dir_info_iter(ctx, iter)) != 0) { + if (ctx->flags & E2F_FLAG_SIGNAL_MASK || + ctx->flags & E2F_FLAG_RESTART) + goto abort_exit; + if (ctx->progress && (ctx->progress)(ctx, 3, count++, maxdirs)) + goto abort_exit; + if (ext2fs_test_inode_bitmap2(ctx->inode_dir_map, dir->ino)) + if (check_directory(ctx, dir->ino, &pctx)) + goto abort_exit; + } + + /* + * Force the creation of /lost+found if not present + */ + if ((ctx->options & 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: + if (iter) + e2fsck_dir_info_iter_end(ctx, iter); + 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; + } + + if (ctx->lnf_repair_block) { + ext2fs_unmark_block_bitmap2(ctx->block_found_map, + ctx->lnf_repair_block); + ctx->lnf_repair_block = 0; + } + if (ctx->root_repair_block) { + ext2fs_unmark_block_bitmap2(ctx->block_found_map, + ctx->root_repair_block); + ctx->root_repair_block = 0; + } + + print_resource_track(ctx, _("Pass 3"), &rtrack, ctx->fs->io); +} + +/* + * 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; + blk64_t blk; + struct ext2_inode_large inode; + struct ext2_inode *iptr = (struct ext2_inode *) &inode; + char * block; + struct problem_context pctx; + + clear_problem_context(&pctx); + + if (ext2fs_test_inode_bitmap2(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_bitmap2(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 + */ + if (ctx->root_repair_block) { + blk = ctx->root_repair_block; + ctx->root_repair_block = 0; + goto skip_new_block; + } + pctx.errcode = ext2fs_new_block2(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_bitmap2(ctx->block_found_map, blk); +skip_new_block: + ext2fs_mark_block_bitmap2(fs->block_map, blk); + ext2fs_mark_bb_dirty(fs); + + /* + * 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 = ctx->now; + inode.i_links_count = 2; + ext2fs_iblk_set(fs, iptr, 1); + inode.i_block[0] = blk; + inode.i_extra_isize = sizeof(struct ext2_inode_large) - + EXT2_GOOD_OLD_INODE_SIZE; + + /* + * Write out the inode. + */ + pctx.errcode = ext2fs_write_new_inode(fs, EXT2_ROOT_INO, iptr); + if (pctx.errcode) { + pctx.str = "ext2fs_write_inode"; + fix_problem(ctx, PR_3_CREATE_ROOT_ERROR, &pctx); + ctx->flags |= E2F_FLAG_ABORT; + return; + } + + /* + * Now let's create the actual data block for the inode. + * Due to metadata_csum, we must write the dir blocks AFTER + * the inode has been written to disk! + */ + 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_block4(fs, blk, block, 0, + EXT2_ROOT_INO); + ext2fs_free_mem(&block); + if (pctx.errcode) { + pctx.str = "ext2fs_write_dir_block4"; + 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_bitmap2(ctx->inode_used_map, EXT2_ROOT_INO); + ext2fs_mark_inode_bitmap2(ctx->inode_dir_map, EXT2_ROOT_INO); + ext2fs_mark_inode_bitmap2(fs->inode_map, EXT2_ROOT_INO); + ext2fs_mark_ib_dirty(fs); + quota_data_add(ctx->qctx, &inode, EXT2_ROOT_INO, + EXT2_CLUSTER_SIZE(fs->super)); + quota_data_inodes(ctx->qctx, &inode, EXT2_ROOT_INO, +1); +} + +/* + * 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, ext2_ino_t dir, + struct problem_context *pctx) +{ + ext2_filsys fs = ctx->fs; + ext2_ino_t ino = dir, parent; + int loop_pass = 0, parent_count = 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_bitmap2(inode_done_map, ino)) + break; + + if (e2fsck_dir_info_get_parent(ctx, ino, &parent)) { + fix_problem(ctx, PR_3_NO_DIRINFO, pctx); + return 0; + } + + /* + * 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 (!parent || + (loop_pass && + ext2fs_test_inode_bitmap2(inode_loop_detect, parent))) { + pctx->ino = ino; + if (parent) + pctx->dir = parent; + else + (void) ext2fs_lookup(fs, ino, "..", 2, NULL, + &pctx->dir); + if (fix_problem(ctx, !parent ? PR_3_UNCONNECTED_DIR : + PR_3_LOOPED_DIR, pctx)) { + if (e2fsck_reconnect_file(ctx, pctx->ino)) { + ext2fs_unmark_valid(fs); + } else { + fix_dotdot(ctx, pctx->ino, + ctx->lost_and_found); + parent = ctx->lost_and_found; + } + } + break; + } + ino = parent; + if (loop_pass) { + ext2fs_mark_inode_bitmap2(inode_loop_detect, 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 = e2fsck_allocate_inode_bitmap(fs, _("inode loop detection bitmap"), EXT2FS_BMAP64_AUTODIR, "inode_loop_detect", &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; + } + } + ino = dir; + } + } + + /* + * Make sure that .. and the parent directory are the same; + * offer to fix it if not. + */ + pctx->ino = dir; + if (e2fsck_dir_info_get_dotdot(ctx, dir, &pctx->ino2) || + e2fsck_dir_info_get_parent(ctx, dir, &pctx->dir)) { + fix_problem(ctx, PR_3_NO_DIRINFO, pctx); + return 0; + } + if (pctx->ino2 != pctx->dir) { + if (fix_problem(ctx, PR_3_BAD_DOT_DOT, pctx)) + fix_dotdot(ctx, dir, pctx->dir); + } + 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; + blk64_t blk; + errcode_t retval; + struct ext2_inode_large inode; + char * block; + static const char name[] = "lost+found"; + struct problem_context pctx; + int will_rehash, flags; + + if (ctx->lost_and_found) + return ctx->lost_and_found; + + clear_problem_context(&pctx); + + will_rehash = e2fsck_dir_will_be_rehashed(ctx, EXT2_ROOT_INO); + if (will_rehash) { + flags = ctx->fs->flags; + ctx->fs->flags |= EXT2_FLAG_IGNORE_CSUM_ERRORS; + } + retval = ext2fs_lookup(fs, EXT2_ROOT_INO, name, + sizeof(name)-1, 0, &ino); + if (will_rehash) + ctx->fs->flags = (flags & EXT2_FLAG_IGNORE_CSUM_ERRORS) | + (ctx->fs->flags & ~EXT2_FLAG_IGNORE_CSUM_ERRORS); + if (retval && !fix) + return 0; + if (!retval) { + /* Lost+found shouldn't have inline data */ + retval = ext2fs_read_inode_full(fs, ino, EXT2_INODE(&inode), + sizeof(inode)); + if (fix && retval) + return 0; + + if (fix && (inode.i_flags & EXT4_INLINE_DATA_FL)) { + if (!fix_problem(ctx, PR_3_LPF_INLINE_DATA, &pctx)) + return 0; + goto unlink; + } + + if (fix && (inode.i_flags & EXT4_ENCRYPT_FL)) { + if (!fix_problem(ctx, PR_3_LPF_ENCRYPTED, &pctx)) + return 0; + goto unlink; + } + + if (ext2fs_check_directory(fs, ino) == 0) { + 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; + +unlink: + /* 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; + } + (void) e2fsck_dir_info_set_parent(ctx, ino, 0); + e2fsck_adjust_inode_count(ctx, ino, -1); + /* + * If the old lost+found was a directory, we've just + * disconnected it from the directory tree, which + * means we need to restart the directory tree scan. + * The simplest way to do this is restart the whole + * e2fsck operation. + */ + if (LINUX_S_ISDIR(inode.i_mode)) + ctx->flags |= E2F_FLAG_RESTART; + } 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 + */ + if (ctx->lnf_repair_block) { + blk = ctx->lnf_repair_block; + ctx->lnf_repair_block = 0; + goto skip_new_block; + } + retval = ext2fs_new_block2(fs, 0, ctx->block_found_map, &blk); + if (retval == EXT2_ET_BLOCK_ALLOC_FAIL && + fix_problem(ctx, PR_3_LPF_NO_SPACE, &pctx)) { + fix_problem(ctx, PR_3_NO_SPACE_TO_RECOVER, &pctx); + ctx->lost_and_found = EXT2_ROOT_INO; + return 0; + } + if (retval) { + pctx.errcode = retval; + fix_problem(ctx, PR_3_ERR_LPF_NEW_BLOCK, &pctx); + return 0; + } + ext2fs_mark_block_bitmap2(ctx->block_found_map, blk); +skip_new_block: + ext2fs_block_alloc_stats2(fs, blk, +1); + + /* + * Next find a free inode. + */ + retval = ext2fs_new_inode(fs, EXT2_ROOT_INO, 040700, + ctx->inode_used_map, &ino); + if (retval == EXT2_ET_INODE_ALLOC_FAIL && + fix_problem(ctx, PR_3_LPF_NO_SPACE, &pctx)) { + fix_problem(ctx, PR_3_NO_SPACE_TO_RECOVER, &pctx); + ctx->lost_and_found = EXT2_ROOT_INO; + return 0; + } + if (retval) { + pctx.errcode = retval; + fix_problem(ctx, PR_3_ERR_LPF_NEW_INODE, &pctx); + return 0; + } + ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino); + ext2fs_mark_inode_bitmap2(ctx->inode_dir_map, ino); + ext2fs_inode_alloc_stats2(fs, ino, +1, 1); + + /* + * 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 = ctx->now; + inode.i_links_count = 2; + ext2fs_iblk_set(fs, EXT2_INODE(&inode), 1); + inode.i_block[0] = blk; + + /* + * Next, write out the inode. + */ + pctx.errcode = ext2fs_write_new_inode(fs, ino, EXT2_INODE(&inode)); + if (pctx.errcode) { + pctx.str = "ext2fs_write_inode"; + fix_problem(ctx, PR_3_CREATE_LPF_ERROR, &pctx); + return 0; + } + + /* + * Now let's create the actual data block for the inode. + * Due to metadata_csum, the directory block MUST be written + * after the inode is written to disk! + */ + 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_block4(fs, blk, block, 0, ino); + ext2fs_free_mem(&block); + if (retval) { + pctx.errcode = retval; + fix_problem(ctx, PR_3_ERR_LPF_WRITE_BLOCK, &pctx); + return 0; + } + + /* + * Finally, create the directory link + */ + pctx.errcode = ext2fs_link(fs, EXT2_ROOT_INO, name, ino, EXT2_FT_DIR); + if (pctx.errcode == EXT2_ET_DIR_NO_SPACE) { + pctx.errcode = ext2fs_expand_dir(fs, EXT2_ROOT_INO); + if (pctx.errcode) + goto link_error; + pctx.errcode = ext2fs_link(fs, EXT2_ROOT_INO, name, ino, + EXT2_FT_DIR); + } + if (pctx.errcode) { +link_error: + 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; + quota_data_add(ctx->qctx, &inode, ino, EXT2_CLUSTER_SIZE(fs->super)); + quota_data_inodes(ctx->qctx, &inode, ino, +1); +#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 (ext2fs_dirent_name_len(dirent) != 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; + if (ext2fs_has_feature_filetype(fp->ctx->fs->super)) + ext2fs_dirent_set_file_type(dirent, EXT2_FT_DIR); + else + ext2fs_dirent_set_file_type(dirent, EXT2_FT_UNKNOWN); + + fp->done++; + return DIRENT_ABORT | DIRENT_CHANGED; +} + +static void fix_dotdot(e2fsck_t ctx, ext2_ino_t ino, ext2_ino_t parent) +{ + ext2_filsys fs = ctx->fs; + errcode_t retval; + struct fix_dotdot_struct fp; + struct problem_context pctx; + int flags, will_rehash; + + fp.fs = fs; + fp.parent = parent; + fp.done = 0; + fp.ctx = ctx; + +#if 0 + printf("Fixing '..' of inode %lu to be %lu...\n", ino, parent); +#endif + + clear_problem_context(&pctx); + pctx.ino = ino; + will_rehash = e2fsck_dir_will_be_rehashed(ctx, ino); + if (will_rehash) { + flags = ctx->fs->flags; + ctx->fs->flags |= EXT2_FLAG_IGNORE_CSUM_ERRORS; + } + retval = ext2fs_dir_iterate(fs, ino, DIRENT_FLAG_INCLUDE_EMPTY, + 0, fix_dotdot_proc, &fp); + if (will_rehash) + ctx->fs->flags = (flags & EXT2_FLAG_IGNORE_CSUM_ERRORS) | + (ctx->fs->flags & ~EXT2_FLAG_IGNORE_CSUM_ERRORS); + if (retval || !fp.done) { + pctx.errcode = retval; + fix_problem(ctx, retval ? PR_3_FIX_PARENT_ERR : + PR_3_FIX_PARENT_NOFIND, &pctx); + ext2fs_unmark_valid(fs); + } + (void) e2fsck_dir_info_set_dotdot(ctx, ino, parent); + if (e2fsck_dir_info_set_parent(ctx, ino, ctx->lost_and_found)) + fix_problem(ctx, PR_3_NO_DIRINFO, &pctx); + + return; +} + +/* + * These routines are responsible for expanding a /lost+found if it is + * too small. + */ + +struct expand_dir_struct { + blk64_t num; + e2_blkcnt_t guaranteed_size; + blk64_t newblocks; + blk64_t last_block; + errcode_t err; + e2fsck_t ctx; + ext2_ino_t dir; +}; + +static int expand_dir_proc(ext2_filsys fs, + blk64_t *blocknr, + e2_blkcnt_t blockcnt, + blk64_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; + blk64_t new_blk; + static blk64_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; + } + + if (blockcnt && + (EXT2FS_B2C(fs, last_blk) == EXT2FS_B2C(fs, last_blk + 1))) + new_blk = last_blk + 1; + else { + last_blk &= ~EXT2FS_CLUSTER_MASK(fs); + retval = ext2fs_new_block2(fs, last_blk, ctx->block_found_map, + &new_blk); + if (retval) { + es->err = retval; + return BLOCK_ABORT; + } + es->newblocks++; + ext2fs_block_alloc_stats2(fs, new_blk, +1); + } + last_blk = new_blk; + + 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_block4(fs, new_blk, block, 0, + es->dir); + ext2fs_free_mem(&block); + } else + retval = ext2fs_zero_blocks2(fs, new_blk, 1, NULL, NULL); + if (retval) { + es->err = retval; + return BLOCK_ABORT; + } + *blocknr = new_blk; + ext2fs_mark_block_bitmap2(ctx->block_found_map, new_blk); + + 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_large inode; + blk64_t sz; + + 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; + es.dir = dir; + + retval = ext2fs_block_iterate3(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_full(fs, dir, + EXT2_INODE(&inode), sizeof(inode)); + if (retval) + return retval; + + sz = (es.last_block + 1) * fs->blocksize; + retval = ext2fs_inode_size_set(fs, EXT2_INODE(&inode), sz); + if (retval) + return retval; + ext2fs_iblk_add_blocks(fs, EXT2_INODE(&inode), es.newblocks); + quota_data_add(ctx->qctx, &inode, dir, + es.newblocks * EXT2_CLUSTER_SIZE(fs->super)); + + e2fsck_write_inode_full(ctx, dir, EXT2_INODE(&inode), + sizeof(inode), "expand_directory"); + + return 0; +} + diff --git a/e2fsck/pass4.c b/e2fsck/pass4.c new file mode 100644 index 0000000..d2dda02 --- /dev/null +++ b/e2fsck/pass4.c @@ -0,0 +1,302 @@ +/* + * 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) + * - Ref counts for ea_inodes. (ea_inode_refs) + */ + +#include "config.h" +#include "e2fsck.h" +#include "problem.h" +#include + +/* + * 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_ino_t *last_ino, + struct ext2_inode_large *inode) +{ + ext2_filsys fs = ctx->fs; + struct problem_context pctx; + __u32 eamagic = 0; + int extra_size = 0; + + if (*last_ino != i) { + e2fsck_read_inode_full(ctx, i, EXT2_INODE(inode), + EXT2_INODE_SIZE(fs->super), + "pass4: disconnect_inode"); + *last_ino = i; + } + if (EXT2_INODE_SIZE(fs->super) > EXT2_GOOD_OLD_INODE_SIZE) + extra_size = inode->i_extra_isize; + + clear_problem_context(&pctx); + pctx.ino = i; + pctx.inode = EXT2_INODE(inode); + + if (EXT2_INODE_SIZE(fs->super) -EXT2_GOOD_OLD_INODE_SIZE -extra_size >0) + eamagic = *(__u32 *)(((char *)inode) +EXT2_GOOD_OLD_INODE_SIZE + + extra_size); + /* + * 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 && eamagic != EXT2_EXT_ATTR_MAGIC && + (LINUX_S_ISREG(inode->i_mode) || LINUX_S_ISDIR(inode->i_mode))) { + if (fix_problem(ctx, PR_4_ZERO_LEN_INODE, &pctx)) { + e2fsck_clear_inode(ctx, i, EXT2_INODE(inode), 0, + "disconnect_inode"); + /* + * Fix up the bitmaps... + */ + e2fsck_read_bitmaps(ctx); + ext2fs_inode_alloc_stats2(fs, i, -1, + LINUX_S_ISDIR(inode->i_mode)); + quota_data_inodes(ctx->qctx, inode, i, -1); + return 0; + } + } + + /* + * Prompt to reconnect. + */ + if (fix_problem(ctx, PR_4_UNATTACHED_INODE, &pctx)) { + if (e2fsck_reconnect_file(ctx, i)) + ext2fs_unmark_valid(fs); + *last_ino = 0; + } 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; +} + +/* + * This function is called when link_counted is zero. So this may not be + * an xattr inode at all. Return immediately if EA_INODE flag is not set. + */ +static void check_ea_inode(e2fsck_t ctx, ext2_ino_t i, ext2_ino_t *last_ino, + struct ext2_inode_large *inode, __u16 *link_counted) +{ + __u64 actual_refs = 0; + __u64 ref_count; + + if (*last_ino != i) { + e2fsck_read_inode_full(ctx, i, EXT2_INODE(inode), + EXT2_INODE_SIZE(ctx->fs->super), + "pass4: check_ea_inode"); + *last_ino = i; + } + if (!(inode->i_flags & EXT4_EA_INODE_FL)) + return; + + if (ctx->ea_inode_refs) + ea_refcount_fetch(ctx->ea_inode_refs, i, &actual_refs); + if (!actual_refs) + return; + + /* + * There are some attribute references, link_counted is now considered + * to be 1. + */ + *link_counted = 1; + + ref_count = ext2fs_get_ea_inode_ref(EXT2_INODE(inode)); + + /* Old Lustre-style xattr inodes do not have a stored refcount. + * However, their i_ctime and i_atime should be the same. + */ + if (ref_count != actual_refs && inode->i_ctime != inode->i_atime) { + struct problem_context pctx; + + clear_problem_context(&pctx); + pctx.ino = i; + pctx.num = ref_count; + pctx.num2 = actual_refs; + if (fix_problem(ctx, PR_4_EA_INODE_REF_COUNT, &pctx)) { + ext2fs_set_ea_inode_ref(EXT2_INODE(inode), actual_refs); + e2fsck_write_inode(ctx, i, EXT2_INODE(inode), "pass4"); + } + } +} + +void e2fsck_pass4(e2fsck_t ctx) +{ + ext2_filsys fs = ctx->fs; + ext2_ino_t i; + struct ext2_inode_large *inode; + int inode_size = EXT2_INODE_SIZE(fs->super); +#ifdef RESOURCE_TRACK + struct resource_track rtrack; +#endif + struct problem_context pctx; + __u16 link_count, link_counted; + int dir_nlink_fs; + char *buf = 0; + dgrp_t group, maxgroup; + + init_resource_track(&rtrack, ctx->fs->io); + +#ifdef MTRACE + mtrace_print("Pass 4"); +#endif + /* + * Since pass4 is mostly CPU bound, start readahead of bitmaps + * ahead of pass 5 if we haven't already loaded them. + */ + if (ctx->readahead_kb && + (fs->block_map == NULL || fs->inode_map == NULL)) + e2fsck_readahead(fs, E2FSCK_READA_BBITMAP | + E2FSCK_READA_IBITMAP, + 0, fs->group_desc_count); + + clear_problem_context(&pctx); + + if (!(ctx->options & E2F_OPT_PREEN)) + fix_problem(ctx, PR_4_PASS_HEADER, &pctx); + + dir_nlink_fs = ext2fs_has_feature_dir_nlink(fs->super); + + group = 0; + maxgroup = fs->group_desc_count; + if (ctx->progress) + if ((ctx->progress)(ctx, 4, 0, maxgroup)) + return; + + inode = e2fsck_allocate_memory(ctx, inode_size, "scratch inode"); + + /* Protect loop from wrap-around if s_inodes_count maxed */ + for (i = 1; i <= fs->super->s_inodes_count && i > 0; i++) { + ext2_ino_t last_ino = 0; + int isdir; + + if (ctx->flags & E2F_FLAG_SIGNAL_MASK) + goto errout; + if ((i % fs->super->s_inodes_per_group) == 0) { + group++; + if (ctx->progress) + if ((ctx->progress)(ctx, 4, group, maxgroup)) + goto errout; + } + if (i == quota_type2inum(PRJQUOTA, ctx->fs->super) || + i == fs->super->s_orphan_file_inum || i == EXT2_BAD_INO || + (i > EXT2_ROOT_INO && i < EXT2_FIRST_INODE(fs->super))) + continue; + if (!(ext2fs_test_inode_bitmap2(ctx->inode_used_map, i)) || + (ctx->inode_imagic_map && + ext2fs_test_inode_bitmap2(ctx->inode_imagic_map, i)) || + (ctx->inode_bb_map && + ext2fs_test_inode_bitmap2(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) { + /* + * link_counted is expected to be 0 for an ea_inode. + * check_ea_inode() will update link_counted if + * necessary. + */ + check_ea_inode(ctx, i, &last_ino, inode, &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, &last_ino, inode)) + continue; + ext2fs_icount_fetch(ctx->inode_link_info, i, + &link_count); + ext2fs_icount_fetch(ctx->inode_count, i, + &link_counted); + } + isdir = ext2fs_test_inode_bitmap2(ctx->inode_dir_map, i); + if (isdir && (link_counted > EXT2_LINK_MAX)) { + if (!dir_nlink_fs && + fix_problem(ctx, PR_4_DIR_NLINK_FEATURE, &pctx)) { + ext2fs_set_feature_dir_nlink(fs->super); + ext2fs_mark_super_dirty(fs); + dir_nlink_fs = 1; + } + link_counted = 1; + } + if (link_counted != link_count) { + int fix_nlink = 0; + + if (last_ino != i) { + e2fsck_read_inode_full(ctx, i, + EXT2_INODE(inode), + inode_size, "pass4"); + last_ino = i; + } + pctx.ino = i; + pctx.inode = EXT2_INODE(inode); + if ((link_count != inode->i_links_count) && !isdir && + (inode->i_links_count <= EXT2_LINK_MAX)) { + pctx.num = link_count; + fix_problem(ctx, + PR_4_INCONSISTENT_COUNT, &pctx); + } + pctx.num = link_counted; + /* i_link_count was previously exceeded, but no longer + * is, fix this but don't consider it an error */ + if (isdir && link_counted > 1 && + (inode->i_flags & EXT2_INDEX_FL) && + link_count == 1) { + if ((ctx->options & E2F_OPT_READONLY) == 0) { + fix_nlink = + fix_problem(ctx, + PR_4_DIR_OVERFLOW_REF_COUNT, + &pctx); + } + } else { + fix_nlink = fix_problem(ctx, PR_4_BAD_REF_COUNT, + &pctx); + } + if (fix_nlink) { + inode->i_links_count = link_counted; + e2fsck_write_inode_full(ctx, i, + EXT2_INODE(inode), + inode_size, "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; + ea_refcount_free(ctx->ea_inode_refs); + ctx->ea_inode_refs = 0; + ext2fs_free_inode_bitmap(ctx->inode_imagic_map); + ctx->inode_imagic_map = 0; +errout: + if (buf) + ext2fs_free_mem(&buf); + + ext2fs_free_mem(&inode); + print_resource_track(ctx, _("Pass 4"), &rtrack, ctx->fs->io); +} + diff --git a/e2fsck/pass5.c b/e2fsck/pass5.c new file mode 100644 index 0000000..c1d45a5 --- /dev/null +++ b/e2fsck/pass5.c @@ -0,0 +1,958 @@ +/* + * 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 "config.h" +#include +#include +#include +#include +#include +#include + +#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); +static void check_inode_bitmap_checksum(e2fsck_t ctx); +static void check_block_bitmap_checksum(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 + + init_resource_track(&rtrack, ctx->fs->io); + 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; + + check_inode_bitmap_checksum(ctx); + check_block_bitmap_checksum(ctx); + + 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; + ext2fs_free_block_bitmap(ctx->block_metadata_map); + ctx->block_metadata_map = 0; + + print_resource_track(ctx, _("Pass 5"), &rtrack, ctx->fs->io); +} + +static void check_inode_bitmap_checksum(e2fsck_t ctx) +{ + struct problem_context pctx; + char *buf = NULL; + dgrp_t i; + int nbytes; + ext2_ino_t ino_itr; + errcode_t retval; + + if (!ext2fs_has_feature_metadata_csum(ctx->fs->super)) + return; + + /* If bitmap is dirty from being fixed, checksum will be corrected */ + if (ext2fs_test_ib_dirty(ctx->fs)) + return; + + nbytes = (size_t)(EXT2_INODES_PER_GROUP(ctx->fs->super) / 8); + retval = ext2fs_get_mem(ctx->fs->blocksize, &buf); + if (retval) { + com_err(ctx->program_name, 0, "%s", + _("check_inode_bitmap_checksum: Memory allocation error")); + fatal_error(ctx, 0); + } + + clear_problem_context(&pctx); + for (i = 0; i < ctx->fs->group_desc_count; i++) { + if (ext2fs_bg_flags_test(ctx->fs, i, EXT2_BG_INODE_UNINIT)) + continue; + + ino_itr = 1 + (i * (nbytes << 3)); + retval = ext2fs_get_inode_bitmap_range2(ctx->fs->inode_map, + ino_itr, nbytes << 3, + buf); + if (retval) + break; + + if (ext2fs_inode_bitmap_csum_verify(ctx->fs, i, buf, nbytes)) + continue; + pctx.group = i; + if (!fix_problem(ctx, PR_5_INODE_BITMAP_CSUM_INVALID, &pctx)) + continue; + + /* + * Fixing one checksum will rewrite all of them. The bitmap + * will be checked against the one we made during pass1 for + * discrepancies, and fixed if need be. + */ + ext2fs_mark_ib_dirty(ctx->fs); + break; + } + + ext2fs_free_mem(&buf); +} + +static void check_block_bitmap_checksum(e2fsck_t ctx) +{ + struct problem_context pctx; + char *buf = NULL; + dgrp_t i; + int nbytes; + blk64_t blk_itr; + errcode_t retval; + + if (!ext2fs_has_feature_metadata_csum(ctx->fs->super)) + return; + + /* If bitmap is dirty from being fixed, checksum will be corrected */ + if (ext2fs_test_bb_dirty(ctx->fs)) + return; + + nbytes = (size_t)(EXT2_CLUSTERS_PER_GROUP(ctx->fs->super) / 8); + retval = ext2fs_get_mem(ctx->fs->blocksize, &buf); + if (retval) { + com_err(ctx->program_name, 0, "%s", + _("check_block_bitmap_checksum: Memory allocation error")); + fatal_error(ctx, 0); + } + + clear_problem_context(&pctx); + for (i = 0; i < ctx->fs->group_desc_count; i++) { + if (ext2fs_bg_flags_test(ctx->fs, i, EXT2_BG_BLOCK_UNINIT)) + continue; + + blk_itr = EXT2FS_B2C(ctx->fs, + ctx->fs->super->s_first_data_block) + + ((blk64_t) i * (nbytes << 3)); + retval = ext2fs_get_block_bitmap_range2(ctx->fs->block_map, + blk_itr, nbytes << 3, + buf); + if (retval) + break; + + if (ext2fs_block_bitmap_csum_verify(ctx->fs, i, buf, nbytes)) + continue; + pctx.group = i; + if (!fix_problem(ctx, PR_5_BLOCK_BITMAP_CSUM_INVALID, &pctx)) + continue; + + /* + * Fixing one checksum will rewrite all of them. The bitmap + * will be checked against the one we made during pass1 for + * discrepancies, and fixed if need be. + */ + ext2fs_mark_bb_dirty(ctx->fs); + break; + } + + ext2fs_free_mem(&buf); +} + +static void e2fsck_discard_blocks(e2fsck_t ctx, blk64_t start, + blk64_t count) +{ + ext2_filsys fs = ctx->fs; + + /* + * If the filesystem has changed it means that there was an corruption + * which should be repaired, but in some cases just one e2fsck run is + * not enough to fix the problem, hence it is not safe to run discard + * in this case. + */ + if (ext2fs_test_changed(fs)) + ctx->options &= ~E2F_OPT_DISCARD; + + if ((ctx->options & E2F_OPT_DISCARD) && + (io_channel_discard(fs->io, start, count))) + ctx->options &= ~E2F_OPT_DISCARD; +} + +/* + * This will try to discard number 'count' inodes starting at + * inode number 'start' within the 'group'. Note that 'start' + * is 1-based, it means that we need to adjust it by -1 in this + * function to compute right offset in the particular inode table. + */ +static void e2fsck_discard_inodes(e2fsck_t ctx, dgrp_t group, + ext2_ino_t start, int count) +{ + ext2_filsys fs = ctx->fs; + blk64_t blk, num; + + /* + * Sanity check for 'start' + */ + if ((start < 1) || (start > EXT2_INODES_PER_GROUP(fs->super))) { + printf("PROGRAMMING ERROR: Got start %d outside of group %d!" + " Disabling discard\n", + start, group); + ctx->options &= ~E2F_OPT_DISCARD; + } + + /* + * Do not attempt to discard if E2F_OPT_DISCARD is not set. And also + * skip the discard on this group if discard does not zero data. + * The reason is that if the inode table is not zeroed discard would + * no help us since we need to zero it anyway, or if the inode table + * is zeroed then the read after discard would not be deterministic + * anyway and we would not be able to assume that this inode table + * was zeroed anymore so we would have to zero it again, which does + * not really make sense. + */ + if (!(ctx->options & E2F_OPT_DISCARD) || + !io_channel_discard_zeroes_data(fs->io)) + return; + + /* + * Start is inode number within the group which starts + * counting from 1, so we need to adjust it. + */ + start -= 1; + + /* + * We can discard only blocks containing only unused + * inodes in the table. + */ + blk = DIV_ROUND_UP(start, + EXT2_INODES_PER_BLOCK(fs->super)); + count -= (blk * EXT2_INODES_PER_BLOCK(fs->super) - start); + blk += ext2fs_inode_table_loc(fs, group); + num = count / EXT2_INODES_PER_BLOCK(fs->super); + + if (num > 0) + e2fsck_discard_blocks(ctx, blk, num); +} + +#define NO_BLK ((blk64_t) -1) + +static void print_bitmap_problem(e2fsck_t ctx, problem_t 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; +} + +/* Just to be more succinct */ +#define B2C(x) EXT2FS_B2C(fs, (x)) +#define EQ_CLSTR(x, y) (B2C(x) == B2C(y)) +#define LE_CLSTR(x, y) (B2C(x) <= B2C(y)) +#define GE_CLSTR(x, y) (B2C(x) >= B2C(y)) + +static void check_block_bitmaps(e2fsck_t ctx) +{ + ext2_filsys fs = ctx->fs; + blk64_t i; + unsigned int *free_array; + dgrp_t g, group = 0; + unsigned int blocks = 0; + blk64_t free_blocks = 0; + blk64_t first_free = ext2fs_blocks_count(fs->super); + unsigned int group_free = 0; + int actual, bitmap; + struct problem_context pctx; + problem_t problem, save_problem; + int fixit, had_problem; + errcode_t retval; + int redo_flag = 0; + char *actual_buf, *bitmap_buf; + + actual_buf = (char *) e2fsck_allocate_memory(ctx, fs->blocksize, + "actual bitmap buffer"); + bitmap_buf = (char *) e2fsck_allocate_memory(ctx, fs->blocksize, + "bitmap block buffer"); + + clear_problem_context(&pctx); + free_array = (unsigned int *) e2fsck_allocate_memory(ctx, + fs->group_desc_count * sizeof(unsigned int), "free block count array"); + + if ((B2C(fs->super->s_first_data_block) < + ext2fs_get_block_bitmap_start2(ctx->block_found_map)) || + (B2C(ext2fs_blocks_count(fs->super)-1) > + ext2fs_get_block_bitmap_end2(ctx->block_found_map))) { + pctx.num = 1; + pctx.blk = B2C(fs->super->s_first_data_block); + pctx.blk2 = B2C(ext2fs_blocks_count(fs->super) - 1); + pctx.ino = ext2fs_get_block_bitmap_start2(ctx->block_found_map); + pctx.ino2 = ext2fs_get_block_bitmap_end2(ctx->block_found_map); + fix_problem(ctx, PR_5_BMAP_ENDPOINTS, &pctx); + + ctx->flags |= E2F_FLAG_ABORT; /* fatal */ + goto errout; + } + + if ((B2C(fs->super->s_first_data_block) < + ext2fs_get_block_bitmap_start2(fs->block_map)) || + (B2C(ext2fs_blocks_count(fs->super)-1) > + ext2fs_get_block_bitmap_end2(fs->block_map))) { + pctx.num = 2; + pctx.blk = B2C(fs->super->s_first_data_block); + pctx.blk2 = B2C(ext2fs_blocks_count(fs->super) - 1); + pctx.ino = ext2fs_get_block_bitmap_start2(fs->block_map); + pctx.ino2 = ext2fs_get_block_bitmap_end2(fs->block_map); + fix_problem(ctx, PR_5_BMAP_ENDPOINTS, &pctx); + + ctx->flags |= E2F_FLAG_ABORT; /* fatal */ + goto errout; + } + +redo_counts: + had_problem = 0; + save_problem = 0; + pctx.blk = pctx.blk2 = NO_BLK; + for (i = B2C(fs->super->s_first_data_block); + i < ext2fs_blocks_count(fs->super); + i += EXT2FS_CLUSTER_RATIO(fs)) { + int first_block_in_bg = (B2C(i) - + B2C(fs->super->s_first_data_block)) % + fs->super->s_clusters_per_group == 0; + int n, nbytes = fs->super->s_clusters_per_group / 8; + + actual = ext2fs_fast_test_block_bitmap2(ctx->block_found_map, i); + + /* + * Try to optimize pass5 by extracting a bitmap block + * as expected from what we have on disk, and then + * comparing the two. If they are identical, then + * update the free block counts and go on to the next + * block group. This is much faster than doing the + * individual bit-by-bit comparison. The one downside + * is that this doesn't work if we are asking e2fsck + * to do a discard operation. + */ + if (!first_block_in_bg || + (group == fs->group_desc_count - 1) || + (ctx->options & E2F_OPT_DISCARD)) + goto no_optimize; + + retval = ext2fs_get_block_bitmap_range2(ctx->block_found_map, + B2C(i), fs->super->s_clusters_per_group, + actual_buf); + if (retval) + goto no_optimize; + retval = ext2fs_get_block_bitmap_range2(fs->block_map, + B2C(i), fs->super->s_clusters_per_group, + bitmap_buf); + if (retval) + goto no_optimize; + if (memcmp(actual_buf, bitmap_buf, nbytes) != 0) + goto no_optimize; + n = ext2fs_bitcount(actual_buf, nbytes); + group_free = fs->super->s_clusters_per_group - n; + free_blocks += group_free; + i += EXT2FS_C2B(fs, fs->super->s_clusters_per_group - 1); + goto next_group; + no_optimize: + + if (redo_flag) + bitmap = actual; + else + bitmap = ext2fs_fast_test_block_bitmap2(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 (ext2fs_bg_flags_test(fs, group, + EXT2_BG_BLOCK_UNINIT)) { + struct problem_context pctx2; + pctx2.blk = i; + pctx2.group = group; + if (fix_problem(ctx, PR_5_BLOCK_UNINIT, + &pctx2)) + ext2fs_bg_flags_clear(fs, group, + EXT2_BG_BLOCK_UNINIT); + } + } + if (pctx.blk == NO_BLK) { + pctx.blk = pctx.blk2 = i; + save_problem = problem; + } else { + if ((problem == save_problem) && + (pctx.blk2 == i - EXT2FS_CLUSTER_RATIO(fs))) + pctx.blk2 += EXT2FS_CLUSTER_RATIO(fs); + else { + print_bitmap_problem(ctx, save_problem, &pctx); + pctx.blk = pctx.blk2 = i; + save_problem = problem; + } + } + ctx->flags |= E2F_FLAG_PROG_SUPPRESS; + had_problem++; + + /* + * If there a problem we should turn off the discard so we + * do not compromise the filesystem. + */ + ctx->options &= ~E2F_OPT_DISCARD; + + do_counts: + if (!bitmap) { + group_free++; + free_blocks++; + if (first_free > i) + first_free = i; + } else if (i > first_free) { + e2fsck_discard_blocks(ctx, first_free, + (i - first_free)); + first_free = ext2fs_blocks_count(fs->super); + } + blocks ++; + if ((blocks == fs->super->s_clusters_per_group) || + (EXT2FS_B2C(fs, i) == + EXT2FS_B2C(fs, ext2fs_blocks_count(fs->super)-1))) { + /* + * If the last block of this group is free, then we can + * discard it as well. + */ + if (!bitmap && i >= first_free) + e2fsck_discard_blocks(ctx, first_free, + (i - first_free) + 1); + next_group: + first_free = ext2fs_blocks_count(fs->super); + + 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)) + goto errout; + } + } + 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; + goto errout; + } + 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)); + redo_flag++; + goto redo_counts; + } else if (fixit == 0) + ext2fs_unmark_valid(fs); + + for (g = 0; g < fs->group_desc_count; g++) { + if (free_array[g] != ext2fs_bg_free_blocks_count(fs, g)) { + pctx.group = g; + pctx.blk = ext2fs_bg_free_blocks_count(fs, g); + pctx.blk2 = free_array[g]; + + if (fix_problem(ctx, PR_5_FREE_BLOCK_COUNT_GROUP, + &pctx)) { + ext2fs_bg_free_blocks_count_set(fs, g, free_array[g]); + ext2fs_mark_super_dirty(fs); + } else + ext2fs_unmark_valid(fs); + } + } + free_blocks = EXT2FS_C2B(fs, free_blocks); + if (free_blocks != ext2fs_free_blocks_count(fs->super)) { + pctx.group = 0; + pctx.blk = ext2fs_free_blocks_count(fs->super); + pctx.blk2 = free_blocks; + + if (fix_problem(ctx, PR_5_FREE_BLOCK_COUNT, &pctx)) { + ext2fs_free_blocks_count_set(fs->super, free_blocks); + ext2fs_mark_super_dirty(fs); + } + } +errout: + ext2fs_free_mem(&free_array); + ext2fs_free_mem(&actual_buf); + ext2fs_free_mem(&bitmap_buf); +} + +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; + dgrp_t group = 0; + unsigned int inodes = 0; + ext2_ino_t *free_array; + ext2_ino_t *dir_array; + int actual, bitmap; + errcode_t retval; + struct problem_context pctx; + problem_t problem, save_problem; + int fixit, had_problem; + int csum_flag; + int skip_group = 0; + int redo_flag = 0; + ext2_ino_t first_free = fs->super->s_inodes_per_group + 1; + + clear_problem_context(&pctx); + free_array = (ext2_ino_t *) e2fsck_allocate_memory(ctx, + fs->group_desc_count * sizeof(ext2_ino_t), "free inode count array"); + + dir_array = (ext2_ino_t *) e2fsck_allocate_memory(ctx, + fs->group_desc_count * sizeof(ext2_ino_t), "directory count array"); + + if ((1 < ext2fs_get_inode_bitmap_start2(ctx->inode_used_map)) || + (fs->super->s_inodes_count > + ext2fs_get_inode_bitmap_end2(ctx->inode_used_map))) { + pctx.num = 3; + pctx.blk = 1; + pctx.blk2 = fs->super->s_inodes_count; + pctx.ino = ext2fs_get_inode_bitmap_start2(ctx->inode_used_map); + pctx.ino2 = ext2fs_get_inode_bitmap_end2(ctx->inode_used_map); + fix_problem(ctx, PR_5_BMAP_ENDPOINTS, &pctx); + + ctx->flags |= E2F_FLAG_ABORT; /* fatal */ + goto errout; + } + if ((1 < ext2fs_get_inode_bitmap_start2(fs->inode_map)) || + (fs->super->s_inodes_count > + ext2fs_get_inode_bitmap_end2(fs->inode_map))) { + pctx.num = 4; + pctx.blk = 1; + pctx.blk2 = fs->super->s_inodes_count; + pctx.ino = ext2fs_get_inode_bitmap_start2(fs->inode_map); + pctx.ino2 = ext2fs_get_inode_bitmap_end2(fs->inode_map); + fix_problem(ctx, PR_5_BMAP_ENDPOINTS, &pctx); + + ctx->flags |= E2F_FLAG_ABORT; /* fatal */ + goto errout; + } + + csum_flag = ext2fs_has_group_desc_csum(fs); +redo_counts: + had_problem = 0; + save_problem = 0; + pctx.ino = pctx.ino2 = 0; + if (csum_flag && + (ext2fs_bg_flags_test(fs, group, EXT2_BG_INODE_UNINIT))) + skip_group++; + + /* Protect loop from wrap-around if inodes_count is maxed */ + for (i = 1; i <= fs->super->s_inodes_count && i > 0; i++) { + bitmap = 0; + if (skip_group && + i % fs->super->s_inodes_per_group == 1) { + /* + * Current inode is the first inode + * in the current block group. + */ + if (ext2fs_test_inode_bitmap_range( + ctx->inode_used_map, i, + fs->super->s_inodes_per_group)) { + /* + * When the compared inodes in inodes bitmap + * are 0, count the free inode, + * skip the current block group. + */ + first_free = 1; + inodes = fs->super->s_inodes_per_group - 1; + group_free = inodes; + free_inodes += inodes; + i += inodes; + skip_group = 0; + goto do_counts; + } + } + + actual = ext2fs_fast_test_inode_bitmap2(ctx->inode_used_map, i); + if (redo_flag) + bitmap = actual; + else if (!skip_group) + bitmap = ext2fs_fast_test_inode_bitmap2(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; + + /* We should never hit this, because it means that + * inodes were marked in use that weren't noticed + * in pass1 or pass 2. It is easier to fix the problem + * than to kill e2fsck and leave the user stuck. */ + if (skip_group) { + struct problem_context pctx2; + pctx2.blk = i; + pctx2.group = group; + if (fix_problem(ctx, PR_5_INODE_UNINIT,&pctx2)){ + ext2fs_bg_flags_clear(fs, group, EXT2_BG_INODE_UNINIT); + skip_group = 0; + } + } + } + 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++; + /* + * If there a problem we should turn off the discard so we + * do not compromise the filesystem. + */ + ctx->options &= ~E2F_OPT_DISCARD; + +do_counts: + inodes++; + if (bitmap) { + if (ext2fs_test_inode_bitmap2(ctx->inode_dir_map, i)) + dirs_count++; + if (inodes > first_free) { + e2fsck_discard_inodes(ctx, group, first_free, + inodes - first_free); + first_free = fs->super->s_inodes_per_group + 1; + } + } else { + group_free++; + free_inodes++; + if (first_free > inodes) + first_free = inodes; + } + + if ((inodes == fs->super->s_inodes_per_group) || + (i == fs->super->s_inodes_count)) { + /* + * If the last inode is free, we can discard it as well. + */ + if (!bitmap && inodes >= first_free) + e2fsck_discard_inodes(ctx, group, first_free, + inodes - first_free + 1); + /* + * If discard zeroes data and the group inode table + * was not zeroed yet, set itable as zeroed + */ + if ((ctx->options & E2F_OPT_DISCARD) && + io_channel_discard_zeroes_data(fs->io) && + !(ext2fs_bg_flags_test(fs, group, + EXT2_BG_INODE_ZEROED))) { + ext2fs_bg_flags_set(fs, group, + EXT2_BG_INODE_ZEROED); + ext2fs_group_desc_csum_set(fs, group); + } + + first_free = fs->super->s_inodes_per_group + 1; + free_array[group] = group_free; + dir_array[group] = dirs_count; + group ++; + inodes = 0; + skip_group = 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)) + goto errout; + if (csum_flag && + (i != fs->super->s_inodes_count) && + (ext2fs_bg_flags_test(fs, group, EXT2_BG_INODE_UNINIT) + )) + skip_group++; + } + } + 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; + goto errout; + } + 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)); + redo_flag++; + goto redo_counts; + } else if (fixit == 0) + ext2fs_unmark_valid(fs); + + for (i = 0; i < fs->group_desc_count; i++) { + if (free_array[i] != ext2fs_bg_free_inodes_count(fs, i)) { + pctx.group = i; + pctx.ino = ext2fs_bg_free_inodes_count(fs, i); + pctx.ino2 = free_array[i]; + if (fix_problem(ctx, PR_5_FREE_INODE_COUNT_GROUP, + &pctx)) { + ext2fs_bg_free_inodes_count_set(fs, i, free_array[i]); + ext2fs_mark_super_dirty(fs); + } else + ext2fs_unmark_valid(fs); + } + if (dir_array[i] != ext2fs_bg_used_dirs_count(fs, i)) { + pctx.group = i; + pctx.ino = ext2fs_bg_used_dirs_count(fs, i); + pctx.ino2 = dir_array[i]; + + if (fix_problem(ctx, PR_5_FREE_DIR_COUNT_GROUP, + &pctx)) { + ext2fs_bg_used_dirs_count_set(fs, i, 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); + } + } +errout: + 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; + int asked = 0; + + clear_problem_context(&pctx); + + end = (__u64)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) + goto check_intra_bg_tail; + + /* protect loop from wrap-around if end is maxed */ + for (i = save_inodes_count + 1; i <= end && i > save_inodes_count; i++) { + if (!ext2fs_test_inode_bitmap(fs->inode_map, i)) { + asked = 1; + if (fix_problem(ctx, PR_5_INODE_BMAP_PADDING, &pctx)) { + for (; 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; + } + /* + * If the number of inodes per block group != blocksize, we + * can also have a potential problem with the tail bits in + * each individual inode bitmap block. If there is a problem, + * it would have been noticed when the bitmap was loaded. And + * fixing this is easy; all we need to do force the bitmap to + * be written back to disk. + */ +check_intra_bg_tail: + if (!asked && fs->flags & EXT2_FLAG_IBITMAP_TAIL_PROBLEM) { + if (fix_problem(ctx, PR_5_INODE_BMAP_PADDING, &pctx)) + ext2fs_mark_ib_dirty(fs); + else + ext2fs_unmark_valid(fs); + } +} + +static void check_block_end(e2fsck_t ctx) +{ + ext2_filsys fs = ctx->fs; + blk64_t end, save_blocks_count, i; + struct problem_context pctx; + int asked = 0; + + clear_problem_context(&pctx); + + end = ext2fs_get_block_bitmap_start2(fs->block_map) + + EXT2_GROUPS_TO_CLUSTERS(fs->super, fs->group_desc_count) - 1; + pctx.errcode = ext2fs_fudge_block_bitmap_end2(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) + goto check_intra_bg_tail; + + /* Protect loop from wrap-around if end is maxed */ + for (i = save_blocks_count + 1; i <= end && i > save_blocks_count; i++) { + if (!ext2fs_test_block_bitmap2(fs->block_map, + EXT2FS_C2B(fs, i))) { + asked = 1; + if (fix_problem(ctx, PR_5_BLOCK_BMAP_PADDING, &pctx)) { + for (; i <= end; i++) + ext2fs_mark_block_bitmap2(fs->block_map, + EXT2FS_C2B(fs, i)); + ext2fs_mark_bb_dirty(fs); + } else + ext2fs_unmark_valid(fs); + break; + } + } + + pctx.errcode = ext2fs_fudge_block_bitmap_end2(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; + } + /* + * If the number of blocks per block group != blocksize, we + * can also have a potential problem with the tail bits in + * each individual block bitmap block. If there is a problem, + * it would have been noticed when the bitmap was loaded. And + * fixing this is easy; all we need to do force the bitmap to + * be written back to disk. + */ +check_intra_bg_tail: + if (!asked && fs->flags & EXT2_FLAG_BBITMAP_TAIL_PROBLEM) { + if (fix_problem(ctx, PR_5_BLOCK_BMAP_PADDING, &pctx)) + ext2fs_mark_bb_dirty(fs); + else + ext2fs_unmark_valid(fs); + } +} diff --git a/e2fsck/problem.c b/e2fsck/problem.c new file mode 100644 index 0000000..6ad6fb8 --- /dev/null +++ b/e2fsck/problem.c @@ -0,0 +1,2756 @@ +/* + * 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 "config.h" +#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_OPTIMIZE 20 +#define PROMPT_CLEAR_FLAG 21 +#define PROMPT_NULL 22 + +/* + * 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)"), /* PROMPT_NONE = 0 */ + N_("Fix"), /* PROMPT_FIX = 1 */ + N_("Clear"), /* PROMPT_CLEAR = 2 */ + N_("Relocate"), /* PROMPT_RELOCATE = 3 */ + N_("Allocate"), /* PROMPT_CREATE = 4 */ + N_("Expand"), /* PROMPT_EXPAND = 5 */ + N_("Connect to /lost+found"), /* PROMPT_CONNECT = 6 */ + N_("Create"), /* PROMPT_CREATE = 7 */ + N_("Salvage"), /* PROMPT_SALVAGE = 8 */ + N_("Truncate"), /* PROMPT_TRUNCATE = 9 */ + N_("Clear inode"), /* PROMPT_CLEAR_INODE = 10 */ + N_("Abort"), /* PROMPT_ABORT = 11 */ + N_("Split"), /* PROMPT_SPLIT = 12 */ + N_("Continue"), /* PROMPT_CONTINUE = 13 */ + N_("Clone multiply-claimed blocks"), /* PROMPT_CLONE = 14 */ + N_("Delete file"), /* PROMPT_DELETE = 15 */ + N_("Suppress messages"), /* PROMPT_SUPPRESS = 16 */ + N_("Unlink"), /* PROMPT_UNLINK = 17 */ + N_("Clear HTree index"), /* PROMPT_CLEAR_HTREE = 18 */ + N_("Recreate"), /* PROMPT_RECREATE = 19 */ + N_("Optimize"), /* PROMPT_OPTIMIZE = 20 */ + N_("Clear flag"), /* PROMPT_CLEAR_FLAG = 21 */ + "", /* PROMPT_NULL = 22 */ +}; + +/* + * 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_("MULTIPLY-CLAIMED BLOCKS CLONED"), /* 14 */ + N_("FILE DELETED"), /* 15 */ + N_("SUPPRESSED"), /* 16 */ + N_("UNLINKED"), /* 17 */ + N_("HTREE INDEX CLEARED"),/* 18 */ + N_("WILL RECREATE"), /* 19 */ + N_("WILL OPTIMIZE"), /* 20 */ + N_("FLAG CLEARED"), /* 21 */ + "", /* 22 */ +}; + +#if __GNUC_PREREQ (4, 6) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wmissing-field-initializers" +#endif + +static struct e2fsck_problem problem_table[] = { + + /* Pre-Pass 1 errors */ + + /* Block bitmap for group is 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, 0, 0, 0 }, + + /* Inode bitmap for group is 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, 0, 0, 0 }, + + /* Inode table for group is not in group. (block nnnn) */ + { 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, 0, 0, 0 }, + + /* Superblock corrupt */ + { PR_0_SB_CORRUPT, + N_("\nThe @S could not be read or does not describe a valid ext2/ext3/ext4\n" + "@f. If the @v is valid and it really contains an ext2/ext3/ext4\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 8193 <@v>\n" + " or\n" + " e2fsck -b 32768 <@v>\n\n"), + PROMPT_NONE, 0, 0, 0, 0 }, + + /* 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, 0, 0, 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, 0, 0, 0 }, + + /* Superblock blocks_per_group = bbbb, should have been cccc */ + { 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, 0, 0 }, + + /* Superblock first_data_block = bbbb, should have been cccc */ + { 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, 0, 0 }, + + /* Filesystem did not have a UUID; generating one */ + { PR_0_ADD_UUID, + N_("@f did not have a UUID; generating one.\n\n"), + PROMPT_NONE, 0, 0, 0, 0 }, + + /* Relocate hint */ + { PR_0_RELOCATE_HINT, + /* xgettext:no-c-format */ + N_("Note: if several inode or block bitmap blocks or part\n" + "of the inode table require relocation, you may wish to try\n" + "running e2fsck with the '-b %S' option first. The problem\n" + "may lie only with the primary block group descriptors, and\n" + "the backup block group descriptors may be OK.\n\n"), + PROMPT_NONE, PR_PREEN_OK | PR_NOCOLLATE, 0, 0, 0 }, + + /* 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, 0, 0 }, + + /* Error determining physical device size of filesystem */ + { PR_0_GETSIZE_ERROR, + /* xgettext:no-c-format */ + N_("Error determining size of the physical @v: %m\n"), + PROMPT_NONE, PR_FATAL, 0, 0, 0 }, + + /* Inode count in superblock is incorrect */ + { PR_0_INODE_COUNT_WRONG, + N_("@i count in @S is %i, @s %j.\n"), + PROMPT_FIX, 0, 0, 0, 0 }, + + { PR_0_HURD_CLEAR_FILETYPE, + N_("The Hurd does not support the filetype feature.\n"), + PROMPT_CLEAR, 0, 0, 0, 0 }, + + /* Superblock has an invalid journal (inode inum) */ + { PR_0_JOURNAL_BAD_INODE, + /* xgettext:no-c-format */ + N_("@S has an @n @j (@i %i).\n"), + PROMPT_CLEAR, PR_PREEN_OK, 0, 0, 0 }, + + /* External journal has multiple filesystem users (unsupported) */ + { PR_0_JOURNAL_UNSUPP_MULTIFS, + N_("External @j has multiple @f users (unsupported).\n"), + PROMPT_NONE, PR_FATAL, 0, 0, 0 }, + + /* Can't find external journal */ + { PR_0_CANT_FIND_JOURNAL, + N_("Can't find external @j\n"), + PROMPT_NONE, PR_FATAL, 0, 0, 0 }, + + /* External journal has bad superblock */ + { PR_0_EXT_JOURNAL_BAD_SUPER, + N_("External @j has bad @S\n"), + PROMPT_NONE, PR_FATAL, 0, 0, 0 }, + + /* Superblock has a bad journal UUID */ + { PR_0_JOURNAL_BAD_UUID, + N_("External @j does not support this @f\n"), + PROMPT_NONE, PR_FATAL, 0, 0, 0 }, + + /* Filesystem journal superblock is an unknown type */ + { PR_0_JOURNAL_UNSUPP_SUPER, + N_("@f @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, + 0, 0 }, + + /* Journal superblock is corrupt */ + { PR_0_JOURNAL_BAD_SUPER, + N_("@j @S is corrupt.\n"), + PROMPT_FIX, PR_PREEN_OK, 0, 0, 0 }, + + /* Superblock has_journal flag is clear but has a journal */ + { PR_0_JOURNAL_HAS_JOURNAL, + N_("@S has_@j flag is clear, but a @j is present.\n"), + PROMPT_CLEAR, PR_PREEN_OK, 0, 0, 0 }, + + /* Superblock needs_recovery flag is set but no journal is present */ + { PR_0_JOURNAL_RECOVER_SET, + N_("@S needs_recovery flag is set, but no @j is present.\n"), + PROMPT_CLEAR, PR_PREEN_OK, 0, 0, 0 }, + + /* Superblock needs_recovery flag is set, but journal has data */ + { PR_0_JOURNAL_RECOVERY_CLEAR, + N_("@S needs_recovery flag is clear, but @j has data.\n"), + PROMPT_NONE, 0, 0, 0, 0 }, + + /* Ask if we should clear the journal */ + { PR_0_JOURNAL_RESET_JOURNAL, + N_("Clear @j"), + PROMPT_NULL, PR_PREEN_NOMSG, 0, 0, 0 }, + + /* Filesystem revision is 0, but feature flags are set */ + { PR_0_FS_REV_LEVEL, + N_("@f has feature flag(s) set, but is a revision 0 @f. "), + PROMPT_FIX, PR_PREEN_OK | PR_NO_OK, 0, 0, 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, 0, 0, 0 }, + + /* Illegal block found in orphaned inode */ + { PR_0_ORPHAN_ILLEGAL_BLOCK_NUM, + N_("@I %B (%b) found in @o @i %i.\n"), + PROMPT_NONE, 0, 0, 0, 0 }, + + /* Already cleared block found in orphaned inode */ + { PR_0_ORPHAN_ALREADY_CLEARED_BLOCK, + N_("Already cleared %B (%b) found in @o @i %i.\n"), + PROMPT_NONE, 0, 0, 0, 0 }, + + /* Illegal orphan inode in superblock */ + { PR_0_ORPHAN_ILLEGAL_HEAD_INODE, + /* xgettext:no-c-format */ + N_("@I @o @i %i in @S.\n"), + PROMPT_NONE, 0, 0, 0, 0 }, + + /* Illegal inode in orphaned inode list */ + { PR_0_ORPHAN_ILLEGAL_INODE, + /* xgettext:no-c-format */ + N_("@I @i %i in @o @i list.\n"), + PROMPT_NONE, 0, 0, 0, 0 }, + + /* Journal superblock has an unknown read-only feature flag set */ + { PR_0_JOURNAL_UNSUPP_ROCOMPAT, + N_("@j @S has an unknown read-only feature flag set.\n"), + PROMPT_ABORT, 0, 0, 0, 0 }, + + /* Journal superblock has an unknown incompatible feature flag set */ + { PR_0_JOURNAL_UNSUPP_INCOMPAT, + N_("@j @S has an unknown incompatible feature flag set.\n"), + PROMPT_ABORT, 0, 0, 0, 0 }, + + /* Journal version not supported by this e2fsck */ + { PR_0_JOURNAL_UNSUPP_VERSION, + N_("@j version not supported by this e2fsck.\n"), + PROMPT_ABORT, 0, 0, 0, 0 }, + + /* Moving journal from /file to hidden inode */ + { PR_0_MOVE_JOURNAL, + /* xgettext:no-c-format */ + N_("Moving @j from /%s to hidden @i.\n\n"), + PROMPT_NONE, 0, 0, 0, 0 }, + + /* Error moving journal to hidden file */ + { PR_0_ERR_MOVE_JOURNAL, + /* xgettext:no-c-format */ + N_("Error moving @j: %m\n\n"), + PROMPT_NONE, 0, 0, 0, 0 }, + + /* Found invalid V2 journal superblock fields */ + { PR_0_CLEAR_V2_JOURNAL, + N_("Found @n V2 @j @S fields (from V1 @j).\n" + "Clearing fields beyond the V1 @j @S...\n\n"), + PROMPT_NONE, 0, 0, 0, 0 }, + + /* Ask if we should run the journal anyway */ + { PR_0_JOURNAL_RUN, + N_("Run @j anyway"), + PROMPT_NULL, 0, 0, 0, 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, 0, 0, 0 }, + + /* Backing up journal inode block information */ + { PR_0_BACKUP_JNL, + N_("Backing up @j @i @b information.\n\n"), + PROMPT_NONE, 0, 0, 0, 0 }, + + /* Filesystem does not have resize_inode enabled, but + * s_reserved_gdt_blocks is nnnn; should be zero */ + { 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, 0, 0, 0 }, + + /* Resize_inode not enabled, but the resize inode is non-zero */ + { PR_0_CLEAR_RESIZE_INODE, + N_("Resize_@i not enabled, but the resize @i is non-zero. "), + PROMPT_CLEAR, 0, 0, 0, 0 }, + + /* Resize inode not valid */ + { PR_0_RESIZE_INODE_INVALID, + N_("Resize @i not valid. "), + PROMPT_RECREATE, 0, 0, 0, 0 }, + + /* Superblock last mount time is in the future */ + { PR_0_FUTURE_SB_LAST_MOUNT, + N_("@S last mount time (%t,\n\tnow = %T) is in the future.\n"), + PROMPT_FIX, PR_PREEN_OK | PR_NO_OK, 0, 0, 0 }, + + /* Superblock last write time is in the future */ + { PR_0_FUTURE_SB_LAST_WRITE, + N_("@S last write time (%t,\n\tnow = %T) is in the future.\n"), + PROMPT_FIX, PR_PREEN_OK | PR_NO_OK, 0, 0, 0 }, + + /* Superblock hint for external superblock should be xxxx */ + { PR_0_EXTERNAL_JOURNAL_HINT, + /* xgettext:no-c-format */ + N_("@S hint for external superblock @s %X. "), + PROMPT_FIX, PR_PREEN_OK, 0, 0, 0 }, + + /* Adding dirhash hint to filesystem */ + { PR_0_DIRHASH_HINT, + N_("Adding dirhash hint to @f.\n\n"), + PROMPT_NONE, 0, 0, 0, 0 }, + + /* group descriptor N checksum is invalid, should be yyyy. */ + { PR_0_GDT_CSUM, + N_("@g descriptor %g checksum is %04x, should be %04y. "), + PROMPT_FIX, PR_PREEN_OK | PR_LATCH_BG_CHECKSUM, 0, 0, 0 }, + + /* group descriptor N marked uninitialized without feature set. */ + { PR_0_GDT_UNINIT, + /* xgettext:no-c-format */ + N_("@g descriptor %g marked uninitialized without feature set.\n"), + PROMPT_FIX, PR_PREEN_OK, 0, 0, 0 }, + + /* Group descriptor N has invalid unused inodes count. */ + { PR_0_GDT_ITABLE_UNUSED, + N_("@g descriptor %g has invalid unused inodes count %b. "), + PROMPT_FIX, PR_PREEN_OK, 0, 0, 0 }, + + /* Last group block bitmap uninitialized. */ + { PR_0_BB_UNINIT_LAST, + N_("Last @g @b @B uninitialized. "), + PROMPT_FIX, PR_PREEN_OK, 0, 0, 0 }, + + /* Journal transaction was corrupt, replay was aborted */ + { PR_0_JNL_TXN_CORRUPT, + /* xgettext:no-c-format */ + N_("Journal transaction %i was corrupt, replay was aborted.\n"), + PROMPT_NONE, 0, 0, 0, 0 }, + + /* The test_fs filesystem flag is set (and ext4 is available) */ + { PR_0_CLEAR_TESTFS_FLAG, + N_("The test_fs flag is set (and ext4 is available). "), + PROMPT_CLEAR, PR_PREEN_OK, 0, 0, 0 }, + + /* Last mount time is in the future (fudged) */ + { PR_0_FUTURE_SB_LAST_MOUNT_FUDGED, + N_("@S last mount time is in the future.\n\t(by less than a day, " + "probably due to the hardware clock being incorrectly set)\n"), + PROMPT_NONE, PR_PREEN_OK | PR_NO_OK, 0, 0, 0 }, + + /* Last write time is in the future (fudged) */ + { PR_0_FUTURE_SB_LAST_WRITE_FUDGED, + N_("@S last write time is in the future.\n\t(by less than a day, " + "probably due to the hardware clock being incorrectly set)\n"), + PROMPT_NONE, PR_PREEN_OK | PR_NO_OK, 0, 0, 0 }, + + /* One or more block group descriptor checksums are invalid (latch) */ + { PR_0_GDT_CSUM_LATCH, + N_("One or more @b @g descriptor checksums are invalid. "), + PROMPT_FIX, PR_PREEN_OK, 0, 0, 0 }, + + /* Setting free inodes count to right (was wrong) */ + { PR_0_FREE_INODE_COUNT, + N_("Setting free @is count to %j (was %i)\n"), + PROMPT_NONE, PR_PREEN_NOMSG, 0, 0, 0 }, + + /* Setting free blocks count to right (was wrong) */ + { PR_0_FREE_BLOCK_COUNT, + N_("Setting free @bs count to %c (was %b)\n"), + PROMPT_NONE, PR_PREEN_NOMSG, 0, 0, 0 }, + + /* Making quota inode hidden */ + { PR_0_HIDE_QUOTA, + N_("Hiding %U @q @i %i (%Q).\n"), + PROMPT_NONE, PR_PREEN_OK, 0, 0, 0 }, + + /* Superblock has invalid MMP block. */ + { PR_0_MMP_INVALID_BLK, + N_("@S has invalid MMP block. "), + PROMPT_CLEAR, PR_PREEN_OK, 0, 0, 0 }, + + /* Superblock has invalid MMP magic. */ + { PR_0_MMP_INVALID_MAGIC, + N_("@S has invalid MMP magic. "), + PROMPT_FIX, PR_PREEN_OK | PR_NO_OK, 0, 0, 0 }, + + /* Opening file system failed */ + { PR_0_OPEN_FAILED, + /* xgettext:no-c-format */ + N_("ext2fs_open2: %m\n"), + PROMPT_NONE, 0, 0, 0, 0 }, + + /* Checking group descriptor failed */ + { PR_0_CHECK_DESC_FAILED, + /* xgettext:no-c-format */ + N_("ext2fs_check_desc: %m\n"), + PROMPT_NONE, 0, 0, 0, 0 }, + + /* Superblock metadata_csum supersedes uninit_bg; both feature + * bits cannot be set simultaneously. */ + { PR_0_META_AND_GDT_CSUM_SET, + N_("@S metadata_csum supersedes uninit_bg; both feature " + "bits cannot be set simultaneously."), + PROMPT_FIX, PR_PREEN_OK | PR_NO_OK, 0, 0, 0 }, + + /* Superblock MMP block checksum does not match MMP block. */ + { PR_0_MMP_CSUM_INVALID, + N_("@S MMP @b checksum does not match. "), + PROMPT_FIX, PR_PREEN_OK | PR_NO_OK, 0, 0, 0 }, + + /* Superblock 64bit filesystem needs extents to access the whole disk */ + { PR_0_64BIT_WITHOUT_EXTENTS, + N_("@S 64bit @f needs extents to access the whole disk. "), + PROMPT_FIX, PR_PREEN_OK | PR_NO_OK, 0, 0, 0 }, + + /* The first_meta_bg is too big */ + { PR_0_FIRST_META_BG_TOO_BIG, + N_("First_meta_bg is too big. (%N, max value %g). "), + PROMPT_CLEAR, 0, 0, 0, 0 }, + + /* External journal superblock checksum does not match superblock */ + { PR_0_EXT_JOURNAL_SUPER_CSUM_INVALID, + N_("External @j @S checksum does not match @S. "), + PROMPT_FIX, PR_PREEN_OK, 0, 0, 0 }, + + /* Superblock metadata_csum_seed means nothing without metadata_csum */ + { PR_0_CSUM_SEED_WITHOUT_META_CSUM, + N_("@S metadata_csum_seed is not necessary without metadata_csum."), + PROMPT_FIX, PR_PREEN_OK | PR_NO_OK, 0, 0, 0 }, + + /* Error initializing quota context */ + { PR_0_QUOTA_INIT_CTX, + /* xgettext:no-c-format */ + N_("Error initializing quota context in support library: %m\n"), + PROMPT_NULL, PR_FATAL, 0, 0, 0 }, + + /* Bad required extra isize in superblock */ + { PR_0_BAD_MIN_EXTRA_ISIZE, + N_("Bad required extra isize in @S (%N). "), + PROMPT_FIX, 0, 0, 0, 0 }, + + /* Bad desired extra isize in superblock */ + { PR_0_BAD_WANT_EXTRA_ISIZE, + N_("Bad desired extra isize in @S (%N). "), + PROMPT_FIX, 0, 0, 0, 0 }, + + /* Invalid quota inode number */ + { PR_0_INVALID_QUOTA_INO, + N_("Invalid %U @q @i %i. "), + PROMPT_FIX, 0, 0, 0, 0 }, + + /* Too many inodes in the filesystem */ + { PR_0_INODE_COUNT_BIG, + N_("@S would have too many inodes (%N).\n"), + PROMPT_NONE, PR_AFTER_CODE, PR_0_SB_CORRUPT, 0, 0 }, + + /* Meta_bg and resize_inode are not compatible, disable resize_inode*/ + { PR_0_DISABLE_RESIZE_INODE, + N_("Resize_@i and meta_bg features are enabled. Those features are\n" + "not compatible. Resize @i should be disabled. "), + PROMPT_FIX, 0, 0, 0, 0 }, + + /* Orphan file contains holes */ + { PR_0_ORPHAN_FILE_HOLE, + N_("Orphan file (@i %i) contains hole at @b %b. Terminating orphan file recovery.\n"), + PROMPT_NONE, 0 }, + + /* Orphan file block has wrong magic */ + { PR_0_ORPHAN_FILE_BAD_MAGIC, + N_("Orphan file (@i %i) @b %b contains wrong magic. Terminating orphan file recovery.\n"), + PROMPT_NONE, 0 }, + + /* Orphan file block has wrong checksum */ + { PR_0_ORPHAN_FILE_BAD_CHECKSUM, + N_("Orphan file (@i %i) @b %b contains wrong checksum. Terminating orphan file recovery.\n"), + PROMPT_NONE, 0 }, + + /* Orphan file size isn't multiple of blocks size */ + { PR_0_ORPHAN_FILE_WRONG_SIZE, + N_("Orphan file (@i %i) size is not multiple of block size. Terminating orphan file recovery.\n"), + PROMPT_NONE, 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, PR_HEADER, 0, 0, 0 }, + + /* Root inode is not a directory */ + { PR_1_ROOT_NO_DIR, N_("@r is not a @d. "), + PROMPT_CLEAR, 0, 0, 0, 0 }, + + /* Root inode has dtime set */ + { PR_1_ROOT_DTIME, + N_("@r has dtime set (probably due to old mke2fs). "), + PROMPT_FIX, PR_PREEN_OK, 0, 0, 0 }, + + /* Reserved inode has bad mode */ + { PR_1_RESERVED_BAD_MODE, + N_("Reserved @i %i (%Q) has @n mode. "), + PROMPT_CLEAR, PR_PREEN_OK, 0, 0, 0 }, + + /* Deleted inode inum has zero dtime */ + { PR_1_ZERO_DTIME, + /* xgettext:no-c-format */ + N_("@D @i %i has zero dtime. "), + PROMPT_FIX, PR_PREEN_OK, 0, 0, 0 }, + + /* Inode inum is in use, but has dtime set */ + { PR_1_SET_DTIME, + /* xgettext:no-c-format */ + N_("@i %i is in use, but has dtime set. "), + PROMPT_FIX, PR_PREEN_OK, 0, 0, 0 }, + + /* Inode inum is a zero-length directory */ + { PR_1_ZERO_LENGTH_DIR, + /* xgettext:no-c-format */ + N_("@i %i is a @z @d. "), + PROMPT_CLEAR, PR_PREEN_OK, 0, 0, 0 }, + + /* Group block bitmap at block conflicts with some other fs block */ + { PR_1_BB_CONFLICT, + N_("@g %g's @b @B at %b @C.\n"), + PROMPT_RELOCATE, 0, 0, 0, 0 }, + + /* Group inode bitmap at block conflicts with some other fs block */ + { PR_1_IB_CONFLICT, + N_("@g %g's @i @B at %b @C.\n"), + PROMPT_RELOCATE, 0, 0, 0, 0 }, + + /* Group inode table at block conflicts with some other fs block */ + { PR_1_ITABLE_CONFLICT, + N_("@g %g's @i table at %b @C.\n"), + PROMPT_RELOCATE, 0, 0, 0, 0 }, + + /* Group block bitmap (block) is bad */ + { PR_1_BB_BAD_BLOCK, + N_("@g %g's @b @B (%b) is bad. "), + PROMPT_RELOCATE, 0, 0, 0, 0 }, + + /* Group inode bitmap (block) is bad */ + { PR_1_IB_BAD_BLOCK, + N_("@g %g's @i @B (%b) is bad. "), + PROMPT_RELOCATE, 0, 0, 0, 0 }, + + /* Inode inum, i_size is small, should be larger */ + { PR_1_BAD_I_SIZE, + N_("@i %i, i_size is %Is, @s %N. "), + PROMPT_FIX, PR_PREEN_OK, 0, 0, 0 }, + + /* Inode inum, i_blocks is small, should be larger */ + { PR_1_BAD_I_BLOCKS, + N_("@i %i, i_@bs is %Ib, @s %N. "), + PROMPT_FIX, PR_PREEN_OK, 0, 0, 0 }, + + /* Illegal block number in inode */ + { PR_1_ILLEGAL_BLOCK_NUM, + N_("@I %B (%b) in @i %i. "), + PROMPT_CLEAR, PR_LATCH_BLOCK, 0, 0, 0 }, + + /* Block number overlaps filesystem metadata in inode */ + { PR_1_BLOCK_OVERLAPS_METADATA, + N_("%B (%b) overlaps @f metadata in @i %i. "), + PROMPT_CLEAR, PR_LATCH_BLOCK, 0, 0, 0 }, + + /* Inode has illegal blocks (latch question) */ + { PR_1_INODE_BLOCK_LATCH, + /* xgettext:no-c-format */ + N_("@i %i has illegal @b(s). "), + PROMPT_CLEAR, 0, 0, 0, 0 }, + + /* Too many illegal blocks in inode */ + { PR_1_TOO_MANY_BAD_BLOCKS, + /* xgettext:no-c-format */ + N_("Too many illegal @bs in @i %i.\n"), + PROMPT_CLEAR_INODE, PR_NO_OK, 0, 0, 0 }, + + /* Illegal block number in bad block inode */ + { PR_1_BB_ILLEGAL_BLOCK_NUM, + N_("@I %B (%b) in bad @b @i. "), + PROMPT_CLEAR, PR_LATCH_BBLOCK, 0, 0, 0 }, + + /* Bad block inode has illegal blocks (latch question) */ + { PR_1_INODE_BBLOCK_LATCH, + N_("Bad @b @i has illegal @b(s). "), + PROMPT_CLEAR, 0, 0, 0, 0 }, + + /* Duplicate or bad blocks in use! */ + { PR_1_DUP_BLOCKS_PREENSTOP, + N_("Duplicate or bad @b in use!\n"), + PROMPT_NONE, 0, 0, 0, 0 }, + + /* Bad block number used as bad block inode indirect block */ + { PR_1_BBINODE_BAD_METABLOCK, + N_("Bad @b %b used as bad @b @i indirect @b. "), + PROMPT_CLEAR, PR_LATCH_BBLOCK, 0, 0, 0 }, + + /* 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, 0, 0, 0 }, + + /* 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, 0, 0 }, + + /* Bad primary block prompt */ + { PR_1_BAD_PRIMARY_BLOCK_PROMPT, + N_("You can remove this @b from the bad @b list and hope\n" + "that the @b is really OK. But there are no guarantees.\n\n"), + PROMPT_CLEAR, PR_PREEN_NOMSG, 0, 0, 0 }, + + /* The primary superblock block is on the bad block list */ + { 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, 0, 0 }, + + /* 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, 0, 0 }, + + /* Warning: Group number's superblock (block) is bad */ + { PR_1_BAD_SUPERBLOCK, + N_("Warning: Group %g's @S (%b) is bad.\n"), + PROMPT_NONE, PR_PREEN_OK | PR_PREEN_NOMSG, 0, 0, 0 }, + + /* Warning: Group number's copy of the group descriptors has a bad + * block */ + { 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, 0, 0, 0 }, + + /* Block number claimed for no reason in process_bad_blocks */ + { PR_1_PROGERR_CLAIMED_BLOCK, + N_("Programming error? @b #%b claimed for no reason in " + "process_bad_@b.\n"), + PROMPT_NONE, PR_PREEN_OK, 0, 0, 0 }, + + /* Allocating number contiguous block(s) in block group number */ + { PR_1_RELOC_BLOCK_ALLOCATE, + N_("@A %N contiguous @b(s) in @b @g %g for %s: %m\n"), + PROMPT_NONE, PR_PREEN_OK, 0, 0, 0 }, + + /* Allocating block buffer for relocating process */ + { PR_1_RELOC_MEMORY_ALLOCATE, + /* xgettext:no-c-format */ + N_("@A @b buffer for relocating %s\n"), + PROMPT_NONE, PR_PREEN_OK, 0, 0, 0 }, + + /* Relocating group number's 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, 0, 0, 0 }, + + /* Relocating group number's information to X */ + { PR_1_RELOC_TO, + /* xgettext:no-c-format */ + N_("Relocating @g %g's %s to %c...\n"), /* xgettext:no-c-format */ + PROMPT_NONE, PR_PREEN_OK, 0, 0, 0 }, + + /* Warning: could not read block number of relocation process */ + { PR_1_RELOC_READ_ERR, + N_("Warning: could not read @b %b of %s: %m\n"), + PROMPT_NONE, PR_PREEN_OK, 0, 0, 0 }, + + /* Warning: could not write block number of relocation process */ + { PR_1_RELOC_WRITE_ERR, + N_("Warning: could not write @b %b for %s: %m\n"), + PROMPT_NONE, PR_PREEN_OK, 0, 0, 0 }, + + /* Error allocating inode bitmap */ + { PR_1_ALLOCATE_IBITMAP_ERROR, + N_("@A @i @B (%N): %m\n"), + PROMPT_NONE, PR_FATAL, 0, 0, 0 }, + + /* Error allocating block bitmap */ + { PR_1_ALLOCATE_BBITMAP_ERROR, + N_("@A @b @B (%N): %m\n"), + PROMPT_NONE, PR_FATAL, 0, 0, 0 }, + + /* Error allocating icount link information */ + { PR_1_ALLOCATE_ICOUNT, + /* xgettext:no-c-format */ + N_("@A icount link information: %m\n"), + PROMPT_NONE, PR_FATAL, 0, 0, 0 }, + + /* Error allocating directory block array */ + { PR_1_ALLOCATE_DBCOUNT, + /* xgettext:no-c-format */ + N_("@A @d @b array: %m\n"), + PROMPT_NONE, PR_FATAL, 0, 0, 0 }, + + /* Error while scanning inodes */ + { PR_1_ISCAN_ERROR, + /* xgettext:no-c-format */ + N_("Error while scanning @is (%i): %m\n"), + PROMPT_NONE, PR_FATAL, 0, 0, 0 }, + + /* Error while iterating over blocks in inode */ + { PR_1_BLOCK_ITERATE, + /* xgettext:no-c-format */ + N_("Error while iterating over @bs in @i %i: %m\n"), + PROMPT_NONE, PR_FATAL, 0, 0, 0 }, + + /* Error storing inode count information */ + { PR_1_ICOUNT_STORE, + N_("Error storing @i count information (@i=%i, count=%N): %m\n"), + PROMPT_NONE, PR_FATAL, 0, 0, 0 }, + + /* Error 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, 0, 0, 0 }, + + /* Error reading inode (for clearing) */ + { PR_1_READ_INODE, + /* xgettext:no-c-format */ + N_("Error reading @i %i: %m\n"), + PROMPT_NONE, PR_FATAL, 0, 0, 0 }, + + /* Suppress messages prompt */ + { PR_1_SUPPRESS_MESSAGES, "", PROMPT_SUPPRESS, PR_NO_OK, 0, 0, 0 }, + + /* Imagic number has imagic flag set when fs doesn't support it */ + { PR_1_SET_IMAGIC, + /* xgettext:no-c-format */ + N_("@i %i has imagic flag set. "), + PROMPT_CLEAR, 0, 0, 0, 0 }, + + /* Immutable flag set on a device or socket inode */ + { PR_1_SET_IMMUTABLE, + /* xgettext:no-c-format */ + 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, 0, 0, 0 }, + + /* Non-zero size for device, fifo or socket inode */ + { PR_1_SET_NONZSIZE, + /* xgettext:no-c-format */ + N_("Special (@v/socket/fifo) @i %i has non-zero size. "), + PROMPT_FIX, PR_PREEN_OK, 0, 0, 0 }, + + /* Filesystem has feature flag(s) set, but is a revision 0 filesystem */ + { PR_1_FS_REV_LEVEL, + N_("@f has feature flag(s) set, but is a revision 0 @f. "), + PROMPT_FIX, PR_PREEN_OK | PR_NO_OK, 0, 0, 0 }, + + /* Journal inode is not in use, but contains data */ + { PR_1_JOURNAL_INODE_NOT_CLEAR, + N_("@j @i is not in use, but contains data. "), + PROMPT_CLEAR, PR_PREEN_OK, 0, 0, 0 }, + + /* Journal is not a regular file */ + { PR_1_JOURNAL_BAD_MODE, + N_("@j is not regular file. "), + PROMPT_FIX, PR_PREEN_OK, 0, 0, 0 }, + + /* Inode that was part of the orphan list */ + { PR_1_LOW_DTIME, + /* xgettext:no-c-format */ + N_("@i %i was part of the @o @i list. "), + PROMPT_FIX, PR_LATCH_LOW_DTIME, 0, 0, 0 }, + + /* Inodes that were part of a corrupted orphan linked list found + * (latch question) */ + { PR_1_ORPHAN_LIST_REFUGEES, + N_("@is that were part of a corrupted orphan linked list found. "), + PROMPT_FIX, 0, 0, 0, 0 }, + + /* Error allocating refcount structure */ + { PR_1_ALLOCATE_REFCOUNT, + N_("@A refcount structure (%N): %m\n"), + PROMPT_NONE, PR_FATAL, 0, 0, 0 }, + + /* Error reading extended attribute block */ + { PR_1_READ_EA_BLOCK, + N_("Error reading @a @b %b for @i %i. "), + PROMPT_CLEAR, 0, 0, 0, 0 }, + + /* Inode number has a bad extended attribute block */ + { PR_1_BAD_EA_BLOCK, + N_("@i %i has a bad @a @b %b. "), + PROMPT_CLEAR, 0, 0, 0, 0 }, + + /* Error reading Extended Attribute block while fixing refcount */ + { PR_1_EXTATTR_READ_ABORT, + N_("Error reading @a @b %b (%m). "), + PROMPT_NONE, PR_FATAL, 0, 0, 0 }, + + /* Extended attribute number has reference count incorrect */ + { PR_1_EXTATTR_REFCOUNT, + N_("@a @b %b has reference count %r, @s %N. "), + PROMPT_FIX, 0, 0, 0, 0 }, + + /* Error writing Extended Attribute block while fixing refcount */ + { PR_1_EXTATTR_WRITE_ABORT, + N_("Error writing @a @b %b (%m). "), + PROMPT_NONE, PR_FATAL, 0, 0, 0 }, + + /* Extended attribute block has h_blocks > 1 */ + { PR_1_EA_MULTI_BLOCK, + N_("@a @b %b has h_@bs > 1. "), + PROMPT_CLEAR, 0, 0, 0, 0 }, + + /* Allocating extended attribute region allocation structure */ + { PR_1_EA_ALLOC_REGION_ABORT, + N_("@A @a region allocation structure. "), + PROMPT_NONE, PR_FATAL, 0, 0, 0 }, + + /* Extended Attribute block number is corrupt (allocation collision) */ + { PR_1_EA_ALLOC_COLLISION, + N_("@a @b %b is corrupt (allocation collision). "), + PROMPT_CLEAR, 0, 0, 0, 0 }, + + /* Extended attribute block number is corrupt (invalid name) */ + { PR_1_EA_BAD_NAME, + N_("@a @b %b is corrupt (@n name). "), + PROMPT_CLEAR, 0, 0, 0, 0 }, + + /* Extended attribute block number is corrupt (invalid value) */ + { PR_1_EA_BAD_VALUE, + N_("@a @b %b is corrupt (@n value). "), + PROMPT_CLEAR, 0, 0, 0, 0 }, + + /* Inode number is too big (latch question) */ + { PR_1_INODE_TOOBIG, + /* xgettext:no-c-format */ + N_("@i %i is too big. "), PROMPT_TRUNCATE, 0, 0, 0, 0 }, + + /* Problem causes directory to be too big */ + { PR_1_TOOBIG_DIR, + N_("%B (%b) causes @d to be too big. "), + PROMPT_CLEAR, PR_LATCH_TOOBIG, 0, 0, 0 }, + + /* Problem causes file to be too big */ + { PR_1_TOOBIG_REG, + N_("%B (%b) causes file to be too big. "), + PROMPT_CLEAR, PR_LATCH_TOOBIG, 0, 0, 0 }, + + /* Problem causes symlink to be too big */ + { PR_1_TOOBIG_SYMLINK, + N_("%B (%b) causes symlink to be too big. "), + PROMPT_CLEAR, PR_LATCH_TOOBIG, 0, 0, 0 }, + + /* Inode has INDEX_FL flag set on filesystem without htree support */ + { PR_1_HTREE_SET, + /* xgettext:no-c-format */ + N_("@i %i has INDEX_FL flag set on @f without htree support.\n"), + PROMPT_CLEAR_HTREE, PR_PREEN_OK, 0, 0, 0 }, + + /* Inode number has INDEX_FL flag set but is on a directory */ + { PR_1_HTREE_NODIR, + /* xgettext:no-c-format */ + N_("@i %i has INDEX_FL flag set but is not a @d.\n"), + PROMPT_CLEAR_HTREE, PR_PREEN_OK, 0, 0, 0 }, + + /* htree directory has an invalid root node */ + { PR_1_HTREE_BADROOT, + /* xgettext:no-c-format */ + N_("@h %i has an @n root node.\n"), + PROMPT_CLEAR_HTREE, PR_PREEN_OK, 0, 0, 0 }, + + /* Htree directory has an unsupported hash version */ + { PR_1_HTREE_HASHV, + N_("@h %i has an unsupported hash version (%N)\n"), + PROMPT_CLEAR_HTREE, PR_PREEN_OK, 0, 0, 0 }, + + /* Htree directory uses an Incompatible htree root node flag */ + { PR_1_HTREE_INCOMPAT, + /* xgettext:no-c-format */ + N_("@h %i uses an incompatible htree root node flag.\n"), + PROMPT_CLEAR_HTREE, PR_PREEN_OK, 0, 0, 0 }, + + /* Htree directory has a tree depth which is too big */ + { PR_1_HTREE_DEPTH, + N_("@h %i has a tree depth (%N) which is too big\n"), + PROMPT_CLEAR_HTREE, PR_PREEN_OK, 0, 0, 0 }, + + /* Bad block inode has an indirect block number that conflicts with + * filesystem metadata */ + { 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, 0, 0, 0 }, + + /* Resize inode (re)creation failed */ + { PR_1_RESIZE_INODE_CREATE, + /* xgettext:no-c-format */ + N_("Resize @i (re)creation failed: %m."), + PROMPT_CONTINUE, 0, 0, 0, 0 }, + + /* inode has a extra size i_extra_isize which is invalid */ + { PR_1_EXTRA_ISIZE, + N_("@i %i has a extra size (%IS) which is @n\n"), + PROMPT_FIX, PR_PREEN_OK, 0, 0, 0 }, + + /* Extended attribute in inode has a namelen which is invalid */ + { PR_1_ATTR_NAME_LEN, + N_("@a in @i %i has a namelen (%N) which is @n\n"), + PROMPT_CLEAR, PR_PREEN_OK, 0, 0, 0 }, + + /* Extended attribute in inode has a value offset which is invalid */ + { PR_1_ATTR_VALUE_OFFSET, + N_("@a in @i %i has a value offset (%N) which is @n\n"), + PROMPT_CLEAR, PR_PREEN_OK, 0, 0, 0 }, + + /* extended attribute in inode has a value block which is invalid */ + { PR_1_ATTR_VALUE_BLOCK, + N_("@a in @i %i has a value @b (%N) which is @n (must be 0)\n"), + PROMPT_CLEAR, PR_PREEN_OK, 0, 0, 0 }, + + /* extended attribute in inode has a value size which is invalid */ + { PR_1_ATTR_VALUE_SIZE, + N_("@a in @i %i has a value size (%N) which is @n\n"), + PROMPT_CLEAR, PR_PREEN_OK, 0, 0, 0 }, + + /* extended attribute in inode has a hash which is invalid */ + { PR_1_ATTR_HASH, + N_("@a in @i %i has a hash (%N) which is @n\n"), + PROMPT_CLEAR, PR_PREEN_OK, 0, 0, 0 }, + + /* inode is a type but it looks like it is really a directory */ + { PR_1_TREAT_AS_DIRECTORY, + N_("@i %i is a %It but it looks like it is really a directory.\n"), + PROMPT_FIX, 0, 0, 0, 0 }, + + /* Error while reading extent tree in inode */ + { PR_1_READ_EXTENT, + /* xgettext:no-c-format */ + N_("Error while reading over @x tree in @i %i: %m\n"), + PROMPT_CLEAR_INODE, 0, 0, 0, 0 }, + + /* Failure to iterate extents in inode */ + { PR_1_EXTENT_ITERATE_FAILURE, + N_("Failed to iterate extents in @i %i\n" + "\t(op %s, blk %b, lblk %c): %m\n"), + PROMPT_CLEAR_INODE, 0, 0, 0, 0 }, + + /* Inode has an invalid extent starting block */ + { PR_1_EXTENT_BAD_START_BLK, + N_("@i %i has an @n extent\n\t(logical @b %c, @n physical @b %b, len %N)\n"), + PROMPT_CLEAR, 0, 0, 0, 0 }, + + /* Inode has an invalid extent that ends beyond filesystem */ + { PR_1_EXTENT_ENDS_BEYOND, + N_("@i %i has an @n extent\n\t(logical @b %c, physical @b %b, @n len %N)\n"), + PROMPT_CLEAR, 0, 0, 0, 0 }, + + /* inode has EXTENTS_FL flag set on filesystem without extents support*/ + { PR_1_EXTENTS_SET, + /* xgettext:no-c-format */ + N_("@i %i has EXTENTS_FL flag set on @f without extents support.\n"), + PROMPT_CLEAR, 0, 0, 0, 0 }, + + /* inode is in extents format, but superblock is missing EXTENTS feature */ + { PR_1_EXTENT_FEATURE, + /* xgettext:no-c-format */ + N_("@i %i is in extent format, but @S is missing EXTENTS feature\n"), + PROMPT_FIX, 0, 0, 0, 0 }, + + /* inode missing EXTENTS_FL, but is an extent inode */ + { PR_1_UNSET_EXTENT_FL, + /* xgettext:no-c-format */ + N_("@i %i missing EXTENT_FL, but is in extents format\n"), + PROMPT_FIX, PR_PREEN_OK, 0, 0, 0 }, + + /* Fast symlink has EXTENTS_FL set */ + { PR_1_FAST_SYMLINK_EXTENT_FL, + /* xgettext:no-c-format */ + N_("Fast symlink %i has EXTENT_FL set. "), + PROMPT_CLEAR, 0, 0, 0, 0 }, + + /* Extents are out of order */ + { PR_1_OUT_OF_ORDER_EXTENTS, + N_("@i %i has out of order extents\n\t(@n logical @b %c, physical @b %b, len %N)\n"), + PROMPT_CLEAR, 0, 0, 0, 0 }, + + { PR_1_EXTENT_HEADER_INVALID, + N_("@i %i has an invalid extent node (blk %b, lblk %c)\n"), + PROMPT_CLEAR, 0, 0, 0, 0 }, + + /* Failed to convert subcluster block bitmap */ + { PR_1_CONVERT_SUBCLUSTER, + /* xgettext:no-c-format */ + N_("Error converting subcluster @b @B: %m\n"), + PROMPT_NONE, PR_FATAL, 0, 0, 0 }, + + /* Quota inode is not a regular file */ + { PR_1_QUOTA_BAD_MODE, + N_("@q @i is not a regular file. "), + PROMPT_CLEAR, PR_PREEN_OK, 0, 0, 0 }, + + /* Quota inode is not in use, but contains data */ + { PR_1_QUOTA_INODE_NOT_CLEAR, + N_("@q @i is not in use, but contains data. "), + PROMPT_CLEAR, PR_PREEN_OK, 0, 0, 0 }, + + /* Quota inode is visible to the user */ + { PR_1_QUOTA_INODE_NOT_HIDDEN, + N_("@q @i is visible to the user. "), + PROMPT_CLEAR, PR_PREEN_OK, 0, 0, 0 }, + + /* The bad block inode looks invalid */ + { PR_1_INVALID_BAD_INODE, + N_("The bad @b @i looks @n. "), + PROMPT_CLEAR, 0, 0, 0, 0 }, + + /* Extent has zero length extent */ + { PR_1_EXTENT_LENGTH_ZERO, + N_("@i %i has zero length extent\n\t(@n logical @b %c, physical @b %b)\n"), + PROMPT_CLEAR, 0, 0, 0, 0 }, + + /* inode seems to contain garbage */ + { PR_1_INODE_IS_GARBAGE, + /* xgettext:no-c-format */ + N_("@i %i seems to contain garbage. "), + PROMPT_CLEAR, 0, 0, 0, 0 }, + + /* inode passes checks, but checksum does not match inode */ + { PR_1_INODE_ONLY_CSUM_INVALID, + /* xgettext:no-c-format */ + N_("@i %i passes checks, but checksum does not match @i. "), + PROMPT_FIX, PR_PREEN_OK, 0, 0, 0 }, + + /* Inode extended attribute is corrupt (allocation collision) */ + { PR_1_INODE_EA_ALLOC_COLLISION, + /* xgettext:no-c-format */ + N_("@i %i @a is corrupt (allocation collision). "), + PROMPT_CLEAR, 0, 0, 0, 0}, + + /* + * Inode extent block passes checks, but checksum does not match + * extent + */ + { PR_1_EXTENT_ONLY_CSUM_INVALID, + N_("@i %i extent block passes checks, but checksum does not match " + "extent\n\t(logical @b %c, physical @b %b, len %N)\n"), + PROMPT_FIX, 0, 0, 0, 0 }, + + /* + * Inode extended attribute block passes checks, but checksum does not + * match block. + */ + { PR_1_EA_BLOCK_ONLY_CSUM_INVALID, + N_("@i %i @a @b %b passes checks, but checksum does not match @b. "), + PROMPT_FIX, 0, 0, 0, 0 }, + + /* Interior extent node level number of inode doesn't first node down */ + { PR_1_EXTENT_INDEX_START_INVALID, + N_("Interior @x node level %N of @i %i:\n" + "Logical start %b does not match logical start %c at next level. "), + PROMPT_FIX, 0, 0, 0, 0 }, + + /* Inode end of extent exceeds allowed value */ + { PR_1_EXTENT_END_OUT_OF_BOUNDS, + N_("@i %i, end of extent exceeds allowed value\n\t(logical @b %c, physical @b %b, len %N)\n"), + PROMPT_CLEAR, 0, 0, 0, 0 }, + + /* Inode has inline data, but superblock is missing INLINE_DATA feature */ + { PR_1_INLINE_DATA_FEATURE, + /* xgettext:no-c-format */ + N_("@i %i has inline data, but @S is missing INLINE_DATA feature\n"), + PROMPT_FIX, PR_PREEN_OK, 0, 0, 0 }, + + /* inode has INLINE_DATA_FL flag on filesystem without inline data */ + { PR_1_INLINE_DATA_SET, + /* xgettext:no-c-format */ + N_("@i %i has INLINE_DATA_FL flag on @f without inline data support.\n"), + PROMPT_CLEAR, 0, 0, 0, 0 }, + + /* + * Inode block conflicts with critical metadata, skipping block checks + */ + { PR_1_CRITICAL_METADATA_COLLISION, + /* xgettext:no-c-format */ + N_("@i %i block %b conflicts with critical metadata, skipping block checks.\n"), + PROMPT_NONE, 0, 0, 0, 0 }, + + /* Directory inode block should be at block */ + { PR_1_COLLAPSE_DBLOCK, + N_("@d @i %i @b %b should be at @b %c. "), + PROMPT_FIX, 0, 0, 0, 0 }, + + /* Extents/inlinedata flag set on a device or socket inode */ + { PR_1_UNINIT_DBLOCK, + /* xgettext:no-c-format */ + N_("@d @i %i has @x marked uninitialized at @b %c. "), + PROMPT_FIX, PR_PREEN_OK, 0, 0, 0 }, + + /* Inode logical block (physical block) violates cluster allocation */ + { PR_1_MISALIGNED_CLUSTER, + N_("@i %i logical @b %b (physical @b %c) violates cluster allocation rules.\nWill fix in pass 1B.\n"), + PROMPT_NONE, 0, 0, 0, 0 }, + + /* Inode has INLINE_DATA_FL flag but extended attribute not found */ + { PR_1_INLINE_DATA_NO_ATTR, + /* xgettext:no-c-format */ + N_("@i %i has INLINE_DATA_FL flag but @a not found. "), + PROMPT_TRUNCATE, 0, 0, 0, 0 }, + + /* Special (device/socket/fifo) file (inode num) has extents + * or inline-data flag set */ + { PR_1_SPECIAL_EXTENTS_IDATA, + /* xgettext:no-c-format */ + N_("Special (@v/socket/fifo) file (@i %i) has extents\n" + "or inline-data flag set. "), + PROMPT_CLEAR, PR_PREEN_OK | PR_PREEN_NO | PR_NO_OK, 0, 0, 0 }, + + /* Inode has extent header but inline data flag is set */ + { PR_1_CLEAR_INLINE_DATA_FOR_EXTENT, + /* xgettext:no-c-format */ + N_("@i %i has @x header but inline data flag is set.\n"), + PROMPT_FIX, 0, 0, 0, 0 }, + + /* Inode seems to have inline data but extent flag is set */ + { PR_1_CLEAR_EXTENT_FOR_INLINE_DATA, + /* xgettext:no-c-format */ + N_("@i %i seems to have inline data but @x flag is set.\n"), + PROMPT_FIX, 0, 0, 0, 0 }, + + /* Inode seems to have block map but inline data and extent flags set */ + { PR_1_CLEAR_EXTENT_INLINE_DATA_FLAGS, + /* xgettext:no-c-format */ + N_("@i %i seems to have @b map but inline data and @x flags set.\n"), + PROMPT_FIX, 0, 0, 0, 0 }, + + /* Inode has inline data and extent flags but i_block contains junk */ + { PR_1_CLEAR_EXTENT_INLINE_DATA_INODE, + /* xgettext:no-c-format */ + N_("@i %i has inline data and @x flags set but i_block contains junk.\n"), + PROMPT_CLEAR_INODE, 0, 0, 0, 0 }, + + /* Bad block list says the bad block list inode is bad */ + { PR_1_BADBLOCKS_IN_BADBLOCKS, + N_("Bad block list says the bad block list @i is bad. "), + PROMPT_CLEAR_INODE, 0, 0, 0, 0 }, + + /* Error allocating extent region allocation structure */ + { PR_1_EXTENT_ALLOC_REGION_ABORT, + N_("@A @x region allocation structure. "), + PROMPT_NONE, PR_FATAL, 0, 0, 0 }, + + /* Inode leaf has a duplicate extent mapping */ + { PR_1_EXTENT_COLLISION, + N_("@i %i has a duplicate @x mapping\n\t(logical @b %c, @n physical @b %b, len %N)\n"), + PROMPT_CLEAR, 0, 0, 0, 0 }, + + /* Error allocating memory for encrypted inode list */ + { PR_1_ALLOCATE_ENCRYPTED_INODE_LIST, + N_("@A %N bytes of memory for encrypted @i list\n"), + PROMPT_NONE, PR_FATAL, 0, 0, 0 }, + + /* Inode extent tree could be more shallow */ + { PR_1_EXTENT_BAD_MAX_DEPTH, + N_("@i %i @x tree could be more shallow (%b; could be <= %c)\n"), + PROMPT_FIX, PR_NO_OK | PR_PREEN_NO | PR_PREEN_OK, 0, 0, 0 }, + + /* inode num on bigalloc filesystem cannot be block mapped */ + { PR_1_NO_BIGALLOC_BLOCKMAP_FILES, + /* xgettext:no-c-format */ + N_("@i %i on bigalloc @f cannot be @b mapped. "), + PROMPT_FIX, 0, 0, 0, 0 }, + + /* Inode has corrupt extent header */ + { PR_1_MISSING_EXTENT_HEADER, + /* xgettext:no-c-format */ + N_("@i %i has corrupt @x header. "), + PROMPT_CLEAR_INODE, 0, 0, 0, 0 }, + + /* Timestamp(s) on inode beyond 2310-04-04 are likely pre-1970. */ + { PR_1_EA_TIME_OUT_OF_RANGE, + /* xgettext:no-c-format */ + N_("Timestamp(s) on @i %i beyond 2310-04-04 are likely pre-1970.\n"), + PROMPT_FIX, PR_PREEN_OK | PR_NO_OK, 0, 0, 0 }, + + /* Inode has illegal extended attribute value inode */ + { PR_1_ATTR_VALUE_EA_INODE, + N_("@i %i has @I @a value @i %N.\n"), + PROMPT_CLEAR, PR_PREEN_OK, 0, 0, 0 }, + + /* Inode has invalid extended attribute. EA inode missing + * EA_INODE flag. */ + { PR_1_ATTR_NO_EA_INODE_FL, + N_("@i %i has @n @a. EA @i %N missing EA_INODE flag.\n"), + PROMPT_CLEAR, PR_PREEN_OK, 0, 0, 0 }, + + /* EA inode for parent inode missing EA_INODE flag. */ + { PR_1_ATTR_SET_EA_INODE_FL, + N_("EA @i %N for parent @i %i missing EA_INODE flag.\n "), + PROMPT_FIX, PR_PREEN_OK, 0, 0, 0 }, + + /* Offer to clear uninitialized flag on an extent */ + { PR_1_CLEAR_UNINIT_EXTENT, + /* xgettext:no-c-format */ + N_("@i %i has @x marked uninitialized at @b %c (len %N). "), + PROMPT_CLEAR, PR_PREEN_OK, 0, 0, 0 }, + + /* Casefold flag set on a non-directory */ + { PR_1_CASEFOLD_NONDIR, + N_("@i %i has the casefold flag set but is not a directory. "), + PROMPT_CLEAR_FLAG, 0, 0, 0, 0 }, + + /* Casefold flag set, but file system is missing the casefold feature */ + { PR_1_CASEFOLD_FEATURE, + N_("@d %p has the casefold flag, but the\ncasefold feature is not enabled. "), + PROMPT_CLEAR_FLAG, 0, 0, 0, 0 }, + + /* Inode has encrypt flag but no encryption extended attribute */ + { PR_1_MISSING_ENCRYPTION_XATTR, + N_("@i %i has encrypt flag but no encryption @a.\n"), + PROMPT_CLEAR_FLAG, 0, 0, 0, 0 }, + + /* Encrypted inode has corrupt encryption extended attribute */ + { PR_1_CORRUPT_ENCRYPTION_XATTR, + N_("Encrypted @i %i has corrupt encryption @a.\n"), + PROMPT_CLEAR_INODE, 0, 0, 0, 0 }, + + /* Htree directory should use SipHash but does not */ + { PR_1_HTREE_NEEDS_SIPHASH, + N_("@h %i uses hash version (%N), but should use SipHash (6) \n"), + PROMPT_CLEAR_HTREE, PR_PREEN_OK, 0, 0, 0 }, + + /* Htree directory uses SipHash but should not */ + { PR_1_HTREE_CANNOT_SIPHASH, + N_("@h %i uses SipHash, but should not. "), + PROMPT_CLEAR_HTREE, PR_PREEN_OK, 0, 0, 0 }, + + /* Orphan file has bad mode */ + { PR_1_ORPHAN_FILE_BAD_MODE, + N_("Orphan file @i %i is not regular file. "), + PROMPT_CLEAR, PR_PREEN_OK }, + + /* Orphan file inode is not in use, but contains data */ + { PR_1_ORPHAN_FILE_NOT_CLEAR, + N_("Orphan file @i %i is not in use, but contains data. "), + PROMPT_CLEAR, PR_PREEN_OK }, + + /* Pass 1b errors */ + + /* Pass 1B: Rescan for duplicate/bad blocks */ + { PR_1B_PASS_HEADER, + N_("\nRunning additional passes to resolve @bs claimed by more than one @i...\n" + "Pass 1B: Rescanning for @m @bs\n"), + PROMPT_NONE, PR_HEADER, 0, 0, 0 }, + + /* Duplicate/bad block(s) header */ + { PR_1B_DUP_BLOCK_HEADER, + /* xgettext:no-c-format */ + N_("@m @b(s) in @i %i:"), + PROMPT_NONE, 0, 0, 0, 0 }, + + /* Duplicate/bad block(s) in inode */ + { PR_1B_DUP_BLOCK, + " %b", + PROMPT_NONE, PR_LATCH_DBLOCK | PR_PREEN_NOHDR, 0, 0, 0 }, + + /* Duplicate/bad block(s) end */ + { PR_1B_DUP_BLOCK_END, + "\n", + PROMPT_NONE, PR_PREEN_NOHDR, 0, 0, 0 }, + + /* Error while scanning inodes */ + { PR_1B_ISCAN_ERROR, + /* xgettext:no-c-format */ + N_("Error while scanning inodes (%i): %m\n"), + PROMPT_NONE, PR_FATAL, 0, 0, 0 }, + + /* Error allocating inode bitmap */ + { PR_1B_ALLOCATE_IBITMAP_ERROR, + /* xgettext:no-c-format */ + N_("@A @i @B (@i_dup_map): %m\n"), + PROMPT_NONE, PR_FATAL, 0, 0, 0 }, + + /* Error while iterating over blocks */ + { PR_1B_BLOCK_ITERATE, + /* xgettext:no-c-format */ + N_("Error while iterating over @bs in @i %i (%s): %m\n"), + PROMPT_NONE, 0, 0, 0, 0 }, + + /* Error adjusting EA refcount */ + { PR_1B_ADJ_EA_REFCOUNT, + N_("Error adjusting refcount for @a @b %b (@i %i): %m\n"), + PROMPT_NONE, 0, 0, 0, 0 }, + + /* Duplicate/bad block range in inode */ + { PR_1B_DUP_RANGE, + " %b--%c", + PROMPT_NONE, PR_LATCH_DBLOCK | PR_PREEN_NOHDR, 0, 0, 0 }, + + /* Pass 1C: Scan directories for inodes with multiply-claimed blocks. */ + { PR_1C_PASS_HEADER, + N_("Pass 1C: Scanning directories for @is with @m @bs\n"), + PROMPT_NONE, PR_HEADER, 0, 0, 0 }, + + + /* Pass 1D: Reconciling multiply-claimed blocks */ + { PR_1D_PASS_HEADER, + N_("Pass 1D: Reconciling @m @bs\n"), + PROMPT_NONE, PR_HEADER, 0, 0, 0 }, + + /* File has duplicate blocks */ + { PR_1D_DUP_FILE, + N_("File %Q (@i #%i, mod time %IM) \n" + " has %r @m @b(s), shared with %N file(s):\n"), + PROMPT_NONE, 0, 0, 0, 0 }, + + /* List of files sharing duplicate blocks */ + { PR_1D_DUP_FILE_LIST, + N_("\t%Q (@i #%i, mod time %IM)\n"), + PROMPT_NONE, 0, 0, 0, 0 }, + + /* File sharing blocks with filesystem metadata */ + { PR_1D_SHARE_METADATA, + N_("\t<@f metadata>\n"), + PROMPT_NONE, 0, 0, 0, 0 }, + + /* Report of how many duplicate/bad inodes */ + { PR_1D_NUM_DUP_INODES, + N_("(There are %N @is containing @m @bs.)\n\n"), + PROMPT_NONE, 0, 0, 0, 0 }, + + /* Duplicated blocks already reassigned or cloned. */ + { PR_1D_DUP_BLOCKS_DEALT, + N_("@m @bs already reassigned or cloned.\n\n"), + PROMPT_NONE, 0, 0, 0, 0 }, + + /* Clone duplicate/bad blocks? */ + { PR_1D_CLONE_QUESTION, + "", PROMPT_CLONE, PR_NO_OK, 0, 0, 0 }, + + /* Delete file? */ + { PR_1D_DELETE_QUESTION, + "", PROMPT_DELETE, 0, 0, 0, 0 }, + + /* Couldn't clone file (error) */ + { PR_1D_CLONE_ERROR, + /* xgettext:no-c-format */ + N_("Couldn't clone file: %m\n"), PROMPT_NONE, 0, 0, 0, 0 }, + + /* Pass 1E Extent tree optimization */ + + /* Pass 1E: Optimizing extent trees */ + { PR_1E_PASS_HEADER, + N_("Pass 1E: Optimizing @x trees\n"), + PROMPT_NONE, PR_HEADER | PR_PREEN_NOMSG, 0, 0, 0 }, + + /* Failed to optimize extent tree */ + { PR_1E_OPTIMIZE_EXT_ERR, + /* xgettext:no-c-format */ + N_("Failed to optimize @x tree %p (%i): %m\n"), + PROMPT_NONE, 0, 0, 0, 0 }, + + /* Optimizing extent trees */ + { PR_1E_OPTIMIZE_EXT_HEADER, + N_("Optimizing @x trees: "), + PROMPT_NONE, PR_MSG_ONLY, 0, 0, 0 }, + + /* Rebuilding extent tree %d */ + { PR_1E_OPTIMIZE_EXT, + " %i", + PROMPT_NONE, PR_LATCH_OPTIMIZE_EXT | PR_PREEN_NOHDR, 0, 0, 0 }, + + /* Rebuilding extent tree end */ + { PR_1E_OPTIMIZE_EXT_END, + "\n", + PROMPT_NONE, PR_PREEN_NOHDR, 0, 0, 0 }, + + /* Internal error: extent tree depth too large */ + { PR_1E_MAX_EXTENT_TREE_DEPTH, + N_("Internal error: max extent tree depth too large (%b; expected=%c).\n"), + PROMPT_NONE, PR_FATAL, 0, 0, 0 }, + + /* Inode extent tree could be shorter */ + { PR_1E_CAN_COLLAPSE_EXTENT_TREE, + N_("@i %i @x tree (at level %b) could be shorter. "), + PROMPT_OPTIMIZE, PR_NO_OK | PR_PREEN_NO | PR_PREEN_OK | PR_NOT_A_FIX, 0, 0, 0 }, + + /* Inode extent tree could be narrower */ + { PR_1E_CAN_NARROW_EXTENT_TREE, + N_("@i %i @x tree (at level %b) could be narrower. "), + PROMPT_OPTIMIZE, PR_NO_OK | PR_PREEN_NO | PR_PREEN_OK | PR_NOT_A_FIX, 0, 0, 0 }, + + /* Pass 2 errors */ + + /* Pass 2: Checking directory structure */ + { PR_2_PASS_HEADER, + N_("Pass 2: Checking @d structure\n"), + PROMPT_NONE, PR_HEADER, 0, 0, 0 }, + + /* Bad inode number for '.' */ + { PR_2_BAD_INODE_DOT, + /* xgettext:no-c-format */ + N_("@n @i number for '.' in @d @i %i.\n"), + PROMPT_FIX, 0, 0, 0, 0 }, + + /* Entry 'xxxx' in /a/b/c has bad inode number.*/ + { PR_2_BAD_INO, + N_("@E has @n @i #: %Di.\n"), + PROMPT_CLEAR, 0, 0, 0, 0 }, + + /* Entry 'xxxx' in /a/b/c has deleted/unused inode nnnnn.*/ + { PR_2_UNUSED_INODE, + N_("@E has @D/unused @i %Di. "), + PROMPT_CLEAR, PR_PREEN_OK, 0, 0, 0 }, + + /* Directory entry is link to '.' */ + { PR_2_LINK_DOT, + N_("@E @L to '.' "), + PROMPT_CLEAR, 0, 0, 0, 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, 0, 0, 0 }, + + /* Directory entry contains a link to a directory */ + { PR_2_LINK_DIR, + N_("@E @L to @d %P (%Di).\n"), + PROMPT_CLEAR, 0, 0, 0, 0 }, + + /* Directory entry contains a link to the root directory */ + { PR_2_LINK_ROOT, + N_("@E @L to the @r.\n"), + PROMPT_CLEAR, 0, 0, 0, 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, 0, 0, 0 }, + + /* Missing '.' in directory inode */ + { PR_2_MISSING_DOT, + /* xgettext:no-c-format */ + N_("Missing '.' in @d @i %i.\n"), + PROMPT_FIX, 0, 0, 0, 0 }, + + /* Missing '..' in directory inode */ + { PR_2_MISSING_DOT_DOT, + /* xgettext:no-c-format */ + N_("Missing '..' in @d @i %i.\n"), + PROMPT_FIX, 0, 0, 0, 0 }, + + /* First entry in directory inode doesn't contain '.' */ + { PR_2_1ST_NOT_DOT, + N_("First @e '%Dn' (@i=%Di) in @d @i %i (%p) @s '.'\n"), + PROMPT_FIX, 0, 0, 0, 0 }, + + /* Second entry in directory inode doesn't contain '..' */ + { PR_2_2ND_NOT_DOT_DOT, + N_("Second @e '%Dn' (@i=%Di) in @d @i %i @s '..'\n"), + PROMPT_FIX, 0, 0, 0, 0 }, + + /* i_faddr should be zero */ + { PR_2_FADDR_ZERO, + N_("i_faddr @F %IF, @s zero.\n"), + PROMPT_CLEAR, 0, 0, 0, 0 }, + + /* i_file_acl should be zero */ + { PR_2_FILE_ACL_ZERO, + N_("i_file_acl @F %If, @s zero.\n"), + PROMPT_CLEAR, 0, 0, 0, 0 }, + + /* i_size_high should be zero */ + { PR_2_DIR_SIZE_HIGH_ZERO, + N_("i_size_high @F %Id, @s zero.\n"), + PROMPT_CLEAR, 0, 0, 0, 0 }, + + /* i_frag should be zero */ + { PR_2_FRAG_ZERO, + N_("i_frag @F %N, @s zero.\n"), + PROMPT_CLEAR, 0, 0, 0, 0 }, + + /* i_fsize should be zero */ + { PR_2_FSIZE_ZERO, + N_("i_fsize @F %N, @s zero.\n"), + PROMPT_CLEAR, 0, 0, 0, 0 }, + + /* inode has bad mode */ + { PR_2_BAD_MODE, + N_("@i %i (%Q) has @n mode (%Im).\n"), + PROMPT_CLEAR, 0, 0, 0, 0 }, + + /* directory corrupted */ + { PR_2_DIR_CORRUPTED, + N_("@d @i %i, %B, offset %N: @d corrupted\n"), + PROMPT_SALVAGE, 0, 0, 0, 0 }, + + /* filename too long */ + { PR_2_FILENAME_LONG, + N_("@d @i %i, %B, offset %N: filename too long\n"), + PROMPT_TRUNCATE, 0, 0, 0, 0 }, + + /* Directory inode has a missing block (hole) */ + { PR_2_DIRECTORY_HOLE, + N_("@d @i %i has an unallocated %B. "), + PROMPT_ALLOCATE, 0, 0, 0, 0 }, + + /* '.' is not NULL terminated */ + { PR_2_DOT_NULL_TERM, + /* xgettext:no-c-format */ + N_("'.' @d @e in @d @i %i is not NULL terminated\n"), + PROMPT_FIX, 0, 0, 0, 0 }, + + /* '..' is not NULL terminated */ + { PR_2_DOT_DOT_NULL_TERM, + /* xgettext:no-c-format */ + N_("'..' @d @e in @d @i %i is not NULL terminated\n"), + PROMPT_FIX, 0, 0, 0, 0 }, + + /* Illegal character device inode */ + { PR_2_BAD_CHAR_DEV, + N_("@i %i (%Q) is an @I character @v.\n"), + PROMPT_CLEAR, 0, 0, 0, 0 }, + + /* Illegal block device inode */ + { PR_2_BAD_BLOCK_DEV, + N_("@i %i (%Q) is an @I @b @v.\n"), + PROMPT_CLEAR, 0, 0, 0, 0 }, + + /* Duplicate '.' entry */ + { PR_2_DUP_DOT, + N_("@E is duplicate '.' @e.\n"), + PROMPT_FIX, 0, 0, 0, 0 }, + + /* Duplicate '..' entry */ + { PR_2_DUP_DOT_DOT, + N_("@E is duplicate '..' @e.\n"), + PROMPT_FIX, 0, 0, 0, 0 }, + + /* Internal error: couldn't find dir_info */ + { PR_2_NO_DIRINFO, + /* xgettext:no-c-format */ + N_("Internal error: couldn't find dir_info for %i.\n"), + PROMPT_NONE, PR_FATAL, 0, 0, 0 }, + + /* Final rec_len is wrong */ + { PR_2_FINAL_RECLEN, + N_("@E has rec_len of %Dr, @s %N.\n"), + PROMPT_FIX, 0, 0, 0, 0 }, + + /* Error allocating icount structure */ + { PR_2_ALLOCATE_ICOUNT, + /* xgettext:no-c-format */ + N_("@A icount structure: %m\n"), + PROMPT_NONE, PR_FATAL, 0, 0, 0 }, + + /* Error iterating over directory blocks */ + { PR_2_DBLIST_ITERATE, + /* xgettext:no-c-format */ + N_("Error iterating over @d @bs: %m\n"), + PROMPT_NONE, PR_FATAL, 0, 0, 0 }, + + /* Error reading directory block */ + { PR_2_READ_DIRBLOCK, + N_("Error reading @d @b %b (@i %i): %m\n"), + PROMPT_CONTINUE, 0, 0, 0, 0 }, + + /* Error writing directory block */ + { PR_2_WRITE_DIRBLOCK, + N_("Error writing @d @b %b (@i %i): %m\n"), + PROMPT_CONTINUE, 0, 0, 0, 0 }, + + /* Error allocating new directory block */ + { PR_2_ALLOC_DIRBOCK, + /* xgettext:no-c-format */ + N_("@A new @d @b for @i %i (%s): %m\n"), + PROMPT_NONE, 0, 0, 0, 0 }, + + /* Error deallocating inode */ + { PR_2_DEALLOC_INODE, + /* xgettext:no-c-format */ + N_("Error deallocating @i %i: %m\n"), + PROMPT_NONE, PR_FATAL, 0, 0, 0 }, + + /* Directory entry for '.' is big. Split? */ + { PR_2_SPLIT_DOT, + /* xgettext:no-c-format */ + N_("@d @e for '.' in %p (%i) is big.\n"), + PROMPT_SPLIT, PR_NO_OK, 0, 0, 0 }, + + /* Illegal FIFO inode */ + { PR_2_BAD_FIFO, + N_("@i %i (%Q) is an @I FIFO.\n"), + PROMPT_CLEAR, 0, 0, 0, 0 }, + + /* Illegal socket inode */ + { PR_2_BAD_SOCKET, + N_("@i %i (%Q) is an @I socket.\n"), + PROMPT_CLEAR, 0, 0, 0, 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, 0, 0, 0 }, + + /* Directory filetype incorrect */ + { PR_2_BAD_FILETYPE, + N_("@E has an incorrect filetype (was %Dt, @s %N).\n"), + PROMPT_FIX, 0, 0, 0, 0 }, + + /* Directory filetype set on filesystem */ + { PR_2_CLEAR_FILETYPE, + N_("@E has filetype set.\n"), + PROMPT_CLEAR, PR_PREEN_OK, 0, 0, 0 }, + + /* Directory filename is null */ + { PR_2_NULL_NAME, + N_("@E has a @z name.\n"), + PROMPT_CLEAR, 0, 0, 0, 0 }, + + /* Invalid symlink */ + { PR_2_INVALID_SYMLINK, + N_("Symlink %Q (@i #%i) is @n.\n"), + PROMPT_CLEAR, 0, 0, 0, 0 }, + + /* i_file_acl (extended attribute block) is bad */ + { PR_2_FILE_ACL_BAD, + N_("@a @b @F @n (%If).\n"), + PROMPT_CLEAR, 0, 0, 0, 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, PR_PREEN_OK, 0, 0, 0 }, + + /* Node in HTREE directory not referenced */ + { PR_2_HTREE_NOTREF, + N_("@p @h %d: %B not referenced\n"), + PROMPT_NONE, 0, 0, 0, 0 }, + + /* Node in HTREE directory referenced twice */ + { PR_2_HTREE_DUPREF, + N_("@p @h %d: %B referenced twice\n"), + PROMPT_NONE, 0, 0, 0, 0 }, + + /* Node in HTREE directory has bad min hash */ + { PR_2_HTREE_MIN_HASH, + N_("@p @h %d: %B has bad min hash\n"), + PROMPT_NONE, 0, 0, 0, 0 }, + + /* Node in HTREE directory has bad max hash */ + { PR_2_HTREE_MAX_HASH, + N_("@p @h %d: %B has bad max hash\n"), + PROMPT_NONE, 0, 0, 0, 0 }, + + /* Clear invalid HTREE directory */ + { PR_2_HTREE_CLEAR, + N_("@n @h %d (%q). "), PROMPT_CLEAR_HTREE, 0, 0, 0, 0 }, + + /* Filesystem has large directories, but has no such flag in sb */ + { PR_2_FEATURE_LARGE_DIRS, + N_("@f has large directories, but lacks LARGE_DIR flag in @S.\n"), + PROMPT_FIX, PR_PREEN_OK, 0, 0, 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, 0, 0, 0 }, + + /* Error adjusting EA refcount */ + { PR_2_ADJ_EA_REFCOUNT, + N_("Error adjusting refcount for @a @b %b (@i %i): %m\n"), + PROMPT_NONE, PR_FATAL, 0, 0, 0 }, + + /* Problem in HTREE directory inode: root node is invalid */ + { PR_2_HTREE_BAD_ROOT, + /* xgettext:no-c-format */ + N_("@p @h %d: root node is @n\n"), + PROMPT_CLEAR_HTREE, PR_PREEN_OK, 0, 0, 0 }, + + /* Invalid HTREE limit */ + { PR_2_HTREE_BAD_LIMIT, + N_("@p @h %d: %B has @n limit (%N)\n"), + PROMPT_CLEAR_HTREE, PR_PREEN_OK, 0, 0, 0 }, + + /* Invalid HTREE count */ + { PR_2_HTREE_BAD_COUNT, + N_("@p @h %d: %B has @n count (%N)\n"), + PROMPT_CLEAR_HTREE, PR_PREEN_OK, 0, 0, 0 }, + + /* HTREE interior node has out-of-order hashes in table */ + { PR_2_HTREE_HASH_ORDER, + N_("@p @h %d: %B has an unordered hash table\n"), + PROMPT_CLEAR_HTREE, PR_PREEN_OK, 0, 0, 0 }, + + /* Node in HTREE directory has invalid depth */ + { PR_2_HTREE_BAD_DEPTH, + N_("@p @h %d: %B has @n depth (%N)\n"), + PROMPT_NONE, 0, 0, 0, 0 }, + + /* Duplicate directory entry found */ + { PR_2_DUPLICATE_DIRENT, + N_("Duplicate @E found. "), + PROMPT_CLEAR, 0, 0, 0, 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, 0, 0, 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, 0, 0, 0 }, + + /* i_blocks_hi should be zero */ + { PR_2_BLOCKS_HI_ZERO, + N_("i_blocks_hi @F %N, @s zero.\n"), + PROMPT_CLEAR, 0, 0, 0, 0 }, + + /* Unexpected HTREE block */ + { PR_2_UNEXPECTED_HTREE_BLOCK, + N_("Unexpected @b in @h %d (%q).\n"), PROMPT_CLEAR_HTREE, 0, + 0, 0, 0 }, + + /* Inode found in group where _INODE_UNINIT is set */ + { PR_2_INOREF_BG_INO_UNINIT, + N_("@E references @i %Di in @g %g where _INODE_UNINIT is set.\n"), + PROMPT_FIX, PR_PREEN_OK, 0, 0, 0 }, + + /* Inode found in group unused inodes area */ + { PR_2_INOREF_IN_UNUSED, + N_("@E references @i %Di found in @g %g's unused inodes area.\n"), + PROMPT_FIX, PR_PREEN_OK, 0, 0, 0 }, + + /* i_blocks_hi should be zero */ + { PR_2_I_FILE_ACL_HI_ZERO, + N_("i_file_acl_hi @F %N, @s zero.\n"), + PROMPT_CLEAR, PR_PREEN_OK, 0, 0, 0 }, + + /* htree root node fails checksum */ + { PR_2_HTREE_ROOT_CSUM_INVALID, + /* xgettext:no-c-format */ + N_("@p @h %d: root node fails checksum.\n"), + PROMPT_CLEAR_HTREE, PR_PREEN_OK, 0, 0, 0 }, + + /* htree internal node fails checksum */ + { PR_2_HTREE_NODE_CSUM_INVALID, + /* xgettext:no-c-format */ + N_("@p @h %d: internal node fails checksum.\n"), + PROMPT_CLEAR_HTREE, PR_PREEN_OK, 0, 0, 0 }, + + /* leaf node has no checksum */ + { PR_2_LEAF_NODE_MISSING_CSUM, + N_("@d @i %i, %B, offset %N: @d has no checksum.\n"), + PROMPT_FIX, PR_PREEN_OK, 0, 0, 0 }, + + /* leaf node passes checks but fails checksum */ + { PR_2_LEAF_NODE_ONLY_CSUM_INVALID, + N_("@d @i %i, %B: @d passes checks but fails checksum.\n"), + PROMPT_FIX, PR_PREEN_OK, 0, 0, 0 }, + + /* inline directory inode size must be a multiple of 4 */ + { PR_2_BAD_INLINE_DIR_SIZE, + N_("Inline @d @i %i size (%N) must be a multiple of 4.\n"), + PROMPT_FIX, 0, 0, 0, 0 }, + + /* fixing size of inline directory inode failed */ + { PR_2_FIX_INLINE_DIR_FAILED, + /* xgettext:no-c-format */ + N_("Fixing size of inline @d @i %i failed.\n"), + PROMPT_TRUNCATE, 0, 0, 0, 0 }, + + /* Encrypted directory entry is too short */ + { PR_2_BAD_ENCRYPTED_NAME, + N_("Encrypted @E is too short.\n"), + PROMPT_CLEAR, 0, 0, 0, 0 }, + + /* Encrypted directory contains unencrypted file */ + { PR_2_UNENCRYPTED_FILE, + N_("Encrypted @E references unencrypted @i %Di.\n"), + PROMPT_CLEAR, 0, 0, 0, 0 }, + + /* Encrypted directory contains file with different encryption policy */ + { PR_2_INCONSISTENT_ENCRYPTION_POLICY, + N_("Encrypted @E references @i %Di, which has a different encryption policy.\n"), + PROMPT_CLEAR, 0, 0, 0, 0 }, + + /* Casefolded directory entry has illegal characters in its name */ + { PR_2_BAD_ENCODED_NAME, + N_("@E has illegal UTF-8 characters in its name.\n"), + PROMPT_FIX, 0, 0, 0, 0 }, + + /* Non-unique filename found, but can't rename */ + { PR_2_NON_UNIQUE_FILE_NO_RENAME, + N_("Duplicate filename @E found. "), + PROMPT_CLEAR, 0, 0, 0, 0 }, + + + /* Pass 3 errors */ + + /* Pass 3: Checking directory connectivity */ + { PR_3_PASS_HEADER, + N_("Pass 3: Checking @d connectivity\n"), + PROMPT_NONE, PR_HEADER, 0, 0, 0 }, + + /* Root inode not allocated */ + { PR_3_NO_ROOT_INODE, + N_("@r not allocated. "), + PROMPT_ALLOCATE, 0, 0, 0, 0 }, + + /* No room in lost+found */ + { PR_3_EXPAND_LF_DIR, + N_("No room in @l @d. "), + PROMPT_EXPAND, 0, 0, 0, 0 }, + + /* Unconnected directory inode */ + { PR_3_UNCONNECTED_DIR, + /* xgettext:no-c-format */ + N_("Unconnected @d @i %i (was in %q)\n"), + PROMPT_CONNECT, 0, 0, 0, 0 }, + + /* /lost+found not found */ + { PR_3_NO_LF_DIR, + N_("/@l not found. "), + PROMPT_CREATE, PR_PREEN_OK, 0, 0, 0 }, + + /* .. entry is incorrect */ + { PR_3_BAD_DOT_DOT, + N_("'..' in %Q (%i) is %P (%j), @s %q (%d).\n"), + PROMPT_FIX, 0, 0, 0, 0 }, + + /* Bad or non-existent /lost+found. Cannot reconnect */ + { PR_3_NO_LPF, + /* xgettext:no-c-format */ + N_("Bad or non-existent /@l. Cannot reconnect.\n"), + PROMPT_NONE, 0, 0, 0, 0 }, + + /* Could not expand /lost+found */ + { PR_3_CANT_EXPAND_LPF, + /* xgettext:no-c-format */ + N_("Could not expand /@l: %m\n"), + PROMPT_NONE, 0, 0, 0, 0 }, + + /* Could not reconnect inode */ + { PR_3_CANT_RECONNECT, + /* xgettext:no-c-format */ + N_("Could not reconnect %i: %m\n"), + PROMPT_NONE, 0, 0, 0, 0 }, + + /* Error while trying to find /lost+found */ + { PR_3_ERR_FIND_LPF, + /* xgettext:no-c-format */ + N_("Error while trying to find /@l: %m\n"), + PROMPT_NONE, 0, 0, 0, 0 }, + + /* Error in ext2fs_new_block while creating /lost+found */ + { PR_3_ERR_LPF_NEW_BLOCK, + /* xgettext:no-c-format */ + N_("ext2fs_new_@b: %m while trying to create /@l @d\n"), + PROMPT_NONE, 0, 0, 0, 0 }, + + /* Error in ext2fs_new_inode while creating /lost+found */ + { PR_3_ERR_LPF_NEW_INODE, + /* xgettext:no-c-format */ + N_("ext2fs_new_@i: %m while trying to create /@l @d\n"), + PROMPT_NONE, 0, 0, 0, 0 }, + + /* Error in ext2fs_new_dir_block while creating /lost+found */ + { PR_3_ERR_LPF_NEW_DIR_BLOCK, + /* xgettext:no-c-format */ + N_("ext2fs_new_dir_@b: %m while creating new @d @b\n"), + PROMPT_NONE, 0, 0, 0, 0 }, + + /* Error while writing directory block for /lost+found */ + { PR_3_ERR_LPF_WRITE_BLOCK, + /* xgettext:no-c-format */ + N_("ext2fs_write_dir_@b: %m while writing the @d @b for /@l\n"), + PROMPT_NONE, 0, 0, 0, 0 }, + + /* Error while adjusting inode count */ + { PR_3_ADJUST_INODE, + /* xgettext:no-c-format */ + N_("Error while adjusting @i count on @i %i\n"), + PROMPT_NONE, 0, 0, 0, 0 }, + + /* Couldn't fix parent directory -- error */ + { PR_3_FIX_PARENT_ERR, + /* xgettext:no-c-format */ + N_("Couldn't fix parent of @i %i: %m\n\n"), + PROMPT_NONE, 0, 0, 0, 0 }, + + /* Couldn't fix parent directory -- couldn't find it */ + { PR_3_FIX_PARENT_NOFIND, + /* xgettext:no-c-format */ + N_("Couldn't fix parent of @i %i: Couldn't find parent @d @e\n\n"), + PROMPT_NONE, 0, 0, 0, 0 }, + + /* Error allocating inode bitmap */ + { PR_3_ALLOCATE_IBITMAP_ERROR, + N_("@A @i @B (%N): %m\n"), + PROMPT_NONE, PR_FATAL, 0, 0, 0 }, + + /* Error creating root directory */ + { PR_3_CREATE_ROOT_ERROR, + /* xgettext:no-c-format */ + N_("Error creating root @d (%s): %m\n"), + PROMPT_NONE, PR_FATAL, 0, 0, 0 }, + + /* Error creating lost and found directory */ + { PR_3_CREATE_LPF_ERROR, + /* xgettext:no-c-format */ + N_("Error creating /@l @d (%s): %m\n"), + PROMPT_NONE, 0, 0, 0, 0 }, + + /* Root inode is not directory; aborting */ + { PR_3_ROOT_NOT_DIR_ABORT, + N_("@r is not a @d; aborting.\n"), + PROMPT_NONE, PR_FATAL, 0, 0, 0 }, + + /* Cannot proceed without a root inode. */ + { PR_3_NO_ROOT_INODE_ABORT, + N_("Cannot proceed without a @r.\n"), + PROMPT_NONE, PR_FATAL, 0, 0, 0 }, + + /* 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, 0, 0, 0 }, + + /* Lost+found not a directory */ + { PR_3_LPF_NOTDIR, + /* xgettext:no-c-format */ + N_("/@l is not a @d (ino=%i)\n"), + PROMPT_UNLINK, 0, 0, 0, 0 }, + + /* Lost+found has inline data */ + { PR_3_LPF_INLINE_DATA, + N_("/@l has inline data\n"), + PROMPT_CLEAR, 0, 0, 0, 0 }, + + /* Cannot allocate /lost+found. */ + { PR_3_LPF_NO_SPACE, + N_("Cannot allocate space for /@l.\nPlace lost files in root directory instead"), + PROMPT_NULL, 0, 0, 0, 0 }, + + /* Delete some files and re-run e2fsck. */ + { PR_3_NO_SPACE_TO_RECOVER, + N_("Insufficient space to recover lost files!\nMove data off the @f and re-run e2fsck.\n\n"), + PROMPT_NONE, 0, 0, 0, 0 }, + + /* Lost+found is encrypted */ + { PR_3_LPF_ENCRYPTED, + N_("/@l is encrypted\n"), + PROMPT_CLEAR, 0, 0, 0, 0 }, + + /* Recursively looped directory inode */ + { PR_3_LOOPED_DIR, + /* xgettext:no-c-format */ + N_("Recursively looped @d @i %i (%p)\n"), + PROMPT_CONNECT, 0, 0, 0, 0 }, + + /* Pass 3A Directory Optimization */ + + /* Pass 3A: Optimizing directories */ + { PR_3A_PASS_HEADER, + N_("Pass 3A: Optimizing directories\n"), + PROMPT_NONE, PR_HEADER | PR_PREEN_NOMSG, 0, 0, 0 }, + + /* Error iterating over directories */ + { PR_3A_OPTIMIZE_ITER, + /* xgettext:no-c-format */ + N_("Failed to create dirs_to_hash iterator: %m\n"), + PROMPT_NONE, 0, 0, 0, 0 }, + + /* Error rehash directory */ + { PR_3A_OPTIMIZE_DIR_ERR, + N_("Failed to optimize directory %q (%d): %m\n"), + PROMPT_NONE, 0, 0, 0, 0 }, + + /* Rehashing dir header */ + { PR_3A_OPTIMIZE_DIR_HEADER, + N_("Optimizing directories: "), + PROMPT_NONE, PR_MSG_ONLY, 0, 0, 0 }, + + /* Rehashing directory %d */ + { PR_3A_OPTIMIZE_DIR, + " %d", + PROMPT_NONE, PR_LATCH_OPTIMIZE_DIR | PR_PREEN_NOHDR, 0, 0, 0 }, + + /* Rehashing dir end */ + { PR_3A_OPTIMIZE_DIR_END, + "\n", + PROMPT_NONE, PR_PREEN_NOHDR, 0, 0, 0 }, + + /* Pass 4 errors */ + + /* Pass 4: Checking reference counts */ + { PR_4_PASS_HEADER, + N_("Pass 4: Checking reference counts\n"), + PROMPT_NONE, PR_HEADER, 0, 0, 0 }, + + /* Unattached zero-length inode */ + { PR_4_ZERO_LEN_INODE, + /* xgettext:no-c-format */ + N_("@u @z @i %i. "), + PROMPT_CLEAR, PR_PREEN_OK|PR_NO_OK, 0, 0, 0 }, + + /* Unattached inode */ + { PR_4_UNATTACHED_INODE, + /* xgettext:no-c-format */ + N_("@u @i %i\n"), + PROMPT_CONNECT, 0, 0, 0, 0 }, + + /* Inode ref count wrong */ + { PR_4_BAD_REF_COUNT, + N_("@i %i ref count is %Il, @s %N. "), + PROMPT_FIX, PR_PREEN_OK, 0, 0, 0 }, + + { 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 @s the same!\n"), + PROMPT_NONE, 0, 0, 0, 0 }, + + { PR_4_EA_INODE_REF_COUNT, + N_("@a @i %i ref count is %N, @s %n. "), + PROMPT_FIX, PR_PREEN_OK, 0, 0, 0 }, + + /* directory exceeds max links, but no DIR_NLINK feature in superblock*/ + { PR_4_DIR_NLINK_FEATURE, + N_("@d exceeds max links, but no DIR_NLINK feature in @S.\n"), + PROMPT_FIX, 0, 0, 0, 0 }, + + /* Directory inode ref count set to overflow but could be exact value */ + { PR_4_DIR_OVERFLOW_REF_COUNT, + N_("@d @i %i ref count set to overflow but could be exact value %N. "), + PROMPT_FIX, PR_PREEN_OK, 0, 0, 0 }, + + /* Pass 5 errors */ + + /* Pass 5: Checking group summary information */ + { PR_5_PASS_HEADER, + N_("Pass 5: Checking @g summary information\n"), + PROMPT_NONE, PR_HEADER, 0, 0, 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, 0, 0, 0 }, + + /* 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, 0, 0, 0 }, + + /* Block bitmap differences header */ + { PR_5_BLOCK_BITMAP_HEADER, + N_("@b @B differences: "), + PROMPT_NONE, PR_PREEN_OK | PR_PREEN_NOMSG, 0, 0, 0 }, + + /* Block not used, but marked in bitmap */ + { PR_5_BLOCK_UNUSED, + " -%b", + PROMPT_NONE, PR_LATCH_BBITMAP | PR_PREEN_OK | PR_PREEN_NOMSG, + 0, 0, 0 }, + + /* Block used, but not marked used in bitmap */ + { PR_5_BLOCK_USED, + " +%b", + PROMPT_NONE, PR_LATCH_BBITMAP | PR_PREEN_OK | PR_PREEN_NOMSG, + 0, 0, 0 }, + + /* Block bitmap differences end */ + { PR_5_BLOCK_BITMAP_END, + "\n", + PROMPT_FIX, PR_PREEN_OK | PR_PREEN_NOMSG, 0, 0, 0 }, + + /* Inode bitmap differences header */ + { PR_5_INODE_BITMAP_HEADER, + N_("@i @B differences: "), + PROMPT_NONE, PR_PREEN_OK | PR_PREEN_NOMSG, 0, 0, 0 }, + + /* Inode not used, but marked in bitmap */ + { PR_5_INODE_UNUSED, + " -%i", + PROMPT_NONE, PR_LATCH_IBITMAP | PR_PREEN_OK | PR_PREEN_NOMSG, + 0, 0, 0 }, + + /* Inode used, but not marked used in bitmap */ + { PR_5_INODE_USED, + " +%i", + PROMPT_NONE, PR_LATCH_IBITMAP | PR_PREEN_OK | PR_PREEN_NOMSG, + 0, 0, 0 }, + + /* Inode bitmap differences end */ + { PR_5_INODE_BITMAP_END, + "\n", + PROMPT_FIX, PR_PREEN_OK | PR_PREEN_NOMSG, 0, 0, 0 }, + + /* 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, 0, 0, 0 }, + + /* 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, 0, 0, 0 }, + + /* Free inodes count wrong */ + { PR_5_FREE_INODE_COUNT, + N_("Free @is count wrong (%i, counted=%j).\n"), + PROMPT_FIX, PR_PREEN_OK | PR_NO_OK | PR_PREEN_NOMSG, 0, 0, 0 }, + + /* 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, 0, 0, 0 }, + + /* Free blocks count wrong */ + { PR_5_FREE_BLOCK_COUNT, + N_("Free @bs count wrong (%b, counted=%c).\n"), + PROMPT_FIX, PR_PREEN_OK | PR_NO_OK | PR_PREEN_NOMSG, 0, 0, 0 }, + + /* 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, 0, 0, 0 }, + + /* Internal error: fudging end of bitmap */ + { PR_5_FUDGE_BITMAP_ERROR, + N_("Internal error: fudging end of bitmap (%N)\n"), + PROMPT_NONE, PR_FATAL, 0, 0, 0 }, + + /* Error copying in replacement inode bitmap */ + { PR_5_COPY_IBITMAP_ERROR, + /* xgettext:no-c-format */ + N_("Error copying in replacement @i @B: %m\n"), + PROMPT_NONE, PR_FATAL, 0, 0, 0 }, + + /* Error copying in replacement block bitmap */ + { PR_5_COPY_BBITMAP_ERROR, + /* xgettext:no-c-format */ + N_("Error copying in replacement @b @B: %m\n"), + PROMPT_NONE, PR_FATAL, 0, 0, 0 }, + + /* 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, + 0, 0, 0 }, + + /* 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, + 0, 0, 0 }, + + /* 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, + 0, 0, 0 }, + + /* 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, 0, 0 }, + + /* Group N block(s) in use but group is marked BLOCK_UNINIT */ + { PR_5_BLOCK_UNINIT, + /* xgettext:no-c-format */ + N_("@g %g @b(s) in use but @g is marked BLOCK_UNINIT\n"), + PROMPT_FIX, PR_PREEN_OK, 0, 0, 0 }, + + /* Group N inode(s) in use but group is marked INODE_UNINIT */ + { PR_5_INODE_UNINIT, + /* xgettext:no-c-format */ + N_("@g %g @i(s) in use but @g is marked INODE_UNINIT\n"), + PROMPT_FIX, PR_PREEN_OK, 0, 0, 0 }, + + /* Group N inode bitmap does not match checksum */ + { PR_5_INODE_BITMAP_CSUM_INVALID, + /* xgettext:no-c-format */ + N_("@g %g @i @B does not match checksum.\n"), + PROMPT_FIX, PR_LATCH_IBITMAP | PR_PREEN_OK, 0, 0, 0 }, + + /* Group N block bitmap does not match checksum */ + { PR_5_BLOCK_BITMAP_CSUM_INVALID, + /* xgettext:no-c-format */ + N_("@g %g @b @B does not match checksum.\n"), + PROMPT_FIX, PR_LATCH_BBITMAP | PR_PREEN_OK, 0, 0, 0 }, + + /* Post-Pass 5 errors */ + + /* Recreate journal if E2F_FLAG_JOURNAL_INODE flag is set */ + { PR_6_RECREATE_JOURNAL, + N_("Recreate @j"), + PROMPT_NULL, PR_PREEN_OK | PR_NO_OK, 0, 0, 0 }, + + /* Update quota information if it is inconsistent */ + { PR_6_UPDATE_QUOTAS, + N_("Update quota info for quota type %N"), + PROMPT_NULL, PR_PREEN_OK, 0, 0, 0 }, + + /* Error setting block group checksum info */ + { PR_6_SET_BG_CHECKSUM, + /* xgettext:no-c-format */ + N_("Error setting @b @g checksum info: %m\n"), + PROMPT_NULL, PR_FATAL, 0, 0, 0 }, + + /* Error writing file system info */ + { PR_6_FLUSH_FILESYSTEM, + /* xgettext:no-c-format */ + N_("Error writing file system info: %m\n"), + PROMPT_NULL, PR_FATAL, 0, 0, 0 }, + + /* Error flushing writes to storage device */ + { PR_6_IO_FLUSH, + /* xgettext:no-c-format */ + N_("Error flushing writes to storage device: %m\n"), + PROMPT_NULL, PR_FATAL, 0, 0, 0 }, + + /* Error writing quota information */ + { PR_6_WRITE_QUOTAS, + N_("Error writing quota info for quota type %N: %m\n"), + PROMPT_NULL, 0, 0, 0, 0 }, + + /* Orphan file without a journal */ + { PR_6_ORPHAN_FILE_WITHOUT_JOURNAL, + N_("@S has orphan file without @j.\n"), + PROMPT_CLEAR, PR_PREEN_OK }, + + /* Orphan file truncation failed */ + { PR_6_ORPHAN_FILE_TRUNC_FAILED, + N_("Failed to truncate orphan file.\n"), + PROMPT_NONE, 0 }, + + /* Failed to initialize orphan file */ + { PR_6_ORPHAN_FILE_CORRUPTED, + N_("Failed to initialize orphan file.\n"), + PROMPT_RECREATE, PR_PREEN_OK }, + + /* Cannot fix corrupted orphan file with invalid bitmaps */ + { PR_6_ORPHAN_FILE_BITMAP_INVALID, + N_("Cannot fix corrupted orphan file with invalid bitmaps.\n"), + PROMPT_NONE, 0 }, + + /* Orphan file creation failed */ + { PR_6_ORPHAN_FILE_CREATE_FAILED, + N_("Failed to truncate orphan file (@i %i).\n"), + PROMPT_NONE, 0 }, + + /* Orphan file block contains data */ + { PR_6_ORPHAN_BLOCK_DIRTY, + N_("Orphan file (@i %i) @b %b is not clean.\n"), + PROMPT_CLEAR, PR_PREEN_OK }, + + /* orphan_present set but orphan file is empty */ + { PR_6_ORPHAN_PRESENT_CLEAN_FILE, + N_("Feature orphan_present is set but orphan file is clean.\n"), + PROMPT_CLEAR, PR_PREEN_OK }, + + /* orphan_present set but orphan_file is not */ + { PR_6_ORPHAN_PRESENT_NO_FILE, + N_("Feature orphan_present is set but feature orphan_file is not.\n"), + PROMPT_CLEAR, PR_PREEN_OK }, + + /* Orphan file size isn't multiple of blocks size */ + { PR_6_ORPHAN_FILE_WRONG_SIZE, + N_("Orphan file (@i %i) size is not multiple of block size.\n"), + PROMPT_NONE, 0 }, + + /* Orphan file contains holes */ + { PR_6_ORPHAN_FILE_HOLE, + N_("Orphan file (@i %i) contains hole at @b %b.\n"), + PROMPT_NONE, 0 }, + + { 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, 0 }, + { PR_LATCH_BBLOCK, PR_1_INODE_BBLOCK_LATCH, 0, 0 }, + { PR_LATCH_IBITMAP, PR_5_INODE_BITMAP_HEADER, PR_5_INODE_BITMAP_END, 0 }, + { PR_LATCH_BBITMAP, PR_5_BLOCK_BITMAP_HEADER, PR_5_BLOCK_BITMAP_END, 0 }, + { PR_LATCH_RELOC, PR_0_RELOCATE_HINT, 0, 0 }, + { PR_LATCH_DBLOCK, PR_1B_DUP_BLOCK_HEADER, PR_1B_DUP_BLOCK_END, 0 }, + { PR_LATCH_LOW_DTIME, PR_1_ORPHAN_LIST_REFUGEES, 0, 0 }, + { PR_LATCH_TOOBIG, PR_1_INODE_TOOBIG, 0, 0 }, + { PR_LATCH_OPTIMIZE_DIR, PR_3A_OPTIMIZE_DIR_HEADER, PR_3A_OPTIMIZE_DIR_END, 0 }, + { PR_LATCH_BG_CHECKSUM, PR_0_GDT_CSUM_LATCH, 0, 0 }, + { PR_LATCH_OPTIMIZE_EXT, PR_1E_OPTIMIZE_EXT_HEADER, PR_1E_OPTIMIZE_EXT_END, 0 }, + { -1, 0, 0, 0 }, +}; +#if __GNUC_PREREQ (4, 6) +#pragma GCC diagnostic pop +#endif + +static 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) + return answer; + 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; +} + +static void reconfigure_bool(e2fsck_t ctx, struct e2fsck_problem *ptr, + const char *key, int mask, const char *name) +{ + int val; + + val = (ptr->flags & mask); + profile_get_boolean(ctx->profile, "problems", key, name, val, &val); + if (val) + ptr->flags |= mask; + else + ptr->flags &= ~mask; +} + +static void print_problem(FILE *f, problem_t code, int answer, int fixed, + struct e2fsck_problem *ptr, + struct problem_context *pctx) +{ + if (ptr->flags & PR_HEADER) { + fprintf(f, "
\n", code); + return; + } + fprintf(f, "errcode) + fprintf(f, " errcode=\"%lu\"", pctx->errcode); + if (fixed) + fputs(" fixed=\"1\"", f); + if (pctx->ino) + fprintf(f, " ino=\"%u\"", pctx->ino); + if (pctx->ino2) + fprintf(f, " ino2=\"%u\"", pctx->ino2); + if (pctx->dir) + fprintf(f, " dir=\"%u\"", pctx->dir); + if (pctx->blk) + fprintf(f, " blk=\"%llu\"", (unsigned long long) pctx->blk); + if (pctx->blk2) + fprintf(f, " blk2=\"%llu\"", (unsigned long long) pctx->blk2); + if (pctx->blkcount != (e2_blkcnt_t) -1) + fprintf(f, " blkcount=\"%lld\"", (unsigned long long) pctx->blkcount); + if (pctx->group != (dgrp_t) -1) + fprintf(f, " group=\"%u\"", pctx->group); + if (pctx->csum1) + fprintf(f, " csum1=\"%u\"", pctx->csum1); + if (pctx->csum2) + fprintf(f, " csum2=\"%u\"", pctx->csum2); + if (pctx->num) + fprintf(f, " num=\"%llu\"", (unsigned long long) pctx->num); + if (pctx->num2) + fprintf(f, " num2=\"%llu\"", (unsigned long long) pctx->num2); + if (pctx->str) + fprintf(f, " str=\"%s\"", pctx->str); + fputs("/>\n", f); +} + +int fix_problem(e2fsck_t ctx, problem_t code, struct problem_context *pctx) +{ + ext2_filsys fs = ctx->fs; + struct e2fsck_problem *ptr; + struct latch_descr *ldesc = 0; + const char *message; + int def_yn, answer, ans; + int print_answer = 0; + int suppress = 0; + int fixed = 0; + + ptr = find_problem(code); + if (!ptr) { + printf(_("Unhandled error code (0x%x)!\n"), code); + return 0; + } + if (!(ptr->flags & PR_CONFIG)) { + char key[9], *new_desc = NULL; + + sprintf(key, "0x%06x", code); + + profile_get_string(ctx->profile, "problems", key, + "description", 0, &new_desc); + if (new_desc) + ptr->e2p_description = new_desc; + + reconfigure_bool(ctx, ptr, key, PR_PREEN_OK, "preen_ok"); + reconfigure_bool(ctx, ptr, key, PR_NO_OK, "no_ok"); + reconfigure_bool(ctx, ptr, key, PR_NO_DEFAULT, "no_default"); + reconfigure_bool(ctx, ptr, key, PR_MSG_ONLY, "print_message_only"); + reconfigure_bool(ctx, ptr, key, PR_PREEN_NOMSG, "preen_nomessage"); + reconfigure_bool(ctx, ptr, key, PR_NOCOLLATE, "no_collate"); + reconfigure_bool(ctx, ptr, key, PR_NO_NOMSG, "no_nomsg"); + reconfigure_bool(ctx, ptr, key, PR_PREEN_NOHDR, "preen_noheader"); + reconfigure_bool(ctx, ptr, key, PR_FORCE_NO, "force_no"); + reconfigure_bool(ctx, ptr, key, PR_NOT_A_FIX, "not_a_fix"); + profile_get_integer(ctx->profile, "options", + "max_count_problems", 0, 0, + &ptr->max_count); + profile_get_integer(ctx->profile, "problems", key, "max_count", + ptr->max_count, &ptr->max_count); + + ptr->flags |= PR_CONFIG; + } + def_yn = 1; + ptr->count++; + 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)) != NULL) { + 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) || (ptr->flags & PR_FORCE_NO))) + suppress++; + if (ptr->max_count && (ptr->count > ptr->max_count)) { + if (ctx->options & (E2F_OPT_NO | E2F_OPT_YES)) + suppress++; + if ((ctx->options & E2F_OPT_PREEN) && + (ptr->flags & PR_PREEN_OK)) + suppress++; + if (ldesc && (ldesc->flags & (PRL_YES | PRL_NO))) + suppress++; + if (ptr->count == ptr->max_count + 1) { + if (ctx->problem_logf) + fprintf(ctx->problem_logf, + "\n", + code); + printf("...problem 0x%06x suppressed\n", + ptr->e2p_code); + fflush(stdout); + } + } + message = ptr->e2p_description; + if (*message) + message = _(message); + if (!suppress) { + 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(stdout, ctx, message, pctx, 1, 0); + } + if (ctx->logf && message) + print_e2fsck_message(ctx->logf, ctx, message, pctx, 1, 0); + 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 (ptr->flags & PR_FORCE_NO) { + answer = 0; + print_answer = 1; + } else if (ctx->options & E2F_OPT_PREEN) { + answer = def_yn; + if (!(ptr->flags & PR_PREEN_NOMSG)) + print_answer = 1; + } else if (ldesc && (ldesc->flags & (PRL_YES | PRL_NO))) { + print_answer = 1; + if (ldesc->flags & PRL_YES) + answer = 1; + else + answer = 0; + } else + answer = ask(ctx, (ptr->prompt == PROMPT_NULL) ? "" : + _(prompt[(int) ptr->prompt]), def_yn); + if (!answer && !(ptr->flags & PR_NO_OK)) + ext2fs_unmark_valid(fs); + + if (print_answer) { + if (!suppress) + printf("%s.\n", answer ? + _(preen_msg[(int) ptr->prompt]) : + _("IGNORED")); + if (ctx->logf) + fprintf(ctx->logf, "%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); + + if (answer && (ptr->prompt != PROMPT_NONE) && + !(ptr->flags & PR_NOT_A_FIX)) { + fixed = 1; + ctx->flags |= E2F_FLAG_PROBLEMS_FIXED; + } + + if (ctx->problem_logf) + print_problem(ctx->problem_logf, code, answer, fixed, + ptr, pctx); + + return answer; +} + +#ifdef UNITTEST + +#include +#include + +errcode_t +profile_get_boolean(profile_t profile, const char *name, const char *subname, + const char *subsubname, int def_val, int *ret_boolean) +{ + return 0; +} + +errcode_t +profile_get_integer(profile_t profile, const char *name, const char *subname, + const char *subsubname, int def_val, int *ret_int) +{ + return 0; +} + +void print_e2fsck_message(FILE *f, e2fsck_t ctx, const char *msg, + struct problem_context *pctx, int first, + int recurse) +{ + return; +} + +void fatal_error(e2fsck_t ctx, const char *msg) +{ + return; +} + +void preenhalt(e2fsck_t ctx) +{ + return; +} + +errcode_t +profile_get_string(profile_t profile, const char *name, const char *subname, + const char *subsubname, const char *def_val, + char **ret_string) +{ + return 0; +} + +int ask (e2fsck_t ctx, const char * string, int def) +{ + return 0; +} + +int verify_problem_table(e2fsck_t ctx) +{ + struct e2fsck_problem *curr, *prev = NULL; + int rc = 0; + + for (prev = NULL, curr = problem_table; curr->e2p_code; prev = curr++) { + if (prev == NULL) + continue; + + if (curr->e2p_code > prev->e2p_code) + continue; + + if (curr->e2p_code == prev->e2p_code) + fprintf(stderr, "*** Duplicate in problem table:\n"); + else + fprintf(stderr, "*** Unordered problem table:\n"); + + fprintf(stderr, "curr code = 0x%08x: %s\n", + curr->e2p_code, curr->e2p_description); + fprintf(stderr, "*** prev code = 0x%08x: %s\n", + prev->e2p_code, prev->e2p_description); + + fprintf(stderr, "*** This is a %sprogramming error in e2fsck\n", + (curr->e2p_code == prev->e2p_code) ? "fatal " : ""); + + rc = 1; + } + + return rc; +} + +int main(int argc, char *argv[]) +{ + e2fsck_t ctx; + int rc; + + memset(&ctx, 0, sizeof(ctx)); /* just to quiet compiler */ + rc = verify_problem_table(ctx); + if (rc == 0) + printf("e2fsck problem table verified\n"); + + return rc; +} +#endif /* UNITTEST */ diff --git a/e2fsck/problem.h b/e2fsck/problem.h new file mode 100644 index 0000000..b47b0c6 --- /dev/null +++ b/e2fsck/problem.h @@ -0,0 +1,1359 @@ +/* + * 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; + blk64_t blk, blk2; + e2_blkcnt_t blkcount; + dgrp_t group; + __u32 csum1, csum2; + __u64 num, num2; + 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_BG_CHECKSUM 0x00A0 /* Latch for block group checksums */ +#define PR_LATCH_OPTIMIZE_EXT 0x00B0 /* Latch for rebuild extents */ + +#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 for group gggg is not in group */ +#define PR_0_BB_NOT_GROUP 0x000001 + +/* Inode bitmap for group gggg is not in group */ +#define PR_0_IB_NOT_GROUP 0x000002 + +/* Inode table for group gggg is not in group. (block nnnn) */ +#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 + +/* Superblock blocks_per_group = bbbb, should have been cccc */ +#define PR_0_BLOCKS_PER_GROUP 0x000007 + +/* Superblock first_data_block = bbbb, should have been cccc */ +#define PR_0_FIRST_DATA_BLOCK 0x000008 + +/* Filesystem did not have a UUID; generating one */ +#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 determining 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 + +/* Superblock has an invalid journal (inode inum) */ +#define PR_0_JOURNAL_BAD_INODE 0x00000F + +/* External journal has multiple filesystem users (unsupported) */ +#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 + +/* Filesystem journal superblock is an unknown type */ +#define PR_0_JOURNAL_UNSUPP_SUPER 0x000014 + +/* Journal superblock is corrupt */ +#define PR_0_JOURNAL_BAD_SUPER 0x000015 + +/* Superblock has_journal flag is clear but has a journal */ +#define PR_0_JOURNAL_HAS_JOURNAL 0x000016 + +/* Superblock needs_recovery flag is set but no journal is present */ +#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 version not supported by this e2fsck */ +#define PR_0_JOURNAL_UNSUPP_VERSION 0x000027 + +/* Moving journal from /file to hidden inode */ +#define PR_0_MOVE_JOURNAL 0x000028 + +/* Error moving journal to hidden file */ +#define PR_0_ERR_MOVE_JOURNAL 0x000029 + +/* Found invalid V2 journal superblock fields */ +#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 + +/* Backing up journal inode block information */ +#define PR_0_BACKUP_JNL 0x00002D + +/* Filesystem does not have resize_inode enabled, but + * s_reserved_gdt_blocks is nnnn; should be zero */ +#define PR_0_NONZERO_RESERVED_GDT_BLOCKS 0x00002E + +/* Resize_inode not enabled, but the resize inode is non-zero */ +#define PR_0_CLEAR_RESIZE_INODE 0x00002F + +/* Resize inode not valid */ +#define PR_0_RESIZE_INODE_INVALID 0x000030 + +/* Superblock last mount time is in the future */ +#define PR_0_FUTURE_SB_LAST_MOUNT 0x000031 + +/* Superblock last write time is in the future */ +#define PR_0_FUTURE_SB_LAST_WRITE 0x000032 + +/* Superblock hint for external superblock should be xxxx */ +#define PR_0_EXTERNAL_JOURNAL_HINT 0x000033 + +/* Adding dirhash hint to filesystem */ +#define PR_0_DIRHASH_HINT 0x000034 + +/* group descriptor N checksum is invalid, should be yyyy. */ +#define PR_0_GDT_CSUM 0x000035 + +/* Group descriptor N marked uninitialized without feature set. */ +#define PR_0_GDT_UNINIT 0x000036 + +/* Block bitmap is not initialised and Inode bitmap is -- NO LONGER USED */ +/* #define PR_0_BB_UNINIT_IB_INIT 0x000037 */ + +/* Group descriptor N has invalid unused inodes count. */ +#define PR_0_GDT_ITABLE_UNUSED 0x000038 + +/* Last group block bitmap is uninitialized. */ +#define PR_0_BB_UNINIT_LAST 0x000039 + +/* Journal transaction was corrupt, replay was aborted */ +#define PR_0_JNL_TXN_CORRUPT 0x00003A + +/* The test_fs filesystem flag is set and ext4 is available */ +#define PR_0_CLEAR_TESTFS_FLAG 0x00003B + +/* Last mount time is in the future (fudged) */ +#define PR_0_FUTURE_SB_LAST_MOUNT_FUDGED 0x00003C + +/* Last write time is in the future (fudged) */ +#define PR_0_FUTURE_SB_LAST_WRITE_FUDGED 0x00003D + +/* One or more block group descriptor checksums are invalid (latch) */ +#define PR_0_GDT_CSUM_LATCH 0x00003E + +/* Setting free inodes count to right (was wrong) */ +#define PR_0_FREE_INODE_COUNT 0x00003F + +/* Setting free blocks count to right (was wrong) */ +#define PR_0_FREE_BLOCK_COUNT 0x000040 + +/* Making quota inode hidden */ +#define PR_0_HIDE_QUOTA 0x000041 + +/* Superblock has invalid MMP block. */ +#define PR_0_MMP_INVALID_BLK 0x000042 + +/* Superblock has invalid MMP magic. */ +#define PR_0_MMP_INVALID_MAGIC 0x000043 + +/* Opening file system failed */ +#define PR_0_OPEN_FAILED 0x000044 + +/* Checking group descriptor failed */ +#define PR_0_CHECK_DESC_FAILED 0x000045 + +/* Superblock metadata_csum supersedes uninit_bg; both feature + * bits cannot be set simultaneously. */ +#define PR_0_META_AND_GDT_CSUM_SET 0x000046 + +/* Superblock MMP block checksum does not match MMP block. */ +#define PR_0_MMP_CSUM_INVALID 0x000047 + +/* Superblock 64bit filesystem needs extents to access the whole disk */ +#define PR_0_64BIT_WITHOUT_EXTENTS 0x000048 + +/* The first_meta_bg is too big */ +#define PR_0_FIRST_META_BG_TOO_BIG 0x000049 + +/* External journal superblock checksum does not match superblock */ +#define PR_0_EXT_JOURNAL_SUPER_CSUM_INVALID 0x00004A + +/* metadata_csum_seed means nothing without metadata_csum */ +#define PR_0_CSUM_SEED_WITHOUT_META_CSUM 0x00004B + +/* Error initializing quota context */ +#define PR_0_QUOTA_INIT_CTX 0x00004C + +/* Bad required extra isize in superblock */ +#define PR_0_BAD_MIN_EXTRA_ISIZE 0x00004D + +/* Bad desired extra isize in superblock */ +#define PR_0_BAD_WANT_EXTRA_ISIZE 0x00004E + +/* Invalid quota inode number */ +#define PR_0_INVALID_QUOTA_INO 0x00004F + +/* Inode count in the superblock incorrect */ +#define PR_0_INODE_COUNT_BIG 0x000050 + +/* Meta_bg and resize_inode are not compatible, remove resize_inode*/ +#define PR_0_DISABLE_RESIZE_INODE 0x000051 + +/* Orphan file contains holes */ +#define PR_0_ORPHAN_FILE_HOLE 0x000052 + +/* Orphan file block has wrong magic */ +#define PR_0_ORPHAN_FILE_BAD_MAGIC 0x000053 + +/* Orphan file block has wrong checksum */ +#define PR_0_ORPHAN_FILE_BAD_CHECKSUM 0x000054 + +/* Orphan file size isn't multiple of blocks size */ +#define PR_0_ORPHAN_FILE_WRONG_SIZE 0x000055 + +/* + * Pass 1 errors + */ + +/* Pass 1: Checking inodes, blocks, and sizes */ +#define PR_1_PASS_HEADER 0x010000 + +/* Root inode is not a directory */ +#define PR_1_ROOT_NO_DIR 0x010001 + +/* Root inode has dtime set */ +#define PR_1_ROOT_DTIME 0x010002 + +/* Reserved inode has bad mode */ +#define PR_1_RESERVED_BAD_MODE 0x010003 + +/* Deleted inode inum has zero dtime */ +#define PR_1_ZERO_DTIME 0x010004 + +/* Inode inum is in use, but has dtime set */ +#define PR_1_SET_DTIME 0x010005 + +/* Inode inum is a zero-length directory */ +#define PR_1_ZERO_LENGTH_DIR 0x010006 + +/* Group block bitmap at block conflicts with some other fs block */ +#define PR_1_BB_CONFLICT 0x010007 + +/* Group inode bitmap at block conflicts with some other fs block */ +#define PR_1_IB_CONFLICT 0x010008 + +/* Group inode table at block conflicts with some other fs block */ +#define PR_1_ITABLE_CONFLICT 0x010009 + +/* Group block bitmap (block) is bad */ +#define PR_1_BB_BAD_BLOCK 0x01000A + +/* Group inode bitmap (block) is bad */ +#define PR_1_IB_BAD_BLOCK 0x01000B + +/* Inode i_size is small, should be larger */ +#define PR_1_BAD_I_SIZE 0x01000C + +/* Inode i_blocks is small, should be larger */ +#define PR_1_BAD_I_BLOCKS 0x01000D + +/* Illegal block number in inode */ +#define PR_1_ILLEGAL_BLOCK_NUM 0x01000E + +/* Block number overlaps filesystem metadata in inode */ +#define PR_1_BLOCK_OVERLAPS_METADATA 0x01000F + +/* Inode has illegal blocks (latch question) */ +#define PR_1_INODE_BLOCK_LATCH 0x010010 + +/* Too many illegal 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 number used as bad block inode 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 + +/* The primary superblock block is on the bad block list */ +#define PR_1_BAD_PRIMARY_SUPERBLOCK 0x010019 + +/* Bad primary block group descriptors */ +#define PR_1_BAD_PRIMARY_GROUP_DESCRIPTOR 0x01001A + +/* Warning: Group number's superblock (block) is bad */ +#define PR_1_BAD_SUPERBLOCK 0x01001B + +/* Warning: Group number's copy of the group descriptors has a bad block */ +#define PR_1_BAD_GROUP_DESCRIPTORS 0x01001C + +/* Block number claimed for no reason in process_bad_blocks */ +#define PR_1_PROGERR_CLAIMED_BLOCK 0x01001D + +/* Allocating number contiguous block(s) in block group number */ +#define PR_1_RELOC_BLOCK_ALLOCATE 0x01001E + +/* Allocating block buffer for relocating process */ +#define PR_1_RELOC_MEMORY_ALLOCATE 0x01001F + +/* Relocating group number's information from X to Y */ +#define PR_1_RELOC_FROM_TO 0x010020 + +/* Relocating group number's information to X */ +#define PR_1_RELOC_TO 0x010021 + +/* Warning: could not read block number of relocation process */ +#define PR_1_RELOC_READ_ERR 0x010022 + +/* Warning: could not write block number of 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 link information */ +#define PR_1_ALLOCATE_ICOUNT 0x010026 + +/* Error allocating directory block array */ +#define PR_1_ALLOCATE_DBCOUNT 0x010027 + +/* Error while scanning inodes */ +#define PR_1_ISCAN_ERROR 0x010028 + +/* Error while iterating over blocks in inode */ +#define PR_1_BLOCK_ITERATE 0x010029 + +/* Error storing inode count information */ +#define PR_1_ICOUNT_STORE 0x01002A + +/* Error storing directory block information */ +#define PR_1_ADD_DBLOCK 0x01002B + +/* Error reading inode (for clearing) */ +#define PR_1_READ_INODE 0x01002C + +/* Suppress messages prompt */ +#define PR_1_SUPPRESS_MESSAGES 0x01002D + +/* Imagic number has imagic flag set when fs 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 -- no longer used*/ +/* #define PR_1_COMPR_SET 0x010031 */ + +/* Non-zero size on on device, fifo or socket inode */ +#define PR_1_SET_NONZSIZE 0x010032 + +/* Filesystem has feature flag(s) set, but is a revision 0 filesystem */ +#define PR_1_FS_REV_LEVEL 0x010033 + +/* Journal inode is not in use, but contains data */ +#define PR_1_JOURNAL_INODE_NOT_CLEAR 0x010034 + +/* Journal is not a regular file */ +#define PR_1_JOURNAL_BAD_MODE 0x010035 + +/* Inode that was part of the orphan list */ +#define PR_1_LOW_DTIME 0x010036 + +/* Inodes that were part of a corrupted orphan linked list found + * (latch question) */ +#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 + +/* Inode number has a bad 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 number has reference count incorrect, should be */ +#define PR_1_EXTATTR_REFCOUNT 0x01003C + +/* Error writing Extended Attribute block while fixing refcount */ +#define PR_1_EXTATTR_WRITE_ABORT 0x01003D + +/* Extended attribute block has h_blocks > 1 */ +#define PR_1_EA_MULTI_BLOCK 0x01003E + +/* Allocating extended attribute region allocation structure */ +#define PR_1_EA_ALLOC_REGION_ABORT 0x01003F + +/* Extended Attribute block number is corrupt (allocation collision) */ +#define PR_1_EA_ALLOC_COLLISION 0x010040 + +/* Extended attribute block number is corrupt (invalid name) */ +#define PR_1_EA_BAD_NAME 0x010041 + +/* Extended attribute block number is corrupt (invalid value) */ +#define PR_1_EA_BAD_VALUE 0x010042 + +/* Inode number is too big (latch question) */ +#define PR_1_INODE_TOOBIG 0x010043 + +/* Problem causes directory to be too big */ +#define PR_1_TOOBIG_DIR 0x010044 + +/* Problem causes file to be too big */ +#define PR_1_TOOBIG_REG 0x010045 + +/* Problem causes symlink to be too big */ +#define PR_1_TOOBIG_SYMLINK 0x010046 + +/* Inode has INDEX_FL flag set on filesystem without htree support */ +#define PR_1_HTREE_SET 0x010047 + +/* Inode number has INDEX_FL flag set but is on a directory */ +#define PR_1_HTREE_NODIR 0x010048 + +/* htree directory has an invalid root node */ +#define PR_1_HTREE_BADROOT 0x010049 + +/* Htree directory has an unsupported hash version */ +#define PR_1_HTREE_HASHV 0x01004A + +/* Htree directory uses an Incompatible htree root node flag */ +#define PR_1_HTREE_INCOMPAT 0x01004B + +/* Htree directory has a tree depth which is too big */ +#define PR_1_HTREE_DEPTH 0x01004C + +/* Bad block inode has an indirect block number that conflicts with + * filesystem metadata */ +#define PR_1_BB_FS_BLOCK 0x01004D + +/* Resize inode (re)creation failed */ +#define PR_1_RESIZE_INODE_CREATE 0x01004E + +/* inode has a extra size i_extra_isize which is invalid */ +#define PR_1_EXTRA_ISIZE 0x01004F + +/* Extended attribute in inode has a namelen which is invalid */ +#define PR_1_ATTR_NAME_LEN 0x010050 + +/* Extended attribute in inode has a value offset which is invalid */ +#define PR_1_ATTR_VALUE_OFFSET 0x010051 + +/* extended attribute in inode has a value block which is invalid */ +#define PR_1_ATTR_VALUE_BLOCK 0x010052 + +/* extended attribute in inode has a value size which is invalid */ +#define PR_1_ATTR_VALUE_SIZE 0x010053 + +/* extended attribute in inode has a hash which is invalid */ +#define PR_1_ATTR_HASH 0x010054 + +/* inode is a type but it looks like it is really a directory */ +#define PR_1_TREAT_AS_DIRECTORY 0x010055 + +/* Error while reading extent tree in inode */ +#define PR_1_READ_EXTENT 0x010056 + +/* Failure to iterate extents in inode */ +#define PR_1_EXTENT_ITERATE_FAILURE 0x010057 + +/* Inode has an invalid extent starting block */ +#define PR_1_EXTENT_BAD_START_BLK 0x010058 + +/* Inode has an invalid extent that ends beyond filesystem */ +#define PR_1_EXTENT_ENDS_BEYOND 0x010059 + +/* inode has EXTENTS_FL flag set on filesystem without extents support */ +#define PR_1_EXTENTS_SET 0x01005A + +/* inode is in extents format, but superblock is missing EXTENTS feature */ +#define PR_1_EXTENT_FEATURE 0x01005B + +/* inode missing EXTENTS_FL, but is an extent inode */ +#define PR_1_UNSET_EXTENT_FL 0x01005C + +/* Fast symlink has EXTENTS_FL set */ +#define PR_1_FAST_SYMLINK_EXTENT_FL 0x01005D + +/* Extents are out of order */ +#define PR_1_OUT_OF_ORDER_EXTENTS 0x01005E + +/* Extent node header invalid */ +#define PR_1_EXTENT_HEADER_INVALID 0x01005F + +/* PR_1_EOFBLOCKS_FL_SET 0x010060 was here */ + +/* Failed to convert subcluster block bitmap */ +#define PR_1_CONVERT_SUBCLUSTER 0x010061 + +/* Quota inode is not a regular file */ +#define PR_1_QUOTA_BAD_MODE 0x010062 + +/* Quota inode is not in use, but contains data */ +#define PR_1_QUOTA_INODE_NOT_CLEAR 0x010063 + +/* Quota inode is visible to the user */ +#define PR_1_QUOTA_INODE_NOT_HIDDEN 0x010064 + +/* The bad block inode looks invalid */ +#define PR_1_INVALID_BAD_INODE 0x010065 + +/* Extent has zero length extent */ +#define PR_1_EXTENT_LENGTH_ZERO 0x010066 + +/* inode seems to contain garbage */ +#define PR_1_INODE_IS_GARBAGE 0x010067 + +/* inode passes checks, but checksum does not match inode */ +#define PR_1_INODE_ONLY_CSUM_INVALID 0x010068 + +/* Inode extended attribute is corrupt (allocation collision) */ +#define PR_1_INODE_EA_ALLOC_COLLISION 0x010069 + +/* Inode extent block passes checks, but checksum does not match extent */ +#define PR_1_EXTENT_ONLY_CSUM_INVALID 0x01006A + +/* Inode extended attribute block passes checks, but checksum does not + * match block. */ +#define PR_1_EA_BLOCK_ONLY_CSUM_INVALID 0x01006C + +/* Interior extent node level number of inode doesn't first node down */ +#define PR_1_EXTENT_INDEX_START_INVALID 0x01006D + +/* Inode end of extent exceeds allowed value */ +#define PR_1_EXTENT_END_OUT_OF_BOUNDS 0x01006E + +/* inode has INLINE_DATA_FL flag on filesystem without inline data */ +#define PR_1_INLINE_DATA_FEATURE 0x01006F + +/* inode has INLINE_DATA_FL flag on filesystem without inline data */ +#define PR_1_INLINE_DATA_SET 0x010070 + +/* Inode block conflicts with critical metadata, skipping block checks */ +#define PR_1_CRITICAL_METADATA_COLLISION 0x010071 + +/* Directory inode block should be at block */ +#define PR_1_COLLAPSE_DBLOCK 0x010072 + +/* Directory inode block should be at block */ +#define PR_1_UNINIT_DBLOCK 0x010073 + +/* Inode logical block (physical block) violates cluster allocation */ +#define PR_1_MISALIGNED_CLUSTER 0x010074 + +/* Inode has INLINE_DATA_FL flag but extended attribute not found */ +#define PR_1_INLINE_DATA_NO_ATTR 0x010075 + +/* Special (device/socket/fifo) file (inode num) has extents + * or inline-data flag set */ +#define PR_1_SPECIAL_EXTENTS_IDATA 0x010076 + +/* Inode has extent header but inline data flag is set */ +#define PR_1_CLEAR_INLINE_DATA_FOR_EXTENT 0x010077 + +/* Inode seems to have inline data but extent flag is set */ +#define PR_1_CLEAR_EXTENT_FOR_INLINE_DATA 0x010078 + +/* Inode seems to have block map but inline data and extent flags set */ +#define PR_1_CLEAR_EXTENT_INLINE_DATA_FLAGS 0x010079 + +/* Inode has inline data and extent flags but i_block contains junk */ +#define PR_1_CLEAR_EXTENT_INLINE_DATA_INODE 0x01007A + +/* Bad block list says the bad block list inode is bad */ +#define PR_1_BADBLOCKS_IN_BADBLOCKS 0x01007B + +/* Error allocating extent region allocation structure */ +#define PR_1_EXTENT_ALLOC_REGION_ABORT 0x01007C + +/* Inode leaf has a duplicate extent mapping */ +#define PR_1_EXTENT_COLLISION 0x01007D + +/* Error allocating memory for encrypted inode list */ +#define PR_1_ALLOCATE_ENCRYPTED_INODE_LIST 0x01007E + +/* Inode extent tree could be more shallow */ +#define PR_1_EXTENT_BAD_MAX_DEPTH 0x01007F + +/* inode num on bigalloc filesystem cannot be block mapped */ +#define PR_1_NO_BIGALLOC_BLOCKMAP_FILES 0x010080 + +/* Inode has corrupt extent header */ +#define PR_1_MISSING_EXTENT_HEADER 0x010081 + +/* Timestamp(s) on inode beyond 2310-04-04 are likely pre-1970. */ +#define PR_1_EA_TIME_OUT_OF_RANGE 0x010082 + +/* Inode has illegal EA value inode */ +#define PR_1_ATTR_VALUE_EA_INODE 0x010083 + +/* Parent inode has invalid EA entry. EA inode does not have + * EXT4_EA_INODE_FL flag. Delete EA entry? */ +#define PR_1_ATTR_NO_EA_INODE_FL 0x010085 + +/* EA inode for parent inode does not have EXT4_EA_INODE_FL flag */ +#define PR_1_ATTR_SET_EA_INODE_FL 0x010086 + +/* Offer to clear uninitialized flag on an extent */ +#define PR_1_CLEAR_UNINIT_EXTENT 0x010087 + +/* Casefold flag set on a non-directory */ +#define PR_1_CASEFOLD_NONDIR 0x010088 + +/* Casefold flag set, but file system is missing the casefold feature */ +#define PR_1_CASEFOLD_FEATURE 0x010089 + +/* Inode has encrypt flag but no encryption extended attribute */ +#define PR_1_MISSING_ENCRYPTION_XATTR 0x01008A + +/* Encrypted inode has corrupt encryption extended attribute */ +#define PR_1_CORRUPT_ENCRYPTION_XATTR 0x01008B + +/* Error allocating memory for casefolded directory list */ +#define PR_1_ALLOCATE_CASEFOLDED_DIRLIST 0x01008C + +/* Htree directory should use SipHash but does not */ +#define PR_1_HTREE_NEEDS_SIPHASH 0x01008D + +/* Htree directory uses SipHash but should not */ +#define PR_1_HTREE_CANNOT_SIPHASH 0x01008E + +/* Orphan file inode is not a regular file */ +#define PR_1_ORPHAN_FILE_BAD_MODE 0x01008F + +/* Orphan file inode is not in use, but contains data */ +#define PR_1_ORPHAN_FILE_NOT_CLEAR 0x010090 + +/* + * 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 0x011006 + +/* Error adjusting EA refcount */ +#define PR_1B_ADJ_EA_REFCOUNT 0x011007 + +/* Duplicate/bad block range in inode */ +#define PR_1B_DUP_RANGE 0x011008 + +/* 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 1e --- rebuilding extent trees + */ +/* Pass 1e: Rebuilding extent trees */ +#define PR_1E_PASS_HEADER 0x014000 + +/* Error rehash directory */ +#define PR_1E_OPTIMIZE_EXT_ERR 0x014001 + +/* Rebuilding extent trees */ +#define PR_1E_OPTIMIZE_EXT_HEADER 0x014002 + +/* Rebuilding extent %d */ +#define PR_1E_OPTIMIZE_EXT 0x014003 + +/* Rebuilding extent tree end */ +#define PR_1E_OPTIMIZE_EXT_END 0x014004 + +/* Internal error: extent tree depth too large */ +#define PR_1E_MAX_EXTENT_TREE_DEPTH 0x014005 + +/* Inode extent tree could be shorter */ +#define PR_1E_CAN_COLLAPSE_EXTENT_TREE 0x014006 + +/* Inode extent tree could be narrower */ +#define PR_1E_CAN_NARROW_EXTENT_TREE 0x014007 + +/* + * 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 + +/* Directory 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 directory */ +#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_size_high should be zero */ +#define PR_2_DIR_SIZE_HIGH_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 + +/* Filesystem has large directories, but has no such flag in superblock */ +#define PR_2_FEATURE_LARGE_DIRS 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 + +/* i_blocks_hi should be zero */ +#define PR_2_BLOCKS_HI_ZERO 0x020044 + +/* Unexpected HTREE block */ +#define PR_2_UNEXPECTED_HTREE_BLOCK 0x020045 + +/* Inode found in group where _INODE_UNINIT is set */ +#define PR_2_INOREF_BG_INO_UNINIT 0x020046 + +/* Inode found in group unused inodes area */ +#define PR_2_INOREF_IN_UNUSED 0x020047 + +/* i_file_acl_hi should be zero */ +#define PR_2_I_FILE_ACL_HI_ZERO 0x020048 + +/* htree root node fails checksum */ +#define PR_2_HTREE_ROOT_CSUM_INVALID 0x020049 + +/* htree node fails checksum */ +#define PR_2_HTREE_NODE_CSUM_INVALID 0x02004A + +/* no space in leaf for checksum */ +#define PR_2_LEAF_NODE_MISSING_CSUM 0x02004C + +/* dir leaf node passes checks, but fails checksum */ +#define PR_2_LEAF_NODE_ONLY_CSUM_INVALID 0x02004D + +/* bad inline directory size */ +#define PR_2_BAD_INLINE_DIR_SIZE 0x02004E + +/* fixing inline dir size failed */ +#define PR_2_FIX_INLINE_DIR_FAILED 0x02004F + +/* Encrypted directory entry is too short */ +#define PR_2_BAD_ENCRYPTED_NAME 0x020050 + +/* Encrypted directory contains unencrypted file */ +#define PR_2_UNENCRYPTED_FILE 0x020051 + +/* Encrypted directory contains file with different encryption policy */ +#define PR_2_INCONSISTENT_ENCRYPTION_POLICY 0x020052 + +/* Encoded directory entry has illegal characters in its name */ +#define PR_2_BAD_ENCODED_NAME 0x020053 + +/* Non-unique filename found, but can't rename */ +#define PR_2_NON_UNIQUE_FILE_NO_RENAME 0x020054 + +/* + * 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 + +/* Lost+found has inline data */ +#define PR_3_LPF_INLINE_DATA 0x030018 + +/* Cannot allocate lost+found */ +#define PR_3_LPF_NO_SPACE 0x030019 + +/* Insufficient space to recover lost files */ +#define PR_3_NO_SPACE_TO_RECOVER 0x03001A + +/* Lost+found is encrypted */ +#define PR_3_LPF_ENCRYPTED 0x03001B + +/* Recursively looped directory inode */ +#define PR_3_LOOPED_DIR 0x03001D + +/* + * Pass 3a --- rehashing directories + */ +/* 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 3B is really just 1E */ + +/* + * 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 + +/* Extended attribute inode ref count wrong */ +#define PR_4_EA_INODE_REF_COUNT 0x040005 + +/* directory exceeds max links, but no DIR_NLINK feature in superblock */ +#define PR_4_DIR_NLINK_FEATURE 0x040006 + +/* Directory ref count set to overflow but it doesn't have to be */ +#define PR_4_DIR_OVERFLOW_REF_COUNT 0x040007 + +/* + * 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 range used, but not marked used in bitmap */ +#define PR_5_INODE_RANGE_USED 0x050017 + +/* Block in use but group is marked BLOCK_UNINIT */ +#define PR_5_BLOCK_UNINIT 0x050018 + +/* Inode in use but group is marked INODE_UNINIT */ +#define PR_5_INODE_UNINIT 0x050019 + +/* Inode bitmap checksum does not match */ +#define PR_5_INODE_BITMAP_CSUM_INVALID 0x05001A + +/* Block bitmap checksum does not match */ +#define PR_5_BLOCK_BITMAP_CSUM_INVALID 0x05001B + +/* + * Post-Pass 5 errors + */ + +/* Recreate the journal if E2F_FLAG_JOURNAL_INODE flag is set */ +#define PR_6_RECREATE_JOURNAL 0x060001 + +/* Update quota information if it is inconsistent */ +#define PR_6_UPDATE_QUOTAS 0x060002 + +/* Error setting block group checksum info */ +#define PR_6_SET_BG_CHECKSUM 0x060003 + +/* Error writing file system info */ +#define PR_6_FLUSH_FILESYSTEM 0x060004 + +/* Error flushing writes to storage device */ +#define PR_6_IO_FLUSH 0x060005 + +/* Error updating quota information */ +#define PR_6_WRITE_QUOTAS 0x060006 + +/* Orphan file without a journal */ +#define PR_6_ORPHAN_FILE_WITHOUT_JOURNAL 0x060007 + +/* Orphan file truncation failed */ +#define PR_6_ORPHAN_FILE_TRUNC_FAILED 0x060008 + +/* Failed to initialize orphan file */ +#define PR_6_ORPHAN_FILE_CORRUPTED 0x060009 + +/* Cannot fix corrupted orphan file with invalid bitmaps */ +#define PR_6_ORPHAN_FILE_BITMAP_INVALID 0x06000A + +/* Orphan file creation failed */ +#define PR_6_ORPHAN_FILE_CREATE_FAILED 0x06000B + +/* Orphan file block contains data */ +#define PR_6_ORPHAN_BLOCK_DIRTY 0x06000C + +/* orphan_present set but orphan file is empty */ +#define PR_6_ORPHAN_PRESENT_CLEAN_FILE 0x06000D + +/* orphan_present set but orphan_file is not */ +#define PR_6_ORPHAN_PRESENT_NO_FILE 0x06000E + +/* Orphan file size isn't multiple of blocks size */ +#define PR_6_ORPHAN_FILE_WRONG_SIZE 0x06000F + +/* Orphan file contains holes */ +#define PR_6_ORPHAN_FILE_HOLE 0x060010 + +/* + * 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 *pctx); + +/* message.c */ +void print_e2fsck_message(FILE *f, e2fsck_t ctx, const char *msg, + struct problem_context *pctx, int first, + int recurse); + diff --git a/e2fsck/problemP.h b/e2fsck/problemP.h new file mode 100644 index 0000000..95c1a70 --- /dev/null +++ b/e2fsck/problemP.h @@ -0,0 +1,48 @@ +/* + * 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; + int count; + int max_count; +}; + +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 */ +#define PR_CONFIG 0x080000 /* This problem has been customized + from the config file */ +#define PR_FORCE_NO 0x100000 /* Force the answer to be no */ +#define PR_NOT_A_FIX 0x200000 /* Yes doesn't mean a problem was fixed */ +#define PR_HEADER 0x400000 /* Problem is a header marker */ diff --git a/e2fsck/quota.c b/e2fsck/quota.c new file mode 100644 index 0000000..f9b68c9 --- /dev/null +++ b/e2fsck/quota.c @@ -0,0 +1,127 @@ +/* + * quota.c --- code for handling ext4 quota inodes + * + */ + +#include "config.h" +#ifdef HAVE_SYS_MOUNT_H +#include +#include +#define MNT_FL (MS_MGC_VAL | MS_RDONLY) +#endif +#ifdef HAVE_SYS_STAT_H +#include +#endif + +#include "e2fsck.h" +#include "problem.h" + +static errcode_t move_quota_inode(ext2_filsys fs, ext2_ino_t from_ino, + ext2_ino_t to_ino, enum quota_type qtype) +{ + struct ext2_inode inode; + errcode_t retval; + char qf_name[QUOTA_NAME_LEN]; + + /* We need the inode bitmap to be loaded */ + retval = ext2fs_read_bitmaps(fs); + if (retval) { + com_err("ext2fs_read_bitmaps", retval, "%s", + _("in move_quota_inode")); + return retval; + } + + retval = ext2fs_read_inode(fs, from_ino, &inode); + if (retval) { + com_err("ext2fs_read_inode", retval, "%s", + _("in move_quota_inode")); + return retval; + } + + inode.i_links_count = 1; + inode.i_mode = LINUX_S_IFREG | 0600; + inode.i_flags = EXT2_IMMUTABLE_FL; + if (ext2fs_has_feature_extents(fs->super)) + inode.i_flags |= EXT4_EXTENTS_FL; + + retval = ext2fs_write_new_inode(fs, to_ino, &inode); + if (retval) { + com_err("ext2fs_write_new_inode", retval, "%s", + _("in move_quota_inode")); + return retval; + } + + /* unlink the old inode */ + quota_get_qf_name(qtype, QFMT_VFS_V1, qf_name); + retval = ext2fs_unlink(fs, EXT2_ROOT_INO, qf_name, from_ino, 0); + if (retval) { + com_err("ext2fs_unlink", retval, "%s", + _("in move_quota_inode")); + return retval; + } + ext2fs_inode_alloc_stats(fs, from_ino, -1); + /* Clear out the original inode in the inode-table block. */ + memset(&inode, 0, sizeof(struct ext2_inode)); + ext2fs_write_inode(fs, from_ino, &inode); + return 0; +} + +void e2fsck_hide_quota(e2fsck_t ctx) +{ + struct ext2_super_block *sb = ctx->fs->super; + struct problem_context pctx; + ext2_filsys fs = ctx->fs; + enum quota_type qtype; + ext2_ino_t quota_ino; + + clear_problem_context(&pctx); + + if ((ctx->options & E2F_OPT_READONLY) || + !ext2fs_has_feature_quota(sb)) + return; + + for (qtype = 0; qtype < MAXQUOTAS; qtype++) { + pctx.dir = 2; /* This is a guess, but it's a good one */ + pctx.ino = *quota_sb_inump(sb, qtype); + pctx.num = qtype; + quota_ino = quota_type2inum(qtype, fs->super); + if (pctx.ino && (pctx.ino != quota_ino) && + fix_problem(ctx, PR_0_HIDE_QUOTA, &pctx)) { + if (move_quota_inode(fs, pctx.ino, quota_ino, qtype)) + continue; + *quota_sb_inump(sb, qtype) = quota_ino; + ext2fs_mark_super_dirty(fs); + } + } + + return; +} + +void e2fsck_validate_quota_inodes(e2fsck_t ctx) +{ + struct ext2_super_block *sb = ctx->fs->super; + struct problem_context pctx; + ext2_filsys fs = ctx->fs; + enum quota_type qtype; + + clear_problem_context(&pctx); + + for (qtype = 0; qtype < MAXQUOTAS; qtype++) { + pctx.ino = *quota_sb_inump(sb, qtype); + pctx.num = qtype; + if (pctx.ino && + ((pctx.ino == EXT2_BAD_INO) || + (pctx.ino == EXT2_ROOT_INO) || + (pctx.ino == EXT2_BOOT_LOADER_INO) || + (pctx.ino == EXT2_UNDEL_DIR_INO) || + (pctx.ino == EXT2_RESIZE_INO) || + (pctx.ino == EXT2_JOURNAL_INO) || + (pctx.ino == EXT2_EXCLUDE_INO) || + (pctx.ino == EXT4_REPLICA_INO) || + (pctx.ino > fs->super->s_inodes_count)) && + fix_problem(ctx, PR_0_INVALID_QUOTA_INO, &pctx)) { + *quota_sb_inump(sb, qtype) = 0; + ext2fs_mark_super_dirty(fs); + } + } +} diff --git a/e2fsck/readahead.c b/e2fsck/readahead.c new file mode 100644 index 0000000..38d4ec4 --- /dev/null +++ b/e2fsck/readahead.c @@ -0,0 +1,254 @@ +/* + * readahead.c -- Prefetch filesystem metadata to speed up fsck. + * + * Copyright (C) 2014 Oracle. + * + * %Begin-Header% + * This file may be redistributed under the terms of the GNU Library + * General Public License, version 2. + * %End-Header% + */ + +#include "config.h" +#include + +#include "e2fsck.h" + +#undef DEBUG + +#ifdef DEBUG +# define dbg_printf(f, a...) do {printf(f, ## a); fflush(stdout); } while (0) +#else +# define dbg_printf(f, a...) +#endif + +struct read_dblist { + errcode_t err; + blk64_t run_start; + blk64_t run_len; + int flags; +}; + +static int readahead_dir_block(ext2_filsys fs, struct ext2_db_entry2 *db, + void *priv_data) +{ + struct read_dblist *pr = priv_data; + e2_blkcnt_t count = (pr->flags & E2FSCK_RA_DBLIST_IGNORE_BLOCKCNT ? + 1 : db->blockcnt); + + if (!pr->run_len || db->blk != pr->run_start + pr->run_len) { + if (pr->run_len) { + pr->err = io_channel_cache_readahead(fs->io, + pr->run_start, + pr->run_len); + dbg_printf("readahead start=%llu len=%llu err=%d\n", + pr->run_start, pr->run_len, + (int)pr->err); + } + pr->run_start = db->blk; + pr->run_len = 0; + } + pr->run_len += count; + + return pr->err ? DBLIST_ABORT : 0; +} + +errcode_t e2fsck_readahead_dblist(ext2_filsys fs, int flags, + ext2_dblist dblist, + unsigned long long start, + unsigned long long count) +{ + errcode_t err; + struct read_dblist pr; + + dbg_printf("%s: flags=0x%x\n", __func__, flags); + if (flags & ~E2FSCK_RA_DBLIST_ALL_FLAGS) + return EXT2_ET_INVALID_ARGUMENT; + + memset(&pr, 0, sizeof(pr)); + pr.flags = flags; + err = ext2fs_dblist_iterate3(dblist, readahead_dir_block, start, + count, &pr); + if (pr.err) + return pr.err; + if (err) + return err; + + if (pr.run_len) + err = io_channel_cache_readahead(fs->io, pr.run_start, + pr.run_len); + + return err; +} + +static errcode_t e2fsck_readahead_bitmap(ext2_filsys fs, + ext2fs_block_bitmap ra_map) +{ + blk64_t start, end, out; + errcode_t err; + + start = 1; + end = ext2fs_blocks_count(fs->super) - 1; + + err = ext2fs_find_first_set_block_bitmap2(ra_map, start, end, &out); + while (err == 0) { + start = out; + err = ext2fs_find_first_zero_block_bitmap2(ra_map, start, end, + &out); + if (err == ENOENT) { + out = end; + err = 0; + if (out == start) + break; + } else if (err) + break; + + err = io_channel_cache_readahead(fs->io, start, out - start); + if (err) + break; + start = out; + err = ext2fs_find_first_set_block_bitmap2(ra_map, start, end, + &out); + } + + if (err == ENOENT) + err = 0; + + return err; +} + +/* Try not to spew bitmap range errors for readahead */ +static errcode_t mark_bmap_range(ext2fs_block_bitmap map, + blk64_t blk, unsigned int num) +{ + if (blk >= ext2fs_get_generic_bmap_start(map) && + blk + num <= ext2fs_get_generic_bmap_end(map)) + ext2fs_mark_block_bitmap_range2(map, blk, num); + else + return EXT2_ET_INVALID_ARGUMENT; + return 0; +} + +static errcode_t mark_bmap(ext2fs_block_bitmap map, blk64_t blk) +{ + if (blk >= ext2fs_get_generic_bmap_start(map) && + blk <= ext2fs_get_generic_bmap_end(map)) + ext2fs_mark_block_bitmap2(map, blk); + else + return EXT2_ET_INVALID_ARGUMENT; + return 0; +} + +errcode_t e2fsck_readahead(ext2_filsys fs, int flags, dgrp_t start, + dgrp_t ngroups) +{ + blk64_t super, old_gdt, new_gdt; + blk_t blocks; + dgrp_t i; + ext2fs_block_bitmap ra_map = NULL; + dgrp_t end = start + ngroups; + errcode_t err = 0; + + dbg_printf("%s: flags=0x%x start=%d groups=%d\n", __func__, flags, + start, ngroups); + if (flags & ~E2FSCK_READA_ALL_FLAGS) + return EXT2_ET_INVALID_ARGUMENT; + + if (end > fs->group_desc_count) + end = fs->group_desc_count; + + if (flags == 0) + return 0; + + err = ext2fs_allocate_block_bitmap(fs, "readahead bitmap", + &ra_map); + if (err) + return err; + + for (i = start; i < end; i++) { + err = ext2fs_super_and_bgd_loc2(fs, i, &super, &old_gdt, + &new_gdt, &blocks); + if (err) + break; + + if (flags & E2FSCK_READA_SUPER) { + err = mark_bmap(ra_map, super); + if (err) + break; + } + + if (flags & E2FSCK_READA_GDT) { + err = mark_bmap_range(ra_map, + old_gdt ? old_gdt : new_gdt, + blocks); + if (err) + break; + } + + if ((flags & E2FSCK_READA_BBITMAP) && + !ext2fs_bg_flags_test(fs, i, EXT2_BG_BLOCK_UNINIT) && + ext2fs_bg_free_blocks_count(fs, i) < + fs->super->s_blocks_per_group) { + super = ext2fs_block_bitmap_loc(fs, i); + err = mark_bmap(ra_map, super); + if (err) + break; + } + + if ((flags & E2FSCK_READA_IBITMAP) && + !ext2fs_bg_flags_test(fs, i, EXT2_BG_INODE_UNINIT) && + ext2fs_bg_free_inodes_count(fs, i) < + fs->super->s_inodes_per_group) { + super = ext2fs_inode_bitmap_loc(fs, i); + err = mark_bmap(ra_map, super); + if (err) + break; + } + + if ((flags & E2FSCK_READA_ITABLE) && + ext2fs_bg_free_inodes_count(fs, i) < + fs->super->s_inodes_per_group) { + super = ext2fs_inode_table_loc(fs, i); + blocks = fs->inode_blocks_per_group - + (ext2fs_bg_itable_unused(fs, i) * + EXT2_INODE_SIZE(fs->super) / fs->blocksize); + err = mark_bmap_range(ra_map, super, blocks); + if (err) + break; + } + } + + if (!err) + err = e2fsck_readahead_bitmap(fs, ra_map); + + ext2fs_free_block_bitmap(ra_map); + return err; +} + +int e2fsck_can_readahead(ext2_filsys fs) +{ + errcode_t err; + + err = io_channel_cache_readahead(fs->io, 0, 1); + dbg_printf("%s: supp=%d\n", __func__, err != EXT2_ET_OP_NOT_SUPPORTED); + return err != EXT2_ET_OP_NOT_SUPPORTED; +} + +unsigned long long e2fsck_guess_readahead(ext2_filsys fs) +{ + unsigned long long guess; + + /* + * The optimal readahead sizes were experimentally determined by + * djwong in August 2014. Setting the RA size to two block groups' + * worth of inode table blocks seems to yield the largest reductions + * in e2fsck runtime. + */ + guess = 2ULL * fs->blocksize * fs->inode_blocks_per_group; + + /* Disable RA if it'd use more 1/50th of RAM. */ + if (get_memory_size() > (guess * 50)) + return guess / 1024; + + return 0; +} diff --git a/e2fsck/recovery.c b/e2fsck/recovery.c new file mode 100644 index 0000000..8ca3527 --- /dev/null +++ b/e2fsck/recovery.c @@ -0,0 +1,931 @@ +// SPDX-License-Identifier: GPL-2.0+ +/* + * linux/fs/jbd2/recovery.c + * + * Written by Stephen C. Tweedie , 1999 + * + * Copyright 1999-2000 Red Hat Software --- All Rights Reserved + * + * 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 +#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; +}; + +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 */ +static 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 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_total_len) + max = journal->j_total_len; + + /* 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 = jbd2_journal_bmap(journal, next, &blocknr); + + if (err) { + printk(KERN_ERR "JBD2: 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(REQ_OP_READ, 0, nbufs, bufs); + journal_brelse_array(bufs, nbufs); + nbufs = 0; + } + } else + brelse(bh); + } + + if (nbufs) + ll_rw_block(REQ_OP_READ, 0, 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 long blocknr; + struct buffer_head *bh; + + *bhp = NULL; + + if (offset >= journal->j_total_len) { + printk(KERN_ERR "JBD2: corrupted journal superblock\n"); + return -EFSCORRUPTED; + } + + err = jbd2_journal_bmap(journal, offset, &blocknr); + + if (err) { + printk(KERN_ERR "JBD2: 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 "JBD2: Failed to read block at offset %u\n", + offset); + brelse(bh); + return -EIO; + } + + *bhp = bh; + return 0; +} + +static int jbd2_descriptor_block_csum_verify(journal_t *j, void *buf) +{ + struct jbd2_journal_block_tail *tail; + __be32 provided; + __u32 calculated; + + if (!jbd2_journal_has_csum_v2or3(j)) + return 1; + + tail = (struct jbd2_journal_block_tail *)((char *)buf + + j->j_blocksize - sizeof(struct jbd2_journal_block_tail)); + provided = tail->t_checksum; + tail->t_checksum = 0; + calculated = jbd2_chksum(j, j->j_csum_seed, buf, j->j_blocksize); + tail->t_checksum = provided; + + return provided == cpu_to_be32(calculated); +} + +/* + * Count the number of in-use tags in a journal descriptor block. + */ + +static int count_tags(journal_t *journal, struct buffer_head *bh) +{ + char * tagp; + journal_block_tag_t tag; + int nr = 0, size = journal->j_blocksize; + int tag_bytes = journal_tag_bytes(journal); + + if (jbd2_journal_has_csum_v2or3(journal)) + size -= sizeof(struct jbd2_journal_block_tail); + + tagp = &bh->b_data[sizeof(journal_header_t)]; + + while ((tagp - bh->b_data + tag_bytes) <= size) { + memcpy(&tag, tagp, sizeof(tag)); + + nr++; + tagp += tag_bytes; + if (!(tag.t_flags & cpu_to_be16(JBD2_FLAG_SAME_UUID))) + tagp += 16; + + if (tag.t_flags & cpu_to_be16(JBD2_FLAG_LAST_TAG)) + break; + } + + return nr; +} + + +/* Make sure we wrap around the log correctly! */ +#define wrap(journal, var) \ +do { \ + unsigned long _wrap_last = \ + jbd2_has_feature_fast_commit(journal) ? \ + (journal)->j_fc_last : (journal)->j_last; \ + \ + if (var >= _wrap_last) \ + var -= (_wrap_last - (journal)->j_first); \ +} while (0) + +static int fc_do_one_pass(journal_t *journal, + struct recovery_info *info, enum passtype pass) +{ + unsigned int expected_commit_id = info->end_transaction; + unsigned long next_fc_block; + struct buffer_head *bh; + int err = 0; + + next_fc_block = journal->j_fc_first; + if (!journal->j_fc_replay_callback) + return 0; + + while (next_fc_block <= journal->j_fc_last) { + jbd_debug(3, "Fast commit replay: next block %ld\n", + next_fc_block); + err = jread(&bh, journal, next_fc_block); + if (err) { + jbd_debug(3, "Fast commit replay: read error\n"); + break; + } + + err = journal->j_fc_replay_callback(journal, bh, pass, + next_fc_block - journal->j_fc_first, + expected_commit_id); + next_fc_block++; + if (err < 0 || err == JBD2_FC_REPLAY_STOP) + break; + err = 0; + } + + if (err) + jbd_debug(3, "Fast commit replay failed, err = %d\n", err); + + return err; +} + +/** + * jbd2_journal_recover - 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 jbd2_journal_recover(journal_t *journal) +{ + int err, err2; + 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", + be32_to_cpu(sb->s_sequence)); + journal->j_transaction_sequence = be32_to_cpu(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(1, "JBD2: recovery, exit status %d, " + "recovered transactions %u to %u\n", + err, info.start_transaction, info.end_transaction); + jbd_debug(1, "JBD2: 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; + + jbd2_journal_clear_revoke(journal); + err2 = sync_blockdev(journal->j_fs_dev); + if (!err) + err = err2; + /* Make sure all replayed data is on permanent storage */ + if (journal->j_flags & JBD2_BARRIER) { + err2 = blkdev_issue_flush(journal->j_fs_dev); + if (!err) + err = err2; + } + return err; +} + +/** + * jbd2_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 doesn't appear to be exported.. + * + * 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 jbd2_journal_skip_recovery(journal_t *journal) +{ + int err; + + struct recovery_info info; + + memset (&info, 0, sizeof(info)); + + err = do_one_pass(journal, &info, PASS_SCAN); + + if (err) { + printk(KERN_ERR "JBD2: error %d scanning journal\n", err); + ++journal->j_transaction_sequence; + } else { +#ifdef CONFIG_JBD2_DEBUG + int dropped = info.end_transaction - + be32_to_cpu(journal->j_superblock->s_sequence); + jbd_debug(1, + "JBD2: ignoring %d transaction%s from the journal.\n", + dropped, (dropped == 1) ? "" : "s"); +#endif + journal->j_transaction_sequence = ++info.end_transaction; + } + + journal->j_tail = 0; + return err; +} + +static inline unsigned long long read_tag_block(journal_t *journal, + journal_block_tag_t *tag) +{ + unsigned long long block = be32_to_cpu(tag->t_blocknr); + if (jbd2_has_feature_64bit(journal)) + block |= (u64)be32_to_cpu(tag->t_blocknr_high) << 32; + return block; +} + +/* + * calc_chksums calculates the checksums for the blocks described in the + * descriptor block. + */ +static int calc_chksums(journal_t *journal, struct buffer_head *bh, + unsigned long *next_log_block, __u32 *crc32_sum) +{ + int i, num_blks, err; + unsigned long io_block; + struct buffer_head *obh; + + num_blks = count_tags(journal, bh); + /* Calculate checksum of the descriptor block. */ + *crc32_sum = crc32_be(*crc32_sum, (void *)bh->b_data, bh->b_size); + + for (i = 0; i < num_blks; i++) { + io_block = (*next_log_block)++; + wrap(journal, *next_log_block); + err = jread(&obh, journal, io_block); + if (err) { + printk(KERN_ERR "JBD2: IO error %d recovering block " + "%lu in log\n", err, io_block); + return 1; + } else { + *crc32_sum = crc32_be(*crc32_sum, (void *)obh->b_data, + obh->b_size); + } + put_bh(obh); + } + return 0; +} + +static int jbd2_commit_block_csum_verify(journal_t *j, void *buf) +{ + struct commit_header *h; + __be32 provided; + __u32 calculated; + + if (!jbd2_journal_has_csum_v2or3(j)) + return 1; + + h = buf; + provided = h->h_chksum[0]; + h->h_chksum[0] = 0; + calculated = jbd2_chksum(j, j->j_csum_seed, buf, j->j_blocksize); + h->h_chksum[0] = provided; + + return provided == cpu_to_be32(calculated); +} + +static int jbd2_block_tag_csum_verify(journal_t *j, journal_block_tag_t *tag, + journal_block_tag3_t *tag3, + void *buf, __u32 sequence) +{ + __u32 csum32; + __be32 seq; + + if (!jbd2_journal_has_csum_v2or3(j)) + return 1; + + seq = cpu_to_be32(sequence); + csum32 = jbd2_chksum(j, j->j_csum_seed, (__u8 *)&seq, sizeof(seq)); + csum32 = jbd2_chksum(j, csum32, buf, j->j_blocksize); + + if (jbd2_has_feature_csum3(j)) + return tag3->t_checksum == cpu_to_be32(csum32); + else + return tag->t_checksum == cpu_to_be16(csum32); +} + +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; + int tag_bytes = journal_tag_bytes(journal); + __u32 crc32_sum = ~0; /* Transactional Checksums */ + int descr_csum_size = 0; + int block_error = 0; + bool need_check_commit_time = false; + __u64 last_trans_commit_time = 0, commit_time; + + /* + * 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 = be32_to_cpu(sb->s_sequence); + next_log_block = be32_to_cpu(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; + + cond_resched(); + + /* 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, + jbd2_has_feature_fast_commit(journal) ? + journal->j_fc_last : journal->j_last); + + /* Skip over each chunk of the transaction looking + * either the next descriptor block or the final commit + * record. */ + + jbd_debug(3, "JBD2: 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 != cpu_to_be32(JBD2_MAGIC_NUMBER)) { + brelse(bh); + break; + } + + blocktype = be32_to_cpu(tmp->h_blocktype); + sequence = be32_to_cpu(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 JBD2_DESCRIPTOR_BLOCK: + /* Verify checksum first */ + if (jbd2_journal_has_csum_v2or3(journal)) + descr_csum_size = + sizeof(struct jbd2_journal_block_tail); + if (descr_csum_size > 0 && + !jbd2_descriptor_block_csum_verify(journal, + bh->b_data)) { + /* + * PASS_SCAN can see stale blocks due to lazy + * journal init. Don't error out on those yet. + */ + if (pass != PASS_SCAN) { + pr_err("JBD2: Invalid checksum recovering block %lu in log\n", + next_log_block); + err = -EFSBADCRC; + brelse(bh); + goto failed; + } + need_check_commit_time = true; + jbd_debug(1, + "invalid descriptor block found in %lu\n", + next_log_block); + } + + /* If it is a valid descriptor block, replay it + * in pass REPLAY; if journal_checksums enabled, then + * calculate checksums in PASS_SCAN, otherwise, + * just skip over the blocks it describes. */ + if (pass != PASS_REPLAY) { + if (pass == PASS_SCAN && + jbd2_has_feature_checksum(journal) && + !need_check_commit_time && + !info->end_transaction) { + if (calc_chksums(journal, bh, + &next_log_block, + &crc32_sum)) { + put_bh(bh); + break; + } + put_bh(bh); + continue; + } + next_log_block += count_tags(journal, bh); + wrap(journal, next_log_block); + put_bh(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 + tag_bytes) + <= journal->j_blocksize - descr_csum_size) { + unsigned long io_block; + + memcpy(&tag, tagp, sizeof(tag)); + flags = be16_to_cpu(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 + "JBD2: IO error %d recovering " + "block %ld in log\n", + err, io_block); + } else { + unsigned long long blocknr; + + J_ASSERT(obh != NULL); + blocknr = read_tag_block(journal, + &tag); + + /* If the block has been + * revoked, then we're all done + * here. */ + if (jbd2_journal_test_revoke + (journal, blocknr, + next_commit_ID)) { + brelse(obh); + ++info->nr_revoke_hits; + goto skip_write; + } + + /* Look for block corruption */ + if (!jbd2_block_tag_csum_verify( + journal, &tag, (journal_block_tag3_t *)tagp, + obh->b_data, be32_to_cpu(tmp->h_sequence))) { + brelse(obh); + success = -EFSBADCRC; + printk(KERN_ERR "JBD2: Invalid " + "checksum recovering " + "data block %llu in " + "log\n", blocknr); + block_error = 1; + 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 + "JBD2: 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 & JBD2_FLAG_ESCAPE) { + *((__be32 *)nbh->b_data) = + cpu_to_be32(JBD2_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 += tag_bytes; + if (!(flags & JBD2_FLAG_SAME_UUID)) + tagp += 16; + + if (flags & JBD2_FLAG_LAST_TAG) + break; + } + + brelse(bh); + continue; + + case JBD2_COMMIT_BLOCK: + /* How to differentiate between interrupted commit + * and journal corruption ? + * + * {nth transaction} + * Checksum Verification Failed + * | + * ____________________ + * | | + * async_commit sync_commit + * | | + * | GO TO NEXT "Journal Corruption" + * | TRANSACTION + * | + * {(n+1)th transanction} + * | + * _______|______________ + * | | + * Commit block found Commit block not found + * | | + * "Journal Corruption" | + * _____________|_________ + * | | + * nth trans corrupt OR nth trans + * and (n+1)th interrupted interrupted + * before commit block + * could reach the disk. + * (Cannot find the difference in above + * mentioned conditions. Hence assume + * "Interrupted Commit".) + */ + commit_time = be64_to_cpu( + ((struct commit_header *)bh->b_data)->h_commit_sec); + /* + * If need_check_commit_time is set, it means we are in + * PASS_SCAN and csum verify failed before. If + * commit_time is increasing, it's the same journal, + * otherwise it is stale journal block, just end this + * recovery. + */ + if (need_check_commit_time) { + if (commit_time >= last_trans_commit_time) { + pr_err("JBD2: Invalid checksum found in transaction %u\n", + next_commit_ID); + err = -EFSBADCRC; + brelse(bh); + goto failed; + } + ignore_crc_mismatch: + /* + * It likely does not belong to same journal, + * just end this recovery with success. + */ + jbd_debug(1, "JBD2: Invalid checksum ignored in transaction %u, likely stale data\n", + next_commit_ID); + brelse(bh); + goto done; + } + + /* + * Found an expected commit block: if checksums + * are present, verify them in PASS_SCAN; else not + * much to do other than move on to the next sequence + * number. + */ + if (pass == PASS_SCAN && + jbd2_has_feature_checksum(journal)) { + struct commit_header *cbh = + (struct commit_header *)bh->b_data; + unsigned found_chksum = + be32_to_cpu(cbh->h_chksum[0]); + + if (info->end_transaction) { + journal->j_failed_commit = + info->end_transaction; + brelse(bh); + break; + } + + /* Neither checksum match nor unused? */ + if (!((crc32_sum == found_chksum && + cbh->h_chksum_type == + JBD2_CRC32_CHKSUM && + cbh->h_chksum_size == + JBD2_CRC32_CHKSUM_SIZE) || + (cbh->h_chksum_type == 0 && + cbh->h_chksum_size == 0 && + found_chksum == 0))) + goto chksum_error; + + crc32_sum = ~0; + } + if (pass == PASS_SCAN && + !jbd2_commit_block_csum_verify(journal, + bh->b_data)) { + chksum_error: + if (commit_time < last_trans_commit_time) + goto ignore_crc_mismatch; + info->end_transaction = next_commit_ID; + + if (!jbd2_has_feature_async_commit(journal)) { + journal->j_failed_commit = + next_commit_ID; + brelse(bh); + break; + } + } + if (pass == PASS_SCAN) + last_trans_commit_time = commit_time; + brelse(bh); + next_commit_ID++; + continue; + + case JBD2_REVOKE_BLOCK: + /* + * Check revoke block crc in pass_scan, if csum verify + * failed, check commit block time later. + */ + if (pass == PASS_SCAN && + !jbd2_descriptor_block_csum_verify(journal, + bh->b_data)) { + jbd_debug(1, "JBD2: invalid revoke block found in %lu\n", + next_log_block); + need_check_commit_time = true; + } + /* 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); + brelse(bh); + 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) { + if (!info->end_transaction) + 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 "JBD2: recovery pass %d ended at " + "transaction %u, expected %u\n", + pass, next_commit_ID, info->end_transaction); + if (!success) + success = -EIO; + } + } + + if (jbd2_has_feature_fast_commit(journal) && pass != PASS_REVOKE) { + err = fc_do_one_pass(journal, info, pass); + if (err) + success = err; + } + + if (block_error && success == 0) + 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) +{ + jbd2_journal_revoke_header_t *header; + int offset, max; + unsigned csum_size = 0; + __u32 rcount; + int record_len = 4; + + header = (jbd2_journal_revoke_header_t *) bh->b_data; + offset = sizeof(jbd2_journal_revoke_header_t); + rcount = be32_to_cpu(header->r_count); + + if (jbd2_journal_has_csum_v2or3(journal)) + csum_size = sizeof(struct jbd2_journal_block_tail); + if (rcount > journal->j_blocksize - csum_size) + return -EINVAL; + max = rcount; + + if (jbd2_has_feature_64bit(journal)) + record_len = 8; + + while (offset + record_len <= max) { + unsigned long long blocknr; + int err; + + if (record_len == 4) + blocknr = be32_to_cpu(* ((__be32 *) (bh->b_data+offset))); + else + blocknr = be64_to_cpu(* ((__be64 *) (bh->b_data+offset))); + offset += record_len; + err = jbd2_journal_set_revoke(journal, blocknr, sequence); + if (err) + return err; + ++info->nr_revokes; + } + return 0; +} diff --git a/e2fsck/region.c b/e2fsck/region.c new file mode 100644 index 0000000..698f7bd --- /dev/null +++ b/e2fsck/region.c @@ -0,0 +1,236 @@ +/* + * 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% + */ + +#include "config.h" +#if HAVE_UNISTD_H +#include +#endif +#include + +#ifdef TEST_PROGRAM +#undef ENABLE_NLS +#endif +#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; + struct region_el *last; +}; + +region_t region_create(region_addr_t min, region_addr_t max) +{ + region_t region; + errcode_t retval; + + retval = ext2fs_get_memzero(sizeof(struct region_struct), ®ion); + if (retval) + return NULL; + + region->min = min; + region->max = max; + region->last = NULL; + return region; +} + +void region_free(region_t region) +{ + struct region_el *r, *next; + + for (r = region->allocated; r; r = next) { + next = r->next; + ext2fs_free_mem(&r); + } + memset(region, 0, sizeof(struct region_struct)); + ext2fs_free_mem(®ion); +} + +int region_allocate(region_t region, region_addr_t start, int n) +{ + struct region_el *r, *new_region, *prev, *next; + region_addr_t end; + errcode_t retval; + + end = start+n; + if ((start < region->min) || (end > region->max)) + return -1; + if (n == 0) + return 1; + + if (region->last && region->last->end == start && + !region->last->next) { + region->last->end = end; + return 0; + } + if (region->last && start > region->last->end && + !region->last->next) { + r = NULL; + prev = region->last; + goto append_to_list; + } + + /* + * Search through the linked list. If we find that it + * conflicts with 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; + ext2fs_free_mem(&next); + if (!r->next) + region->last = r; + return 0; + } + } + r->end = end; + return 0; + } + if (start < r->start) + break; + } + /* + * Insert a new region element structure into the linked list + */ +append_to_list: + retval = ext2fs_get_mem(sizeof(struct region_el), &new_region); + if (retval) + return -1; + new_region->start = start; + new_region->end = start + n; + new_region->next = r; + if (!new_region->next) + region->last = new_region; + 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=%llu. max=%llu)\n\t", + (unsigned long long) region->min, + (unsigned long long) region->max); + for (r = region->allocated; r; r = r->next) { + fprintf(f, "(%llu, %llu) ", + (unsigned long long) r->start, + (unsigned long long) r->end); + if (++i >= 8) + fprintf(f, "\n\t"); + } + fprintf(f, "\n"); +} + +int main(int argc, char **argv) +{ + region_t r = NULL; + int pc = 0, ret; + region_addr_t start, end; + + + 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(%llu, %llu)\n", + (unsigned long long) start, + (unsigned long long) 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(%llu, %llu) returns %d\n", + (unsigned long long) start, + (unsigned long long) end, ret); + break; + case BCODE_PRINT: + region_print(r, stdout); + break; + } + } + if (r) + region_free(r); +} + +#endif /* TEST_PROGRAM */ diff --git a/e2fsck/rehash.c b/e2fsck/rehash.c new file mode 100644 index 0000000..c1da7d5 --- /dev/null +++ b/e2fsck/rehash.c @@ -0,0 +1,1189 @@ +/* + * 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 "config.h" +#include +#include +#include +#include "e2fsck.h" +#include "problem.h" +#include "support/sort_r.h" + +/* Schedule a dir to be rebuilt during pass 3A. */ +void e2fsck_rehash_dir_later(e2fsck_t ctx, ext2_ino_t ino) +{ + 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); +} + +/* Ask if a dir will be rebuilt during pass 3A. */ +int e2fsck_dir_will_be_rehashed(e2fsck_t ctx, ext2_ino_t ino) +{ + if (ctx->options & E2F_OPT_COMPRESS_DIRS) + return 1; + if (!ctx->dirs_to_hash) + return 0; + return ext2fs_u32_list_test(ctx->dirs_to_hash, ino); +} + +#undef REHASH_DEBUG + +struct fill_dir_struct { + char *buf; + struct ext2_inode *inode; + ext2_ino_t ino; + errcode_t err; + e2fsck_t ctx; + struct hash_entry *harray; + blk_t max_array, num_array; + ext2_off64_t dir_size; + int compress; + ext2_ino_t parent; + ext2_ino_t dir; +}; + +struct hash_entry { + ext2_dirhash_t hash; + ext2_dirhash_t minor_hash; + ext2_ino_t ino; + struct ext2_dir_entry *dir; +}; + +struct out_dir { + blk_t num; + blk_t max; + char *buf; + ext2_dirhash_t *hashes; +}; + +#define DOTDOT_OFFSET 12 + +static int is_fake_entry(ext2_filsys fs, int lblk, unsigned int offset) +{ + /* Entries in the first block before this value refer to . or .. */ + if (lblk == 0 && offset <= DOTDOT_OFFSET) + return 1; + /* Check if this is likely the csum entry */ + if (ext2fs_has_feature_metadata_csum(fs->super) && + (offset & (fs->blocksize - 1)) == + fs->blocksize - sizeof(struct ext2_dir_entry_tail)) + return 1; + return 0; +} + +static int fill_dir_block(ext2_filsys fs, + blk64_t *block_nr, + e2_blkcnt_t blockcnt, + blk64_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 *ent; + struct ext2_dir_entry *dirent; + char *dir; + unsigned int offset, dir_offset, rec_len, name_len; + int hash_alg, hash_flags, hash_in_entry; + + 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 (*block_nr == 0) { + memset(dir, 0, fs->blocksize); + dirent = (struct ext2_dir_entry *) dir; + (void) ext2fs_set_rec_len(fs, fs->blocksize, dirent); + } else { + int flags = fs->flags; + fs->flags |= EXT2_FLAG_IGNORE_CSUM_ERRORS; + fd->err = ext2fs_read_dir_block4(fs, *block_nr, dir, 0, + fd->dir); + fs->flags = (flags & EXT2_FLAG_IGNORE_CSUM_ERRORS) | + (fs->flags & ~EXT2_FLAG_IGNORE_CSUM_ERRORS); + if (fd->err) + return BLOCK_ABORT; + } + hash_flags = fd->inode->i_flags & EXT4_CASEFOLD_FL; + hash_in_entry = ext4_hash_in_dirent(fd->inode); + hash_alg = fs->super->s_def_hash_version; + if ((hash_alg <= EXT2_HASH_TEA) && + (fs->super->s_flags & EXT2_FLAGS_UNSIGNED_HASH)) + hash_alg += 3; + /* While the directory block is "hot", index it. */ + dir_offset = 0; + while (dir_offset < fs->blocksize) { + unsigned int min_rec = EXT2_DIR_ENTRY_HEADER_LEN; + int extended = hash_in_entry && !is_fake_entry(fs, blockcnt, dir_offset); + + if (extended) + min_rec += EXT2_DIR_ENTRY_HASH_LEN; + dirent = (struct ext2_dir_entry *) (dir + dir_offset); + (void) ext2fs_get_rec_len(fs, dirent, &rec_len); + name_len = ext2fs_dirent_name_len(dirent); + if (((dir_offset + rec_len) > fs->blocksize) || + (rec_len < min_rec) || + ((rec_len % 4) != 0) || + (name_len + min_rec > rec_len)) { + fd->err = EXT2_ET_DIR_CORRUPTED; + return BLOCK_ABORT; + } + dir_offset += rec_len; + if (dirent->inode == 0) + continue; + if ((name_len) == 0) { + fd->err = EXT2_ET_DIR_CORRUPTED; + return BLOCK_ABORT; + } + if (!fd->compress && (name_len == 1) && + (dirent->name[0] == '.')) + continue; + if (!fd->compress && (name_len == 2) && + (dirent->name[0] == '.') && (dirent->name[1] == '.')) { + fd->parent = dirent->inode; + continue; + } + if (fd->num_array >= fd->max_array) { + errcode_t retval; + + retval = ext2fs_resize_array(sizeof(struct hash_entry), + fd->max_array, + fd->max_array + 500, + &fd->harray); + if (retval) { + fd->err = retval; + return BLOCK_ABORT; + } + fd->max_array += 500; + } + ent = fd->harray + fd->num_array++; + ent->dir = dirent; + fd->dir_size += ext2fs_dir_rec_len(name_len, extended); + ent->ino = dirent->inode; + if (extended) { + ent->hash = EXT2_DIRENT_HASH(dirent); + ent->minor_hash = EXT2_DIRENT_MINOR_HASH(dirent); + } else if (fd->compress) { + ent->hash = ent->minor_hash = 0; + } else { + fd->err = ext2fs_dirhash2(hash_alg, + dirent->name, name_len, + fs->encoding, hash_flags, + 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 ino_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; + + return (he_a->ino - he_b->ino); +} + +struct name_cmp_ctx +{ + int casefold; + const struct ext2fs_nls_table *tbl; +}; + +static int same_name(const struct name_cmp_ctx *cmp_ctx, char *s1, + int len1, char *s2, int len2) +{ + if (!cmp_ctx->casefold) + return (len1 == len2 && !memcmp(s1, s2, len1)); + else + return !ext2fs_casefold_cmp(cmp_ctx->tbl, + (unsigned char *) s1, len1, + (unsigned char *) s2, len2); +} + +/* 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; + unsigned int he_a_len, he_b_len, min_len; + int ret; + + he_a_len = ext2fs_dirent_name_len(he_a->dir); + he_b_len = ext2fs_dirent_name_len(he_b->dir); + min_len = he_a_len; + if (min_len > he_b_len) + min_len = he_b_len; + + ret = memcmp(he_a->dir->name, he_b->dir->name, min_len); + if (ret == 0) { + if (he_a_len > he_b_len) + ret = 1; + else if (he_a_len < he_b_len) + ret = -1; + else + ret = he_b->dir->inode - he_a->dir->inode; + } + return ret; +} + +static EXT2_QSORT_TYPE name_cf_cmp(const struct name_cmp_ctx *ctx, + 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; + unsigned int he_a_len, he_b_len; + int ret; + + he_a_len = ext2fs_dirent_name_len(he_a->dir); + he_b_len = ext2fs_dirent_name_len(he_b->dir); + + ret = ext2fs_casefold_cmp(ctx->tbl, + (unsigned char *) he_a->dir->name, he_a_len, + (unsigned char *) he_b->dir->name, he_b_len); + if (ret == 0) { + if (he_a_len > he_b_len) + ret = 1; + else if (he_a_len < he_b_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, void *arg) +{ + const struct name_cmp_ctx *ctx = (struct name_cmp_ctx *) arg; + 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 { + if (ctx->casefold) + ret = name_cf_cmp(ctx, a, b); + else + ret = name_cmp(a, b); + } + } + return ret; +} + +static errcode_t alloc_size_dir(ext2_filsys fs, struct out_dir *outdir, + blk_t blocks) +{ + errcode_t retval; + + if (outdir->max) { + retval = ext2fs_resize_array(fs->blocksize, outdir->max, blocks, + &outdir->buf); + if (retval) + return retval; + retval = ext2fs_resize_array(sizeof(ext2_dirhash_t), + outdir->max, blocks, + &outdir->hashes); + if (retval) + return retval; + } else { + retval = ext2fs_get_array(fs->blocksize, blocks, &outdir->buf); + if (retval) + return retval; + retval = ext2fs_get_array(sizeof(ext2_dirhash_t), blocks, + &outdir->hashes); + if (retval) + return retval; + outdir->num = 0; + } + outdir->max = blocks; + return 0; +} + +static void free_out_dir(struct out_dir *outdir) +{ + free(outdir->buf); + 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) { + int increment = outdir->max / 10; + + if (increment < 50) + increment = 50; + retval = alloc_size_dir(fs, outdir, outdir->max + increment); + if (retval) + return retval; + } + *ret = outdir->buf + (size_t)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, unsigned int *len) +{ + int i; + unsigned int l = *len; + + /* + * 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 == (int)l - 1) || (str[i] != '~')) { + if (((l-1) & 3) < 2) + l += 2; + else + l = (l+3) & ~3; + if (l > 255) + l = 255; + str[l-2] = '~'; + str[l-1] = '0'; + *len = l; + 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, + const struct name_cmp_ctx *cmp_ctx) +{ + struct problem_context pctx; + struct hash_entry *ent, *prev; + blk_t i, j; + int fixed = 0; + char new_name[256]; + unsigned int new_len; + int hash_alg; + int hash_flags = fd->inode->i_flags & EXT4_CASEFOLD_FL; + + clear_problem_context(&pctx); + pctx.ino = ino; + + hash_alg = fs->super->s_def_hash_version; + if ((hash_alg <= EXT2_HASH_TEA) && + (fs->super->s_flags & EXT2_FLAGS_UNSIGNED_HASH)) + hash_alg += 3; + + for (i=1; i < fd->num_array; i++) { + ent = fd->harray + i; + prev = ent - 1; + if (!ent->dir->inode || + !same_name(cmp_ctx, ent->dir->name, + ext2fs_dirent_name_len(ent->dir), + prev->dir->name, + ext2fs_dirent_name_len(prev->dir))) + 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; + } + /* Can't alter encrypted name without key, so just drop it */ + if (fd->inode->i_flags & EXT4_ENCRYPT_FL) { + if (fix_problem(ctx, PR_2_NON_UNIQUE_FILE_NO_RENAME, &pctx)) { + e2fsck_adjust_inode_count(ctx, ent->dir->inode, -1); + ent->dir->inode = 0; + fixed++; + continue; + } + } + new_len = ext2fs_dirent_name_len(ent->dir); + if (new_len == 0) { + /* should never happen */ + ext2fs_unmark_valid(fs); + continue; + } + memcpy(new_name, ent->dir->name, new_len); + mutate_name(new_name, &new_len); + for (j=0; j < fd->num_array; j++) { + if ((i==j) || + !same_name(cmp_ctx, new_name, new_len, + fd->harray[j].dir->name, + ext2fs_dirent_name_len(fd->harray[j].dir))) { + continue; + } + mutate_name(new_name, &new_len); + + j = -1; + } + new_name[new_len] = 0; + pctx.str = new_name; + if (fix_problem(ctx, PR_2_NON_UNIQUE_FILE, &pctx)) { + memcpy(ent->dir->name, new_name, new_len); + ext2fs_dirent_set_name_len(ent->dir, new_len); + ext2fs_dirhash2(hash_alg, new_name, new_len, + fs->encoding, hash_flags, + fs->super->s_hash_seed, + &ent->hash, &ent->minor_hash); + fixed++; + } + } + return fixed; +} + + +static errcode_t copy_dir_entries(e2fsck_t ctx, + struct fill_dir_struct *fd, + struct out_dir *outdir) +{ + ext2_filsys fs = ctx->fs; + errcode_t retval; + char *block_start; + struct hash_entry *ent; + struct ext2_dir_entry *dirent; + unsigned int rec_len, prev_rec_len, left, slack, offset; + blk_t i; + ext2_dirhash_t prev_hash; + int csum_size = 0; + struct ext2_dir_entry_tail *t; + int hash_in_entry = ext4_hash_in_dirent(fd->inode); + unsigned int min_rec_len = ext2fs_dir_rec_len(1, hash_in_entry); + + if (ctx->htree_slack_percentage == 255) { + profile_get_uint(ctx->profile, "options", + "indexed_dir_slack_percentage", + 0, 20, + &ctx->htree_slack_percentage); + if (ctx->htree_slack_percentage > 100) + ctx->htree_slack_percentage = 20; + } + + if (ext2fs_has_feature_metadata_csum(fs->super)) + csum_size = sizeof(struct ext2_dir_entry_tail); + + 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; + prev_rec_len = 0; + rec_len = 0; + left = fs->blocksize - csum_size; + slack = fd->compress ? min_rec_len : + ((fs->blocksize - csum_size) * ctx->htree_slack_percentage)/100; + if (slack < min_rec_len) + slack = min_rec_len; + for (i = 0; i < fd->num_array; i++) { + ent = fd->harray + i; + if (ent->dir->inode == 0) + continue; + rec_len = ext2fs_dir_rec_len(ext2fs_dirent_name_len(ent->dir), + hash_in_entry); + if (rec_len > left) { + if (left) { + left += prev_rec_len; + retval = ext2fs_set_rec_len(fs, left, dirent); + if (retval) + return retval; + } + if (csum_size) { + t = EXT2_DIRENT_TAIL(block_start, + fs->blocksize); + ext2fs_initialize_dirent_tail(fs, t); + } + if ((retval = get_next_block(fs, outdir, + &block_start))) + return retval; + offset = 0; + } + left = (fs->blocksize - csum_size) - 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; + ext2fs_dirent_set_name_len(dirent, + ext2fs_dirent_name_len(ent->dir)); + ext2fs_dirent_set_file_type(dirent, + ext2fs_dirent_file_type(ent->dir)); + retval = ext2fs_set_rec_len(fs, rec_len, dirent); + if (retval) + return retval; + prev_rec_len = rec_len; + memcpy(dirent->name, ent->dir->name, + ext2fs_dirent_name_len(dirent)); + if (hash_in_entry) { + EXT2_DIRENT_HASHES(dirent)->hash = ext2fs_cpu_to_le32(ent->hash); + EXT2_DIRENT_HASHES(dirent)->minor_hash = + ext2fs_cpu_to_le32(ent->minor_hash); + } + offset += rec_len; + left -= rec_len; + if (left < slack) { + prev_rec_len += left; + retval = ext2fs_set_rec_len(fs, prev_rec_len, dirent); + if (retval) + return retval; + offset += left; + left = 0; + } + prev_hash = ent->hash; + } + if (left) + retval = ext2fs_set_rec_len(fs, rec_len + left, dirent); + if (csum_size) { + t = EXT2_DIRENT_TAIL(block_start, fs->blocksize); + ext2fs_initialize_dirent_tail(fs, t); + } + + return retval; +} + + +static struct ext2_dx_root_info *set_root_node(ext2_filsys fs, char *buf, + ext2_ino_t ino, ext2_ino_t parent, + struct ext2_inode *inode) +{ + struct ext2_dir_entry *dir; + struct ext2_dx_root_info *root; + struct ext2_dx_countlimit *limits; + int filetype = 0; + int csum_size = 0; + + if (ext2fs_has_feature_filetype(fs->super)) + filetype = EXT2_FT_DIR; + + memset(buf, 0, fs->blocksize); + dir = (struct ext2_dir_entry *) buf; + dir->inode = ino; + dir->name[0] = '.'; + ext2fs_dirent_set_name_len(dir, 1); + ext2fs_dirent_set_file_type(dir, filetype); + dir->rec_len = 12; + dir = (struct ext2_dir_entry *) (buf + 12); + dir->inode = parent; + dir->name[0] = '.'; + dir->name[1] = '.'; + ext2fs_dirent_set_name_len(dir, 2); + ext2fs_dirent_set_file_type(dir, filetype); + dir->rec_len = fs->blocksize - 12; + + root = (struct ext2_dx_root_info *) (buf+24); + root->reserved_zero = 0; + if (ext4_hash_in_dirent(inode)) + root->hash_version = EXT2_HASH_SIPHASH; + else + root->hash_version = fs->super->s_def_hash_version; + root->info_length = 8; + root->indirect_levels = 0; + root->unused_flags = 0; + + if (ext2fs_has_feature_metadata_csum(fs->super)) + csum_size = sizeof(struct ext2_dx_tail); + + limits = (struct ext2_dx_countlimit *) (buf+32); + limits->limit = (fs->blocksize - (32 + csum_size)) / + 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; + int csum_size = 0; + + memset(buf, 0, fs->blocksize); + dir = (struct ext2_dir_entry *) buf; + dir->inode = 0; + (void) ext2fs_set_rec_len(fs, fs->blocksize, dir); + + if (ext2fs_has_feature_metadata_csum(fs->super)) + csum_size = sizeof(struct ext2_dx_tail); + + limits = (struct ext2_dx_countlimit *) (buf+8); + limits->limit = (fs->blocksize - (8 + csum_size)) / + sizeof(struct ext2_dx_entry); + limits->count = 0; + + return (struct ext2_dx_entry *) limits; +} + +static int alloc_blocks(ext2_filsys fs, + struct ext2_dx_countlimit **limit, + struct ext2_dx_entry **prev_ent, + struct ext2_dx_entry **next_ent, + int *prev_offset, int *next_offset, + struct out_dir *outdir, int i, + int *prev_count, int *next_count) +{ + errcode_t retval; + char *block_start; + + if (*limit) + (*limit)->limit = (*limit)->count = + ext2fs_cpu_to_le16((*limit)->limit); + *prev_ent = (struct ext2_dx_entry *) (outdir->buf + *prev_offset); + (*prev_ent)->block = ext2fs_cpu_to_le32(outdir->num); + + if (i != 1) + (*prev_ent)->hash = + ext2fs_cpu_to_le32(outdir->hashes[i]); + + retval = get_next_block(fs, outdir, &block_start); + if (retval) + return retval; + + /* outdir->buf might be reallocated */ + *prev_ent = (struct ext2_dx_entry *) (outdir->buf + *prev_offset); + + *next_ent = set_int_node(fs, block_start); + *limit = (struct ext2_dx_countlimit *)(*next_ent); + if (next_offset) + *next_offset = ((char *) *next_ent - outdir->buf); + + *next_count = (*limit)->limit; + (*prev_offset) += sizeof(struct ext2_dx_entry); + (*prev_count)--; + + return 0; +} + +/* + * 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_inode *inode) +{ + struct ext2_dx_root_info *root_info; + struct ext2_dx_entry *root, *int_ent, *dx_ent = 0; + struct ext2_dx_countlimit *root_limit, *int_limit, *limit; + errcode_t retval; + int i, c1, c2, c3, nblks; + int limit_offset, int_offset, root_offset; + + root_info = set_root_node(fs, outdir->buf, ino, parent, inode); + 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 if (nblks - 1 <= ext2fs_htree_intnode_maxrecs(fs, c1)) { + c2 = 0; + limit = NULL; + root_info->indirect_levels = 1; + for (i=1; i < nblks; i++) { + if (c2 == 0 && c1 == 0) + return ENOSPC; + if (c2 == 0) { + retval = alloc_blocks(fs, &limit, &root, + &dx_ent, &root_offset, + NULL, outdir, i, &c1, + &c2); + if (retval) + return retval; + } + 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); + } else { + c2 = 0; + c3 = 0; + limit = NULL; + int_limit = 0; + root_info->indirect_levels = 2; + for (i = 1; i < nblks; i++) { + if (c3 == 0 && c2 == 0 && c1 == 0) + return ENOSPC; + if (c3 == 0 && c2 == 0) { + retval = alloc_blocks(fs, &int_limit, &root, + &int_ent, &root_offset, + &int_offset, outdir, i, + &c1, &c2); + if (retval) + return retval; + } + if (c3 == 0) { + int delta1 = (char *)int_limit - outdir->buf; + int delta2 = (char *)root - outdir->buf; + + retval = alloc_blocks(fs, &limit, &int_ent, + &dx_ent, &int_offset, + NULL, outdir, i, &c2, + &c3); + if (retval) + return retval; + + /* outdir->buf might be reallocated */ + int_limit = (struct ext2_dx_countlimit *) + (outdir->buf + delta1); + root = (struct ext2_dx_entry *) + (outdir->buf + delta2); + } + dx_ent->block = ext2fs_cpu_to_le32(i); + if (c3 != limit->limit) + dx_ent->hash = + ext2fs_cpu_to_le32(outdir->hashes[i]); + dx_ent++; + c3--; + } + int_limit->count = ext2fs_cpu_to_le16(limit->limit - c2); + int_limit->limit = ext2fs_cpu_to_le16(limit->limit); + + limit->count = ext2fs_cpu_to_le16(limit->limit - c3); + 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; + ext2_ino_t ino; + e2fsck_t ctx; + ext2_ino_t dir; +}; + +/* + * Helper function which writes out a directory block. + */ +static int write_dir_block(ext2_filsys fs, + blk64_t *block_nr, + e2_blkcnt_t blockcnt, + blk64_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; + char *dir, *buf = 0; + +#ifdef REHASH_DEBUG + printf("%u: write_dir_block %lld:%lld", wd->ino, blockcnt, *block_nr); +#endif + if ((*block_nr == 0) || (blockcnt < 0)) { +#ifdef REHASH_DEBUG + printf(" - skip\n"); +#endif + return 0; + } + if (blockcnt < wd->outdir->num) + dir = wd->outdir->buf + (blockcnt * fs->blocksize); + else if (wd->ctx->lost_and_found == wd->dir) { + /* Don't release any extra directory blocks for lost+found */ + wd->err = ext2fs_new_dir_block(fs, 0, 0, &buf); + if (wd->err) + return BLOCK_ABORT; + dir = buf; + wd->outdir->num++; + } else { + /* Don't free blocks at the end of the directory, they + * will be truncated by the caller. */ +#ifdef REHASH_DEBUG + printf(" - not freed\n"); +#endif + return 0; + } + wd->err = ext2fs_write_dir_block4(fs, *block_nr, dir, 0, wd->dir); + if (buf) + ext2fs_free_mem(&buf); + +#ifdef REHASH_DEBUG + printf(" - write (%d)\n", wd->err); +#endif + 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, struct ext2_inode *inode, + int compress) +{ + struct write_dir_struct wd; + errcode_t retval; + + retval = e2fsck_expand_directory(ctx, ino, -1, outdir->num); + if (retval) + return retval; + + wd.outdir = outdir; + wd.err = 0; + wd.ino = ino; + wd.ctx = ctx; + wd.dir = ino; + + retval = ext2fs_block_iterate3(fs, ino, 0, NULL, + 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; +#ifdef REHASH_DEBUG + printf("%u: set inode size to %u blocks = %u bytes\n", + ino, outdir->num, outdir->num * fs->blocksize); +#endif + retval = ext2fs_inode_size_set(fs, inode, (ext2_off64_t)outdir->num * + fs->blocksize); + if (retval) + return retval; + + /* ext2fs_punch() calls ext2fs_write_inode() which writes the size */ + return ext2fs_punch(fs, ino, inode, NULL, outdir->num, ~0ULL); +} + +errcode_t e2fsck_rehash_dir(e2fsck_t ctx, ext2_ino_t ino, + struct problem_context *pctx) +{ + ext2_filsys fs = ctx->fs; + errcode_t retval; + struct ext2_inode inode; + char *dir_buf = 0; + struct fill_dir_struct fd = { NULL, NULL, 0, 0, 0, NULL, + 0, 0, 0, 0, 0, 0 }; + struct out_dir outdir = { 0, 0, 0, 0 }; + struct name_cmp_ctx name_cmp_ctx = {0, NULL}; + + e2fsck_read_inode(ctx, ino, &inode, "rehash_dir"); + + if (ext2fs_has_feature_inline_data(fs->super) && + (inode.i_flags & EXT4_INLINE_DATA_FL)) + return 0; + + retval = ext2fs_get_mem(inode.i_size, &dir_buf); + if (retval) + goto errout; + + fd.max_array = inode.i_size / 32; + retval = ext2fs_get_array(sizeof(struct hash_entry), + fd.max_array, &fd.harray); + if (retval) + goto errout; + + fd.ino = ino; + fd.ctx = ctx; + fd.buf = dir_buf; + fd.inode = &inode; + fd.dir = ino; + if (!ext2fs_has_feature_dir_index(fs->super) || + (inode.i_size / fs->blocksize) < 2) + fd.compress = 1; + fd.parent = 0; + + if (fs->encoding && (inode.i_flags & EXT4_CASEFOLD_FL)) { + name_cmp_ctx.casefold = 1; + name_cmp_ctx.tbl = fs->encoding; + } + +retry_nohash: + /* Read in the entire directory into memory */ + retval = ext2fs_block_iterate3(fs, ino, 0, 0, + fill_dir_block, &fd); + if (fd.err) { + retval = fd.err; + goto errout; + } + + /* + * If the entries read are less than a block, then don't index + * the directory + */ + if (!fd.compress && (fd.dir_size < (fs->blocksize - 24))) { + fd.compress = 1; + fd.dir_size = 0; + fd.num_array = 0; + goto retry_nohash; + } + +#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 && fd.num_array > 1) + sort_r(fd.harray+2, fd.num_array-2, sizeof(struct hash_entry), + hash_cmp, &name_cmp_ctx); + else + sort_r(fd.harray, fd.num_array, sizeof(struct hash_entry), + hash_cmp, &name_cmp_ctx); + + /* + * Look for duplicates + */ + if (duplicate_search_and_fix(ctx, fs, ino, &fd, &name_cmp_ctx)) + goto resort; + + if (ctx->options & E2F_OPT_NO) { + retval = 0; + goto errout; + } + + /* Sort non-hashed directories by inode number */ + if (fd.compress && fd.num_array > 1) + qsort(fd.harray+2, fd.num_array-2, + sizeof(struct hash_entry), ino_cmp); + + /* + * Copy the directory entries. In a htree directory these + * will become the leaf nodes. + */ + retval = copy_dir_entries(ctx, &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, fd.inode); + if (retval) + goto errout; + } + + retval = write_directory(ctx, fs, &outdir, ino, &inode, fd.compress); + if (retval) + goto errout; + + if (ctx->options & E2F_OPT_CONVERT_BMAP) + retval = e2fsck_rebuild_extents_later(ctx, ino); + else + retval = e2fsck_check_rebuild_extents(ctx, ino, &inode, pctx); +errout: + ext2fs_free_mem(&dir_buf); + ext2fs_free_mem(&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; + struct dir_info_iter * dirinfo_iter = 0; + ext2_ino_t ino; + errcode_t retval; + int cur, max, all_dirs, first = 1; + + init_resource_track(&rtrack, ctx->fs->io); + all_dirs = ctx->options & E2F_OPT_COMPRESS_DIRS; + + if (!ctx->dirs_to_hash && !all_dirs) + return; + + (void) e2fsck_get_lost_and_found(ctx, 0); + + clear_problem_context(&pctx); + + cur = 0; + if (all_dirs) { + dirinfo_iter = e2fsck_dir_info_iter_begin(ctx); + 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, + dirinfo_iter)) == 0) + break; + ino = dir->ino; + } else { + if (!ext2fs_u32_list_iterate(iter, &ino)) + break; + } + if (!ext2fs_test_inode_bitmap2(ctx->inode_dir_map, ino)) + 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, &pctx); + 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) + e2fsck_dir_info_iter_end(ctx, dirinfo_iter); + else + ext2fs_u32_list_iterate_end(iter); + + if (ctx->dirs_to_hash) + ext2fs_u32_list_free(ctx->dirs_to_hash); + ctx->dirs_to_hash = 0; + + print_resource_track(ctx, "Pass 3A", &rtrack, ctx->fs->io); +} diff --git a/e2fsck/revoke.c b/e2fsck/revoke.c new file mode 100644 index 0000000..fa60878 --- /dev/null +++ b/e2fsck/revoke.c @@ -0,0 +1,743 @@ +// SPDX-License-Identifier: GPL-2.0+ +/* + * linux/fs/jbd2/revoke.c + * + * Written by Stephen C. Tweedie , 2000 + * + * Copyright 2000 Red Hat corp --- All Rights Reserved + * + * 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. + * + * We cache revoke status of a buffer in the current transaction in b_states + * bits. As the name says, revokevalid flag indicates that the cached revoke + * status of a buffer is valid and we can rely on the cached status. + * + * 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. + * + * Locking rules: + * We keep two hash tables of revoke records. One hashtable belongs to the + * running transaction (is pointed to by journal->j_revoke), the other one + * belongs to the committing transaction. Accesses to the second hash table + * happen only from the kjournald and no other thread touches this table. Also + * journal_switch_revoke_table() which switches which hashtable belongs to the + * running and which to the committing transaction is called only from + * kjournald. Therefore we need no locks when accessing the hashtable belonging + * to the committing transaction. + * + * All users operating on the hash table belonging to the running transaction + * have a handle to the transaction. Therefore they are safe from kjournald + * switching hash tables under them. For operations on the lists of entries in + * the hash table j_revoke_lock is used. + * + * Finally, also replay code uses the hash tables but at this moment no one else + * can touch them (filesystem isn't mounted yet) and hence no locking is + * needed. + */ + +#ifndef __KERNEL__ +#include "jfs_user.h" +#else +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#endif + +static struct kmem_cache *jbd2_revoke_record_cache; +static struct kmem_cache *jbd2_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 jbd2_revoke_record_s +{ + struct list_head hash; + tid_t sequence; /* Used for recovery only */ + unsigned long long blocknr; +}; + + +/* The revoke table is just a simple hash table of revoke records. */ +struct jbd2_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(transaction_t *, + struct list_head *, + struct buffer_head **, int *, + struct jbd2_revoke_record_s *); +static void flush_descriptor(journal_t *, struct buffer_head *, int); +#endif + +/* Utility functions to maintain the revoke table */ + +static inline int hash(journal_t *journal, unsigned long long block) +{ + return hash_64(block, journal->j_revoke->hash_shift); +} + +static int insert_revoke_hash(journal_t *journal, unsigned long long blocknr, + tid_t seq) +{ + struct list_head *hash_list; + struct jbd2_revoke_record_s *record; + gfp_t gfp_mask = GFP_NOFS; + + if (journal_oom_retry) + gfp_mask |= __GFP_NOFAIL; + record = kmem_cache_alloc(jbd2_revoke_record_cache, gfp_mask); + if (!record) + return -ENOMEM; + + record->sequence = seq; + record->blocknr = blocknr; + hash_list = &journal->j_revoke->hash_table[hash(journal, blocknr)]; + spin_lock(&journal->j_revoke_lock); + list_add(&record->hash, hash_list); + spin_unlock(&journal->j_revoke_lock); + return 0; +} + +/* Find a revoke record in the journal's hash table. */ + +static struct jbd2_revoke_record_s *find_revoke_record(journal_t *journal, + unsigned long long blocknr) +{ + struct list_head *hash_list; + struct jbd2_revoke_record_s *record; + + hash_list = &journal->j_revoke->hash_table[hash(journal, blocknr)]; + + spin_lock(&journal->j_revoke_lock); + record = (struct jbd2_revoke_record_s *) hash_list->next; + while (&(record->hash) != hash_list) { + if (record->blocknr == blocknr) { + spin_unlock(&journal->j_revoke_lock); + return record; + } + record = (struct jbd2_revoke_record_s *) record->hash.next; + } + spin_unlock(&journal->j_revoke_lock); + return NULL; +} + +void jbd2_journal_destroy_revoke_record_cache(void) +{ + kmem_cache_destroy(jbd2_revoke_record_cache); + jbd2_revoke_record_cache = NULL; +} + +void jbd2_journal_destroy_revoke_table_cache(void) +{ + kmem_cache_destroy(jbd2_revoke_table_cache); + jbd2_revoke_table_cache = NULL; +} + +int __init jbd2_journal_init_revoke_record_cache(void) +{ + J_ASSERT(!jbd2_revoke_record_cache); + jbd2_revoke_record_cache = KMEM_CACHE(jbd2_revoke_record_s, + SLAB_HWCACHE_ALIGN|SLAB_TEMPORARY); + + if (!jbd2_revoke_record_cache) { + pr_emerg("JBD2: failed to create revoke_record cache\n"); + return -ENOMEM; + } + return 0; +} + +int __init jbd2_journal_init_revoke_table_cache(void) +{ + J_ASSERT(!jbd2_revoke_table_cache); + jbd2_revoke_table_cache = KMEM_CACHE(jbd2_revoke_table_s, + SLAB_TEMPORARY); + if (!jbd2_revoke_table_cache) { + pr_emerg("JBD2: failed to create revoke_table cache\n"); + return -ENOMEM; + } + return 0; +} + +static struct jbd2_revoke_table_s *jbd2_journal_init_revoke_table(int hash_size) +{ + int shift = 0; + int tmp = hash_size; + struct jbd2_revoke_table_s *table; + + table = kmem_cache_alloc(jbd2_revoke_table_cache, GFP_KERNEL); + if (!table) + goto out; + + while((tmp >>= 1UL) != 0UL) + shift++; + + table->hash_size = hash_size; + table->hash_shift = shift; + table->hash_table = + kmalloc_array(hash_size, sizeof(struct list_head), GFP_KERNEL); + if (!table->hash_table) { + kmem_cache_free(jbd2_revoke_table_cache, table); + table = NULL; + goto out; + } + + for (tmp = 0; tmp < hash_size; tmp++) + INIT_LIST_HEAD(&table->hash_table[tmp]); + +out: + return table; +} + +static void jbd2_journal_destroy_revoke_table(struct jbd2_revoke_table_s *table) +{ + int i; + struct list_head *hash_list; + + for (i = 0; i < table->hash_size; i++) { + hash_list = &table->hash_table[i]; + J_ASSERT(list_empty(hash_list)); + } + + kfree(table->hash_table); + kmem_cache_free(jbd2_revoke_table_cache, table); +} + +/* Initialise the revoke table for a given journal to a given size. */ +int jbd2_journal_init_revoke(journal_t *journal, int hash_size) +{ + J_ASSERT(journal->j_revoke_table[0] == NULL); + J_ASSERT(is_power_of_2(hash_size)); + + journal->j_revoke_table[0] = jbd2_journal_init_revoke_table(hash_size); + if (!journal->j_revoke_table[0]) + goto fail0; + + journal->j_revoke_table[1] = jbd2_journal_init_revoke_table(hash_size); + if (!journal->j_revoke_table[1]) + goto fail1; + + journal->j_revoke = journal->j_revoke_table[1]; + + spin_lock_init(&journal->j_revoke_lock); + + return 0; + +fail1: + jbd2_journal_destroy_revoke_table(journal->j_revoke_table[0]); + journal->j_revoke_table[0] = NULL; +fail0: + return -ENOMEM; +} + +/* Destroy a journal's revoke table. The table must already be empty! */ +void jbd2_journal_destroy_revoke(journal_t *journal) +{ + journal->j_revoke = NULL; + if (journal->j_revoke_table[0]) + jbd2_journal_destroy_revoke_table(journal->j_revoke_table[0]); + if (journal->j_revoke_table[1]) + jbd2_journal_destroy_revoke_table(journal->j_revoke_table[1]); +} + + +#ifdef __KERNEL__ + +/* + * jbd2_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 jbd2_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, jbd2_journal_revoke() will decrement its b_count + * by one. + */ + +int jbd2_journal_revoke(handle_t *handle, unsigned long long blocknr, + struct buffer_head *bh_in) +{ + struct buffer_head *bh = NULL; + journal_t *journal; + struct block_device *bdev; + int err; + + might_sleep(); + if (bh_in) + BUFFER_TRACE(bh_in, "enter"); + + journal = handle->h_transaction->t_journal; + if (!jbd2_journal_set_features(journal, 0, 0, JBD2_FEATURE_INCOMPAT_REVOKE)){ + J_ASSERT (!"Cannot set revoke feature!"); + return -EINVAL; + } + + bdev = journal->j_fs_dev; + bh = bh_in; + + if (!bh) { + bh = __find_get_block(bdev, blocknr, journal->j_blocksize); + if (bh) + BUFFER_TRACE(bh, "found on hash"); + } +#ifdef JBD2_EXPENSIVE_CHECKING + else { + struct buffer_head *bh2; + + /* If there is a different buffer_head lying around in + * memory anywhere... */ + bh2 = __find_get_block(bdev, blocknr, journal->j_blocksize); + if (bh2) { + /* ... and it has RevokeValid status... */ + if (bh2 != bh && buffer_revokevalid(bh2)) + /* ...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, buffer_revoked(bh2)); + put_bh(bh2); + } + } +#endif + + if (WARN_ON_ONCE(handle->h_revoke_credits <= 0)) { + if (!bh_in) + brelse(bh); + return -EIO; + } + /* 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) { + if (!J_EXPECT_BH(bh, !buffer_revoked(bh), + "inconsistent data on disk")) { + if (!bh_in) + brelse(bh); + return -EIO; + } + set_buffer_revoked(bh); + set_buffer_revokevalid(bh); + if (bh_in) { + BUFFER_TRACE(bh_in, "call jbd2_journal_forget"); + jbd2_journal_forget(handle, bh_in); + } else { + BUFFER_TRACE(bh, "call brelse"); + __brelse(bh); + } + } + handle->h_revoke_credits--; + + jbd_debug(2, "insert revoke for block %llu, bh_in=%p\n",blocknr, bh_in); + err = insert_revoke_hash(journal, blocknr, + handle->h_transaction->t_tid); + BUFFER_TRACE(bh_in, "exit"); + return err; +} + +/* + * Cancel an outstanding revoke. For use only internally by the + * journaling code (called from jbd2_journal_get_write_access). + * + * We trust buffer_revoked() 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. + */ +int jbd2_journal_cancel_revoke(handle_t *handle, struct journal_head *jh) +{ + struct jbd2_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_set_buffer_revokevalid(bh)) { + need_cancel = test_clear_buffer_revoked(bh); + } else { + need_cancel = 1; + clear_buffer_revoked(bh); + } + + if (need_cancel) { + record = find_revoke_record(journal, bh->b_blocknr); + if (record) { + jbd_debug(4, "cancelled existing revoke on " + "blocknr %llu\n", (unsigned long long)bh->b_blocknr); + spin_lock(&journal->j_revoke_lock); + list_del(&record->hash); + spin_unlock(&journal->j_revoke_lock); + kmem_cache_free(jbd2_revoke_record_cache, record); + did_revoke = 1; + } + } + +#ifdef JBD2_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) { + struct buffer_head *bh2; + bh2 = __find_get_block(bh->b_bdev, bh->b_blocknr, bh->b_size); + if (bh2) { + if (bh2 != bh) + clear_buffer_revoked(bh2); + __brelse(bh2); + } + } + return did_revoke; +} + +/* + * journal_clear_revoked_flag clears revoked flag of buffers in + * revoke table to reflect there is no revoked buffers in the next + * transaction which is going to be started. + */ +void jbd2_clear_buffer_revoked_flags(journal_t *journal) +{ + struct jbd2_revoke_table_s *revoke = journal->j_revoke; + int i = 0; + + for (i = 0; i < revoke->hash_size; i++) { + struct list_head *hash_list; + struct list_head *list_entry; + hash_list = &revoke->hash_table[i]; + + list_for_each(list_entry, hash_list) { + struct jbd2_revoke_record_s *record; + struct buffer_head *bh; + record = (struct jbd2_revoke_record_s *)list_entry; + bh = __find_get_block(journal->j_fs_dev, + record->blocknr, + journal->j_blocksize); + if (bh) { + clear_buffer_revoked(bh); + __brelse(bh); + } + } + } +} + +/* journal_switch_revoke table select j_revoke for next transaction + * we do not want to suspend any processing until all revokes are + * written -bzzz + */ +void jbd2_journal_switch_revoke_table(journal_t *journal) +{ + int i; + + if (journal->j_revoke == journal->j_revoke_table[0]) + journal->j_revoke = journal->j_revoke_table[1]; + else + journal->j_revoke = journal->j_revoke_table[0]; + + for (i = 0; i < journal->j_revoke->hash_size; i++) + INIT_LIST_HEAD(&journal->j_revoke->hash_table[i]); +} + +/* + * Write revoke records to the journal for all entries in the current + * revoke hash, deleting the entries as we go. + */ +void jbd2_journal_write_revoke_records(transaction_t *transaction, + struct list_head *log_bufs) +{ + journal_t *journal = transaction->t_journal; + struct buffer_head *descriptor; + struct jbd2_revoke_record_s *record; + struct jbd2_revoke_table_s *revoke; + struct list_head *hash_list; + int i, offset, count; + + descriptor = NULL; + offset = 0; + count = 0; + + /* select revoke table for committing transaction */ + revoke = journal->j_revoke == journal->j_revoke_table[0] ? + journal->j_revoke_table[1] : journal->j_revoke_table[0]; + + for (i = 0; i < revoke->hash_size; i++) { + hash_list = &revoke->hash_table[i]; + + while (!list_empty(hash_list)) { + record = (struct jbd2_revoke_record_s *) + hash_list->next; + write_one_revoke_record(transaction, log_bufs, + &descriptor, &offset, record); + count++; + list_del(&record->hash); + kmem_cache_free(jbd2_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(transaction_t *transaction, + struct list_head *log_bufs, + struct buffer_head **descriptorp, + int *offsetp, + struct jbd2_revoke_record_s *record) +{ + journal_t *journal = transaction->t_journal; + int csum_size = 0; + struct buffer_head *descriptor; + int sz, offset; + + /* If we are already aborting, this all becomes a noop. We + still need to go round the loop in + jbd2_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; + + /* Do we need to leave space at the end for a checksum? */ + if (jbd2_journal_has_csum_v2or3(journal)) + csum_size = sizeof(struct jbd2_journal_block_tail); + + if (jbd2_has_feature_64bit(journal)) + sz = 8; + else + sz = 4; + + /* Make sure we have a descriptor with space left for the record */ + if (descriptor) { + if (offset + sz > journal->j_blocksize - csum_size) { + flush_descriptor(journal, descriptor, offset); + descriptor = NULL; + } + } + + if (!descriptor) { + descriptor = jbd2_journal_get_descriptor_buffer(transaction, + JBD2_REVOKE_BLOCK); + if (!descriptor) + return; + + /* Record it so that we can wait for IO completion later */ + BUFFER_TRACE(descriptor, "file in log_bufs"); + jbd2_file_log_bh(log_bufs, descriptor); + + offset = sizeof(jbd2_journal_revoke_header_t); + *descriptorp = descriptor; + } + + if (jbd2_has_feature_64bit(journal)) + * ((__be64 *)(&descriptor->b_data[offset])) = + cpu_to_be64(record->blocknr); + else + * ((__be32 *)(&descriptor->b_data[offset])) = + cpu_to_be32(record->blocknr); + offset += sz; + + *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 buffer_head *descriptor, + int offset) +{ + jbd2_journal_revoke_header_t *header; + + if (is_journal_aborted(journal)) + return; + + header = (jbd2_journal_revoke_header_t *)descriptor->b_data; + header->r_count = cpu_to_be32(offset); + jbd2_descriptor_block_csum_set(journal, descriptor); + + set_buffer_jwrite(descriptor); + BUFFER_TRACE(descriptor, "write"); + set_buffer_dirty(descriptor); + write_dirty_buffer(descriptor, REQ_SYNC); +} +#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 jbd2_journal_set_revoke(journal_t *journal, + unsigned long long blocknr, + tid_t sequence) +{ + struct jbd2_revoke_record_s *record; + + record = find_revoke_record(journal, blocknr); + if (record) { + /* If we have multiple occurrences, 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 jbd2_journal_test_revoke(journal_t *journal, + unsigned long long blocknr, + tid_t sequence) +{ + struct jbd2_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 jbd2_journal_clear_revoke(journal_t *journal) +{ + int i; + struct list_head *hash_list; + struct jbd2_revoke_record_s *record; + struct jbd2_revoke_table_s *revoke; + + 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 jbd2_revoke_record_s*) hash_list->next; + list_del(&record->hash); + kmem_cache_free(jbd2_revoke_record_cache, record); + } + } +} diff --git a/e2fsck/scantest.c b/e2fsck/scantest.c new file mode 100644 index 0000000..ed3595f --- /dev/null +++ b/e2fsck/scantest.c @@ -0,0 +1,141 @@ +/* + * scantest.c - test the speed of the inode scan routine + */ + +#include "config.h" +#include +#include +#include +#include +#include +#ifdef HAVE_GETOPT_H +#include +#endif +#include +#include +#ifdef HAVE_MALLOC_H +#include +#endif +#include + +#include "et/com_err.h" +#include "../version.h" + +#include +#include +#include +#include +#include +#include +#include + +#include "ext2fs/ext2_fs.h" +#include "ext2fs/ext2fs.h" + + +extern int isatty(int); + +const char * device_name = NULL; + +/* + * 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; +}; + +struct resource_track global_rtrack; + +void init_resource_track(struct resource_track *track) +{ + struct rusage r; + + track->brk_start = sbrk(0); + gettimeofday(&track->time_start, 0); + getrusage(RUSAGE_SELF, &r); + track->user_start = r.ru_utime; + track->system_start = r.ru_stime; +} + +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); +} + +static void print_resource_track(struct resource_track *track) +{ + struct rusage r; + struct timeval time_end; + + gettimeofday(&time_end, 0); + getrusage(RUSAGE_SELF, &r); + + printf(_("Memory used: %lu, elapsed time: %6.3f/%6.3f/%6.3f\n"), + (unsigned long)((char *)sbrk(0) - (char *)track->brk_start), + timeval_subtract(&time_end, &track->time_start), + timeval_subtract(&r.ru_utime, &track->user_start), + timeval_subtract(&r.ru_stime, &track->system_start)); +} + + + +int main (int argc, char *argv[]) +{ + errcode_t retval = 0; + int exit_value = 0; + int i; + ext2_filsys fs; + ext2_inode_scan scan; + ext2_ino_t ino; + struct ext2_inode inode; + + printf(_("size of inode=%d\n"), sizeof(inode)); + + device_name = "/dev/hda3"; + + init_resource_track(&global_rtrack); + + retval = ext2fs_open(device_name, 0, + 0, 0, unix_io_manager, &fs); + if (retval) { + com_err(argv[0], retval, _("while trying to open %s"), + device_name); + exit(1); + } + + retval = ext2fs_open_inode_scan(fs, 0, &scan); + if (retval) { + com_err(argv[0], retval, _("while opening inode scan")); + exit(1); + } + retval = ext2fs_get_next_inode(scan, &ino, &inode); + if (retval) { + com_err(argv[0], retval, _("while starting inode scan")); + exit(1); + } + while (ino) { + if (!inode.i_links_count) + goto next; + printf("%lu\n", inode.i_blocks); + next: + retval = ext2fs_get_next_inode(scan, &ino, &inode); + if (retval) { + com_err(argv[0], retval, + _("while doing inode scan")); + exit(1); + } + } + + + ext2fs_close_free(&fs); + + print_resource_track(&global_rtrack); + + return exit_value; +} diff --git a/e2fsck/sigcatcher.c b/e2fsck/sigcatcher.c new file mode 100644 index 0000000..a9d3b7f --- /dev/null +++ b/e2fsck/sigcatcher.c @@ -0,0 +1,446 @@ +/* + * sigcatcher.c --- print a backtrace on a SIGSEGV, et. al + * + * Copyright (C) 2011 Theodore Ts'o. + * + * %Begin-Header% + * This file may be redistributed under the terms of the GNU Public + * License. + * %End-Header% + */ + +#include "config.h" +#include +#include +#include +#include +#ifdef HAVE_EXECINFO_H +#include +#endif + +#include "e2fsck.h" + +struct str_table { + int num; + const char *name; +}; + +#define DEFINE_ENTRY(SYM) { SYM, #SYM }, +#define END_TABLE { 0, 0 } + +static struct str_table sig_table[] = { +#ifdef SIGHUP + DEFINE_ENTRY(SIGHUP) +#endif +#ifdef SIGINT + DEFINE_ENTRY(SIGINT) +#endif +#ifdef SIGQUIT + DEFINE_ENTRY(SIGQUIT) +#endif +#ifdef SIGILL + DEFINE_ENTRY(SIGILL) +#endif +#ifdef SIGTRAP + DEFINE_ENTRY(SIGTRAP) +#endif +#ifdef SIGABRT + DEFINE_ENTRY(SIGABRT) +#endif +#ifdef SIGIOT + DEFINE_ENTRY(SIGIOT) +#endif +#ifdef SIGBUS + DEFINE_ENTRY(SIGBUS) +#endif +#ifdef SIGFPE + DEFINE_ENTRY(SIGFPE) +#endif +#ifdef SIGKILL + DEFINE_ENTRY(SIGKILL) +#endif +#ifdef SIGUSR1 + DEFINE_ENTRY(SIGUSR1) +#endif +#ifdef SIGSEGV + DEFINE_ENTRY(SIGSEGV) +#endif +#ifdef SIGUSR2 + DEFINE_ENTRY(SIGUSR2) +#endif +#ifdef SIGPIPE + DEFINE_ENTRY(SIGPIPE) +#endif +#ifdef SIGALRM + DEFINE_ENTRY(SIGALRM) +#endif +#ifdef SIGTERM + DEFINE_ENTRY(SIGTERM) +#endif +#ifdef SIGSTKFLT + DEFINE_ENTRY(SIGSTKFLT) +#endif +#ifdef SIGCHLD + DEFINE_ENTRY(SIGCHLD) +#endif +#ifdef SIGCONT + DEFINE_ENTRY(SIGCONT) +#endif +#ifdef SIGSTOP + DEFINE_ENTRY(SIGSTOP) +#endif +#ifdef SIGTSTP + DEFINE_ENTRY(SIGTSTP) +#endif +#ifdef SIGTTIN + DEFINE_ENTRY(SIGTTIN) +#endif +#ifdef SIGTTOU + DEFINE_ENTRY(SIGTTOU) +#endif +#ifdef SIGURG + DEFINE_ENTRY(SIGURG) +#endif +#ifdef SIGXCPU + DEFINE_ENTRY(SIGXCPU) +#endif +#ifdef SIGXFSZ + DEFINE_ENTRY(SIGXFSZ) +#endif +#ifdef SIGVTALRM + DEFINE_ENTRY(SIGVTALRM) +#endif +#ifdef SIGPROF + DEFINE_ENTRY(SIGPROF) +#endif +#ifdef SIGWINCH + DEFINE_ENTRY(SIGWINCH) +#endif +#ifdef SIGIO + DEFINE_ENTRY(SIGIO) +#endif +#ifdef SIGPOLL + DEFINE_ENTRY(SIGPOLL) +#endif +#ifdef SIGPWR + DEFINE_ENTRY(SIGPWR) +#endif +#ifdef SIGSYS + DEFINE_ENTRY(SIGSYS) +#endif + END_TABLE +}; + +static struct str_table generic_code_table[] = { +#ifdef SI_ASYNCNL + DEFINE_ENTRY(SI_ASYNCNL) +#endif +#ifdef SI_TKILL + DEFINE_ENTRY(SI_TKILL) +#endif +#ifdef SI_SIGIO + DEFINE_ENTRY(SI_SIGIO) +#endif +#ifdef SI_ASYNCIO + DEFINE_ENTRY(SI_ASYNCIO) +#endif +#ifdef SI_MESGQ + DEFINE_ENTRY(SI_MESGQ) +#endif +#ifdef SI_TIMER + DEFINE_ENTRY(SI_TIMER) +#endif +#ifdef SI_QUEUE + DEFINE_ENTRY(SI_QUEUE) +#endif +#ifdef SI_USER + DEFINE_ENTRY(SI_USER) +#endif +#ifdef SI_KERNEL + DEFINE_ENTRY(SI_KERNEL) +#endif + END_TABLE +}; + +static struct str_table sigill_code_table[] = { +#ifdef ILL_ILLOPC + DEFINE_ENTRY(ILL_ILLOPC) +#endif +#ifdef ILL_ILLOPN + DEFINE_ENTRY(ILL_ILLOPN) +#endif +#ifdef ILL_ILLADR + DEFINE_ENTRY(ILL_ILLADR) +#endif +#ifdef ILL_ILLTRP + DEFINE_ENTRY(ILL_ILLTRP) +#endif +#ifdef ILL_PRVOPC + DEFINE_ENTRY(ILL_PRVOPC) +#endif +#ifdef ILL_PRVREG + DEFINE_ENTRY(ILL_PRVREG) +#endif +#ifdef ILL_COPROC + DEFINE_ENTRY(ILL_COPROC) +#endif +#ifdef ILL_BADSTK + DEFINE_ENTRY(ILL_BADSTK) +#endif +#ifdef BUS_ADRALN + DEFINE_ENTRY(BUS_ADRALN) +#endif +#ifdef BUS_ADRERR + DEFINE_ENTRY(BUS_ADRERR) +#endif +#ifdef BUS_OBJERR + DEFINE_ENTRY(BUS_OBJERR) +#endif + END_TABLE +}; + +static struct str_table sigfpe_code_table[] = { +#ifdef FPE_INTDIV + DEFINE_ENTRY(FPE_INTDIV) +#endif +#ifdef FPE_INTOVF + DEFINE_ENTRY(FPE_INTOVF) +#endif +#ifdef FPE_FLTDIV + DEFINE_ENTRY(FPE_FLTDIV) +#endif +#ifdef FPE_FLTOVF + DEFINE_ENTRY(FPE_FLTOVF) +#endif +#ifdef FPE_FLTUND + DEFINE_ENTRY(FPE_FLTUND) +#endif +#ifdef FPE_FLTRES + DEFINE_ENTRY(FPE_FLTRES) +#endif +#ifdef FPE_FLTINV + DEFINE_ENTRY(FPE_FLTINV) +#endif +#ifdef FPE_FLTSUB + DEFINE_ENTRY(FPE_FLTSUB) +#endif + END_TABLE +}; + +static struct str_table sigsegv_code_table[] = { +#ifdef SEGV_MAPERR + DEFINE_ENTRY(SEGV_MAPERR) +#endif +#ifdef SEGV_ACCERR + DEFINE_ENTRY(SEGV_ACCERR) +#endif + END_TABLE +}; + + +static struct str_table sigbus_code_table[] = { +#ifdef BUS_ADRALN + DEFINE_ENTRY(BUS_ADRALN) +#endif +#ifdef BUS_ADRERR + DEFINE_ENTRY(BUS_ADRERR) +#endif +#ifdef BUS_OBJERR + DEFINE_ENTRY(BUS_OBJERR) +#endif + END_TABLE +}; + +#if 0 /* should this be hooked in somewhere? */ +static struct str_table sigstrap_code_table[] = { +#ifdef TRAP_BRKPT + DEFINE_ENTRY(TRAP_BRKPT) +#endif +#ifdef TRAP_TRACE + DEFINE_ENTRY(TRAP_TRACE) +#endif + END_TABLE +}; +#endif + +static struct str_table sigcld_code_table[] = { +#ifdef CLD_EXITED + DEFINE_ENTRY(CLD_EXITED) +#endif +#ifdef CLD_KILLED + DEFINE_ENTRY(CLD_KILLED) +#endif +#ifdef CLD_DUMPED + DEFINE_ENTRY(CLD_DUMPED) +#endif +#ifdef CLD_TRAPPED + DEFINE_ENTRY(CLD_TRAPPED) +#endif +#ifdef CLD_STOPPED + DEFINE_ENTRY(CLD_STOPPED) +#endif +#ifdef CLD_CONTINUED + DEFINE_ENTRY(CLD_CONTINUED) +#endif + END_TABLE +}; + +#if 0 /* should this be hooked in somewhere? */ +static struct str_table sigpoll_code_table[] = { +#ifdef POLL_IN + DEFINE_ENTRY(POLL_IN) +#endif +#ifdef POLL_OUT + DEFINE_ENTRY(POLL_OUT) +#endif +#ifdef POLL_MSG + DEFINE_ENTRY(POLL_MSG) +#endif +#ifdef POLL_ERR + DEFINE_ENTRY(POLL_ERR) +#endif +#ifdef POLL_PRI + DEFINE_ENTRY(POLL_PRI) +#endif +#ifdef POLL_HUP + DEFINE_ENTRY(POLL_HUP) +#endif + END_TABLE +}; +#endif + +static const char *lookup_table(int num, struct str_table *table) +{ + struct str_table *p; + + for (p=table; p->name; p++) + if (num == p->num) + return(p->name); + return NULL; +} + +static const char *lookup_table_fallback(int num, struct str_table *table) +{ + static char buf[32]; + const char *ret = lookup_table(num, table); + + if (ret) + return ret; + snprintf(buf, sizeof(buf), "%d", num); + buf[sizeof(buf)-1] = 0; + return buf; +} + +static void die_signal_handler(int signum, siginfo_t *siginfo, + void *context EXT2FS_ATTR((unused))) +{ + const char *cp; + + fprintf(stderr, "Signal (%d) %s ", signum, + lookup_table_fallback(signum, sig_table)); + if (siginfo->si_code == SI_USER) + fprintf(stderr, "(sent from pid %u) ", siginfo->si_pid); + cp = lookup_table(siginfo->si_code, generic_code_table); + if (cp) + fprintf(stderr, "si_code=%s ", cp); + else if (signum == SIGILL) + fprintf(stderr, "si_code=%s ", + lookup_table_fallback(siginfo->si_code, + sigill_code_table)); + else if (signum == SIGFPE) + fprintf(stderr, "si_code=%s ", + lookup_table_fallback(siginfo->si_code, + sigfpe_code_table)); + else if (signum == SIGSEGV) + fprintf(stderr, "si_code=%s ", + lookup_table_fallback(siginfo->si_code, + sigsegv_code_table)); + else if (signum == SIGBUS) + fprintf(stderr, "si_code=%s ", + lookup_table_fallback(siginfo->si_code, + sigbus_code_table)); + else if (signum == SIGCHLD) + fprintf(stderr, "si_code=%s ", + lookup_table_fallback(siginfo->si_code, + sigcld_code_table)); + else + fprintf(stderr, "si code=%d ", siginfo->si_code); + if ((siginfo->si_code != SI_USER) && + (signum == SIGILL || signum == SIGFPE || + signum == SIGSEGV || signum == SIGBUS)) + fprintf(stderr, "fault addr=%p", siginfo->si_addr); + fprintf(stderr, "\n"); + +#if defined(HAVE_BACKTRACE) && !defined(DISABLE_BACKTRACE) + { + void *stack_syms[32]; + int frames; + + frames = backtrace(stack_syms, 32); + backtrace_symbols_fd(stack_syms, frames, 2); + } +#endif + exit(FSCK_ERROR); +} + +void sigcatcher_setup(void) +{ + struct sigaction sa; + + memset(&sa, 0, sizeof(struct sigaction)); + sa.sa_sigaction = die_signal_handler; + sa.sa_flags = SA_SIGINFO; + + sigaction(SIGFPE, &sa, 0); + sigaction(SIGILL, &sa, 0); + sigaction(SIGBUS, &sa, 0); + sigaction(SIGSEGV, &sa, 0); + sigaction(SIGABRT, &sa, 0); +} + + +#ifdef DEBUG +#include + +void usage(void) +{ + fprintf(stderr, "tst_sigcatcher: [-akfn]\n"); + exit(1); +} + +int main(int argc, char** argv) +{ + struct sigaction sa; + char *p = 0; + int i, c; + volatile x=0; + + memset(&sa, 0, sizeof(struct sigaction)); + sa.sa_sigaction = die_signal_handler; + sa.sa_flags = SA_SIGINFO; + for (i=1; i < 31; i++) + sigaction(i, &sa, 0); + + while ((c = getopt (argc, argv, "afkn")) != EOF) + switch (c) { + case 'a': + abort(); + break; + case 'f': + printf("%d\n", 42/x); + case 'k': + kill(getpid(), SIGTERM); + break; + case 'n': + *p = 42; + default: + usage (); + } + + printf("Sleeping for 10 seconds, send kill signal to pid %u...\n", + getpid()); + fflush(stdout); + sleep(10); + exit(0); +} +#endif diff --git a/e2fsck/super.c b/e2fsck/super.c new file mode 100644 index 0000000..9495e02 --- /dev/null +++ b/e2fsck/super.c @@ -0,0 +1,1461 @@ +/* + * 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% + */ + +#include "config.h" +#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 +#define LOG2_CHECK 4 + +static int 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) || + (flags & LOG2_CHECK && (value & (value - 1)) != 0)) { + clear_problem_context(&pctx); + pctx.num = value; + pctx.str = descr; + fix_problem(ctx, PR_0_MISC_CORRUPT_SUPER, &pctx); + ctx->flags |= E2F_FLAG_ABORT; + return 0; + } + return 1; +} + +static int check_super_value64(e2fsck_t ctx, const char *descr, + __u64 value, int flags, + __u64 min_val, __u64 max_val) +{ + struct problem_context pctx; + + if ((flags & MIN_CHECK && value < min_val) || + (flags & MAX_CHECK && value > max_val) || + (flags & LOG2_CHECK && (value & (value - 1)) != 0)) { + clear_problem_context(&pctx); + pctx.num = value; + pctx.str = descr; + fix_problem(ctx, PR_0_MISC_CORRUPT_SUPER, &pctx); + ctx->flags |= E2F_FLAG_ABORT; + return 0; + } + return 1; +} + +/* + * 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; + blk64_t last_cluster; + struct ext2_inode_large *inode; +}; + +static int release_inode_block(ext2_filsys fs, + blk64_t *block_nr, + e2_blkcnt_t blockcnt, + blk64_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; + blk64_t blk = *block_nr; + blk64_t cluster = EXT2FS_B2C(fs, *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 (blk == 0) + return 0; + + if (pb->last_cluster == cluster) + return 0; + + pb->last_cluster = cluster; + + if ((blk < fs->super->s_first_data_block) || + (blk >= ext2fs_blocks_count(fs->super))) { + fix_problem(ctx, PR_0_ORPHAN_ILLEGAL_BLOCK_NUM, pctx); + return_abort: + pb->abort = 1; + return BLOCK_ABORT; + } + + if (!ext2fs_test_block_bitmap2(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_blk64(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_blk64(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_blk64(fs->io, blk, 1, + pb->buf); + if (pb->errcode) + goto return_abort; + } + pb->truncated_blocks++; + *block_nr = 0; + retval |= BLOCK_CHANGED; + } + + if (ctx->qctx) + quota_data_sub(ctx->qctx, pb->inode, 0, ctx->fs->blocksize); + ext2fs_block_alloc_stats2(fs, blk, -1); + ctx->free_blocks++; + 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_large *inode, char *block_buf, + struct problem_context *pctx) +{ + struct process_block_struct pb; + ext2_filsys fs = ctx->fs; + blk64_t blk; + errcode_t retval; + __u32 count; + + if (!ext2fs_inode_has_valid_blocks2(fs, EXT2_INODE(inode))) + return 0; + + pb.buf = block_buf + 3 * ctx->fs->blocksize; + pb.ctx = ctx; + pb.abort = 0; + pb.errcode = 0; + pb.pctx = pctx; + pb.last_cluster = 0; + pb.inode = inode; + if (inode->i_links_count) { + pb.truncating = 1; + pb.truncate_block = (e2_blkcnt_t) + ((EXT2_I_SIZE(inode) + 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_iterate3(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 %u"), + ino); + return 1; + } + if (pb.abort) + return 1; + + /* Refresh the inode since ext2fs_block_iterate may have changed it */ + e2fsck_read_inode_full(ctx, ino, EXT2_INODE(inode), sizeof(*inode), + "release_inode_blocks"); + + if (pb.truncated_blocks) + ext2fs_iblk_sub_blocks(fs, EXT2_INODE(inode), + pb.truncated_blocks); + + blk = ext2fs_file_acl_block(fs, EXT2_INODE(inode)); + if (blk) { + retval = ext2fs_adjust_ea_refcount3(fs, blk, block_buf, -1, + &count, ino); + 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_refcount2 for inode %u"), + ino); + return 1; + } + if (count == 0) { + if (ctx->qctx) + quota_data_sub(ctx->qctx, inode, 0, + ctx->fs->blocksize); + ext2fs_block_alloc_stats2(fs, blk, -1); + ctx->free_blocks++; + } + ext2fs_file_acl_block_set(fs, EXT2_INODE(inode), 0); + } + return 0; +} + +/* Load all quota data in preparation for orphan clearing. */ +static errcode_t e2fsck_read_all_quotas(e2fsck_t ctx) +{ + ext2_ino_t qf_ino; + enum quota_type qtype; + errcode_t retval = 0; + + if (!ext2fs_has_feature_quota(ctx->fs->super)) + return retval; + + retval = quota_init_context(&ctx->qctx, ctx->fs, 0); + if (retval) + return retval; + + for (qtype = 0 ; qtype < MAXQUOTAS; qtype++) { + qf_ino = *quota_sb_inump(ctx->fs->super, qtype); + if (qf_ino == 0) + continue; + + retval = quota_read_all_dquots(ctx->qctx, qf_ino, qtype, + QREAD_USAGE | QREAD_LIMITS); + if (retval) + break; + } + if (retval) + quota_release_context(&ctx->qctx); + return retval; +} + +/* Write all the quota info to disk. */ +static errcode_t e2fsck_write_all_quotas(e2fsck_t ctx) +{ + struct problem_context pctx; + enum quota_type qtype; + + if (!ext2fs_has_feature_quota(ctx->fs->super)) + return 0; + + clear_problem_context(&pctx); + for (qtype = 0 ; qtype < MAXQUOTAS; qtype++) { + pctx.num = qtype; + pctx.errcode = quota_write_inode(ctx->qctx, 1 << qtype); + if (pctx.errcode) { + fix_problem(ctx, PR_6_WRITE_QUOTAS, &pctx); + break; + } + } + + quota_release_context(&ctx->qctx); + return pctx.errcode; +} + +static int release_orphan_inode(e2fsck_t ctx, ext2_ino_t *ino, char *block_buf) +{ + ext2_filsys fs = ctx->fs; + struct problem_context pctx; + struct ext2_inode_large inode; + ext2_ino_t next_ino; + + e2fsck_read_inode_full(ctx, *ino, EXT2_INODE(&inode), + sizeof(inode), "release_orphan_inode"); + clear_problem_context(&pctx); + pctx.ino = *ino; + pctx.inode = EXT2_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); + return 1; + } + + if (release_inode_blocks(ctx, *ino, &inode, block_buf, &pctx)) + return 1; + + if (!inode.i_links_count) { + if (ctx->qctx) + quota_data_inodes(ctx->qctx, &inode, *ino, -1); + ext2fs_inode_alloc_stats2(fs, *ino, -1, + LINUX_S_ISDIR(inode.i_mode)); + ctx->free_inodes++; + inode.i_dtime = ctx->now; + } else { + inode.i_dtime = 0; + } + e2fsck_write_inode_full(ctx, *ino, EXT2_INODE(&inode), + sizeof(inode), "delete_file"); + *ino = next_ino; + return 0; +} + +struct process_orphan_block_data { + e2fsck_t ctx; + char *buf; + char *block_buf; + e2_blkcnt_t blocks; + int abort; + int clear; + errcode_t errcode; + ext2_ino_t ino; + __u32 generation; +}; + +static int process_orphan_block(ext2_filsys fs, + blk64_t *block_nr, + e2_blkcnt_t blockcnt, + blk64_t ref_blk EXT2FS_ATTR((unused)), + int ref_offset EXT2FS_ATTR((unused)), + void *priv_data) +{ + struct process_orphan_block_data *pd; + e2fsck_t ctx; + struct problem_context pctx; + blk64_t blk = *block_nr; + struct ext4_orphan_block_tail *tail; + int j; + int inodes_per_ob; + __u32 *bdata; + ext2_ino_t ino; + + pd = priv_data; + ctx = pd->ctx; + clear_problem_context(&pctx); + pctx.ino = fs->super->s_orphan_file_inum; + pctx.blk = blockcnt; + + /* Orphan file must not have holes */ + if (!blk) { + if (blockcnt == pd->blocks) + return BLOCK_ABORT; + fix_problem(ctx, PR_0_ORPHAN_FILE_HOLE, &pctx); +return_abort: + pd->abort = 1; + return BLOCK_ABORT; + } + inodes_per_ob = ext2fs_inodes_per_orphan_block(fs); + pd->errcode = io_channel_read_blk64(fs->io, blk, 1, pd->buf); + if (pd->errcode) + goto return_abort; + tail = ext2fs_orphan_block_tail(fs, pd->buf); + if (ext2fs_le32_to_cpu(tail->ob_magic) != + EXT4_ORPHAN_BLOCK_MAGIC) { + fix_problem(ctx, PR_0_ORPHAN_FILE_BAD_MAGIC, &pctx); + goto return_abort; + } + if (!ext2fs_orphan_file_block_csum_verify(fs, + fs->super->s_orphan_file_inum, blk, pd->buf)) { + fix_problem(ctx, PR_0_ORPHAN_FILE_BAD_CHECKSUM, &pctx); + goto return_abort; + } + bdata = (__u32 *)pd->buf; + for (j = 0; j < inodes_per_ob; j++) { + if (!bdata[j]) + continue; + ino = ext2fs_le32_to_cpu(bdata[j]); + if (release_orphan_inode(ctx, &ino, pd->block_buf)) + goto return_abort; + } + return 0; +} + +static int process_orphan_file(e2fsck_t ctx, char *block_buf) +{ + ext2_filsys fs = ctx->fs; + char *orphan_buf; + struct process_orphan_block_data pd; + int ret = 0; + ext2_ino_t orphan_inum = fs->super->s_orphan_file_inum; + struct ext2_inode orphan_inode; + struct problem_context pctx; + errcode_t retval; + + if (!ext2fs_has_feature_orphan_file(fs->super)) + return 0; + + clear_problem_context(&pctx); + pctx.ino = orphan_inum; + + orphan_buf = (char *) e2fsck_allocate_memory(ctx, fs->blocksize * 4, + "orphan block buffer"); + retval = ext2fs_read_inode(fs, orphan_inum, &orphan_inode); + if (retval < 0) { + com_err("process_orphan_file", retval, + _("while reading inode %d"), orphan_inum); + ret = 1; + goto out; + } + if (EXT2_I_SIZE(&orphan_inode) & (fs->blocksize - 1)) { + fix_problem(ctx, PR_0_ORPHAN_FILE_WRONG_SIZE, &pctx); + ret = 1; + goto out; + } + pd.buf = orphan_buf + 3 * fs->blocksize; + pd.block_buf = block_buf; + pd.blocks = EXT2_I_SIZE(&orphan_inode) / fs->blocksize; + pd.ctx = ctx; + pd.abort = 0; + pd.errcode = 0; + retval = ext2fs_block_iterate3(fs, orphan_inum, + BLOCK_FLAG_DATA_ONLY | BLOCK_FLAG_HOLE, + orphan_buf, process_orphan_block, &pd); + if (retval) { + com_err("process_orphan_block", retval, + _("while calling ext2fs_block_iterate for inode %d"), + orphan_inum); + ret = 1; + goto out; + } + if (pd.abort) { + if (pd.errcode) { + com_err("process_orphan_block", pd.errcode, + _("while reading blocks of inode %d"), + orphan_inum); + } + ret = 1; + } +out: + ext2fs_free_mem(&orphan_buf); + return ret; +} + +/* + * 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; + struct problem_context pctx; + char *block_buf; + + if (fs->super->s_last_orphan == 0 && + !ext2fs_has_feature_orphan_present(fs->super)) + return 0; + + clear_problem_context(&pctx); + ino = fs->super->s_last_orphan; + pctx.ino = ino; + pctx.errcode = e2fsck_read_all_quotas(ctx); + if (pctx.errcode) { + fix_problem(ctx, PR_0_QUOTA_INIT_CTX, &pctx); + return 1; + } + + /* + * 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 process the orphan list + * or orphan file, since neither can be trusted; and we're going to + * be running a full e2fsck run anyway... We clear orphan file contents + * after filesystem is checked to avoid clearing someone else's data. + */ + if (fs->super->s_state & EXT2_ERROR_FS) { + if (ctx->qctx) + quota_release_context(&ctx->qctx); + return 0; + } + + if (ino && ((ino < EXT2_FIRST_INODE(fs->super)) || + (ino > fs->super->s_inodes_count))) { + fix_problem(ctx, PR_0_ORPHAN_ILLEGAL_HEAD_INODE, &pctx); + goto err_qctx; + } + + block_buf = (char *) e2fsck_allocate_memory(ctx, fs->blocksize * 4, + "block iterate buffer"); + e2fsck_read_bitmaps(ctx); + + /* First process orphan list */ + while (ino) { + if (release_orphan_inode(ctx, &ino, block_buf)) + goto err_buf; + } + + /* Next process orphan file */ + if (ext2fs_has_feature_orphan_present(fs->super) && + !ext2fs_has_feature_orphan_file(fs->super)) + goto err_buf; + if (process_orphan_file(ctx, block_buf)) + goto err_buf; + + ext2fs_free_mem(&block_buf); + pctx.errcode = e2fsck_write_all_quotas(ctx); + if (pctx.errcode) + goto err; + return 0; +err_buf: + ext2fs_free_mem(&block_buf); +err_qctx: + if (ctx->qctx) + quota_release_context(&ctx->qctx); +err: + return 1; +} + +static int reinit_orphan_block(ext2_filsys fs, + blk64_t *block_nr, + e2_blkcnt_t blockcnt, + blk64_t ref_blk EXT2FS_ATTR((unused)), + int ref_offset EXT2FS_ATTR((unused)), + void *priv_data) +{ + struct process_orphan_block_data *pd; + e2fsck_t ctx; + blk64_t blk = *block_nr; + struct problem_context pctx; + + pd = priv_data; + ctx = pd->ctx; + + /* Orphan file must not have holes */ + if (!blk) { + if (blockcnt == pd->blocks) + return BLOCK_ABORT; + + clear_problem_context(&pctx); + pctx.ino = fs->super->s_orphan_file_inum; + pctx.blk = blockcnt; + fix_problem(ctx, PR_6_ORPHAN_FILE_HOLE, &pctx); +return_abort: + pd->abort = 1; + return BLOCK_ABORT; + } + + if (ext2fs_has_feature_metadata_csum(fs->super)) { + struct ext4_orphan_block_tail *tail; + + tail = ext2fs_orphan_block_tail(fs, pd->buf); + /* + * Update checksum to match expected buffer contents with + * appropriate block number. + */ + tail->ob_checksum = ext2fs_do_orphan_file_block_csum(fs, + pd->ino, pd->generation, blk, pd->buf); + } + if (!pd->clear) { + pd->errcode = io_channel_read_blk64(fs->io, blk, 1, + pd->block_buf); + /* Block is already cleanly initialized? */ + if (!memcmp(pd->block_buf, pd->buf, fs->blocksize)) + return 0; + + clear_problem_context(&pctx); + pctx.ino = fs->super->s_orphan_file_inum; + pctx.blk = blockcnt; + if (!fix_problem(ctx, PR_6_ORPHAN_BLOCK_DIRTY, &pctx)) + goto return_abort; + pd->clear = 1; + } + pd->errcode = io_channel_write_blk64(fs->io, blk, 1, pd->buf); + if (pd->errcode) + goto return_abort; + return 0; +} + +/* + * Check and clear orphan file. We just return non-zero if we hit some + * inconsistency. Caller will truncate & recreate new orphan file. + */ +int check_init_orphan_file(e2fsck_t ctx) +{ + ext2_filsys fs = ctx->fs; + char *orphan_buf; + struct process_orphan_block_data pd; + struct ext4_orphan_block_tail *tail; + ext2_ino_t orphan_inum = fs->super->s_orphan_file_inum; + struct ext2_inode orphan_inode; + int ret = 0; + errcode_t retval; + + orphan_buf = (char *) e2fsck_allocate_memory(ctx, fs->blocksize * 5, + "orphan block buffer"); + e2fsck_read_inode(ctx, orphan_inum, &orphan_inode, "orphan inode"); + if (EXT2_I_SIZE(&orphan_inode) & (fs->blocksize - 1)) { + struct problem_context pctx; + + clear_problem_context(&pctx); + pctx.ino = orphan_inum; + fix_problem(ctx, PR_6_ORPHAN_FILE_WRONG_SIZE, &pctx); + ret = 1; + goto out; + } + pd.buf = orphan_buf + 3 * fs->blocksize; + pd.block_buf = orphan_buf + 4 * fs->blocksize; + pd.blocks = EXT2_I_SIZE(&orphan_inode) / fs->blocksize; + pd.ctx = ctx; + pd.abort = 0; + pd.clear = 0; + pd.errcode = 0; + pd.ino = orphan_inum; + pd.generation = orphan_inode.i_generation; + /* Initialize buffer to write */ + memset(pd.buf, 0, fs->blocksize); + tail = ext2fs_orphan_block_tail(fs, pd.buf); + tail->ob_magic = ext2fs_cpu_to_le32(EXT4_ORPHAN_BLOCK_MAGIC); + + retval = ext2fs_block_iterate3(fs, orphan_inum, + BLOCK_FLAG_DATA_ONLY | BLOCK_FLAG_HOLE, + orphan_buf, reinit_orphan_block, &pd); + if (retval) { + com_err("reinit_orphan_block", retval, + _("while calling ext2fs_block_iterate for inode %d"), + orphan_inum); + ret = 1; + goto out; + } + if (pd.abort) { + if (pd.errcode) { + com_err("process_orphan_block", pd.errcode, + _("while reading blocks of inode %d"), + orphan_inum); + } + ret = 1; + } + + /* We had to clear some blocks. Report it up. */ + if (ret == 0 && pd.clear) + ret = 2; +out: + ext2fs_free_mem(&orphan_buf); + return ret; +} + +/* + * 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, gdt_off, ind_off; + dgrp_t j; + blk_t blk, pblk; + blk_t expect; /* for resize inode, which is 32-bit only */ + __u32 *dind_buf = 0, *ind_buf; + errcode_t retval; + + clear_problem_context(&pctx); + + if (ext2fs_has_feature_resize_inode(fs->super) && + ext2fs_has_feature_meta_bg(fs->super) && + fix_problem(ctx, PR_0_DISABLE_RESIZE_INODE, &pctx)) { + ext2fs_clear_feature_resize_inode(fs->super); + fs->super->s_reserved_gdt_blocks = 0; + ext2fs_mark_super_dirty(fs); + } + + /* + * If the resize inode feature isn't set, then + * s_reserved_gdt_blocks must be zero. + */ + if (!ext2fs_has_feature_resize_inode(fs->super)) { + 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 resize inode */ + pctx.ino = EXT2_RESIZE_INO; + retval = ext2fs_read_inode(fs, EXT2_RESIZE_INO, &inode); + if (retval) { + if (ext2fs_has_feature_resize_inode(fs->super)) + 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 (!ext2fs_has_feature_resize_inode(fs->super)) { + 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 >= ext2fs_blocks_count(fs->super))) { + 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; + if (fs->blocksize == 1024 && fs->super->s_first_data_block == 0) + pblk++; /* Deal with 1024 blocksize bigalloc fs */ + 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 + EXT2_GROUPS_TO_BLOCKS(fs->super, j); + if (ind_buf[ind_off] != expect) + goto resize_inode_invalid; + ind_off++; + } + } + +cleanup: + if (dind_buf) + ext2fs_free_mem(&dind_buf); + + } + +/* + * This function checks the dirhash signed/unsigned hint if necessary. + */ +static void e2fsck_fix_dirhash_hint(e2fsck_t ctx) +{ + struct ext2_super_block *sb = ctx->fs->super; + struct problem_context pctx; + char c; + + if ((ctx->options & E2F_OPT_READONLY) || + !ext2fs_has_feature_dir_index(sb) || + (sb->s_flags & (EXT2_FLAGS_SIGNED_HASH|EXT2_FLAGS_UNSIGNED_HASH))) + return; + + c = (char) 255; + + clear_problem_context(&pctx); + if (fix_problem(ctx, PR_0_DIRHASH_HINT, &pctx)) { + if (((int) c) == -1) { + sb->s_flags |= EXT2_FLAGS_SIGNED_HASH; + } else { + sb->s_flags |= EXT2_FLAGS_UNSIGNED_HASH; + } + ext2fs_mark_super_dirty(ctx->fs); + } +} + + +void check_super_block(e2fsck_t ctx) +{ + ext2_filsys fs = ctx->fs; + blk64_t first_block, last_block; + struct ext2_super_block *sb = fs->super; + unsigned int ipg_max; + problem_t problem; + blk64_t blocks_per_group = fs->super->s_blocks_per_group; + __u32 bpg_max, cpg_max; + __u64 blks_max; + int inodes_per_block; + int inode_size; + int accept_time_fudge; + int broken_system_clock; + dgrp_t i; + blk64_t should_be; + struct problem_context pctx; + blk64_t free_blocks = 0; + ext2_ino_t free_inodes = 0; + int csum_flag, clear_test_fs_flag; + + 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); + cpg_max = 8 * EXT2_BLOCK_SIZE(sb); + if (cpg_max > EXT2_MAX_CLUSTERS_PER_GROUP(sb)) + cpg_max = EXT2_MAX_CLUSTERS_PER_GROUP(sb); + bpg_max = 8 * EXT2_BLOCK_SIZE(sb) * EXT2FS_CLUSTER_RATIO(fs); + 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"); + + blks_max = (1ULL << 32) * EXT2_MAX_BLOCKS_PER_GROUP(fs->super); + if (ext2fs_has_feature_64bit(fs->super)) { + if (blks_max > ((1ULL << 48) - 1)) + blks_max = (1ULL << 48) - 1; + } else { + if (blks_max > ((1ULL << 32) - 1)) + blks_max = (1ULL << 32) - 1; + } + + clear_problem_context(&pctx); + + /* + * Verify the super block constants... + */ + if (!check_super_value(ctx, "inodes_count", sb->s_inodes_count, + MIN_CHECK, 1, 0)) + return; + if (!check_super_value64(ctx, "blocks_count", ext2fs_blocks_count(sb), + MIN_CHECK | MAX_CHECK, 1, blks_max)) + return; + if (!check_super_value(ctx, "first_data_block", sb->s_first_data_block, + MAX_CHECK, 0, ext2fs_blocks_count(sb))) + return; + if (!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)) + return; + if (!check_super_value(ctx, "log_cluster_size", + sb->s_log_cluster_size, + MIN_CHECK | MAX_CHECK, sb->s_log_block_size, + (EXT2_MAX_CLUSTER_LOG_SIZE - + EXT2_MIN_CLUSTER_LOG_SIZE))) + return; + if (!check_super_value(ctx, "clusters_per_group", + sb->s_clusters_per_group, + MIN_CHECK | MAX_CHECK, 8, cpg_max)) + return; + if (!check_super_value(ctx, "blocks_per_group", sb->s_blocks_per_group, + MIN_CHECK | MAX_CHECK, 8, bpg_max)) + return; + if (!check_super_value(ctx, "inodes_per_group", sb->s_inodes_per_group, + MIN_CHECK | MAX_CHECK, inodes_per_block, ipg_max)) + return; + if (!check_super_value(ctx, "r_blocks_count", ext2fs_r_blocks_count(sb), + MAX_CHECK, 0, ext2fs_blocks_count(sb) / 2)) + return; + if (!check_super_value(ctx, "reserved_gdt_blocks", + sb->s_reserved_gdt_blocks, MAX_CHECK, 0, + fs->blocksize / sizeof(__u32))) + return; + if (!check_super_value(ctx, "desc_size", + sb->s_desc_size, MAX_CHECK | LOG2_CHECK, 0, + EXT2_MAX_DESC_SIZE)) + return; + + should_be = (__u64)sb->s_inodes_per_group * fs->group_desc_count; + if (should_be > ~0U) { + pctx.num = should_be; + fix_problem(ctx, PR_0_INODE_COUNT_BIG, &pctx); + ctx->flags |= E2F_FLAG_ABORT; + return; + } + 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); + } else { + pctx.num = sb->s_inodes_count; + pctx.str = "inodes_count"; + fix_problem(ctx, PR_0_MISC_CORRUPT_SUPER, &pctx); + ctx->flags |= E2F_FLAG_ABORT; + return; + } + } + if (sb->s_rev_level > EXT2_GOOD_OLD_REV && + !check_super_value(ctx, "first_ino", sb->s_first_ino, + MIN_CHECK | MAX_CHECK, + EXT2_GOOD_OLD_FIRST_INO, sb->s_inodes_count)) + return; + inode_size = EXT2_INODE_SIZE(sb); + if (!check_super_value(ctx, "inode_size", + inode_size, MIN_CHECK | MAX_CHECK | LOG2_CHECK, + EXT2_GOOD_OLD_INODE_SIZE, fs->blocksize)) + return; + if (sb->s_blocks_per_group != (sb->s_clusters_per_group * + EXT2FS_CLUSTER_RATIO(fs))) { + pctx.num = sb->s_clusters_per_group * EXT2FS_CLUSTER_RATIO(fs); + pctx.str = "block_size"; + fix_problem(ctx, PR_0_MISC_CORRUPT_SUPER, &pctx); + ctx->flags |= E2F_FLAG_ABORT; + return; + } + + if ((ctx->flags & E2F_FLAG_GOT_DEVSIZE) && + (ctx->num_blocks < ext2fs_blocks_count(sb))) { + pctx.blk = ext2fs_blocks_count(sb); + pctx.blk2 = ctx->num_blocks; + if (fix_problem(ctx, PR_0_FS_SIZE_WRONG, &pctx)) { + ctx->flags |= E2F_FLAG_ABORT; + return; + } + } + + should_be = (sb->s_log_block_size == 0 && + EXT2FS_CLUSTER_RATIO(fs) == 1) ? 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; + } + + if (EXT2_INODE_SIZE(sb) > EXT2_GOOD_OLD_INODE_SIZE) { + unsigned min = + sizeof(((struct ext2_inode_large *) 0)->i_extra_isize) + + sizeof(((struct ext2_inode_large *) 0)->i_checksum_hi); + unsigned max = EXT2_INODE_SIZE(sb) - EXT2_GOOD_OLD_INODE_SIZE; + pctx.num = sb->s_min_extra_isize; + if (sb->s_min_extra_isize && + (sb->s_min_extra_isize < min || + sb->s_min_extra_isize > max || + sb->s_min_extra_isize & 3) && + fix_problem(ctx, PR_0_BAD_MIN_EXTRA_ISIZE, &pctx)) { + sb->s_min_extra_isize = + (sizeof(struct ext2_inode_large) - + EXT2_GOOD_OLD_INODE_SIZE); + ext2fs_mark_super_dirty(fs); + } + pctx.num = sb->s_want_extra_isize; + if (sb->s_want_extra_isize && + (sb->s_want_extra_isize < min || + sb->s_want_extra_isize > max || + sb->s_want_extra_isize & 3) && + fix_problem(ctx, PR_0_BAD_WANT_EXTRA_ISIZE, &pctx)) { + sb->s_want_extra_isize = + (sizeof(struct ext2_inode_large) - + EXT2_GOOD_OLD_INODE_SIZE); + ext2fs_mark_super_dirty(fs); + } + } + + /* Are metadata_csum and uninit_bg both set? */ + if (ext2fs_has_feature_metadata_csum(fs->super) && + ext2fs_has_feature_gdt_csum(fs->super) && + fix_problem(ctx, PR_0_META_AND_GDT_CSUM_SET, &pctx)) { + ext2fs_clear_feature_gdt_csum(fs->super); + ext2fs_mark_super_dirty(fs); + for (i = 0; i < fs->group_desc_count; i++) + ext2fs_group_desc_csum_set(fs, i); + } + + /* We can't have ^metadata_csum,metadata_csum_seed */ + if (!ext2fs_has_feature_metadata_csum(fs->super) && + ext2fs_has_feature_csum_seed(fs->super) && + fix_problem(ctx, PR_0_CSUM_SEED_WITHOUT_META_CSUM, &pctx)) { + ext2fs_clear_feature_csum_seed(fs->super); + fs->super->s_checksum_seed = 0; + ext2fs_mark_super_dirty(fs); + } + + /* Is 64bit set and extents unset? */ + if (ext2fs_has_feature_64bit(fs->super) && + !ext2fs_has_feature_extents(fs->super) && + fix_problem(ctx, PR_0_64BIT_WITHOUT_EXTENTS, &pctx)) { + ext2fs_set_feature_extents(fs->super); + ext2fs_mark_super_dirty(fs); + } + + /* Did user ask us to convert files to extents? */ + if (ctx->options & E2F_OPT_CONVERT_BMAP) { + ext2fs_set_feature_extents(fs->super); + ext2fs_mark_super_dirty(fs); + } + + if (ext2fs_has_feature_meta_bg(fs->super) && + (fs->super->s_first_meta_bg > fs->desc_blocks)) { + pctx.group = fs->desc_blocks; + pctx.num = fs->super->s_first_meta_bg; + if (fix_problem(ctx, PR_0_FIRST_META_BG_TOO_BIG, &pctx)) { + ext2fs_clear_feature_meta_bg(fs->super); + fs->super->s_first_meta_bg = 0; + ext2fs_mark_super_dirty(fs); + } + } + + /* + * Verify the group descriptors.... + */ + first_block = sb->s_first_data_block; + last_block = ext2fs_blocks_count(sb)-1; + + csum_flag = ext2fs_has_group_desc_csum(fs); + for (i = 0; i < fs->group_desc_count; i++) { + pctx.group = i; + + if (!ext2fs_has_feature_flex_bg(fs->super)) { + first_block = ext2fs_group_first_block2(fs, i); + last_block = ext2fs_group_last_block2(fs, i); + } + + if ((ext2fs_block_bitmap_loc(fs, i) < first_block) || + (ext2fs_block_bitmap_loc(fs, i) > last_block)) { + pctx.blk = ext2fs_block_bitmap_loc(fs, i); + if (fix_problem(ctx, PR_0_BB_NOT_GROUP, &pctx)) + ext2fs_block_bitmap_loc_set(fs, i, 0); + } + if (ext2fs_block_bitmap_loc(fs, i) == 0) { + ctx->invalid_block_bitmap_flag[i]++; + ctx->invalid_bitmaps++; + } + if ((ext2fs_inode_bitmap_loc(fs, i) < first_block) || + (ext2fs_inode_bitmap_loc(fs, i) > last_block)) { + pctx.blk = ext2fs_inode_bitmap_loc(fs, i); + if (fix_problem(ctx, PR_0_IB_NOT_GROUP, &pctx)) + ext2fs_inode_bitmap_loc_set(fs, i, 0); + } + if (ext2fs_inode_bitmap_loc(fs, i) == 0) { + ctx->invalid_inode_bitmap_flag[i]++; + ctx->invalid_bitmaps++; + } + if ((ext2fs_inode_table_loc(fs, i) < first_block) || + ((ext2fs_inode_table_loc(fs, i) + + fs->inode_blocks_per_group - 1) > last_block)) { + pctx.blk = ext2fs_inode_table_loc(fs, i); + if (fix_problem(ctx, PR_0_ITABLE_NOT_GROUP, &pctx)) + ext2fs_inode_table_loc_set(fs, i, 0); + } + if (ext2fs_inode_table_loc(fs, i) == 0) { + ctx->invalid_inode_table_flag[i]++; + ctx->invalid_bitmaps++; + } + free_blocks += ext2fs_bg_free_blocks_count(fs, i); + free_inodes += ext2fs_bg_free_inodes_count(fs, i); + + if ((ext2fs_bg_free_blocks_count(fs, i) > sb->s_blocks_per_group) || + (ext2fs_bg_free_inodes_count(fs, i) > sb->s_inodes_per_group) || + (ext2fs_bg_used_dirs_count(fs, i) > sb->s_inodes_per_group)) + ext2fs_unmark_valid(fs); + + should_be = 0; + if (!ext2fs_group_desc_csum_verify(fs, i)) { + pctx.csum1 = ext2fs_bg_checksum(fs, i); + pctx.csum2 = ext2fs_group_desc_csum(fs, i); + if (fix_problem(ctx, PR_0_GDT_CSUM, &pctx)) { + ext2fs_bg_flags_clear(fs, i, EXT2_BG_BLOCK_UNINIT); + ext2fs_bg_flags_clear(fs, i, EXT2_BG_INODE_UNINIT); + ext2fs_bg_itable_unused_set(fs, i, 0); + should_be = 1; + } + ext2fs_unmark_valid(fs); + } + + if (!csum_flag && + (ext2fs_bg_flags_test(fs, i, EXT2_BG_BLOCK_UNINIT) || + ext2fs_bg_flags_test(fs, i, EXT2_BG_INODE_UNINIT) || + ext2fs_bg_itable_unused(fs, i) != 0)) { + if (fix_problem(ctx, PR_0_GDT_UNINIT, &pctx)) { + ext2fs_bg_flags_clear(fs, i, EXT2_BG_BLOCK_UNINIT); + ext2fs_bg_flags_clear(fs, i, EXT2_BG_INODE_UNINIT); + ext2fs_bg_itable_unused_set(fs, i, 0); + should_be = 1; + } + ext2fs_unmark_valid(fs); + } + + if (i == fs->group_desc_count - 1 && + ext2fs_bg_flags_test(fs, i, EXT2_BG_BLOCK_UNINIT)) { + if (fix_problem(ctx, PR_0_BB_UNINIT_LAST, &pctx)) { + ext2fs_bg_flags_clear(fs, i, EXT2_BG_BLOCK_UNINIT); + should_be = 1; + } + ext2fs_unmark_valid(fs); + } + + if (csum_flag && + (ext2fs_bg_itable_unused(fs, i) > ext2fs_bg_free_inodes_count(fs, i) || + ext2fs_bg_itable_unused(fs, i) > sb->s_inodes_per_group)) { + pctx.blk = ext2fs_bg_itable_unused(fs, i); + if (fix_problem(ctx, PR_0_GDT_ITABLE_UNUSED, &pctx)) { + ext2fs_bg_itable_unused_set(fs, i, 0); + should_be = 1; + } + ext2fs_unmark_valid(fs); + } + + if (should_be) + ext2fs_group_desc_csum_set(fs, i); + /* If the user aborts e2fsck by typing ^C, stop right away */ + if (ctx->flags & E2F_FLAG_SIGNAL_MASK) + return; + } + + ctx->free_blocks = EXT2FS_C2B(fs, free_blocks); + ctx->free_inodes = free_inodes; + + if ((ext2fs_free_blocks_count(sb) > ext2fs_blocks_count(sb)) || + (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. + * Skip if checksums are enabled and the filesystem is mounted, + * if the id changes under the kernel remounting rw may fail. + */ + if (!(ctx->options & E2F_OPT_READONLY) && uuid_is_null(sb->s_uuid) && + !ext2fs_has_feature_metadata_csum(ctx->fs->super) && + (!csum_flag || !(ctx->mount_flags & EXT2_MF_MOUNTED))) { + if (fix_problem(ctx, PR_0_ADD_UUID, &pctx)) { + uuid_generate(sb->s_uuid); + ext2fs_init_csum_seed(fs); + fs->flags |= EXT2_FLAG_DIRTY; + fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY; + } + } +#endif + + /* + * Check to see if we should disable the test_fs flag + */ + profile_get_boolean(ctx->profile, "options", + "clear_test_fs_flag", 0, 1, + &clear_test_fs_flag); + if (!(ctx->options & E2F_OPT_READONLY) && + clear_test_fs_flag && + (fs->super->s_flags & EXT2_FLAGS_TEST_FILESYS) && + (fs_proc_check("ext4") || check_for_modules("ext4"))) { + if (fix_problem(ctx, PR_0_CLEAR_TESTFS_FLAG, &pctx)) { + fs->super->s_flags &= ~EXT2_FLAGS_TEST_FILESYS; + fs->flags |= EXT2_FLAG_DIRTY; + fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY; + } + } + + /* + * 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 && + ext2fs_has_feature_filetype(fs->super)) { + if (fix_problem(ctx, PR_0_HURD_CLEAR_FILETYPE, &pctx)) { + ext2fs_clear_feature_filetype(fs->super); + ext2fs_mark_super_dirty(fs); + fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY; + } + } + + /* + * 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); + fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY; + } + + /* + * 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); + } + + /* + * Unfortunately, due to Windows' unfortunate design decision + * to configure the hardware clock to tick localtime, instead + * of the more proper and less error-prone UTC time, many + * users end up in the situation where the system clock is + * incorrectly set at the time when e2fsck is run. + * + * Historically this was usually due to some distributions + * having buggy init scripts and/or installers that didn't + * correctly detect this case and take appropriate + * countermeasures. However, it's still possible, despite the + * best efforts of init script and installer authors to not be + * able to detect this misconfiguration, usually due to a + * buggy or misconfigured virtualization manager or the + * installer not having access to a network time server during + * the installation process. So by default, we allow the + * superblock times to be fudged by up to 24 hours. This can + * be disabled by setting options.accept_time_fudge to the + * boolean value of false in e2fsck.conf. We also support + * options.buggy_init_scripts for backwards compatibility. + */ + profile_get_boolean(ctx->profile, "options", "accept_time_fudge", + 0, 1, &accept_time_fudge); + profile_get_boolean(ctx->profile, "options", "buggy_init_scripts", + 0, accept_time_fudge, &accept_time_fudge); + ctx->time_fudge = accept_time_fudge ? 86400 : 0; + + profile_get_boolean(ctx->profile, "options", "broken_system_clock", + 0, 0, &broken_system_clock); + + /* + * Check to see if the superblock last mount time or last + * write time is in the future. + */ + if (((ctx->options & E2F_OPT_FORCE) || fs->super->s_checkinterval) && + !broken_system_clock && !(ctx->flags & E2F_FLAG_TIME_INSANE) && + (fs->super->s_mtime > (__u32) ctx->now)) { + pctx.num = fs->super->s_mtime; + problem = PR_0_FUTURE_SB_LAST_MOUNT; + if (fs->super->s_mtime <= (__u32) ctx->now + ctx->time_fudge) + problem = PR_0_FUTURE_SB_LAST_MOUNT_FUDGED; + if (fix_problem(ctx, problem, &pctx)) { + fs->super->s_mtime = ctx->now; + fs->flags |= EXT2_FLAG_DIRTY; + } + } + if (((ctx->options & E2F_OPT_FORCE) || fs->super->s_checkinterval) && + !broken_system_clock && !(ctx->flags & E2F_FLAG_TIME_INSANE) && + (fs->super->s_wtime > (__u32) ctx->now)) { + pctx.num = fs->super->s_wtime; + problem = PR_0_FUTURE_SB_LAST_WRITE; + if (fs->super->s_wtime <= (__u32) ctx->now + ctx->time_fudge) + problem = PR_0_FUTURE_SB_LAST_WRITE_FUDGED; + if (fix_problem(ctx, problem, &pctx)) { + fs->super->s_wtime = ctx->now; + fs->flags |= EXT2_FLAG_DIRTY; + } + } + + e2fsck_validate_quota_inodes(ctx); + + /* + * Move the ext3 journal file, if necessary. + */ + e2fsck_move_ext3_journal(ctx); + + /* + * Fix journal hint, if necessary + */ + e2fsck_fix_ext3_journal_hint(ctx); + + /* + * Add dirhash hint if necessary + */ + e2fsck_fix_dirhash_hint(ctx); + + /* + * Hide quota inodes if necessary. + */ + e2fsck_hide_quota(ctx); + + return; +} + +/* + * Check to see if we should backup the master sb to the backup super + * blocks. Returns non-zero if the sb should be backed up. + */ + +/* + * A few flags are set on the fly by the kernel, but only in the + * primary superblock. This is actually a bad thing, and we should + * try to discourage it in the future. In particular, for the newer + * ext4 files, especially EXT4_FEATURE_RO_COMPAT_DIR_NLINK and + * EXT3_FEATURE_INCOMPAT_EXTENTS. So some of these may go away in the + * future. EXT3_FEATURE_INCOMPAT_RECOVER may also get set when + * copying the primary superblock during online resize. + * + * The kernel will set EXT2_FEATURE_COMPAT_EXT_ATTR, but + * unfortunately, we shouldn't ignore it since if it's not set in the + * backup, the extended attributes in the filesystem will be stripped + * away. + */ +#define FEATURE_RO_COMPAT_IGNORE (EXT2_FEATURE_RO_COMPAT_LARGE_FILE| \ + EXT4_FEATURE_RO_COMPAT_DIR_NLINK) +#define FEATURE_INCOMPAT_IGNORE (EXT3_FEATURE_INCOMPAT_EXTENTS| \ + EXT3_FEATURE_INCOMPAT_RECOVER) + +int check_backup_super_block(e2fsck_t ctx) +{ + ext2_filsys fs = ctx->fs; + errcode_t retval; + dgrp_t g; + blk64_t sb; + int ret = 0; + char buf[SUPERBLOCK_SIZE]; + struct ext2_super_block *backup_sb; + + /* + * If we are already writing out the backup blocks, then we + * don't need to test. Also, if the filesystem is invalid, or + * the check was aborted or cancelled, we also don't want to + * do the backup. If the filesystem was opened read-only then + * we can't do the backup. + */ + if (((fs->flags & EXT2_FLAG_MASTER_SB_ONLY) == 0) || + !ext2fs_test_valid(fs) || + (fs->super->s_state & EXT2_ERROR_FS) || + (ctx->flags & (E2F_FLAG_ABORT | E2F_FLAG_CANCEL)) || + (ctx->options & E2F_OPT_READONLY)) + return 0; + + for (g = 1; g < fs->group_desc_count; g++) { + if (!ext2fs_bg_has_super(fs, g)) + continue; + + sb = ext2fs_group_first_block2(fs, g); + + retval = io_channel_read_blk(fs->io, sb, -SUPERBLOCK_SIZE, + buf); + if (retval) + continue; + backup_sb = (struct ext2_super_block *) buf; +#ifdef WORDS_BIGENDIAN + ext2fs_swap_super(backup_sb); +#endif + if ((backup_sb->s_magic != EXT2_SUPER_MAGIC) || + (backup_sb->s_rev_level > EXT2_LIB_CURRENT_REV) || + ((backup_sb->s_log_block_size + EXT2_MIN_BLOCK_LOG_SIZE) > + EXT2_MAX_BLOCK_LOG_SIZE) || + (EXT2_INODE_SIZE(backup_sb) < EXT2_GOOD_OLD_INODE_SIZE)) + continue; + +#define SUPER_INCOMPAT_DIFFERENT(x) \ + ((fs->super->x & ~FEATURE_INCOMPAT_IGNORE) != \ + (backup_sb->x & ~FEATURE_INCOMPAT_IGNORE)) +#define SUPER_RO_COMPAT_DIFFERENT(x) \ + ((fs->super->x & ~FEATURE_RO_COMPAT_IGNORE) != \ + (backup_sb->x & ~FEATURE_RO_COMPAT_IGNORE)) +#define SUPER_DIFFERENT(x) \ + (fs->super->x != backup_sb->x) + + if (SUPER_DIFFERENT(s_feature_compat) || + SUPER_INCOMPAT_DIFFERENT(s_feature_incompat) || + SUPER_RO_COMPAT_DIFFERENT(s_feature_ro_compat) || + SUPER_DIFFERENT(s_blocks_count) || + SUPER_DIFFERENT(s_blocks_count_hi) || + SUPER_DIFFERENT(s_inodes_count) || + memcmp(fs->super->s_uuid, backup_sb->s_uuid, + sizeof(fs->super->s_uuid))) + ret = 1; + break; + } + return ret; +} diff --git a/e2fsck/unix.c b/e2fsck/unix.c new file mode 100644 index 0000000..e5b672a --- /dev/null +++ b/e2fsck/unix.c @@ -0,0 +1,2171 @@ +/* + * 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% + */ + +#define _XOPEN_SOURCE 600 /* for inclusion of sa_handler in Solaris */ + +#include "config.h" +#include +#ifdef HAVE_STDLIB_H +#include +#endif +#include +#include +#include +#include +#ifdef HAVE_SIGNAL_H +#include +#endif +#ifdef HAVE_GETOPT_H +#include +#else +extern char *optarg; +extern int optind; +#endif +#include +#ifdef HAVE_ERRNO_H +#include +#endif +#ifdef HAVE_SYS_IOCTL_H +#include +#endif +#ifdef HAVE_MALLOC_H +#include +#endif +#ifdef HAVE_SYS_TYPES_H +#include +#endif +#ifdef HAVE_DIRENT_H +#include +#endif +#include + +#include "e2p/e2p.h" +#include "et/com_err.h" +#include "e2p/e2p.h" +#include "uuid/uuid.h" +#include "support/plausible.h" +#include "support/devname.h" +#include "e2fsck.h" +#include "problem.h" +#include "jfs_user.h" +#include "../version.h" + +/* Command line options */ +static int cflag; /* check disk */ +static int show_version_only; +static int verbose; + +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 /* Enabled by configure --enable-jbd-debug */ +int journal_enable_debug = -1; +#endif + +static void usage(e2fsck_t ctx) +{ + fprintf(stderr, + _("Usage: %s [-panyrcdfktvDFV] [-b superblock] [-B blocksize]\n" + "\t\t[-l|-L bad_blocks_file] [-C fd] [-j external_journal]\n" + "\t\t[-E extended-options] [-z undo_file] device\n"), + ctx->program_name ? ctx->program_name : "e2fsck"); + + fprintf(stderr, "%s", _("\nEmergency help:\n" + " -p Automatic repair (no questions)\n" + " -n Make no changes to the filesystem\n" + " -y Assume \"yes\" to all questions\n" + " -c Check for bad blocks and add them to the badblock list\n" + " -f Force checking even if filesystem is marked clean\n")); + fprintf(stderr, "%s", _("" + " -v Be verbose\n" + " -b superblock Use alternative superblock\n" + " -B blocksize Force blocksize when looking for superblock\n" + " -j external_journal Set location of the external journal\n" + " -l bad_blocks_file Add to badblocks list\n" + " -L bad_blocks_file Set badblocks list\n" + " -z undo_file Create an undo file\n" + )); + + exit(FSCK_USAGE); +} + +static void show_stats(e2fsck_t ctx) +{ + ext2_filsys fs = ctx->fs; + ext2_ino_t inodes, inodes_used; + blk64_t blocks, blocks_used; + unsigned int dir_links; + unsigned int num_files, num_links; + __u32 *mask, m; + int frag_percent_file = 0, frag_percent_dir = 0, frag_percent_total = 0; + int i, j, printed = 0; + + dir_links = 2 * ctx->fs_directory_count - 1; + num_files = ctx->fs_total_count - dir_links; + num_links = ctx->fs_links_count - dir_links; + inodes = fs->super->s_inodes_count; + inodes_used = (fs->super->s_inodes_count - + fs->super->s_free_inodes_count); + blocks = ext2fs_blocks_count(fs->super); + blocks_used = (ext2fs_blocks_count(fs->super) - + ext2fs_free_blocks_count(fs->super)); + + if (inodes_used > 0) { + frag_percent_file = (10000 * ctx->fs_fragmented) / inodes_used; + frag_percent_file = (frag_percent_file + 5) / 10; + + frag_percent_dir = (10000 * ctx->fs_fragmented_dir) / inodes_used; + frag_percent_dir = (frag_percent_dir + 5) / 10; + + frag_percent_total = ((10000 * (ctx->fs_fragmented + + ctx->fs_fragmented_dir)) + / inodes_used); + frag_percent_total = (frag_percent_total + 5) / 10; + } + + if (!verbose) { + log_out(ctx, _("%s: %u/%u files (%0d.%d%% non-contiguous), " + "%llu/%llu blocks\n"), + ctx->device_name, inodes_used, inodes, + frag_percent_total / 10, frag_percent_total % 10, + (unsigned long long) blocks_used, + (unsigned long long) blocks); + return; + } + profile_get_boolean(ctx->profile, "options", "report_features", 0, 0, + &i); + if (verbose && i) { + log_out(ctx, "\nFilesystem features:"); + mask = &ctx->fs->super->s_feature_compat; + for (i = 0; i < 3; i++, mask++) { + for (j = 0, m = 1; j < 32; j++, m <<= 1) { + if (*mask & m) { + log_out(ctx, " %s", + e2p_feature2string(i, m)); + printed++; + } + } + } + if (printed == 0) + log_out(ctx, " (none)"); + log_out(ctx, "\n"); + } + + log_out(ctx, P_("\n%12u inode used (%2.2f%%, out of %u)\n", + "\n%12u inodes used (%2.2f%%, out of %u)\n", + inodes_used), inodes_used, + 100.0 * inodes_used / inodes, inodes); + log_out(ctx, P_("%12u non-contiguous file (%0d.%d%%)\n", + "%12u non-contiguous files (%0d.%d%%)\n", + ctx->fs_fragmented), + ctx->fs_fragmented, frag_percent_file / 10, + frag_percent_file % 10); + log_out(ctx, P_("%12u non-contiguous directory (%0d.%d%%)\n", + "%12u non-contiguous directories (%0d.%d%%)\n", + ctx->fs_fragmented_dir), + ctx->fs_fragmented_dir, frag_percent_dir / 10, + frag_percent_dir % 10); + log_out(ctx, _(" # of inodes with ind/dind/tind blocks: " + "%u/%u/%u\n"), + ctx->fs_ind_count, ctx->fs_dind_count, ctx->fs_tind_count); + + for (j=MAX_EXTENT_DEPTH_COUNT-1; j >=0; j--) + if (ctx->extent_depth_count[j]) + break; + if (++j) { + log_out(ctx, "%s", _(" Extent depth histogram: ")); + for (i=0; i < j; i++) { + if (i) + fputc('/', stdout); + log_out(ctx, "%u", ctx->extent_depth_count[i]); + } + log_out(ctx, "\n"); + } + + log_out(ctx, P_("%12llu block used (%2.2f%%, out of %llu)\n", + "%12llu blocks used (%2.2f%%, out of %llu)\n", + blocks_used), + (unsigned long long) blocks_used, 100.0 * blocks_used / blocks, + (unsigned long long) blocks); + log_out(ctx, P_("%12u bad block\n", "%12u bad blocks\n", + ctx->fs_badblocks_count), ctx->fs_badblocks_count); + log_out(ctx, P_("%12u large file\n", "%12u large files\n", + ctx->large_files), ctx->large_files); + log_out(ctx, P_("\n%12u regular file\n", "\n%12u regular files\n", + ctx->fs_regular_count), ctx->fs_regular_count); + log_out(ctx, P_("%12u directory\n", "%12u directories\n", + ctx->fs_directory_count), ctx->fs_directory_count); + log_out(ctx, P_("%12u character device file\n", + "%12u character device files\n", ctx->fs_chardev_count), + ctx->fs_chardev_count); + log_out(ctx, P_("%12u block device file\n", "%12u block device files\n", + ctx->fs_blockdev_count), ctx->fs_blockdev_count); + log_out(ctx, P_("%12u fifo\n", "%12u fifos\n", ctx->fs_fifo_count), + ctx->fs_fifo_count); + log_out(ctx, P_("%12u link\n", "%12u links\n", num_links), + ctx->fs_links_count - dir_links); + log_out(ctx, P_("%12u symbolic link", "%12u symbolic links", + ctx->fs_symlinks_count), ctx->fs_symlinks_count); + log_out(ctx, P_(" (%u fast symbolic link)\n", + " (%u fast symbolic links)\n", + ctx->fs_fast_symlinks_count), + ctx->fs_fast_symlinks_count); + log_out(ctx, P_("%12u socket\n", "%12u sockets\n", + ctx->fs_sockets_count), + ctx->fs_sockets_count); + log_out(ctx, "------------\n"); + log_out(ctx, P_("%12u file\n", "%12u files\n", num_files), + num_files); +} + +static void check_mount(e2fsck_t ctx) +{ + errcode_t retval; + int cont; + + retval = ext2fs_check_if_mounted(ctx->filesystem_name, + &ctx->mount_flags); + if (retval) { + com_err("ext2fs_check_if_mount", retval, + _("while determining whether %s is mounted."), + ctx->filesystem_name); + return; + } + + /* + * If the filesystem isn't mounted, or it's the root + * filesystem and it's mounted read-only, and we're not doing + * a read/write check, then everything's fine. + */ + if ((!(ctx->mount_flags & (EXT2_MF_MOUNTED | EXT2_MF_BUSY))) || + ((ctx->mount_flags & EXT2_MF_ISROOT) && + (ctx->mount_flags & EXT2_MF_READONLY) && + !(ctx->options & E2F_OPT_WRITECHECK))) + return; + + if (((ctx->options & E2F_OPT_READONLY) || + ((ctx->options & E2F_OPT_FORCE) && + (ctx->mount_flags & EXT2_MF_READONLY))) && + !(ctx->options & E2F_OPT_WRITECHECK)) { + if (ctx->mount_flags & EXT2_MF_MOUNTED) + log_out(ctx, _("Warning! %s is mounted.\n"), + ctx->filesystem_name); + else + log_out(ctx, _("Warning! %s is in use.\n"), + ctx->filesystem_name); + return; + } + + if (ctx->mount_flags & EXT2_MF_MOUNTED) + log_out(ctx, _("%s is mounted.\n"), ctx->filesystem_name); + else + log_out(ctx, _("%s is in use.\n"), ctx->filesystem_name); + if (!ctx->interactive || ctx->mount_flags & EXT2_MF_BUSY) + fatal_error(ctx, _("Cannot continue, aborting.\n\n")); + puts("\007\007\007\007"); + log_out(ctx, "%s", _("\n\nWARNING!!! " + "The filesystem is mounted. " + "If you continue you ***WILL***\n" + "cause ***SEVERE*** filesystem damage.\n\n")); + puts("\007\007\007"); + cont = ask_yn(ctx, _("Do you really want to continue"), 0); + if (!cont) { + printf("%s", _("check aborted.\n")); + exit (0); + } + return; +} + +static int is_on_batt(void) +{ + FILE *f; + DIR *d; + char tmp[80], tmp2[80], fname[NAME_MAX+30]; + unsigned int acflag; + struct dirent* de; + + f = fopen("/sys/class/power_supply/AC/online", "r"); + if (f) { + if (fscanf(f, "%u\n", &acflag) == 1) { + fclose(f); + return (!acflag); + } + fclose(f); + } + f = fopen("/proc/apm", "r"); + if (f) { + if (fscanf(f, "%79s %79s %79s %x", tmp, tmp, tmp, &acflag) != 4) + acflag = 1; + fclose(f); + return (acflag != 1); + } + d = opendir("/proc/acpi/ac_adapter"); + if (d) { + while ((de=readdir(d)) != NULL) { + if (!strncmp(".", de->d_name, 1)) + continue; + snprintf(fname, sizeof(fname), + "/proc/acpi/ac_adapter/%s/state", + de->d_name); + f = fopen(fname, "r"); + if (!f) + continue; + if (fscanf(f, "%79s %79s", tmp2, tmp) != 2) + tmp[0] = 0; + fclose(f); + if (strncmp(tmp, "off-line", 8) == 0) { + closedir(d); + return 1; + } + } + closedir(d); + } + return 0; +} + +/* + * This routine checks to see if a filesystem can be skipped; if so, + * it will exit with E2FSCK_OK. Under some conditions it will print a + * message explaining why a check is being forced. + */ +static void check_if_skip(e2fsck_t ctx) +{ + ext2_filsys fs = ctx->fs; + struct problem_context pctx; + const char *reason = NULL; + unsigned int reason_arg = 0; + long next_check; + int batt = is_on_batt(); + int defer_check_on_battery; + int broken_system_clock; + time_t lastcheck; + + if (ctx->flags & E2F_FLAG_PROBLEMS_FIXED) + return; + + profile_get_boolean(ctx->profile, "options", "broken_system_clock", + 0, 0, &broken_system_clock); + if (ctx->flags & E2F_FLAG_TIME_INSANE) + broken_system_clock = 1; + profile_get_boolean(ctx->profile, "options", + "defer_check_on_battery", 0, 1, + &defer_check_on_battery); + if (!defer_check_on_battery) + batt = 0; + + if ((ctx->options & E2F_OPT_FORCE) || bad_blocks_file || cflag) + return; + + if (ctx->options & E2F_OPT_JOURNAL_ONLY) + goto skip; + + lastcheck = fs->super->s_lastcheck; + if (lastcheck > ctx->now) + lastcheck -= ctx->time_fudge; + if ((fs->super->s_state & EXT2_ERROR_FS) || + !ext2fs_test_valid(fs)) + reason = _(" contains a file system with errors"); + else if ((fs->super->s_state & EXT2_VALID_FS) == 0) + reason = _(" was not cleanly unmounted"); + else if (check_backup_super_block(ctx)) + reason = _(" primary superblock features different from backup"); + else if ((fs->super->s_max_mnt_count > 0) && + (fs->super->s_mnt_count >= + (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 < + (unsigned) fs->super->s_max_mnt_count*2)) + reason = 0; + } else if (!broken_system_clock && fs->super->s_checkinterval && + (ctx->now < lastcheck)) { + reason = _(" has filesystem last checked time in the future"); + if (batt) + reason = 0; + } else if (!broken_system_clock && fs->super->s_checkinterval && + ((ctx->now - lastcheck) >= + ((time_t) fs->super->s_checkinterval))) { + reason = _(" has gone %u days without being checked"); + reason_arg = (ctx->now - fs->super->s_lastcheck)/(3600*24); + if (batt && ((ctx->now - fs->super->s_lastcheck) < + fs->super->s_checkinterval*2)) + reason = 0; + } else if (broken_system_clock && fs->super->s_checkinterval) { + log_out(ctx, "%s: ", ctx->device_name); + log_out(ctx, "%s", + _("ignoring check interval, broken_system_clock set\n")); + } + + if (reason) { + log_out(ctx, "%s", ctx->device_name); + log_out(ctx, reason, reason_arg); + log_out(ctx, "%s", _(", check forced.\n")); + return; + } + + /* + * Update the global counts from the block group counts. This + * is needed since modern kernels don't update the global + * counts so as to avoid locking the entire file system. So + * if the filesystem is not unmounted cleanly, the global + * counts may not be accurate. Update them here if we can, + * for the benefit of users who might examine the file system + * using dumpe2fs. (This is for cosmetic reasons only.) + */ + clear_problem_context(&pctx); + pctx.ino = fs->super->s_free_inodes_count; + pctx.ino2 = ctx->free_inodes; + if ((pctx.ino != pctx.ino2) && + !(ctx->options & E2F_OPT_READONLY) && + fix_problem(ctx, PR_0_FREE_INODE_COUNT, &pctx)) { + fs->super->s_free_inodes_count = ctx->free_inodes; + ext2fs_mark_super_dirty(fs); + } + clear_problem_context(&pctx); + pctx.blk = ext2fs_free_blocks_count(fs->super); + pctx.blk2 = ctx->free_blocks; + if ((pctx.blk != pctx.blk2) && + !(ctx->options & E2F_OPT_READONLY) && + fix_problem(ctx, PR_0_FREE_BLOCK_COUNT, &pctx)) { + ext2fs_free_blocks_count_set(fs->super, ctx->free_blocks); + ext2fs_mark_super_dirty(fs); + } + + /* Print the summary message when we're skipping a full check */ + log_out(ctx, _("%s: clean, %u/%u files, %llu/%llu blocks"), + ctx->device_name, + fs->super->s_inodes_count - fs->super->s_free_inodes_count, + fs->super->s_inodes_count, + (unsigned long long) ext2fs_blocks_count(fs->super) - + ext2fs_free_blocks_count(fs->super), + (unsigned long long) ext2fs_blocks_count(fs->super)); + 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) + next_check = 1; + } + if (!broken_system_clock && fs->super->s_checkinterval && + ((ctx->now - fs->super->s_lastcheck) >= fs->super->s_checkinterval)) + next_check = 1; + if (next_check <= 5) { + if (next_check == 1) { + if (batt) + log_out(ctx, "%s", + _(" (check deferred; on battery)")); + else + log_out(ctx, "%s", + _(" (check after next mount)")); + } else + log_out(ctx, _(" (check in %ld mounts)"), + next_check); + } + log_out(ctx, "\n"); +skip: + ext2fs_close_free(&ctx->fs); + e2fsck_free_context(ctx); + exit(FSCK_OK); +} + +/* + * For completion notice + */ +struct percent_tbl { + int max_pass; + int table[32]; +}; +static struct percent_tbl e2fsck_tbl = { + 5, { 0, 70, 90, 92, 95, 100 } +}; +static char bar[128], spaces[128]; + +static float calc_percent(struct percent_tbl *tbl, int pass, int curr, + int max) +{ + float percent; + + if (pass <= 0) + return 0.0; + if (pass > tbl->max_pass || max == 0) + return 100.0; + percent = ((float) curr) / ((float) max); + return ((percent * (tbl->table[pass] - tbl->table[pass-1])) + + tbl->table[pass-1]); +} + +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); + ctx->flags &= ~E2F_FLAG_PROG_BAR; +} + +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 dpywidth; + int fixed_percent; + + if (ctx->flags & E2F_FLAG_PROG_SUPPRESS) + return 0; + + /* + * Calculate the new progress position. If the + * percentage hasn't changed, then we skip out right + * away. + */ + fixed_percent = (int) ((10 * percent) + 0.5); + if (ctx->progress_last_percent == fixed_percent) + return 0; + ctx->progress_last_percent = fixed_percent; + + /* + * If we've already updated the spinner once within + * the last 1/8th of a second, no point doing it + * again. + */ + gettimeofday(&tv, NULL); + tick = (tv.tv_sec << 3) + (tv.tv_usec / (1000000 / 8)); + if ((tick == ctx->progress_last_time) && + (fixed_percent != 0) && (fixed_percent != 1000)) + return 0; + ctx->progress_last_time = tick; + + /* + * Advance the spinner, and note that the progress bar + * will be on the screen + */ + ctx->progress_pos = (ctx->progress_pos+1) & 3; + ctx->flags |= E2F_FLAG_PROG_BAR; + + dpywidth = 66 - strlen(label); + dpywidth = 8 * (dpywidth / 8); + if (dpynum) + dpywidth -= 8; + + i = ((percent * dpywidth) + 50) / 100; + printf("%s%s: |%s%s", ctx->start_meta, label, + bar + (sizeof(bar) - (i+1)), + spaces + (sizeof(spaces) - (dpywidth - i + 1))); + if (fixed_percent == 1000) + fputc('|', stdout); + else + fputc(spinner[ctx->progress_pos & 3], stdout); + printf(" %4.1f%% ", percent); + if (dpynum) + printf("%u\r", dpynum); + else + fputs(" \r", stdout); + fputs(ctx->stop_meta, stdout); + + if (fixed_percent == 1000) + e2fsck_clear_progbar(ctx); + fflush(stdout); + + return 0; +} + +static int e2fsck_update_progress(e2fsck_t ctx, int pass, + unsigned long cur, unsigned long max) +{ + char buf[1024]; + float percent; + + if (pass == 0) + return 0; + + if (ctx->progress_fd) { + snprintf(buf, sizeof(buf), "%d %lu %lu %s\n", + pass, cur, max, ctx->device_name); + write_all(ctx->progress_fd, buf, strlen(buf)); + } else { + percent = calc_percent(&e2fsck_tbl, pass, cur, max); + e2fsck_simple_progress(ctx, ctx->device_name, + percent, 0); + } + return 0; +} + +#define PATH_SET "PATH=/sbin" + +/* + * Make sure 0,1,2 file descriptors are open, so that we don't open + * the filesystem using the same file descriptor as stdout or stderr. + */ +static void reserve_stdio_fds(void) +{ + int fd = 0; + + while (fd <= 2) { + fd = open("/dev/null", O_RDWR); + if (fd < 0) { + fprintf(stderr, _("ERROR: Couldn't open " + "/dev/null (%s)\n"), + strerror(errno)); + return; + } + } + (void) close(fd); +} + +#ifdef HAVE_SIGNAL_H +static void signal_progress_on(int sig EXT2FS_ATTR((unused))) +{ + e2fsck_t ctx = e2fsck_global_ctx; + + if (!ctx) + return; + + ctx->progress = e2fsck_update_progress; +} + +static void signal_progress_off(int sig EXT2FS_ATTR((unused))) +{ + e2fsck_t ctx = e2fsck_global_ctx; + + if (!ctx) + return; + + e2fsck_clear_progbar(ctx); + ctx->progress = 0; +} + +static void signal_cancel(int sig EXT2FS_ATTR((unused))) +{ + e2fsck_t ctx = e2fsck_global_ctx; + + if (!ctx) + exit(FSCK_CANCELED); + + 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; + unsigned long long reada_kb; + + buf = string_copy(ctx, opts, 0); + for (token = buf; token && *token; token = next) { + p = strchr(token, ','); + next = 0; + if (p) { + *p = 0; + next = p+1; + } + arg = strchr(token, '='); + if (arg) { + *arg = 0; + arg++; + } + if (strcmp(token, "ea_ver") == 0) { + if (!arg) { + extended_usage++; + continue; + } + ea_ver = strtoul(arg, &p, 0); + if (*p || + ((ea_ver != 1) && (ea_ver != 2))) { + fprintf(stderr, "%s", + _("Invalid EA version.\n")); + extended_usage++; + continue; + } + ctx->ext_attr_ver = ea_ver; + } else if (strcmp(token, "readahead_kb") == 0) { + if (!arg) { + extended_usage++; + continue; + } + reada_kb = strtoull(arg, &p, 0); + if (*p) { + fprintf(stderr, "%s", + _("Invalid readahead buffer size.\n")); + extended_usage++; + continue; + } + ctx->readahead_kb = reada_kb; + } else if (strcmp(token, "fragcheck") == 0) { + ctx->options |= E2F_OPT_FRAGCHECK; + continue; + } else if (strcmp(token, "journal_only") == 0) { + if (arg) { + extended_usage++; + continue; + } + ctx->options |= E2F_OPT_JOURNAL_ONLY; + } else if (strcmp(token, "discard") == 0) { + ctx->options |= E2F_OPT_DISCARD; + continue; + } else if (strcmp(token, "nodiscard") == 0) { + ctx->options &= ~E2F_OPT_DISCARD; + continue; + } else if (strcmp(token, "optimize_extents") == 0) { + ctx->options &= ~E2F_OPT_NOOPT_EXTENTS; + continue; + } else if (strcmp(token, "no_optimize_extents") == 0) { + ctx->options |= E2F_OPT_NOOPT_EXTENTS; + continue; + } else if (strcmp(token, "inode_count_fullmap") == 0) { + ctx->options |= E2F_OPT_ICOUNT_FULLMAP; + continue; + } else if (strcmp(token, "no_inode_count_fullmap") == 0) { + ctx->options &= ~E2F_OPT_ICOUNT_FULLMAP; + continue; + } else if (strcmp(token, "log_filename") == 0) { + if (!arg) + extended_usage++; + else + ctx->log_fn = string_copy(ctx, arg, 0); + continue; + } else if (strcmp(token, "problem_log") == 0) { + if (!arg) + extended_usage++; + else + ctx->problem_log_fn = string_copy(ctx, arg, 0); + continue; + } else if (strcmp(token, "bmap2extent") == 0) { + ctx->options |= E2F_OPT_CONVERT_BMAP; + continue; + } else if (strcmp(token, "fixes_only") == 0) { + ctx->options |= E2F_OPT_FIXES_ONLY; + continue; + } else if (strcmp(token, "unshare_blocks") == 0) { + ctx->options |= E2F_OPT_UNSHARE_BLOCKS; + ctx->options |= E2F_OPT_FORCE; + continue; + } else if (strcmp(token, "check_encoding") == 0) { + ctx->options |= E2F_OPT_CHECK_ENCODING; + continue; +#ifdef CONFIG_DEVELOPER_FEATURES + } else if (strcmp(token, "clear_all_uninit_bits") == 0) { + ctx->options |= E2F_OPT_CLEAR_UNINIT; + continue; +#endif + } else { + fprintf(stderr, _("Unknown extended option: %s\n"), + token); + extended_usage++; + } + } + free(buf); + + if (extended_usage) { + fputs(_("\nExtended options are separated by commas, " + "and may take an argument which\n" + "is set off by an equals ('=') sign. " + "Valid extended options are:\n\n"), stderr); + fputs(_("\tea_ver=\n"), stderr); + fputs("\tfragcheck\n", stderr); + fputs("\tjournal_only\n", stderr); + fputs("\tdiscard\n", stderr); + fputs("\tnodiscard\n", stderr); + fputs("\toptimize_extents\n", stderr); + fputs("\tno_optimize_extents\n", stderr); + fputs("\tinode_count_fullmap\n", stderr); + fputs("\tno_inode_count_fullmap\n", stderr); + fputs(_("\treadahead_kb=\n"), stderr); + fputs("\tbmap2extent\n", stderr); + fputs("\tunshare_blocks\n", stderr); + fputs("\tfixes_only\n", stderr); + fputs("\tcheck_encoding\n", stderr); + fputc('\n', stderr); + exit(1); + } +} + +static void syntax_err_report(const char *filename, long err, int line_num) +{ + fprintf(stderr, + _("Syntax error in e2fsck config file (%s, line #%d)\n\t%s\n"), + filename, line_num, error_message(err)); + exit(FSCK_ERROR); +} + +static const char *config_fn[] = { ROOT_SYSCONFDIR "/e2fsck.conf", 0 }; + +static errcode_t PRS(int argc, char *argv[], e2fsck_t *ret_ctx) +{ + int flush = 0; + int c, fd; +#ifdef MTRACE + extern void *mallwatch; +#endif + e2fsck_t ctx; + errcode_t retval; +#ifdef HAVE_SIGNAL_H + struct sigaction sa; +#endif + char *extended_opts = 0; + char *cp; + int res; /* result of sscanf */ +#ifdef CONFIG_JBD_DEBUG + char *jbd_debug; +#endif + unsigned long long phys_mem_kb, blk; + + retval = e2fsck_allocate_context(&ctx); + if (retval) + return retval; + + *ret_ctx = ctx; + e2fsck_global_ctx = ctx; + + setvbuf(stdout, NULL, _IONBF, BUFSIZ); + setvbuf(stderr, NULL, _IONBF, BUFSIZ); + if (getenv("E2FSCK_FORCE_INTERACTIVE") || (isatty(0) && isatty(1))) { + ctx->interactive = 1; + } else { + ctx->start_meta[0] = '\001'; + ctx->stop_meta[0] = '\002'; + } + memset(bar, '=', sizeof(bar)-1); + memset(spaces, ' ', sizeof(spaces)-1); + add_error_table(&et_ext2_error_table); + add_error_table(&et_prof_error_table); + blkid_get_cache(&ctx->blkid, NULL); + + if (argc && *argv) + ctx->program_name = *argv; + else + usage(NULL); + + phys_mem_kb = get_memory_size() / 1024; + ctx->readahead_kb = ~0ULL; + while ((c = getopt(argc, argv, "panyrcC:B:dE:fvtFVM:b:I:j:P:l:L:N:SsDkz:")) != EOF) + switch (c) { + case 'C': + ctx->progress = e2fsck_update_progress; + res = sscanf(optarg, "%d", &ctx->progress_fd); + if (res != 1) + goto sscanf_err; + + if (ctx->progress_fd < 0) { + ctx->progress = 0; + ctx->progress_fd = ctx->progress_fd * -1; + } + if (!ctx->progress_fd) + break; + /* Validate the file descriptor to avoid disasters */ + fd = dup(ctx->progress_fd); + if (fd < 0) { + fprintf(stderr, + _("Error validating file descriptor %d: %s\n"), + ctx->progress_fd, + error_message(errno)); + fatal_error(ctx, + _("Invalid completion information file descriptor")); + } else + close(fd); + break; + case 'D': + ctx->options |= E2F_OPT_COMPRESS_DIRS; + break; + case 'E': + extended_opts = optarg; + break; + case 'p': + case 'a': + if (ctx->options & (E2F_OPT_YES|E2F_OPT_NO)) { + conflict_opt: + fatal_error(ctx, + _("Only one of the options -p/-a, -n or -y may be specified.")); + } + ctx->options |= E2F_OPT_PREEN; + break; + case 'n': + if (ctx->options & (E2F_OPT_YES|E2F_OPT_PREEN)) + goto conflict_opt; + ctx->options |= E2F_OPT_NO; + break; + case 'y': + if (ctx->options & (E2F_OPT_PREEN|E2F_OPT_NO)) + goto conflict_opt; + ctx->options |= E2F_OPT_YES; + break; + case 't': +#ifdef RESOURCE_TRACK + if (ctx->options & E2F_OPT_TIME) + ctx->options |= E2F_OPT_TIME2; + else + ctx->options |= E2F_OPT_TIME; +#else + fprintf(stderr, _("The -t option is not " + "supported on this version of e2fsck.\n")); +#endif + break; + case 'c': + if (cflag++) + ctx->options |= E2F_OPT_WRITECHECK; + ctx->options |= E2F_OPT_CHECKBLOCKS; + break; + case 'r': + /* What we do by default, anyway! */ + break; + case 'b': + res = sscanf(optarg, "%llu", &blk); + ctx->use_superblock = blk; + if (res != 1) + goto sscanf_err; + ctx->flags |= E2F_FLAG_SB_SPECIFIED; + break; + case 'B': + ctx->blocksize = atoi(optarg); + break; + case 'I': + res = sscanf(optarg, "%d", &ctx->inode_buffer_blocks); + if (res != 1) + goto sscanf_err; + break; + case 'j': + ctx->journal_name = get_devname(ctx->blkid, + optarg, NULL); + if (!ctx->journal_name) { + com_err(ctx->program_name, 0, + _("Unable to resolve '%s'"), + optarg); + fatal_error(ctx, 0); + } + break; + case 'P': + res = sscanf(optarg, "%d", &ctx->process_inode_size); + if (res != 1) + goto sscanf_err; + break; + case 'L': + replace_bad_blocks++; + /* fall through */ + case 'l': + if (bad_blocks_file) + free(bad_blocks_file); + bad_blocks_file = string_copy(ctx, optarg, 0); + break; + case 'd': + ctx->options |= E2F_OPT_DEBUG; + break; + case 'f': + ctx->options |= E2F_OPT_FORCE; + break; + case 'F': + flush = 1; + break; + case 'v': + verbose = 1; + break; + case 'V': + show_version_only = 1; + break; +#ifdef MTRACE + case 'M': + mallwatch = (void *) strtol(optarg, NULL, 0); + break; +#endif + case 'N': + ctx->device_name = string_copy(ctx, optarg, 0); + break; + case 'k': + keep_bad_blocks++; + break; + case 'z': + ctx->undo_file = optarg; + break; + default: + usage(ctx); + } + if (show_version_only) + return 0; + if (optind != argc - 1) + usage(ctx); + if ((ctx->options & E2F_OPT_NO) && + (ctx->options & E2F_OPT_COMPRESS_DIRS)) { + com_err(ctx->program_name, 0, "%s", + _("The -n and -D options are incompatible.")); + fatal_error(ctx, 0); + } + if ((ctx->options & E2F_OPT_NO) && cflag) { + com_err(ctx->program_name, 0, "%s", + _("The -n and -c options are incompatible.")); + fatal_error(ctx, 0); + } + if ((ctx->options & E2F_OPT_NO) && bad_blocks_file) { + com_err(ctx->program_name, 0, "%s", + _("The -n and -l/-L options are incompatible.")); + fatal_error(ctx, 0); + } + if (ctx->options & E2F_OPT_NO) + ctx->options |= E2F_OPT_READONLY; + + ctx->io_options = strchr(argv[optind], '?'); + if (ctx->io_options) + *ctx->io_options++ = 0; + ctx->filesystem_name = get_devname(ctx->blkid, argv[optind], 0); + if (!ctx->filesystem_name) { + 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); + + /* Complain about mutually exclusive rebuilding activities */ + if (getenv("E2FSCK_FIXES_ONLY")) + ctx->options |= E2F_OPT_FIXES_ONLY; + if ((ctx->options & E2F_OPT_COMPRESS_DIRS) && + (ctx->options & E2F_OPT_FIXES_ONLY)) { + com_err(ctx->program_name, 0, "%s", + _("The -D and -E fixes_only options are incompatible.")); + fatal_error(ctx, 0); + } + if ((ctx->options & E2F_OPT_CONVERT_BMAP) && + (ctx->options & E2F_OPT_FIXES_ONLY)) { + com_err(ctx->program_name, 0, "%s", + _("The -E bmap2extent and fixes_only options are incompatible.")); + fatal_error(ctx, 0); + } + + if ((cp = getenv("E2FSCK_CONFIG")) != NULL) + config_fn[0] = cp; + profile_set_syntax_err_cb(syntax_err_report); + profile_init(config_fn, &ctx->profile); + + profile_get_boolean(ctx->profile, "options", "report_time", 0, 0, + &c); + if (c) + ctx->options |= E2F_OPT_TIME | E2F_OPT_TIME2; + profile_get_boolean(ctx->profile, "options", "report_verbose", 0, 0, + &c); + if (c) + verbose = 1; + + profile_get_boolean(ctx->profile, "options", "no_optimize_extents", + 0, 0, &c); + if (c) + ctx->options |= E2F_OPT_NOOPT_EXTENTS; + + profile_get_boolean(ctx->profile, "options", "inode_count_fullmap", + 0, 0, &c); + if (c) + ctx->options |= E2F_OPT_ICOUNT_FULLMAP; + + if (ctx->readahead_kb == ~0ULL) { + profile_get_integer(ctx->profile, "options", + "readahead_mem_pct", 0, -1, &c); + if (c >= 0 && c <= 100) + ctx->readahead_kb = phys_mem_kb * c / 100; + profile_get_integer(ctx->profile, "options", + "readahead_kb", 0, -1, &c); + if (c >= 0) + ctx->readahead_kb = c; + if (ctx->readahead_kb != ~0ULL && + ctx->readahead_kb > phys_mem_kb) + ctx->readahead_kb = phys_mem_kb; + } + + /* Turn off discard in read-only mode */ + if ((ctx->options & E2F_OPT_NO) && + (ctx->options & E2F_OPT_DISCARD)) + ctx->options &= ~E2F_OPT_DISCARD; + + if (flush) { + fd = open(ctx->filesystem_name, O_RDONLY, 0); + if (fd < 0) { + com_err("open", errno, + _("while opening %s for flushing"), + ctx->filesystem_name); + fatal_error(ctx, 0); + } + if ((retval = ext2fs_sync_device(fd, 1))) { + com_err("ext2fs_sync_device", retval, + _("while trying to flush %s"), + ctx->filesystem_name); + fatal_error(ctx, 0); + } + close(fd); + } + if (cflag && bad_blocks_file) { + fprintf(stderr, "%s", _("The -c and the -l/-L options may not " + "be both used at the same time.\n")); + exit(FSCK_USAGE); + } +#ifdef HAVE_SIGNAL_H + /* + * Set up signal action + */ + memset(&sa, 0, sizeof(struct sigaction)); + sa.sa_handler = signal_cancel; + sigaction(SIGINT, &sa, 0); + sigaction(SIGTERM, &sa, 0); +#ifdef SA_RESTART + sa.sa_flags = SA_RESTART; +#endif + sa.sa_handler = signal_progress_on; + 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) { + char *oldpath = getenv("PATH"); + char *newpath; + int len = sizeof(PATH_SET) + 1; + + if (oldpath) + len += strlen(oldpath); + + newpath = malloc(len); + if (!newpath) + fatal_error(ctx, "Couldn't malloc() newpath"); + strcpy(newpath, PATH_SET); + + if (oldpath) { + strcat(newpath, ":"); + strcat(newpath, oldpath); + } + putenv(newpath); + } +#ifdef CONFIG_JBD_DEBUG + jbd_debug = getenv("E2FSCK_JBD_DEBUG"); + if (jbd_debug) { + res = sscanf(jbd_debug, "%d", &journal_enable_debug); + if (res != 1) { + fprintf(stderr, + _("E2FSCK_JBD_DEBUG \"%s\" not an integer\n\n"), + jbd_debug); + exit (1); + } + } +#endif + return 0; + +sscanf_err: + fprintf(stderr, _("\nInvalid non-numeric argument to -%c (\"%s\")\n\n"), + c, optarg); + exit (1); +} + +static errcode_t try_open_fs(e2fsck_t ctx, int flags, io_manager io_ptr, + ext2_filsys *ret_fs) +{ + errcode_t retval; + + *ret_fs = NULL; + + if (ctx->superblock) { + unsigned long blocksize = ctx->blocksize; + + if (!blocksize) { + for (blocksize = EXT2_MIN_BLOCK_SIZE; + blocksize <= EXT2_MAX_BLOCK_SIZE; blocksize *= 2) { + + retval = ext2fs_open2(ctx->filesystem_name, + ctx->io_options, flags, + ctx->superblock, blocksize, + unix_io_manager, ret_fs); + if (*ret_fs) { + ext2fs_free(*ret_fs); + *ret_fs = NULL; + } + if (!retval) + break; + } + if (retval) + return retval; + } + + retval = ext2fs_open2(ctx->filesystem_name, ctx->io_options, + flags, ctx->superblock, blocksize, + io_ptr, ret_fs); + } else + retval = ext2fs_open2(ctx->filesystem_name, ctx->io_options, + flags, 0, 0, io_ptr, ret_fs); + + if (retval == 0) { + (*ret_fs)->priv_data = ctx; + e2fsck_set_bitmap_type(*ret_fs, EXT2FS_BMAP64_RBTREE, + "default", NULL); + } + return retval; +} + +static const char *my_ver_string = E2FSPROGS_VERSION; +static const char *my_ver_date = E2FSPROGS_DATE; + +static errcode_t e2fsck_check_mmp(ext2_filsys fs, e2fsck_t ctx) +{ + struct mmp_struct *mmp_s; + unsigned int mmp_check_interval; + errcode_t retval = 0; + struct problem_context pctx; + unsigned int wait_time = 0; + + clear_problem_context(&pctx); + if (fs->mmp_buf == NULL) { + retval = ext2fs_get_mem(fs->blocksize, &fs->mmp_buf); + if (retval) + goto check_error; + } + + retval = ext2fs_mmp_read(fs, fs->super->s_mmp_block, fs->mmp_buf); + if (retval) + goto check_error; + + mmp_s = fs->mmp_buf; + + mmp_check_interval = fs->super->s_mmp_update_interval; + if (mmp_check_interval < EXT4_MMP_MIN_CHECK_INTERVAL) + mmp_check_interval = EXT4_MMP_MIN_CHECK_INTERVAL; + + /* + * If check_interval in MMP block is larger, use that instead of + * check_interval from the superblock. + */ + if (mmp_s->mmp_check_interval > mmp_check_interval) + mmp_check_interval = mmp_s->mmp_check_interval; + + wait_time = mmp_check_interval * 2 + 1; + + if (mmp_s->mmp_seq == EXT4_MMP_SEQ_CLEAN) + retval = 0; + else if (mmp_s->mmp_seq == EXT4_MMP_SEQ_FSCK) + retval = EXT2_ET_MMP_FSCK_ON; + else if (mmp_s->mmp_seq > EXT4_MMP_SEQ_MAX) + retval = EXT2_ET_MMP_UNKNOWN_SEQ; + + if (retval) + goto check_error; + + /* Print warning if e2fsck will wait for more than 20 secs. */ + if (verbose || wait_time > EXT4_MMP_MIN_CHECK_INTERVAL * 4) { + log_out(ctx, _("MMP interval is %u seconds and total wait " + "time is %u seconds. Please wait...\n"), + mmp_check_interval, wait_time * 2); + } + + return 0; + +check_error: + + if (retval == EXT2_ET_MMP_BAD_BLOCK) { + if (fix_problem(ctx, PR_0_MMP_INVALID_BLK, &pctx)) { + fs->super->s_mmp_block = 0; + ext2fs_mark_super_dirty(fs); + retval = 0; + } + } else if (retval == EXT2_ET_MMP_FAILED) { + com_err(ctx->program_name, retval, "%s", + _("while checking MMP block")); + dump_mmp_msg(fs->mmp_buf, NULL); + } else if (retval == EXT2_ET_MMP_FSCK_ON || + retval == EXT2_ET_MMP_UNKNOWN_SEQ) { + com_err(ctx->program_name, retval, "%s", + _("while checking MMP block")); + dump_mmp_msg(fs->mmp_buf, + _("If you are sure the filesystem is not " + "in use on any node, run:\n" + "'tune2fs -f -E clear_mmp %s'\n"), + ctx->device_name); + } else if (retval == EXT2_ET_MMP_MAGIC_INVALID) { + if (fix_problem(ctx, PR_0_MMP_INVALID_MAGIC, &pctx)) { + ext2fs_mmp_clear(fs); + retval = 0; + } + } else if (retval == EXT2_ET_MMP_CSUM_INVALID) { + if (fix_problem(ctx, PR_0_MMP_CSUM_INVALID, &pctx)) { + ext2fs_mmp_clear(fs); + retval = 0; + } + } else + com_err(ctx->program_name, retval, "%s", + _("while reading MMP block")); + return retval; +} + +static int e2fsck_setup_tdb(e2fsck_t ctx, io_manager *io_ptr) +{ + errcode_t retval = ENOMEM; + char *tdb_dir = NULL, *tdb_file = NULL; + char *dev_name, *tmp_name; + int free_tdb_dir = 0; + + /* (re)open a specific undo file */ + if (ctx->undo_file && ctx->undo_file[0] != 0) { + retval = set_undo_io_backing_manager(*io_ptr); + if (retval) + goto err; + *io_ptr = undo_io_manager; + retval = set_undo_io_backup_file(ctx->undo_file); + if (retval) + goto err; + printf(_("Overwriting existing filesystem; this can be undone " + "using the command:\n" + " e2undo %s %s\n\n"), + ctx->undo_file, ctx->filesystem_name); + return retval; + } + + /* + * Configuration via a conf file would be + * nice + */ + tdb_dir = getenv("E2FSPROGS_UNDO_DIR"); + if (!tdb_dir) { + profile_get_string(ctx->profile, "defaults", + "undo_dir", 0, "/var/lib/e2fsprogs", + &tdb_dir); + free_tdb_dir = 1; + } + + if (!strcmp(tdb_dir, "none") || (tdb_dir[0] == 0) || + access(tdb_dir, W_OK)) { + if (free_tdb_dir) + free(tdb_dir); + return 0; + } + + tmp_name = strdup(ctx->filesystem_name); + if (!tmp_name) + goto errout; + dev_name = basename(tmp_name); + tdb_file = malloc(strlen(tdb_dir) + 8 + strlen(dev_name) + 7 + 1); + if (!tdb_file) { + free(tmp_name); + goto errout; + } + sprintf(tdb_file, "%s/e2fsck-%s.e2undo", tdb_dir, dev_name); + free(tmp_name); + + if ((unlink(tdb_file) < 0) && (errno != ENOENT)) { + retval = errno; + com_err(ctx->program_name, retval, + _("while trying to delete %s"), tdb_file); + goto errout; + } + + retval = set_undo_io_backing_manager(*io_ptr); + if (retval) + goto errout; + *io_ptr = undo_io_manager; + retval = set_undo_io_backup_file(tdb_file); + if (retval) + goto errout; + printf(_("Overwriting existing filesystem; this can be undone " + "using the command:\n" + " e2undo %s %s\n\n"), tdb_file, ctx->filesystem_name); + + if (free_tdb_dir) + free(tdb_dir); + free(tdb_file); + return 0; + +errout: + if (free_tdb_dir) + free(tdb_dir); + free(tdb_file); +err: + com_err(ctx->program_name, retval, "%s", + _("while trying to setup undo file\n")); + return retval; +} + +int main (int argc, char *argv[]) +{ + errcode_t retval = 0, retval2 = 0, orig_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; + blk64_t orig_superblock = ~(blk64_t)0; + struct problem_context pctx; + int flags, run_result, was_changed; + int journal_size; + int sysval, sys_page_size = 4096; + int old_bitmaps; + __u32 features[3]; + char *cp; + enum quota_type qtype; + struct ext2fs_journal_params jparams; + + clear_problem_context(&pctx); + sigcatcher_setup(); +#ifdef MTRACE + mtrace(); +#endif +#ifdef MCHECK + mcheck(0); +#endif +#ifdef ENABLE_NLS + setlocale(LC_MESSAGES, ""); + setlocale(LC_CTYPE, ""); + bindtextdomain(NLS_CAT_NAME, LOCALEDIR); + textdomain(NLS_CAT_NAME); + set_com_err_gettext(gettext); +#endif + my_ver = ext2fs_parse_version_string(my_ver_string); + lib_ver = ext2fs_get_library_version(0, &lib_ver_date); + if (my_ver > lib_ver) { + fprintf( stderr, "%s", + _("Error: ext2fs library version out of date!\n")); + show_version_only++; + } + + retval = PRS(argc, argv, &ctx); + if (retval) { + com_err("e2fsck", retval, "%s", + _("while trying to initialize program")); + exit(FSCK_ERROR); + } + reserve_stdio_fds(); + + set_up_logging(ctx); + if (ctx->logf) { + int i; + + fputs("E2fsck run: ", ctx->logf); + for (i = 0; i < argc; i++) { + if (i) + fputc(' ', ctx->logf); + fputs(argv[i], ctx->logf); + } + fputc('\n', ctx->logf); + } + if (ctx->problem_logf) { + int i; + + fputs("\n", + ctx->problem_logf); + fprintf(ctx->problem_logf, "\n", + (unsigned long) ctx->now); + fprintf(ctx->problem_logf, "problem_logf, " arg%d=\"%s\"", i, argv[i]); + fputs("/>\n", ctx->problem_logf); + } + + init_resource_track(&ctx->global_rtrack, NULL); + if (!(ctx->options & E2F_OPT_PREEN) || show_version_only) + log_err(ctx, "e2fsck %s (%s)\n", my_ver_string, + my_ver_date); + + if (show_version_only) { + log_err(ctx, _("\tUsing %s, %s\n"), + 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)) { + if (!ctx->interactive) + fatal_error(ctx, + _("need terminal for interactive repairs")); + } + ctx->superblock = ctx->use_superblock; + + flags = EXT2_FLAG_SKIP_MMP | EXT2_FLAG_THREADS; +restart: +#ifdef CONFIG_TESTIO_DEBUG + if (getenv("TEST_IO_FLAGS") || getenv("TEST_IO_BLOCK")) { + io_ptr = test_io_manager; + test_io_backing_manager = unix_io_manager; + } else +#endif + io_ptr = unix_io_manager; + flags |= EXT2_FLAG_NOFREE_ON_ERROR; + profile_get_boolean(ctx->profile, "options", "old_bitmaps", 0, 0, + &old_bitmaps); + if (!old_bitmaps) + flags |= EXT2_FLAG_64BITS; + if ((ctx->options & E2F_OPT_READONLY) == 0) { + flags |= EXT2_FLAG_RW; + if (!(ctx->mount_flags & EXT2_MF_ISROOT && + ctx->mount_flags & EXT2_MF_READONLY)) + flags |= EXT2_FLAG_EXCLUSIVE; + if ((ctx->mount_flags & EXT2_MF_READONLY) && + (ctx->options & E2F_OPT_FORCE)) + flags &= ~EXT2_FLAG_EXCLUSIVE; + } + + if (ctx->undo_file) { + retval = e2fsck_setup_tdb(ctx, &io_ptr); + if (retval) + exit(FSCK_ERROR); + } + + ctx->openfs_flags = flags; + retval = try_open_fs(ctx, flags, io_ptr, &fs); + + if (!ctx->superblock && !(ctx->options & E2F_OPT_PREEN) && + !(ctx->flags & E2F_FLAG_SB_SPECIFIED) && + ((retval == EXT2_ET_BAD_MAGIC) || + (retval == EXT2_ET_SB_CSUM_INVALID) || + (retval == EXT2_ET_CORRUPT_SUPERBLOCK) || + ((retval == 0) && (retval2 = ext2fs_check_desc(fs))))) { + if (retval) { + pctx.errcode = retval; + fix_problem(ctx, PR_0_OPEN_FAILED, &pctx); + } + if (retval2) { + pctx.errcode = retval2; + fix_problem(ctx, PR_0_CHECK_DESC_FAILED, &pctx); + } + pctx.errcode = 0; + if (retval2 == ENOMEM || retval2 == EXT2_ET_NO_MEMORY) { + retval = retval2; + goto failure; + } + if (fs->flags & EXT2_FLAG_NOFREE_ON_ERROR) { + ext2fs_free(fs); + fs = NULL; + } + if (!fs || (fs->group_desc_count > 1)) { + log_out(ctx, _("%s: %s trying backup blocks...\n"), + ctx->program_name, + retval ? _("Superblock invalid,") : + _("Group descriptors look bad...")); + orig_superblock = ctx->superblock; + get_backup_sb(ctx, fs, ctx->filesystem_name, io_ptr); + if (fs) + ext2fs_close_free(&fs); + orig_retval = retval; + retval = try_open_fs(ctx, flags, io_ptr, &fs); + if ((orig_retval == 0) && retval != 0) { + if (fs) + ext2fs_close_free(&fs); + log_out(ctx, _("%s: %s while using the " + "backup blocks"), + ctx->program_name, + error_message(retval)); + log_out(ctx, _("%s: going back to original " + "superblock\n"), + ctx->program_name); + ctx->superblock = orig_superblock; + retval = try_open_fs(ctx, flags, io_ptr, &fs); + } + } + } + if (((retval == EXT2_ET_UNSUPP_FEATURE) || + (retval == EXT2_ET_RO_UNSUPP_FEATURE)) && + fs && fs->super) { + sb = fs->super; + features[0] = (sb->s_feature_compat & + ~EXT2_LIB_FEATURE_COMPAT_SUPP); + features[1] = (sb->s_feature_incompat & + ~EXT2_LIB_FEATURE_INCOMPAT_SUPP); + features[2] = (sb->s_feature_ro_compat & + ~EXT2_LIB_FEATURE_RO_COMPAT_SUPP); + if (features[0] || features[1] || features[2]) + goto print_unsupp_features; + } +failure: + if (retval) { + if (orig_retval) + retval = orig_retval; + com_err(ctx->program_name, retval, _("while trying to open %s"), + ctx->filesystem_name); + if (retval == EXT2_ET_REV_TOO_HIGH) { + log_out(ctx, "%s", + _("The filesystem revision is apparently " + "too high for this version of e2fsck.\n" + "(Or the filesystem superblock " + "is corrupt)\n\n")); + fix_problem(ctx, PR_0_SB_CORRUPT, &pctx); + } else if (retval == EXT2_ET_SHORT_READ) + log_out(ctx, "%s", + _("Could this be a zero-length partition?\n")); + else if ((retval == EPERM) || (retval == EACCES)) + log_out(ctx, _("You must have %s access to the " + "filesystem or be root\n"), + (ctx->options & E2F_OPT_READONLY) ? + "r/o" : "r/w"); + else if (retval == ENXIO) + log_out(ctx, "%s", + _("Possibly non-existent or swap device?\n")); + else if (retval == EBUSY) + log_out(ctx, "%s", _("Filesystem mounted or opened " + "exclusively by another program?\n")); + else if (retval == ENOENT) + log_out(ctx, "%s", + _("Possibly non-existent device?\n")); +#ifdef EROFS + else if (retval == EROFS) + log_out(ctx, "%s", _("Disk write-protected; use the " + "-n option to do a read-only\n" + "check of the device.\n")); +#endif + else { + /* + * Let's try once more will less consistency checking + * so that we are able to recover from more errors + * (e.g. some tool messing up some value in the sb). + */ + if (((retval == EXT2_ET_CORRUPT_SUPERBLOCK) || + (retval == EXT2_ET_BAD_DESC_SIZE)) && + !(flags & EXT2_FLAG_IGNORE_SB_ERRORS)) { + if (fs) + ext2fs_close_free(&fs); + log_out(ctx, _("%s: Trying to load superblock " + "despite errors...\n"), + ctx->program_name); + flags |= EXT2_FLAG_IGNORE_SB_ERRORS; + /* + * If we tried backup sb, revert to the + * original one now. + */ + if (orig_superblock != ~(blk64_t)0) + ctx->superblock = orig_superblock; + goto restart; + } + fix_problem(ctx, PR_0_SB_CORRUPT, &pctx); + if (retval == EXT2_ET_BAD_MAGIC) + check_plausibility(ctx->filesystem_name, + CHECK_FS_EXIST, NULL); + } + fatal_error(ctx, 0); + } + /* + * We only update the master superblock because (a) paranoia; + * we don't want to corrupt the backup superblocks, and (b) we + * don't need to update the mount count and last checked + * fields in the backup superblock (the kernel doesn't update + * the backup superblocks anyway). With newer versions of the + * library this flag is set by ext2fs_open2(), but we set this + * here just to be sure. (No, we don't support e2fsck running + * with some other libext2fs than the one that it was shipped + * with, but just in case....) + */ + fs->flags |= EXT2_FLAG_MASTER_SB_ONLY; + + if (!(ctx->flags & E2F_FLAG_GOT_DEVSIZE)) { + __u32 blocksize = EXT2_BLOCK_SIZE(fs->super); + int need_restart = 0; + + pctx.errcode = ext2fs_get_device_size2(ctx->filesystem_name, + blocksize, + &ctx->num_blocks); + /* + * The floppy driver refuses to allow anyone else to + * open the device if has been opened with O_EXCL; + * this is unlike other block device drivers in Linux. + * To handle this, we close the filesystem and then + * reopen the filesystem after we get the device size. + */ + if (pctx.errcode == EBUSY) { + ext2fs_close_free(&fs); + need_restart++; + pctx.errcode = + ext2fs_get_device_size2(ctx->filesystem_name, + blocksize, + &ctx->num_blocks); + } + if (pctx.errcode == EXT2_ET_UNIMPLEMENTED) + ctx->num_blocks = 0; + else if (pctx.errcode) { + fix_problem(ctx, PR_0_GETSIZE_ERROR, &pctx); + ctx->flags |= E2F_FLAG_ABORT; + fatal_error(ctx, 0); + } + ctx->flags |= E2F_FLAG_GOT_DEVSIZE; + if (need_restart) + goto restart; + } + + ctx->fs = fs; + fs->now = ctx->now; + sb = fs->super; + + if (sb->s_rev_level > E2FSCK_CURRENT_REV) { + com_err(ctx->program_name, EXT2_ET_REV_TOO_HIGH, + _("while trying to open %s"), + ctx->filesystem_name); + get_newer: + fatal_error(ctx, _("Get a newer version of e2fsck!")); + } + + /* + * Set the device name, which is used whenever we print error + * or informational messages to the user. + */ + if (ctx->device_name == 0 && sb->s_volume_name[0]) + ctx->device_name = string_copy(ctx, (char *) sb->s_volume_name, + sizeof(sb->s_volume_name)); + + if (ctx->device_name == 0) + ctx->device_name = string_copy(ctx, ctx->filesystem_name, 0); + for (cp = ctx->device_name; *cp; cp++) + if (isspace(*cp) || *cp == ':') + *cp = '_'; + + if (ctx->problem_logf) { + + fprintf(ctx->problem_logf, "filesystem_name); + if (!uuid_is_null(sb->s_uuid)) { + char buf[48]; + + uuid_unparse(sb->s_uuid, buf); + fprintf(ctx->problem_logf, " uuid=\"%s\"", buf); + } + if (sb->s_volume_name[0]) + fprintf(ctx->problem_logf, " label=\"%.*s\"", + EXT2_LEN_STR(sb->s_volume_name)); + + fputs("/>\n", ctx->problem_logf); + } + + ehandler_init(fs->io); + + if (ext2fs_has_feature_mmp(fs->super) && + (flags & EXT2_FLAG_SKIP_MMP)) { + if (e2fsck_check_mmp(fs, ctx)) + fatal_error(ctx, 0); + + /* + * Restart in order to reopen fs but this time start mmp. + */ + ext2fs_close_free(&ctx->fs); + flags &= ~EXT2_FLAG_SKIP_MMP; + goto restart; + } + + if (ctx->logf) + fprintf(ctx->logf, "Filesystem UUID: %s\n", + e2p_uuid2str(sb->s_uuid)); + + /* + * Make sure the ext3 superblock fields are consistent. + */ + if ((ctx->mount_flags & (EXT2_MF_MOUNTED | EXT2_MF_BUSY)) == 0) { + retval = e2fsck_check_ext3_journal(ctx); + if (retval) { + com_err(ctx->program_name, retval, + _("while checking journal for %s"), + ctx->device_name); + fatal_error(ctx, + _("Cannot proceed with file system check")); + } + } + + /* + * Check to see if we need to do ext3-style recovery. If so, + * do it, and then restart the fsck. + */ + if (ext2fs_has_feature_journal_needs_recovery(sb)) { + if (ctx->options & E2F_OPT_READONLY) { + log_out(ctx, "%s", + _("Warning: skipping journal recovery because " + "doing a read-only filesystem check.\n")); + io_channel_flush(ctx->fs->io); + } else { + if (ctx->flags & E2F_FLAG_RESTARTED) { + /* + * Whoops, we attempted to run the + * journal twice. This should never + * happen, unless the hardware or + * device driver is being bogus. + */ + com_err(ctx->program_name, 0, + _("unable to set superblock flags " + "on %s\n"), ctx->device_name); + fatal_error(ctx, 0); + } + retval = e2fsck_run_ext3_journal(ctx); + if (retval == EFSBADCRC) { + log_out(ctx, _("Journal checksum error " + "found in %s\n"), + ctx->device_name); + } else if (retval == EFSCORRUPTED) { + log_out(ctx, _("Journal corrupted in %s\n"), + ctx->device_name); + } else if (retval) { + com_err(ctx->program_name, retval, + _("while recovering journal of %s"), + ctx->device_name); + } + ext2fs_close_free(&ctx->fs); + ctx->flags |= E2F_FLAG_RESTARTED; + goto restart; + } + } + + /* + * Check for compatibility with the feature sets. We need to + * be more stringent than ext2fs_open(). + */ + features[0] = sb->s_feature_compat & ~EXT2_LIB_FEATURE_COMPAT_SUPP; + features[1] = sb->s_feature_incompat & ~EXT2_LIB_FEATURE_INCOMPAT_SUPP; + features[2] = (sb->s_feature_ro_compat & + ~EXT2_LIB_FEATURE_RO_COMPAT_SUPP); +print_unsupp_features: + if (features[0] || features[1] || features[2]) { + int i, j; + __u32 *mask = features, m; + + log_err(ctx, _("%s has unsupported feature(s):"), + ctx->filesystem_name); + + for (i=0; i <3; i++,mask++) { + for (j=0,m=1; j < 32; j++, m<<=1) { + if (*mask & m) + log_err(ctx, " %s", + e2p_feature2string(i, m)); + } + } + log_err(ctx, "\n"); + goto get_newer; + } + + if (ext2fs_has_feature_casefold(sb) && !fs->encoding) { + log_err(ctx, _("%s has unsupported encoding: %0x\n"), + ctx->filesystem_name, sb->s_encoding); + goto get_newer; + } + + /* + * If the user specified a specific superblock, presumably the + * master superblock has been trashed. So we mark the + * superblock as dirty, so it can be written out. + */ + if (ctx->superblock && + !(ctx->options & E2F_OPT_READONLY)) + ext2fs_mark_super_dirty(fs); + + /* + * Calculate the number of filesystem blocks per pagesize. If + * fs->blocksize > page_size, set the number of blocks per + * pagesize to 1 to avoid division by zero errors. + */ +#ifdef _SC_PAGESIZE + sysval = sysconf(_SC_PAGESIZE); + if (sysval > 0) + sys_page_size = sysval; +#endif /* _SC_PAGESIZE */ + ctx->blocks_per_page = sys_page_size / fs->blocksize; + if (ctx->blocks_per_page == 0) + ctx->blocks_per_page = 1; + + if (ctx->superblock) + set_latch_flags(PR_LATCH_RELOC, PRL_LATCHED, 0); + ext2fs_mark_valid(fs); + check_super_block(ctx); + if (ctx->flags & E2F_FLAG_SIGNAL_MASK) + fatal_error(ctx, 0); + check_if_skip(ctx); + check_resize_inode(ctx); + if (bad_blocks_file) + read_bad_blocks_file(ctx, bad_blocks_file, replace_bad_blocks); + else if (cflag) + read_bad_blocks_file(ctx, 0, !keep_bad_blocks); /* Test disk */ + if (ctx->flags & E2F_FLAG_SIGNAL_MASK) + fatal_error(ctx, 0); + + /* + * Mark the system as valid, 'til proven otherwise + */ + ext2fs_mark_valid(fs); + + retval = ext2fs_read_bb_inode(fs, &fs->badblocks); + if (retval) { + log_out(ctx, _("%s: %s while reading bad blocks inode\n"), + ctx->program_name, error_message(retval)); + preenhalt(ctx); + log_out(ctx, "%s", _("This doesn't bode well, " + "but we'll try to go on...\n")); + } + + /* + * Save the journal size in megabytes. + * Try and use the journal size from the backup else let e2fsck + * find the default journal size. If fast commit feature is enabled, + * it is not clear how many of the journal blocks were fast commit + * blocks. So, ignore the size of journal found in backup. + * + * TODO: Add a new backup type that captures fast commit info as + * well. + */ + if (sb->s_jnl_backup_type == EXT3_JNL_BACKUP_BLOCKS && + !ext2fs_has_feature_fast_commit(sb)) + journal_size = (sb->s_jnl_blocks[15] << (32 - 20)) | + (sb->s_jnl_blocks[16] >> 20); + else + journal_size = -1; + + if (ext2fs_has_feature_quota(sb)) { + /* Quotas were enabled. Do quota accounting during fsck. */ + clear_problem_context(&pctx); + pctx.errcode = quota_init_context(&ctx->qctx, ctx->fs, 0); + if (pctx.errcode) { + fix_problem(ctx, PR_0_QUOTA_INIT_CTX, &pctx); + fatal_error(ctx, 0); + } + } + + run_result = e2fsck_run(ctx); + e2fsck_clear_progbar(ctx); + + if (!ctx->invalid_bitmaps && + (ctx->flags & E2F_FLAG_JOURNAL_INODE)) { + if (fix_problem(ctx, PR_6_RECREATE_JOURNAL, &pctx)) { + if (journal_size < 1024) { + ext2fs_get_journal_params(&jparams, fs); + } else { + jparams.num_journal_blocks = journal_size; + jparams.num_fc_blocks = 0; + } + log_out(ctx, _("Creating journal (%d blocks): "), + jparams.num_journal_blocks); + fflush(stdout); + retval = ext2fs_add_journal_inode3(fs, &jparams, ~0ULL, 0); + if (retval) { + log_out(ctx, "%s: while trying to create " + "journal\n", error_message(retval)); + goto no_journal; + } + log_out(ctx, "%s", _(" Done.\n")); + log_out(ctx, "%s", + _("\n*** journal has been regenerated ***\n")); + } + } + +no_journal: + if (run_result & E2F_FLAG_ABORT) { + fatal_error(ctx, _("aborted")); + } else if (run_result & E2F_FLAG_CANCEL) { + log_out(ctx, _("%s: e2fsck canceled.\n"), ctx->device_name ? + ctx->device_name : ctx->filesystem_name); + exit_value |= FSCK_CANCELED; + goto cleanup; + } + + if (ext2fs_has_feature_orphan_file(fs->super)) { + int ret; + + /* No point in orphan file without a journal... */ + if (!ext2fs_has_feature_journal(fs->super) && + fix_problem(ctx, PR_6_ORPHAN_FILE_WITHOUT_JOURNAL, &pctx)) { + retval = ext2fs_truncate_orphan_file(fs); + if (retval) { + /* Huh, failed to delete file */ + fix_problem(ctx, PR_6_ORPHAN_FILE_TRUNC_FAILED, + &pctx); + goto check_quotas; + } + ext2fs_clear_feature_orphan_file(fs->super); + ext2fs_mark_super_dirty(fs); + goto check_quotas; + } + ret = check_init_orphan_file(ctx); + if (ret == 2 || + (ret == 0 && ext2fs_has_feature_orphan_present(fs->super) && + fix_problem(ctx, PR_6_ORPHAN_PRESENT_CLEAN_FILE, &pctx))) { + ext2fs_clear_feature_orphan_present(fs->super); + ext2fs_mark_super_dirty(fs); + } else if (ret == 1 && + fix_problem(ctx, PR_6_ORPHAN_FILE_CORRUPTED, &pctx)) { + int orphan_file_blocks; + + if (ctx->invalid_bitmaps) { + fix_problem(ctx, + PR_6_ORPHAN_FILE_BITMAP_INVALID, + &pctx); + goto check_quotas; + } + + retval = ext2fs_truncate_orphan_file(fs); + if (retval) { + /* Huh, failed to truncate file */ + fix_problem(ctx, PR_6_ORPHAN_FILE_TRUNC_FAILED, + &pctx); + goto check_quotas; + } + + orphan_file_blocks = + ext2fs_default_orphan_file_blocks(fs); + log_out(ctx, _("Creating orphan file (%d blocks): "), + orphan_file_blocks); + fflush(stdout); + retval = ext2fs_create_orphan_file(fs, + orphan_file_blocks); + if (retval) { + log_out(ctx, "%s: while trying to create " + "orphan file\n", error_message(retval)); + fix_problem(ctx, PR_6_ORPHAN_FILE_CREATE_FAILED, + &pctx); + goto check_quotas; + } + log_out(ctx, "%s", _(" Done.\n")); + } + } else if (ext2fs_has_feature_orphan_present(fs->super) && + fix_problem(ctx, PR_6_ORPHAN_PRESENT_NO_FILE, &pctx)) { + ext2fs_clear_feature_orphan_present(fs->super); + ext2fs_mark_super_dirty(fs); + } +check_quotas: + if (ctx->qctx && !ctx->invalid_bitmaps) { + int needs_writeout; + + for (qtype = 0; qtype < MAXQUOTAS; qtype++) { + if (*quota_sb_inump(sb, qtype) == 0) + continue; + needs_writeout = 0; + pctx.num = qtype; + retval = quota_compare_and_update(ctx->qctx, qtype, + &needs_writeout); + if ((retval || needs_writeout) && + fix_problem(ctx, PR_6_UPDATE_QUOTAS, &pctx)) { + pctx.errcode = quota_write_inode(ctx->qctx, + 1 << qtype); + if (pctx.errcode) + (void) fix_problem(ctx, + PR_6_WRITE_QUOTAS, &pctx); + } + } + quota_release_context(&ctx->qctx); + } + + if (run_result == E2F_FLAG_RESTART) { + log_out(ctx, "%s", + _("Restarting e2fsck from the beginning...\n")); + retval = e2fsck_reset_context(ctx); + if (retval) { + com_err(ctx->program_name, retval, "%s", + _("while resetting context")); + fatal_error(ctx, 0); + } + ext2fs_close_free(&ctx->fs); + goto restart; + } + +cleanup: +#ifdef MTRACE + mtrace_print("Cleanup"); +#endif + was_changed = ext2fs_test_changed(fs); + if (!(ctx->flags & E2F_FLAG_RUN_RETURN) && + !(ctx->options & E2F_OPT_READONLY)) { + if (ext2fs_test_valid(fs)) { + if (!(sb->s_state & EXT2_VALID_FS)) + exit_value |= FSCK_NONDESTRUCT; + sb->s_state = EXT2_VALID_FS; + if (check_backup_super_block(ctx)) + fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY; + } else + sb->s_state &= ~EXT2_VALID_FS; + if (!(ctx->flags & E2F_FLAG_TIME_INSANE)) + sb->s_lastcheck = ctx->now; + sb->s_mnt_count = 0; + memset(((char *) sb) + EXT4_S_ERR_START, 0, EXT4_S_ERR_LEN); + pctx.errcode = ext2fs_set_gdt_csum(ctx->fs); + if (pctx.errcode) + fix_problem(ctx, PR_6_SET_BG_CHECKSUM, &pctx); + ext2fs_mark_super_dirty(fs); + } + + if (ext2fs_has_feature_shared_blocks(ctx->fs->super) && + (ctx->options & E2F_OPT_UNSHARE_BLOCKS) && + (ctx->options & E2F_OPT_NO)) + /* Don't try to write or flush I/O, we just wanted to know whether or + * not there were enough free blocks to undo deduplication. + */ + goto skip_write; + + if (!(ctx->options & E2F_OPT_READONLY)) { + e2fsck_write_bitmaps(ctx); + if (fs->flags & EXT2_FLAG_DIRTY) { + pctx.errcode = ext2fs_flush(ctx->fs); + if (pctx.errcode) + fix_problem(ctx, PR_6_FLUSH_FILESYSTEM, &pctx); + } + pctx.errcode = io_channel_flush(ctx->fs->io); + if (pctx.errcode) + fix_problem(ctx, PR_6_IO_FLUSH, &pctx); + } + + if (was_changed) { + int fs_fixed = (ctx->flags & E2F_FLAG_PROBLEMS_FIXED); + + if (fs_fixed) + exit_value |= FSCK_NONDESTRUCT; + if (!(ctx->options & E2F_OPT_PREEN)) { +#if 0 /* Do this later; it breaks too many tests' golden outputs */ + log_out(ctx, fs_fixed ? + _("\n%s: ***** FILE SYSTEM ERRORS " + "CORRECTED *****\n") : + _("%s: File system was modified.\n"), + ctx->device_name); +#else + log_out(ctx, + _("\n%s: ***** FILE SYSTEM WAS MODIFIED *****\n"), + ctx->device_name); +#endif + } + if (ctx->mount_flags & EXT2_MF_ISROOT) { + log_out(ctx, _("%s: ***** REBOOT SYSTEM *****\n"), + ctx->device_name); + exit_value |= FSCK_REBOOT; + } + } + +skip_write: + if (!ext2fs_test_valid(fs) || + ((exit_value & FSCK_CANCELED) && + (sb->s_state & EXT2_ERROR_FS))) { + log_out(ctx, _("\n%s: ********** WARNING: Filesystem still has " + "errors **********\n\n"), ctx->device_name); + exit_value |= FSCK_UNCORRECTED; + exit_value &= ~FSCK_NONDESTRUCT; + } + if (exit_value & FSCK_CANCELED) { + int allow_cancellation; + + profile_get_boolean(ctx->profile, "options", + "allow_cancellation", 0, 0, + &allow_cancellation); + exit_value &= ~FSCK_NONDESTRUCT; + if (allow_cancellation && ext2fs_test_valid(fs) && + (sb->s_state & EXT2_VALID_FS) && + !(sb->s_state & EXT2_ERROR_FS)) + exit_value = 0; + } else + show_stats(ctx); + + print_resource_track(ctx, NULL, &ctx->global_rtrack, ctx->fs->io); + + ext2fs_close_free(&ctx->fs); + free(ctx->journal_name); + + if (ctx->logf) + fprintf(ctx->logf, "Exit status: %d\n", exit_value); + e2fsck_free_context(ctx); + remove_error_table(&et_ext2_error_table); + remove_error_table(&et_prof_error_table); + return exit_value; +} diff --git a/e2fsck/util.c b/e2fsck/util.c new file mode 100644 index 0000000..42740d9 --- /dev/null +++ b/e2fsck/util.c @@ -0,0 +1,900 @@ +/* + * 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 "config.h" +#include +#include +#include +#include +#include +#ifdef __linux__ +#include +#endif + +#ifdef HAVE_CONIO_H +#undef HAVE_TERMIOS_H +#include +#define read_a_char() getch() +#else +#ifdef HAVE_TERMIOS_H +#include +#endif +#endif + +#ifdef HAVE_MALLOC_H +#include +#endif + +#ifdef HAVE_ERRNO_H +#include +#endif + +#include "e2fsck.h" + +extern e2fsck_t e2fsck_global_ctx; /* Try your very best not to use this! */ + +#include +#include +#include +#include + +void fatal_error(e2fsck_t ctx, const char *msg) +{ + ext2_filsys fs = ctx->fs; + int exit_value = FSCK_ERROR; + + if (msg) + fprintf (stderr, "e2fsck: %s\n", msg); + if (!fs) + goto out; + if (fs->io && fs->super) { + ext2fs_mmp_stop(ctx->fs); + if (ctx->fs->io->magic == EXT2_ET_MAGIC_IO_CHANNEL) + io_channel_flush(ctx->fs->io); + else + log_err(ctx, "e2fsck: io manager magic bad!\n"); + } + if (ext2fs_test_changed(fs)) { + exit_value |= FSCK_NONDESTRUCT; + log_out(ctx, _("\n%s: ***** FILE SYSTEM WAS MODIFIED *****\n"), + ctx->device_name); + if (ctx->mount_flags & EXT2_MF_ISROOT) + exit_value |= FSCK_REBOOT; + } + if (!ext2fs_test_valid(fs)) { + log_out(ctx, _("\n%s: ********** WARNING: Filesystem still has " + "errors **********\n\n"), ctx->device_name); + exit_value |= FSCK_UNCORRECTED; + exit_value &= ~FSCK_NONDESTRUCT; + } +out: + ctx->flags |= E2F_FLAG_ABORT; + if (ctx->flags & E2F_FLAG_SETJMP_OK) + longjmp(ctx->abort_loc, 1); + if (ctx->logf) + fprintf(ctx->logf, "Exit status: %d\n", exit_value); + exit(exit_value); +} + +void log_out(e2fsck_t ctx, const char *fmt, ...) +{ + va_list pvar; + + va_start(pvar, fmt); + vprintf(fmt, pvar); + va_end(pvar); + if (ctx->logf) { + va_start(pvar, fmt); + vfprintf(ctx->logf, fmt, pvar); + va_end(pvar); + } +} + +void log_err(e2fsck_t ctx, const char *fmt, ...) +{ + va_list pvar; + + va_start(pvar, fmt); + vfprintf(stderr, fmt, pvar); + va_end(pvar); + if (ctx->logf) { + va_start(pvar, fmt); + vfprintf(ctx->logf, fmt, pvar); + va_end(pvar); + } +} + +void *e2fsck_allocate_memory(e2fsck_t ctx, unsigned long size, + const char *description) +{ + void *ret; + char buf[256]; + +#ifdef DEBUG_ALLOCATE_MEMORY + printf("Allocating %lu bytes for %s...\n", size, description); +#endif + if (ext2fs_get_memzero(size, &ret)) { + sprintf(buf, "Can't allocate %lu bytes for %s\n", + size, description); + fatal_error(ctx, buf); + } + + return ret; +} + +char *string_copy(e2fsck_t ctx EXT2FS_ATTR((unused)), + const char *str, size_t 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(e2fsck_t ctx, const char * string, int def) +{ + int c; + const char *defstr; + const char *short_yes = _("yY"); + const char *short_no = _("nN"); + const char *short_yesall = _("aA"); + const char *english_yes = "yY"; + const char *english_no = "nN"; + const char *english_yesall = "aA"; + const char *yesall_prompt = _(" ('a' enables 'yes' to all) "); + const char *extra_prompt = ""; + static int yes_answers; + +#ifdef HAVE_TERMIOS_H + struct termios termios, tmp; + + if (tcgetattr (0, &termios) < 0) + memset(&termios, 0, sizeof(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)"); + /* + * If the user presses 'y' more than 8 (but less than 12) times in + * succession without pressing anything else, display a hint about + * yes-to-all mode. + */ + if (yes_answers > 12) + yes_answers = -1; + else if (yes_answers > 8) + extra_prompt = yesall_prompt; + log_out(ctx, "%s%s%s? ", string, extra_prompt, 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 (ctx->flags & E2F_FLAG_SETJMP_OK) { + log_out(ctx, "\n"); + longjmp(e2fsck_global_ctx->abort_loc, 1); + } + log_out(ctx, "%s", _("cancelled!\n")); + yes_answers = 0; + return 0; + } + if (strchr(short_yes, (char) c)) { + do_yes: + def = 1; + if (yes_answers >= 0) + yes_answers++; + break; + } else if (strchr(short_no, (char) c)) { + do_no: + def = 0; + yes_answers = -1; + break; + } else if (strchr(short_yesall, (char)c)) { + do_all: + def = 2; + yes_answers = -1; + ctx->options |= E2F_OPT_YES; + break; + } else if (strchr(english_yes, (char) c)) { + goto do_yes; + } else if (strchr(english_no, (char) c)) { + goto do_no; + } else if (strchr(english_yesall, (char) c)) { + goto do_all; + } else if ((c == 27 || c == ' ' || c == '\n') && (def != -1)) { + yes_answers = -1; + break; + } + } + if (def == 2) + log_out(ctx, "%s", _("yes to all\n")); + else if (def) + log_out(ctx, "%s", _("yes\n")); + else + log_out(ctx, "%s", _("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) { + log_out(ctx, _("%s? no\n\n"), string); + return 0; + } + if (ctx->options & E2F_OPT_YES) { + log_out(ctx, _("%s? yes\n\n"), string); + return 1; + } + if (ctx->options & E2F_OPT_PREEN) { + log_out(ctx, "%s? %s\n\n", string, def ? _("yes") : _("no")); + return def; + } + return ask_yn(ctx, string, def); +} + +void e2fsck_read_bitmaps(e2fsck_t ctx) +{ + ext2_filsys fs = ctx->fs; + errcode_t retval; + const char *old_op; + unsigned int save_type; + int flags; + + 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); + } + + old_op = ehandler_operation(_("reading inode and block bitmaps")); + e2fsck_set_bitmap_type(fs, EXT2FS_BMAP64_RBTREE, "fs_bitmaps", + &save_type); + flags = ctx->fs->flags; + ctx->fs->flags |= EXT2_FLAG_IGNORE_CSUM_ERRORS; + retval = ext2fs_read_bitmaps(fs); + ctx->fs->flags = (flags & EXT2_FLAG_IGNORE_CSUM_ERRORS) | + (ctx->fs->flags & ~EXT2_FLAG_IGNORE_CSUM_ERRORS); + fs->default_bitmap_type = save_type; + ehandler_operation(old_op); + 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; + const char *old_op; + + old_op = ehandler_operation(_("writing block and inode bitmaps")); + retval = ext2fs_write_bitmaps(fs); + ehandler_operation(old_op); + if (retval) { + com_err(ctx->program_name, retval, + _("while rewriting block and 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; + log_err(ctx, _("\n\n%s: UNEXPECTED INCONSISTENCY; " + "RUN fsck MANUALLY.\n\t(i.e., without -a or -p options)\n"), + ctx->device_name); + ctx->flags |= E2F_FLAG_EXITING; + if (fs != NULL) { + fs->super->s_state |= EXT2_ERROR_FS; + ext2fs_mark_super_dirty(fs); + ext2fs_close_free(&fs); + } + exit(FSCK_UNCORRECTED); +} + +#ifdef RESOURCE_TRACK +void init_resource_track(struct resource_track *track, io_channel channel) +{ +#ifdef HAVE_GETRUSAGE + struct rusage r; +#endif + io_stats io_start = 0; + + 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 + track->bytes_read = 0; + track->bytes_written = 0; + if (channel && channel->manager && channel->manager->get_stats) + channel->manager->get_stats(channel, &io_start); + if (io_start) { + track->bytes_read = io_start->bytes_read; + track->bytes_written = io_start->bytes_written; + } +} + +#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(e2fsck_t ctx, const char *desc, + struct resource_track *track, io_channel channel) +{ +#ifdef HAVE_GETRUSAGE + struct rusage r; +#endif + struct timeval time_end; + + if ((desc && !(ctx->options & E2F_OPT_TIME2)) || + (!desc && !(ctx->options & E2F_OPT_TIME))) + return; + + e2fsck_clear_progbar(ctx); + gettimeofday(&time_end, 0); + + if (desc) + log_out(ctx, "%s: ", desc); + +#define kbytes(x) (((unsigned long long)(x) + 1023) / 1024) +#ifdef HAVE_MALLINFO2 + if (1) { + struct mallinfo2 malloc_info = mallinfo2(); + + log_out(ctx, _("Memory used: %lluk/%lluk (%lluk/%lluk), "), + kbytes(malloc_info.arena), kbytes(malloc_info.hblkhd), + kbytes(malloc_info.uordblks), + kbytes(malloc_info.fordblks)); + } else +#elif defined HAVE_MALLINFO + /* don't use mallinfo() if over 2GB used, since it returns "int" */ + if ((char *)sbrk(0) - (char *)track->brk_start < 2LL << 30) { + struct mallinfo malloc_info = mallinfo(); + + log_out(ctx, _("Memory used: %lluk/%lluk (%lluk/%lluk), "), + kbytes(malloc_info.arena), kbytes(malloc_info.hblkhd), + kbytes(malloc_info.uordblks), + kbytes(malloc_info.fordblks)); + } else +#endif + log_out(ctx, _("Memory used: %lluk, "), + kbytes(((char *)sbrk(0)) - ((char *)track->brk_start))); + +#ifdef HAVE_GETRUSAGE + getrusage(RUSAGE_SELF, &r); + + log_out(ctx, _("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 + log_out(ctx, _("elapsed time: %6.3f\n"), + timeval_subtract(&time_end, &track->time_start)); +#endif +#define mbytes(x) (((x) + 1048575) / 1048576) + if (channel && channel->manager && channel->manager->get_stats) { + io_stats delta = 0; + unsigned long long bytes_read = 0; + unsigned long long bytes_written = 0; + + if (desc) + log_out(ctx, "%s: ", desc); + + channel->manager->get_stats(channel, &delta); + if (delta) { + bytes_read = delta->bytes_read - track->bytes_read; + bytes_written = delta->bytes_written - + track->bytes_written; + } + log_out(ctx, "I/O read: %lluMB, write: %lluMB, " + "rate: %.2fMB/s\n", + mbytes(bytes_read), mbytes(bytes_written), + (double)mbytes(bytes_read + bytes_written) / + timeval_subtract(&time_end, &track->time_start)); + } +} +#endif /* RESOURCE_TRACK */ + +void e2fsck_read_inode(e2fsck_t ctx, unsigned long ino, + struct ext2_inode * inode, const char *proc) +{ + errcode_t retval; + + retval = ext2fs_read_inode(ctx->fs, ino, inode); + if (retval) { + com_err("ext2fs_read_inode", retval, + _("while reading inode %lu in %s"), ino, proc); + fatal_error(ctx, 0); + } +} + +void e2fsck_read_inode_full(e2fsck_t ctx, unsigned long ino, + struct ext2_inode *inode, int bufsize, + const char *proc) +{ + errcode_t retval; + + retval = ext2fs_read_inode_full(ctx->fs, ino, inode, bufsize); + if (retval) { + com_err("ext2fs_read_inode_full", retval, + _("while reading inode %lu in %s"), ino, proc); + fatal_error(ctx, 0); + } +} + +void e2fsck_write_inode_full(e2fsck_t ctx, unsigned long ino, + struct ext2_inode * inode, int bufsize, + const char *proc) +{ + errcode_t retval; + + retval = ext2fs_write_inode_full(ctx->fs, ino, inode, bufsize); + if (retval) { + com_err("ext2fs_write_inode", retval, + _("while writing inode %lu in %s"), ino, proc); + fatal_error(ctx, 0); + } +} + +void e2fsck_write_inode(e2fsck_t ctx, unsigned long ino, + struct ext2_inode * inode, const char *proc) +{ + errcode_t retval; + + retval = ext2fs_write_inode(ctx->fs, ino, inode); + if (retval) { + com_err("ext2fs_write_inode", retval, + _("while writing inode %lu 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 + +blk64_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; + blk64_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_blk64(io, superblock, + -SUPERBLOCK_SIZE, buf)) + continue; +#ifdef WORDS_BIGENDIAN + if (sb->s_magic == ext2fs_swab16(EXT2_SUPER_MAGIC)) + ext2fs_swap_super(sb); +#endif + if ((sb->s_magic == EXT2_SUPER_MAGIC) && + (EXT2_BLOCK_SIZE(sb) == blocksize)) { + 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; +} + +/* + * Check to see if a filesystem is in /proc/filesystems. + * Returns 1 if found, 0 if not + */ +int fs_proc_check(const char *fs_name) +{ + FILE *f; + char buf[80], *cp, *t; + + f = fopen("/proc/filesystems", "r"); + if (!f) + return (0); + while (!feof(f)) { + if (!fgets(buf, sizeof(buf), f)) + break; + cp = buf; + if (!isspace(*cp)) { + while (*cp && !isspace(*cp)) + cp++; + } + while (*cp && isspace(*cp)) + cp++; + if ((t = strchr(cp, '\n')) != NULL) + *t = 0; + if ((t = strchr(cp, '\t')) != NULL) + *t = 0; + if ((t = strchr(cp, ' ')) != NULL) + *t = 0; + if (!strcmp(fs_name, cp)) { + fclose(f); + return (1); + } + } + fclose(f); + return (0); +} + +/* + * Check to see if a filesystem is available as a module + * Returns 1 if found, 0 if not + */ +int check_for_modules(const char *fs_name) +{ +#ifdef __linux__ + struct utsname uts; + FILE *f; + char buf[1024], *cp, *t; + int i; + + if (uname(&uts)) + return (0); + snprintf(buf, sizeof(buf), "/lib/modules/%s/modules.dep", uts.release); + + f = fopen(buf, "r"); + if (!f) + return (0); + while (!feof(f)) { + if (!fgets(buf, sizeof(buf), f)) + break; + if ((cp = strchr(buf, ':')) != NULL) + *cp = 0; + else + continue; + if ((cp = strrchr(buf, '/')) != NULL) + cp++; + else + cp = buf; + i = strlen(cp); + if (i > 3) { + t = cp + i - 3; + if (!strcmp(t, ".ko")) + *t = 0; + } + if (!strcmp(cp, fs_name)) { + fclose(f); + return (1); + } + } + fclose(f); +#endif /* __linux__ */ + return (0); +} + +/* + * Helper function that does the right thing if write returns a + * partial write, or an EAGAIN/EINTR error. + */ +int write_all(int fd, char *buf, size_t count) +{ + ssize_t ret; + int c = 0; + + while (count > 0) { + ret = write(fd, buf, count); + if (ret < 0) { + if ((errno == EAGAIN) || (errno == EINTR)) + continue; + return -1; + } + count -= ret; + buf += ret; + c += ret; + } + return c; +} + +void dump_mmp_msg(struct mmp_struct *mmp, const char *fmt, ...) +{ + va_list pvar; + + if (fmt) { + printf("MMP check failed: "); + va_start(pvar, fmt); + vprintf(fmt, pvar); + va_end(pvar); + } + if (mmp) { + time_t t = mmp->mmp_time; + + printf("MMP_block:\n"); + printf(" mmp_magic: 0x%x\n", mmp->mmp_magic); + printf(" mmp_check_interval: %d\n", + mmp->mmp_check_interval); + printf(" mmp_sequence: %08x\n", mmp->mmp_seq); + printf(" mmp_update_date: %s", ctime(&t)); + printf(" mmp_update_time: %lld\n", + (long long) mmp->mmp_time); + printf(" mmp_node_name: %.*s\n", + EXT2_LEN_STR(mmp->mmp_nodename)); + printf(" mmp_device_name: %.*s\n", + EXT2_LEN_STR(mmp->mmp_bdevname)); + } +} + +errcode_t e2fsck_mmp_update(ext2_filsys fs) +{ + errcode_t retval; + + retval = ext2fs_mmp_update(fs); + if (retval == EXT2_ET_MMP_CHANGE_ABORT) + dump_mmp_msg(fs->mmp_cmp, + _("UNEXPECTED INCONSISTENCY: the filesystem is " + "being modified while fsck is running.\n")); + + return retval; +} + +void e2fsck_set_bitmap_type(ext2_filsys fs, unsigned int default_type, + const char *profile_name, unsigned int *old_type) +{ + unsigned type; + e2fsck_t ctx = (e2fsck_t) fs->priv_data; + + if (old_type) + *old_type = fs->default_bitmap_type; + profile_get_uint(ctx->profile, "bitmaps", profile_name, 0, + default_type, &type); + profile_get_uint(ctx->profile, "bitmaps", "all", 0, type, &type); + fs->default_bitmap_type = type ? type : default_type; +} + +errcode_t e2fsck_allocate_inode_bitmap(ext2_filsys fs, const char *descr, + int deftype, + const char *name, + ext2fs_inode_bitmap *ret) +{ + errcode_t retval; + unsigned int save_type; + + e2fsck_set_bitmap_type(fs, deftype, name, &save_type); + retval = ext2fs_allocate_inode_bitmap(fs, descr, ret); + fs->default_bitmap_type = save_type; + return retval; +} + +errcode_t e2fsck_allocate_block_bitmap(ext2_filsys fs, const char *descr, + int deftype, + const char *name, + ext2fs_block_bitmap *ret) +{ + errcode_t retval; + unsigned int save_type; + + e2fsck_set_bitmap_type(fs, deftype, name, &save_type); + retval = ext2fs_allocate_block_bitmap(fs, descr, ret); + fs->default_bitmap_type = save_type; + return retval; +} + +errcode_t e2fsck_allocate_subcluster_bitmap(ext2_filsys fs, const char *descr, + int deftype, + const char *name, + ext2fs_block_bitmap *ret) +{ + errcode_t retval; + unsigned int save_type; + + e2fsck_set_bitmap_type(fs, deftype, name, &save_type); + retval = ext2fs_allocate_subcluster_bitmap(fs, descr, ret); + fs->default_bitmap_type = save_type; + return retval; +} + +/* Return memory size in bytes */ +unsigned long long get_memory_size(void) +{ +#if defined(_SC_PHYS_PAGES) +# if defined(_SC_PAGESIZE) + return (unsigned long long)sysconf(_SC_PHYS_PAGES) * + (unsigned long long)sysconf(_SC_PAGESIZE); +# elif defined(_SC_PAGE_SIZE) + return (unsigned long long)sysconf(_SC_PHYS_PAGES) * + (unsigned long long)sysconf(_SC_PAGE_SIZE); +# endif +#elif defined(CTL_HW) +# if (defined(HW_MEMSIZE) || defined(HW_PHYSMEM64)) +# define CTL_HW_INT64 +# elif (defined(HW_PHYSMEM) || defined(HW_REALMEM)) +# define CTL_HW_UINT +# endif + int mib[2]; + + mib[0] = CTL_HW; +# if defined(HW_MEMSIZE) + mib[1] = HW_MEMSIZE; +# elif defined(HW_PHYSMEM64) + mib[1] = HW_PHYSMEM64; +# elif defined(HW_REALMEM) + mib[1] = HW_REALMEM; +# elif defined(HW_PYSMEM) + mib[1] = HW_PHYSMEM; +# endif +# if defined(CTL_HW_INT64) + unsigned long long size = 0; +# elif defined(CTL_HW_UINT) + unsigned int size = 0; +# endif + return 0; +#else +# warning "Don't know how to detect memory on your platform?" + return 0; +#endif +} -- cgit v1.2.3