193 files changed, 80411 insertions, 44563 deletions
diff --git a/ntfsprogs/ntfsfix.c b/ntfsprogs/ntfsfix.c new file mode 100755 index 0000000..eaf474c --- a/dev/null +++ b/ntfsprogs/ntfsfix.c @@ -0,0 +1,1657 @@ +/** + * ntfsfix - Part of the Linux-NTFS project. + * + * Copyright (c) 2000-2006 Anton Altaparmakov + * Copyright (c) 2002-2006 Szabolcs Szakacsits + * Copyright (c) 2007 Yura Pakhuchiy + * Copyright (c) 2011-2012 Jean-Pierre Andre + * + * This utility fixes some common NTFS problems, resets the NTFS journal file + * and schedules an NTFS consistency check for the first boot into Windows. + * + * Anton Altaparmakov <aia21@cantab.net> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program (in the main directory of the Linux-NTFS source + * in the file COPYING); if not, write to the Free Software Foundation, + * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +/* + * WARNING: This program might not work on architectures which do not allow + * unaligned access. For those, the program would need to start using + * get/put_unaligned macros (#include <asm/unaligned.h>), but not doing it yet, + * since NTFS really mostly applies to ia32 only, which does allow unaligned + * accesses. We might not actually have a problem though, since the structs are + * defined as being packed so that might be enough for gcc to insert the + * correct code. + * + * If anyone using a non-little endian and/or an aligned access only CPU tries + * this program please let me know whether it works or not! + * + * Anton Altaparmakov <aia21@cantab.net> + */ + +#include "config.h" + +#ifdef HAVE_UNISTD_H +#include <unistd.h> +#endif +#ifdef HAVE_STDLIB_H +#include <stdlib.h> +#endif +#ifdef HAVE_STDIO_H +#include <stdio.h> +#endif +#ifdef HAVE_FCNTL_H +#include <fcntl.h> +#endif +#ifdef HAVE_ERRNO_H +#include <errno.h> +#endif +#ifdef HAVE_STRING_H +#include <string.h> +#endif +#ifdef HAVE_GETOPT_H +#include <getopt.h> +#endif + +#include "types.h" +#include "attrib.h" +#include "volume.h" +#include "bootsect.h" +#include "mft.h" +#include "device.h" +#include "logfile.h" +#include "runlist.h" +#include "mst.h" +#include "utils.h" +/* #include "version.h" */ +#include "logging.h" +#include "misc.h" + +#ifdef NO_NTFS_DEVICE_DEFAULT_IO_OPS +# error "No default device io operations! Cannot build ntfsfix. \ +You need to run ./configure without the --disable-default-device-io-ops \ +switch if you want to be able to build the NTFS utilities." +#endif + +static const char *EXEC_NAME = "ntfsfix"; +static const char OK[] = "OK\n"; +static const char FAILED[] = "FAILED\n"; +static const char FOUND[] = "FOUND\n"; + +#define DEFAULT_SECTOR_SIZE 512 + +static struct { + char *volume; + BOOL no_action; + BOOL clear_bad_sectors; + BOOL clear_dirty; +} opt; + +/* + * Definitions for fixing the self-located MFT bug + */ + +#define SELFLOC_LIMIT 16 + +struct MFT_SELF_LOCATED { + ntfs_volume *vol; + MFT_RECORD *mft0; + MFT_RECORD *mft1; + MFT_RECORD *mft2; + ATTR_LIST_ENTRY *attrlist; + ATTR_LIST_ENTRY *attrlist_to_ref1; + MFT_REF mft_ref0; + MFT_REF mft_ref1; + LCN attrlist_lcn; + BOOL attrlist_resident; +} ; + +/** + * usage + */ +__attribute__((noreturn)) +static void usage(void) +{ + ntfs_log_info("%s v%s (libntfs-3g)\n" + "\n" + "Usage: %s [options] device\n" + " Attempt to fix an NTFS partition.\n" + "\n" + " -b, --clear-bad-sectors Clear the bad sector list\n" + " -d, --clear-dirty Clear the volume dirty flag\n" + " -h, --help Display this help\n" + " -n, --no-action Do not write anything\n" + " -V, --version Display version information\n" + "\n" + "For example: %s /dev/hda6\n\n", + EXEC_NAME, VERSION, EXEC_NAME, + EXEC_NAME); + ntfs_log_info("%s%s", ntfs_bugs, ntfs_home); + exit(1); +} + +/** + * version + */ +__attribute__((noreturn)) +static void version(void) +{ + ntfs_log_info("%s v%s\n\n" + "Attempt to fix an NTFS partition.\n\n" + "Copyright (c) 2000-2006 Anton Altaparmakov\n" + "Copyright (c) 2002-2006 Szabolcs Szakacsits\n" + "Copyright (c) 2007 Yura Pakhuchiy\n\n" + "Copyright (c) 2011 Jean-Pierre Andre\n\n", + EXEC_NAME, VERSION); + ntfs_log_info("%s\n%s%s", ntfs_gpl, ntfs_bugs, ntfs_home); + exit(1); +} + +/** + * parse_options + */ +static void parse_options(int argc, char **argv) +{ + int c; + static const char *sopt = "-bdhnV"; + static const struct option lopt[] = { + { "help", no_argument, NULL, 'h' }, + { "no-action", no_argument, NULL, 'n' }, + { "clear-bad-sectors", no_argument, NULL, 'b' }, + { "clear-dirty", no_argument, NULL, 'd' }, + { "version", no_argument, NULL, 'V' }, + { NULL, 0, NULL, 0 } + }; + + memset(&opt, 0, sizeof(opt)); + + while ((c = getopt_long(argc, argv, sopt, lopt, NULL)) != -1) { + switch (c) { + case 1: /* A non-option argument */ + if (!opt.volume) + opt.volume = argv[optind - 1]; + else { + ntfs_log_info("ERROR: Too many arguments.\n"); + usage(); + } + break; + case 'b': + opt.clear_bad_sectors = TRUE; + break; + case 'd': + opt.clear_dirty = TRUE; + break; + case 'n': + opt.no_action = TRUE; + break; + case 'h': + case '?': + usage(); + /* fall through */ + case 'V': + version(); + default: + ntfs_log_info("ERROR: Unknown option '%s'.\n", argv[optind - 1]); + usage(); + } + } + + if (opt.volume == NULL) { + ntfs_log_info("ERROR: You must specify a device.\n"); + usage(); + } +} + +/** + * OLD_ntfs_volume_set_flags + */ +static int OLD_ntfs_volume_set_flags(ntfs_volume *vol, const le16 flags) +{ + MFT_RECORD *m = NULL; + ATTR_RECORD *a; + VOLUME_INFORMATION *c; + ntfs_attr_search_ctx *ctx; + int ret = -1; /* failure */ + + if (!vol) { + errno = EINVAL; + return -1; + } + if (ntfs_file_record_read(vol, FILE_Volume, &m, NULL)) { + ntfs_log_perror("Failed to read $Volume"); + return -1; + } + /* Sanity check */ + if (!(m->flags & MFT_RECORD_IN_USE)) { + ntfs_log_error("$Volume has been deleted. Cannot handle this " + "yet. Run chkdsk to fix this.\n"); + errno = EIO; + goto err_exit; + } + /* Get a pointer to the volume information attribute. */ + ctx = ntfs_attr_get_search_ctx(NULL, m); + if (!ctx) { + ntfs_log_debug("Failed to allocate attribute search " + "context.\n"); + goto err_exit; + } + if (ntfs_attr_lookup(AT_VOLUME_INFORMATION, AT_UNNAMED, 0, + CASE_SENSITIVE, 0, NULL, 0, ctx)) { + ntfs_log_error("Attribute $VOLUME_INFORMATION was not found in " + "$Volume!\n"); + goto err_out; + } + a = ctx->attr; + /* Sanity check. */ + if (a->non_resident) { + ntfs_log_error("Attribute $VOLUME_INFORMATION must be resident " + "(and it isn't)!\n"); + errno = EIO; + goto err_out; + } + /* Get a pointer to the value of the attribute. */ + c = (VOLUME_INFORMATION*)(le16_to_cpu(a->value_offset) + (char*)a); + /* Sanity checks. */ + if ((char*)c + le32_to_cpu(a->value_length) > + (char*)m + le32_to_cpu(m->bytes_in_use) || + le16_to_cpu(a->value_offset) + + le32_to_cpu(a->value_length) > le32_to_cpu(a->length)) { + ntfs_log_error("Attribute $VOLUME_INFORMATION in $Volume is " + "corrupt!\n"); + errno = EIO; + goto err_out; + } + /* Set the volume flags. */ + vol->flags = c->flags = flags; + if (ntfs_mft_record_write(vol, FILE_Volume, m)) { + ntfs_log_perror("Error writing $Volume"); + goto err_out; + } + ret = 0; /* success */ +err_out: + ntfs_attr_put_search_ctx(ctx); +err_exit: + free(m); + return ret; +} + +/** + * set_dirty_flag + */ +static int set_dirty_flag(ntfs_volume *vol) +{ + le16 flags; + + /* Porting note: We test for the current state of VOLUME_IS_DIRTY. This + * should actually be more appropriate than testing for NVolWasDirty. */ + if (vol->flags & VOLUME_IS_DIRTY) + return 0; + ntfs_log_info("Setting required flags on partition... "); + /* + * Set chkdsk flag, i.e. mark the partition dirty so chkdsk will run + * and fix it for us. + */ + flags = vol->flags | VOLUME_IS_DIRTY; + if (!opt.no_action && OLD_ntfs_volume_set_flags(vol, flags)) { + ntfs_log_info(FAILED); + ntfs_log_error("Error setting volume flags.\n"); + return -1; + } + vol->flags = flags; + + /* Porting note: libntfs-3g does not have the 'WasDirty' flag/property, + * and never touches the 'dirty' bit except when explicitly told to do + * so. Since we just wrote the VOLUME_IS_DIRTY bit to disk, and + * vol->flags is up-to-date, we can just ignore the NVolSetWasDirty + * statement. */ + /* NVolSetWasDirty(vol); */ + + ntfs_log_info(OK); + return 0; +} + +/** + * empty_journal + */ +static int empty_journal(ntfs_volume *vol) +{ + if (NVolLogFileEmpty(vol)) + return 0; + ntfs_log_info("Going to empty the journal ($LogFile)... "); + if (ntfs_logfile_reset(vol)) { + ntfs_log_info(FAILED); + ntfs_log_perror("Failed to reset $LogFile"); + return -1; + } + ntfs_log_info(OK); + return 0; +} + +/** + * Clear the bad cluster marks (option) + */ +static int clear_badclus(ntfs_volume *vol) +{ + static ntfschar badstream[] = { + const_cpu_to_le16('$'), const_cpu_to_le16('B'), + const_cpu_to_le16('a'), const_cpu_to_le16('d') + } ; + ntfs_inode *ni; + ntfs_attr *na; + BOOL ok; + + ok = FALSE; + ntfs_log_info("Going to un-mark the bad clusters ($BadClus)... "); + ni = ntfs_inode_open(vol, FILE_BadClus); + if (ni) { + na = ntfs_attr_open(ni, AT_DATA, badstream, 4); + /* + * chkdsk does not adjust the data size when + * moving clusters to $BadClus, so we have to + * check the runlist. + */ + if (na && !ntfs_attr_map_whole_runlist(na)) { + if (na->rl + && na->rl[0].length && na->rl[1].length) { + /* + * Truncate the stream to free all its clusters, + * (which requires setting the data size according + * to allocation), then reallocate a sparse stream + * to full size of volume and reset the data size. + */ + na->data_size = na->allocated_size; + na->initialized_size = na->allocated_size; + if (!ntfs_attr_truncate(na,0) + && !ntfs_attr_truncate(na,vol->nr_clusters + << vol->cluster_size_bits)) { + na->data_size = 0; + na->initialized_size = 0; + ni->flags |= FILE_ATTR_SPARSE_FILE; + NInoFileNameSetDirty(ni); + ok = TRUE; + } else { + ntfs_log_perror("Failed to un-mark the bad clusters"); + } + } else { + ntfs_log_info("No bad clusters..."); + ok = TRUE; + } + ntfs_attr_close(na); + } else { + ntfs_log_perror("Failed to open $BadClus::$Bad"); + } + ntfs_inode_close(ni); + } else { + ntfs_log_perror("Failed to open inode FILE_BadClus"); + } + if (ok) + ntfs_log_info(OK); + return (ok ? 0 : -1); +} + +/** + * fix_mftmirr + */ +static int fix_mftmirr(ntfs_volume *vol) +{ + s64 l, br; + unsigned char *m, *m2; + int i, ret = -1; /* failure */ + BOOL done; + + ntfs_log_info("\nProcessing $MFT and $MFTMirr...\n"); + + /* Load data from $MFT and $MFTMirr and compare the contents. */ + m = (u8*)malloc(vol->mftmirr_size << vol->mft_record_size_bits); + if (!m) { + ntfs_log_perror("Failed to allocate memory"); + return -1; + } + m2 = (u8*)malloc(vol->mftmirr_size << vol->mft_record_size_bits); + if (!m2) { + ntfs_log_perror("Failed to allocate memory"); + free(m); + return -1; + } + + ntfs_log_info("Reading $MFT... "); + l = ntfs_attr_mst_pread(vol->mft_na, 0, vol->mftmirr_size, + vol->mft_record_size, m); + if (l != vol->mftmirr_size) { + ntfs_log_info(FAILED); + if (l != -1) + errno = EIO; + ntfs_log_perror("Failed to read $MFT"); + goto error_exit; + } + ntfs_log_info(OK); + + ntfs_log_info("Reading $MFTMirr... "); + l = ntfs_attr_mst_pread(vol->mftmirr_na, 0, vol->mftmirr_size, + vol->mft_record_size, m2); + if (l != vol->mftmirr_size) { + ntfs_log_info(FAILED); + if (l != -1) + errno = EIO; + ntfs_log_perror("Failed to read $MFTMirr"); + goto error_exit; + } + ntfs_log_info(OK); + + /* + * FIXME: Need to actually check the $MFTMirr for being real. Otherwise + * we might corrupt the partition if someone is experimenting with + * software RAID and the $MFTMirr is not actually in the position we + * expect it to be... )-: + * FIXME: We should emit a warning it $MFTMirr is damaged and ask + * user whether to recreate it from $MFT or whether to abort. - The + * warning needs to include the danger of software RAID arrays. + * Maybe we should go as far as to detect whether we are running on a + * MD disk and if yes then bomb out right at the start of the program? + */ + + ntfs_log_info("Comparing $MFTMirr to $MFT... "); + done = FALSE; + for (i = 0; i < vol->mftmirr_size; ++i) { + MFT_RECORD *mrec, *mrec2; + const char *ESTR[12] = { "$MFT", "$MFTMirr", "$LogFile", + "$Volume", "$AttrDef", "root directory", "$Bitmap", + "$Boot", "$BadClus", "$Secure", "$UpCase", "$Extend" }; + const char *s; + BOOL use_mirr; + + if (i < 12) + s = ESTR[i]; + else if (i < 16) + s = "system file"; + else + s = "mft record"; + + use_mirr = FALSE; + mrec = (MFT_RECORD*)(m + i * vol->mft_record_size); + if (mrec->flags & MFT_RECORD_IN_USE) { + if (ntfs_is_baad_record(mrec->magic)) { + ntfs_log_info(FAILED); + ntfs_log_error("$MFT error: Incomplete multi " + "sector transfer detected in " + "%s.\nCannot handle this yet. " + ")-:\n", s); + goto error_exit; + } + if (!ntfs_is_mft_record(mrec->magic)) { + ntfs_log_info(FAILED); + ntfs_log_error("$MFT error: Invalid mft " + "record for %s.\nCannot " + "handle this yet. )-:\n", s); + goto error_exit; + } + } + mrec2 = (MFT_RECORD*)(m2 + i * vol->mft_record_size); + if (mrec2->flags & MFT_RECORD_IN_USE) { + if (ntfs_is_baad_record(mrec2->magic)) { + ntfs_log_info(FAILED); + ntfs_log_error("$MFTMirr error: Incomplete " + "multi sector transfer " + "detected in %s.\n", s); + goto error_exit; + } + if (!ntfs_is_mft_record(mrec2->magic)) { + ntfs_log_info(FAILED); + ntfs_log_error("$MFTMirr error: Invalid mft " + "record for %s.\n", s); + goto error_exit; + } + /* $MFT is corrupt but $MFTMirr is ok, use $MFTMirr. */ + if (!(mrec->flags & MFT_RECORD_IN_USE) && + !ntfs_is_mft_record(mrec->magic)) + use_mirr = TRUE; + } + if (memcmp(mrec, mrec2, ntfs_mft_record_get_data_size(mrec))) { + if (!done) { + done = TRUE; + ntfs_log_info(FAILED); + } + ntfs_log_info("Correcting differences in $MFT%s " + "record %d...", use_mirr ? "" : "Mirr", + i); + br = ntfs_mft_record_write(vol, i, + use_mirr ? mrec2 : mrec); + if (br) { + ntfs_log_info(FAILED); + ntfs_log_perror("Error correcting $MFT%s", + use_mirr ? "" : "Mirr"); + goto error_exit; + } + ntfs_log_info(OK); + } + } + if (!done) + ntfs_log_info(OK); + ntfs_log_info("Processing of $MFT and $MFTMirr completed " + "successfully.\n"); + ret = 0; +error_exit: + free(m); + free(m2); + return ret; +} + +/* + * Rewrite the $UpCase file as default + * + * Returns 0 if could be written + */ + +static int rewrite_upcase(ntfs_volume *vol, ntfs_attr *na) +{ + s64 l; + int res; + + /* writing the $UpCase may require bitmap updates */ + res = -1; + vol->lcnbmp_ni = ntfs_inode_open(vol, FILE_Bitmap); + if (!vol->lcnbmp_ni) { + ntfs_log_perror("Failed to open bitmap inode"); + } else { + vol->lcnbmp_na = ntfs_attr_open(vol->lcnbmp_ni, AT_DATA, + AT_UNNAMED, 0); + if (!vol->lcnbmp_na) { + ntfs_log_perror("Failed to open bitmap data attribute"); + } else { + /* minimal consistency check on the bitmap */ + if (((vol->lcnbmp_na->data_size << 3) + < vol->nr_clusters) + || ((vol->lcnbmp_na->data_size << 3) + >= (vol->nr_clusters << 1)) + || (vol->lcnbmp_na->data_size + > vol->lcnbmp_na->allocated_size)) { + ntfs_log_error("Corrupt cluster map size %lld" + " (allocated %lld minimum %lld)\n", + (long long)vol->lcnbmp_na->data_size, + (long long)vol->lcnbmp_na->allocated_size, + (long long)(vol->nr_clusters + 7) >> 3); + } else { + ntfs_log_info("Rewriting $UpCase file\n"); + l = ntfs_attr_pwrite(na, 0, vol->upcase_len*2, + vol->upcase); + if (l != vol->upcase_len*2) { + ntfs_log_error("Failed to rewrite $UpCase\n"); + } else { + ntfs_log_info("$UpCase has been set to default\n"); + res = 0; + } + } + ntfs_attr_close(vol->lcnbmp_na); + vol->lcnbmp_na = (ntfs_attr*)NULL; + } + ntfs_inode_close(vol->lcnbmp_ni); + vol->lcnbmp_ni = (ntfs_inode*)NULL; + } + return (res); +} + +/* + * Fix the $UpCase file + * + * Returns 0 if the table is valid or has been fixed + */ + +static int fix_upcase(ntfs_volume *vol) +{ + ntfs_inode *ni; + ntfs_attr *na; + ntfschar *upcase; + s64 l; + u32 upcase_len; + u32 k; + int res; + + res = -1; + ni = (ntfs_inode*)NULL; + na = (ntfs_attr*)NULL; + /* Now load the upcase table from $UpCase. */ + ntfs_log_debug("Loading $UpCase...\n"); + ni = ntfs_inode_open(vol, FILE_UpCase); + if (!ni) { + ntfs_log_perror("Failed to open inode FILE_UpCase"); + goto error_exit; + } + /* Get an ntfs attribute for $UpCase/$DATA. */ + na = ntfs_attr_open(ni, AT_DATA, AT_UNNAMED, 0); + if (!na) { + ntfs_log_perror("Failed to open ntfs attribute"); + goto error_exit; + } + /* + * Note: Normally, the upcase table has a length equal to 65536 + * 2-byte Unicode characters but allow for different cases, so no + * checks done. Just check we don't overflow 32-bits worth of Unicode + * characters. + */ + if (na->data_size & ~0x1ffffffffULL) { + ntfs_log_error("Error: Upcase table is too big (max 32-bit " + "allowed).\n"); + errno = EINVAL; + goto error_exit; + } + upcase_len = na->data_size >> 1; + upcase = (ntfschar*)ntfs_malloc(na->data_size); + if (!upcase) + goto error_exit; + /* Read in the $DATA attribute value into the buffer. */ + l = ntfs_attr_pread(na, 0, na->data_size, upcase); + if (l != na->data_size) { + ntfs_log_error("Failed to read $UpCase, unexpected length " + "(%lld != %lld).\n", (long long)l, + (long long)na->data_size); + errno = EIO; + goto error_exit; + } + /* Consistency check of $UpCase, restricted to plain ASCII chars */ + k = 0x20; + while ((k < upcase_len) + && (k < 0x7f) + && (le16_to_cpu(upcase[k]) + == ((k < 'a') || (k > 'z') ? k : k + 'A' - 'a'))) + k++; + if (k < 0x7f) { + ntfs_log_error("Corrupted file $UpCase\n"); + if (!opt.no_action) { + /* rewrite the $UpCase file from default */ + res = rewrite_upcase(vol, na); + /* free the bad upcase record */ + if (!res) + free(upcase); + } else { + /* keep the default upcase but return an error */ + free(upcase); + } + } else { + /* accept the upcase table read from $UpCase */ + free(vol->upcase); + vol->upcase = upcase; + vol->upcase_len = upcase_len; + res = 0; + } +error_exit : + /* Done with the $UpCase mft record. */ + if (na) + ntfs_attr_close(na); + if (ni && ntfs_inode_close(ni)) { + ntfs_log_perror("Failed to close $UpCase"); + } + return (res); +} + +/* + * Rewrite the boot sector + * + * Returns 0 if successful + */ + +static int rewrite_boot(struct ntfs_device *dev, char *full_bs, + s32 sector_size) +{ + s64 bw; + int res; + + res = -1; + ntfs_log_info("Rewriting the bootsector\n"); + bw = ntfs_pwrite(dev, 0, sector_size, full_bs); + if (bw == sector_size) + res = 0; + else { + if (bw != -1) + errno = EINVAL; + if (!bw) + ntfs_log_error("Failed to rewrite the bootsector (size=0)\n"); + else + ntfs_log_perror("Error rewriting the bootsector"); + } + return (res); +} + +/* + * Locate an unnamed attribute in an MFT record + * + * Returns NULL if not found (with no error message) + */ + +static ATTR_RECORD *find_unnamed_attr(MFT_RECORD *mrec, ATTR_TYPES type) +{ + ATTR_RECORD *a; + u32 offset; + + /* fetch the requested attribute */ + offset = le16_to_cpu(mrec->attrs_offset); + a = (ATTR_RECORD*)((char*)mrec + offset); + while ((a->type != AT_END) + && ((a->type != type) || a->name_length) + && (offset < le32_to_cpu(mrec->bytes_in_use))) { + offset += le32_to_cpu(a->length); + a = (ATTR_RECORD*)((char*)mrec + offset); + } + if ((a->type != type) + || a->name_length) + a = (ATTR_RECORD*)NULL; + return (a); +} + +/* + * First condition for having a self-located MFT : + * only 16 MFT records are defined in MFT record 0 + * + * Only low-level library functions can be used. + * + * Returns TRUE if the condition is met. + */ + +static BOOL short_mft_selfloc_condition(struct MFT_SELF_LOCATED *selfloc) +{ + BOOL ok; + ntfs_volume *vol; + MFT_RECORD *mft0; + ATTR_RECORD *a; + runlist_element *rl; + u16 seqn; + + ok = FALSE; + vol = selfloc->vol; + mft0 = selfloc->mft0; + if ((ntfs_pread(vol->dev, + vol->mft_lcn << vol->cluster_size_bits, + vol->mft_record_size, mft0) + == vol->mft_record_size) + && !ntfs_mst_post_read_fixup((NTFS_RECORD*)mft0, + vol->mft_record_size)) { + a = find_unnamed_attr(mft0,AT_DATA); + if (a + && a->non_resident + && (((le64_to_cpu(a->highest_vcn) + 1) + << vol->cluster_size_bits) + == (SELFLOC_LIMIT*vol->mft_record_size))) { + rl = ntfs_mapping_pairs_decompress(vol, a, NULL); + if (rl) { + /* + * The first error condition is having only + * 16 entries mapped in the first MFT record. + */ + if ((rl[0].lcn >= 0) + && ((rl[0].length << vol->cluster_size_bits) + == SELFLOC_LIMIT*vol->mft_record_size) + && (rl[1].vcn == rl[0].length) + && (rl[1].lcn == LCN_RL_NOT_MAPPED)) { + ok = TRUE; + seqn = le16_to_cpu( + mft0->sequence_number); + selfloc->mft_ref0 + = ((MFT_REF)seqn) << 48; + } + free(rl); + } + } + } + return (ok); +} + +/* + * Second condition for having a self-located MFT : + * The 16th MFT record is defined in MFT record >= 16 + * + * Only low-level library functions can be used. + * + * Returns TRUE if the condition is met. + */ + +static BOOL attrlist_selfloc_condition(struct MFT_SELF_LOCATED *selfloc) +{ + ntfs_volume *vol; + ATTR_RECORD *a; + ATTR_LIST_ENTRY *attrlist; + ATTR_LIST_ENTRY *al; + runlist_element *rl; + VCN vcn; + leVCN levcn; + u32 length; + int ok; + + ok = FALSE; + length = 0; + vol = selfloc->vol; + a = find_unnamed_attr(selfloc->mft0,AT_ATTRIBUTE_LIST); + if (a) { + selfloc->attrlist_resident = !a->non_resident; + selfloc->attrlist_lcn = 0; + if (a->non_resident) { + attrlist = selfloc->attrlist; + rl = ntfs_mapping_pairs_decompress(vol, a, NULL); + if (rl + && (rl->lcn >= 0) + && (le64_to_cpu(a->data_size) < vol->cluster_size) + && (ntfs_pread(vol->dev, + rl->lcn << vol->cluster_size_bits, + vol->cluster_size, attrlist) == vol->cluster_size)) { + selfloc->attrlist_lcn = rl->lcn; + al = attrlist; + length = le64_to_cpu(a->data_size); + } + } else { + al = (ATTR_LIST_ENTRY*) + ((char*)a + le16_to_cpu(a->value_offset)); + length = le32_to_cpu(a->value_length); + } + if (length) { + /* search for a data attribute defining entry 16 */ + vcn = (SELFLOC_LIMIT*vol->mft_record_size) + >> vol->cluster_size_bits; + levcn = cpu_to_le64(vcn); + while ((length > 0) + && al->length + && ((al->type != AT_DATA) + || ((leVCN)al->lowest_vcn != levcn))) { + length -= le16_to_cpu(al->length); + al = (ATTR_LIST_ENTRY*) + ((char*)al + le16_to_cpu(al->length)); + } + if ((length > 0) + && al->length + && (al->type == AT_DATA) + && !al->name_length + && ((leVCN)al->lowest_vcn == levcn) + && (MREF_LE(al->mft_reference) >= SELFLOC_LIMIT)) { + selfloc->mft_ref1 + = le64_to_cpu(al->mft_reference); + selfloc->attrlist_to_ref1 = al; + ok = TRUE; + } + } + } + return (ok); +} + +/* + * Third condition for having a self-located MFT : + * The location of the second part of the MFT is defined in itself + * + * To locate the second part, we have to assume the first and the + * second part of the MFT data are contiguous. + * + * Only low-level library functions can be used. + * + * Returns TRUE if the condition is met. + */ + +static BOOL self_mapped_selfloc_condition(struct MFT_SELF_LOCATED *selfloc) +{ + BOOL ok; + s64 inum; + u64 offs; + VCN lowest_vcn; + MFT_RECORD *mft1; + ATTR_RECORD *a; + ntfs_volume *vol; + runlist_element *rl; + + ok = FALSE; + vol = selfloc->vol; + mft1 = selfloc->mft1; + inum = MREF(selfloc->mft_ref1); + offs = (vol->mft_lcn << vol->cluster_size_bits) + + (inum << vol->mft_record_size_bits); + if ((ntfs_pread(vol->dev, offs, vol->mft_record_size, + mft1) == vol->mft_record_size) + && !ntfs_mst_post_read_fixup((NTFS_RECORD*)mft1, + vol->mft_record_size)) { + lowest_vcn = (SELFLOC_LIMIT*vol->mft_record_size) + >> vol->cluster_size_bits; + a = find_unnamed_attr(mft1,AT_DATA); + if (a + && (mft1->flags & MFT_RECORD_IN_USE) + && ((VCN)le64_to_cpu(a->lowest_vcn) == lowest_vcn) + && (le64_to_cpu(mft1->base_mft_record) + == selfloc->mft_ref0) + && ((u16)MSEQNO(selfloc->mft_ref1) + == le16_to_cpu(mft1->sequence_number))) { + rl = ntfs_mapping_pairs_decompress(vol, a, NULL); + if ((rl[0].lcn == LCN_RL_NOT_MAPPED) + && !rl[0].vcn + && (rl[0].length == lowest_vcn) + && (rl[1].vcn == lowest_vcn) + && ((u64)(rl[1].lcn << vol->cluster_size_bits) + <= offs) + && ((u64)((rl[1].lcn + rl[1].length) + << vol->cluster_size_bits) > offs)) { + ok = TRUE; + } + } + } + return (ok); +} + +/* + * Fourth condition, to be able to fix a self-located MFT : + * The MFT record 15 must be available. + * + * The MFT record 15 is expected to be marked in use, we assume + * it is available if it has no parent, no name and no attr list. + * + * Only low-level library functions can be used. + * + * Returns TRUE if the condition is met. + */ + +static BOOL spare_record_selfloc_condition(struct MFT_SELF_LOCATED *selfloc) +{ + BOOL ok; + s64 inum; + u64 offs; + MFT_RECORD *mft2; + ntfs_volume *vol; + + ok = FALSE; + vol = selfloc->vol; + mft2 = selfloc->mft2; + inum = SELFLOC_LIMIT - 1; + offs = (vol->mft_lcn << vol->cluster_size_bits) + + (inum << vol->mft_record_size_bits); + if ((ntfs_pread(vol->dev, offs, vol->mft_record_size, + mft2) == vol->mft_record_size) + && !ntfs_mst_post_read_fixup((NTFS_RECORD*)mft2, + vol->mft_record_size)) { + if (!mft2->base_mft_record + && (mft2->flags & MFT_RECORD_IN_USE) + && !find_unnamed_attr(mft2,AT_ATTRIBUTE_LIST) + && !find_unnamed_attr(mft2,AT_FILE_NAME)) { + ok = TRUE; + } + } + return (ok); +} + +/* + * Fix a self-located MFT by swapping two MFT records + * + * Only low-level library functions can be used. + * + * Returns 0 if the MFT corruption could be fixed. + */ +static int fix_selfloc_conditions(struct MFT_SELF_LOCATED *selfloc) +{ + MFT_RECORD *mft1; + MFT_RECORD *mft2; + ATTR_RECORD *a; + ATTR_LIST_ENTRY *al; + ntfs_volume *vol; + s64 offs; + s64 offsm; + s64 offs1; + s64 offs2; + s64 inum; + u16 usa_ofs; + int res; + + res = 0; + /* + * In MFT1, we must fix : + * - the self-reference, if present, + * - its own sequence number, must be 15 + * - the sizes of the data attribute. + */ + vol = selfloc->vol; + mft1 = selfloc->mft1; + mft2 = selfloc->mft2; + usa_ofs = le16_to_cpu(mft1->usa_ofs); + if (usa_ofs >= 48) + mft1->mft_record_number = const_cpu_to_le32(SELFLOC_LIMIT - 1); + mft1->sequence_number = const_cpu_to_le16(SELFLOC_LIMIT - 1); + a = find_unnamed_attr(mft1,AT_DATA); + if (a) { + a->allocated_size = const_cpu_to_le64(0); + a->data_size = const_cpu_to_le64(0); + a->initialized_size = const_cpu_to_le64(0); + } else + res = -1; /* bug : it has been found earlier */ + + /* + * In MFT2, we must fix : + * - the self-reference, if present + */ + usa_ofs = le16_to_cpu(mft2->usa_ofs); + if (usa_ofs >= 48) + mft2->mft_record_number = cpu_to_le32(MREF(selfloc->mft_ref1)); + + /* + * In the attribute list, we must fix : + * - the reference to MFT1 + */ + al = selfloc->attrlist_to_ref1; + al->mft_reference = MK_LE_MREF(SELFLOC_LIMIT - 1, SELFLOC_LIMIT - 1); + + /* + * All fixes done, we can write all if allowed + */ + if (!res && !opt.no_action) { + inum = SELFLOC_LIMIT - 1; + offs2 = (vol->mft_lcn << vol->cluster_size_bits) + + (inum << vol->mft_record_size_bits); + inum = MREF(selfloc->mft_ref1); + offs1 = (vol->mft_lcn << vol->cluster_size_bits) + + (inum << vol->mft_record_size_bits); + + /* rewrite the attribute list */ + if (selfloc->attrlist_resident) { + /* write mft0 and mftmirr if it is resident */ + offs = vol->mft_lcn << vol->cluster_size_bits; + offsm = vol->mftmirr_lcn << vol->cluster_size_bits; + if (ntfs_mst_pre_write_fixup( + (NTFS_RECORD*)selfloc->mft0, + vol->mft_record_size) + || (ntfs_pwrite(vol->dev, offs, vol->mft_record_size, + selfloc->mft0) != vol->mft_record_size) + || (ntfs_pwrite(vol->dev, offsm, vol->mft_record_size, + selfloc->mft0) != vol->mft_record_size)) + res = -1; + } else { + /* write a full cluster if non resident */ + offs = selfloc->attrlist_lcn << vol->cluster_size_bits; + if (ntfs_pwrite(vol->dev, offs, vol->cluster_size, + selfloc->attrlist) != vol->cluster_size) + res = -1; + } + /* replace MFT2 by MFT1 and replace MFT1 by MFT2 */ + if (!res + && (ntfs_mst_pre_write_fixup((NTFS_RECORD*)selfloc->mft1, + vol->mft_record_size) + || ntfs_mst_pre_write_fixup((NTFS_RECORD*)selfloc->mft2, + vol->mft_record_size) + || (ntfs_pwrite(vol->dev, offs2, vol->mft_record_size, + mft1) != vol->mft_record_size) + || (ntfs_pwrite(vol->dev, offs1, vol->mft_record_size, + mft2) != vol->mft_record_size))) + res = -1; + } + return (res); +} + +/* + * Detect and fix a Windows XP bug, leading to a corrupt MFT + * + * Windows cannot boot anymore, so chkdsk cannot be started, which + * is a good point, because chkdsk would have deleted all the files. + * Older ntfs-3g fell into an endless recursion (recent versions + * refuse to mount). + * + * This situation is very rare, but it was fun to fix it. + * + * The corrupted condition is : + * - MFT entry 0 has only the runlist for MFT entries 0-15 + * - The attribute list for MFT shows the second part + * in an MFT record beyond 15 + * Of course, this record has to be read in order to know where it is. + * + * Sample case, met in 2011 (Windows XP) : + * MFT record 0 has : stdinfo, nonres attrlist, the first + * part of MFT data (entries 0-15), and bitmap + * MFT record 16 has the name + * MFT record 17 has the third part of MFT data (16-117731) + * MFT record 18 has the second part of MFT data (117732-170908) + * + * Assuming the second part of the MFT is contiguous to the first + * part, we can find it, and fix the condition by relocating it + * and swapping it with MFT record 15. + * This record number 15 appears to be hardcoded into Windows NTFS. + * + * Only low-level library functions can be used. + * + * Returns 0 if the conditions for the error were not met or + * the error could be fixed, + * -1 if some error was encountered + */ + +static int fix_self_located_mft(ntfs_volume *vol) +{ + struct MFT_SELF_LOCATED selfloc; + BOOL res; + + ntfs_log_info("Checking for self-located MFT segment... "); + res = -1; + selfloc.vol = vol; + selfloc.mft0 = (MFT_RECORD*)malloc(vol->mft_record_size); + selfloc.mft1 = (MFT_RECORD*)malloc(vol->mft_record_size); + selfloc.mft2 = (MFT_RECORD*)malloc(vol->mft_record_size); + selfloc.attrlist = (ATTR_LIST_ENTRY*)malloc(vol->cluster_size); + if (selfloc.mft0 && selfloc.mft1 && selfloc.mft2 + && selfloc.attrlist) { + if (short_mft_selfloc_condition(&selfloc) + && attrlist_selfloc_condition(&selfloc) + && self_mapped_selfloc_condition(&selfloc) + && spare_record_selfloc_condition(&selfloc)) { + ntfs_log_info(FOUND); + ntfs_log_info("Fixing the self-located MFT segment... "); + res = fix_selfloc_conditions(&selfloc); + ntfs_log_info(res ? FAILED : OK); + } else { + ntfs_log_info(OK); + res = 0; + } + free(selfloc.mft0); + free(selfloc.mft1); + free(selfloc.mft2); + free(selfloc.attrlist); + } + return (res); +} + +/* + * Try an alternate boot sector and fix the real one + * + * Only after successful checks is the boot sector rewritten. + * + * The alternate boot sector is not rewritten, either because it + * was found correct, or because we truncated the file system + * and the last actual sector might be part of some file. + * + * Returns 0 if successful + */ + +static int try_fix_boot(ntfs_volume *vol, char *full_bs, + s64 read_sector, s64 fix_sectors, s32 sector_size) +{ + s64 br; + int res; + s64 got_sectors; + le16 sector_size_le; + NTFS_BOOT_SECTOR *bs; + + res = -1; + br = ntfs_pread(vol->dev, read_sector*sector_size, + sector_size, full_bs); + if (br != sector_size) { + if (br != -1) + errno = EINVAL; + if (!br) + ntfs_log_error("Failed to read alternate bootsector (size=0)\n"); + else + ntfs_log_perror("Error reading alternate bootsector"); + } else { + bs = (NTFS_BOOT_SECTOR*)full_bs; + got_sectors = le64_to_cpu(bs->number_of_sectors); + bs->number_of_sectors = cpu_to_le64(fix_sectors); + /* alignment problem on Sparc, even doing memcpy() */ + sector_size_le = cpu_to_le16(sector_size); + if (!memcmp(§or_size_le, &bs->bpb.bytes_per_sector,2) + && ntfs_boot_sector_is_ntfs(bs) + && !ntfs_boot_sector_parse(vol, bs)) { + ntfs_log_info("The alternate bootsector is usable\n"); + if (fix_sectors != got_sectors) + ntfs_log_info("Set sector count to %lld instead of %lld\n", + (long long)fix_sectors, + (long long)got_sectors); + /* fix the normal boot sector */ + if (!opt.no_action) { + res = rewrite_boot(vol->dev, full_bs, + sector_size); + } else + res = 0; + } + if (!res && !opt.no_action) + ntfs_log_info("The boot sector has been rewritten\n"); + } + return (res); +} + +/* + * Try the alternate boot sector if the normal one is bad + * + * Actually : + * - first try the last sector of the partition (expected location) + * - then try the last sector as shown in the main boot sector, + * (could be meaningful for an undersized partition) + * - finally try truncating the file system actual size of partition + * (could be meaningful for an oversized partition) + * + * if successful, rewrite the normal boot sector accordingly + * + * Returns 0 if successful + */ + +static int try_alternate_boot(ntfs_volume *vol, char *full_bs, + s32 sector_size, s64 shown_sectors) +{ + s64 actual_sectors; + int res; + + res = -1; + ntfs_log_info("Trying the alternate boot sector\n"); + + /* + * We do not rely on the sector size defined in the + * boot sector, supposed to be corrupt, so we try to get + * the actual sector size and defaulting to 512 if failed + * to get. This value is only used to guess the alternate + * boot sector location and it is checked against the + * value found in the sector itself. It should not damage + * anything if wrong. + * + * Note : the real last sector is not accounted for here. + */ + actual_sectors = ntfs_device_size_get(vol->dev,sector_size) - 1; + + /* first try the actual last sector */ + if ((actual_sectors > 0) + && !try_fix_boot(vol, full_bs, actual_sectors, + actual_sectors, sector_size)) + res = 0; + + /* then try the shown last sector, if less than actual */ + if (res + && (shown_sectors > 0) + && (shown_sectors < actual_sectors) + && !try_fix_boot(vol, full_bs, shown_sectors, + shown_sectors, sector_size)) + res = 0; + + /* then try reducing the number of sectors to actual value */ + if (res + && (shown_sectors > actual_sectors) + && !try_fix_boot(vol, full_bs, 0, actual_sectors, sector_size)) + res = 0; + + return (res); +} + +/* + * Check and fix the alternate boot sector + * + * The alternate boot sector is usually in the last sector of a + * partition, which should not be used by the file system + * (the sector count in the boot sector should be less than + * the total sector count in the partition). + * + * chkdsk never changes the count in the boot sector. + * - If this is less than the total count, chkdsk place the + * alternate boot sector into the sector, + * - if the count is the same as the total count, chkdsk place + * the alternate boot sector into the middle sector (half + * the total count rounded upwards) + * - if the count is greater than the total count, chkdsk + * declares the file system as raw, and refuses to fix anything. + * + * Here, we check and fix the alternate boot sector, only in the + * first situation where the file system does not overflow on the + * last sector. + * + * Note : when shrinking a partition, ntfsresize cannot determine + * the future size of the partition. As a consequence the number of + * sectors in the boot sectors may be less than the possible size. + * + * Returns 0 if successful + */ + +static int check_alternate_boot(ntfs_volume *vol) +{ +#if 0 + s64 got_sectors; + s64 actual_sectors; + s64 last_sector_off; + char *full_bs; + char *alt_bs; + NTFS_BOOT_SECTOR *bs; + s64 br; + s64 bw; + int res; + + res = -1; + full_bs = (char*)malloc(vol->sector_size); + alt_bs = (char*)malloc(vol->sector_size); + if (!full_bs || !alt_bs) { + ntfs_log_info("Error : failed to allocate memory\n"); + goto error_exit; + } + /* Now read both bootsectors. */ + br = ntfs_pread(vol->dev, 0, vol->sector_size, full_bs); + if (br == vol->sector_size) { + bs = (NTFS_BOOT_SECTOR*)full_bs; + got_sectors = le64_to_cpu(bs->number_of_sectors); + actual_sectors = ntfs_device_size_get(vol->dev, + vol->sector_size); + if (actual_sectors > got_sectors) { + last_sector_off = (actual_sectors - 1) + << vol->sector_size_bits; + ntfs_log_info("Checking the alternate boot sector... "); + br = ntfs_pread(vol->dev, last_sector_off, + vol->sector_size, alt_bs); + } else { + ntfs_log_info("Checking file system overflow... "); + br = -1; + } + /* accept getting no byte, needed for short image files */ + if (br >= 0) { + if ((br != vol->sector_size) + || memcmp(full_bs, alt_bs, vol->sector_size)) { + if (opt.no_action) { + ntfs_log_info("BAD\n"); + } else { + bw = ntfs_pwrite(vol->dev, + last_sector_off, + vol->sector_size, full_bs); + if (bw == vol->sector_size) { + ntfs_log_info("FIXED\n"); + res = 0; + } else { + ntfs_log_info(FAILED); + } + } + } else { + ntfs_log_info(OK); + res = 0; + } + } else { + ntfs_log_info(FAILED); + } + } else { + ntfs_log_info("Error : could not read the boot sector again\n"); + } + free(full_bs); + free(alt_bs); + +error_exit : + return (res); +#endif + return (0); +} + +/* + * Try to fix problems which may arise in the start up sequence + * + * This is a replay of the normal start up sequence with fixes when + * some problem arise. + */ + +static int fix_startup(struct ntfs_device *dev, unsigned long flags) +{ + s64 br; + ntfs_volume *vol; + BOOL dev_open; + s64 shown_sectors; + char *full_bs; + NTFS_BOOT_SECTOR *bs; + s32 sector_size; + int res; + int eo; + + errno = 0; + res = -1; + dev_open = FALSE; + full_bs = (char*)NULL; + if (!dev || !dev->d_ops || !dev->d_name) { + errno = EINVAL; + ntfs_log_perror("%s: dev = %p", __FUNCTION__, dev); + vol = (ntfs_volume*)NULL; + goto error_exit; + } + + /* Allocate the volume structure. */ + vol = ntfs_volume_alloc(); + if (!vol) + goto error_exit; + + /* Create the default upcase table. */ + vol->upcase_len = ntfs_upcase_build_default(&vol->upcase); + if (!vol->upcase_len || !vol->upcase) + goto error_exit; + + /* Default with no locase table and case sensitive file names */ + vol->locase = (ntfschar*)NULL; + NVolSetCaseSensitive(vol); + + /* by default, all files are shown and not marked hidden */ + NVolSetShowSysFiles(vol); + NVolSetShowHidFiles(vol); + NVolClearHideDotFiles(vol); + if (flags & NTFS_MNT_RDONLY) + NVolSetReadOnly(vol); + + /* ...->open needs bracketing to compile with glibc 2.7 */ + if ((dev->d_ops->open)(dev, NVolReadOnly(vol) ? O_RDONLY: O_RDWR)) { + ntfs_log_perror("Error opening '%s'", dev->d_name); + goto error_exit; + } + dev_open = TRUE; + /* Attach the device to the volume. */ + vol->dev = dev; + + sector_size = ntfs_device_sector_size_get(dev); + if (sector_size <= 0) + sector_size = DEFAULT_SECTOR_SIZE; + full_bs = (char*)malloc(sector_size); + if (!full_bs) + goto error_exit; + /* Now read the bootsector. */ + br = ntfs_pread(dev, 0, sector_size, full_bs); + if (br != sector_size) { + if (br != -1) + errno = EINVAL; + if (!br) + ntfs_log_error("Failed to read bootsector (size=0)\n"); + else + ntfs_log_perror("Error reading bootsector"); + goto error_exit; + } + bs = (NTFS_BOOT_SECTOR*)full_bs; + if (!ntfs_boot_sector_is_ntfs(bs) + /* get the bootsector data, only fails when inconsistent */ + || (ntfs_boot_sector_parse(vol, bs) < 0)) { + shown_sectors = le64_to_cpu(bs->number_of_sectors); + /* boot sector is wrong, try the alternate boot sector */ + if (try_alternate_boot(vol, full_bs, sector_size, + shown_sectors)) { + errno = EINVAL; + goto error_exit; + } + res = 0; + } else { + res = fix_self_located_mft(vol); + } +error_exit: + if (res) { + switch (errno) { + case ENOMEM : + ntfs_log_error("Failed to allocate memory\n"); + break; + case EINVAL : + ntfs_log_error("Unrecoverable error\n"); + break; + default : + break; + } + } + eo = errno; + free(full_bs); + if (vol) { + free(vol->upcase); + free(vol); + } + if (dev_open) { + (dev->d_ops->close)(dev); + } + errno = eo; + return (res); +} + +/** + * fix_mount + */ +static int fix_mount(void) +{ + int ret = 0; /* default success */ + ntfs_volume *vol; + struct ntfs_device *dev; + unsigned long flags; + + ntfs_log_info("Attempting to correct errors... "); + + dev = ntfs_device_alloc(opt.volume, 0, &ntfs_device_default_io_ops, + NULL); + if (!dev) { + ntfs_log_info(FAILED); + ntfs_log_perror("Failed to allocate device"); + return -1; + } + flags = (opt.no_action ? NTFS_MNT_RDONLY : 0); + vol = ntfs_volume_startup(dev, flags); + if (!vol) { + ntfs_log_info(FAILED); + ntfs_log_perror("Failed to startup volume"); + + /* Try fixing the bootsector and MFT, then redo the startup */ + if (!fix_startup(dev, flags)) { + if (opt.no_action) + ntfs_log_info("The startup data can be fixed, " + "but no change was requested\n"); + else + vol = ntfs_volume_startup(dev, flags); + } + if (!vol) { + ntfs_log_error("Volume is corrupt. You should run chkdsk.\n"); + ntfs_device_free(dev); + return -1; + } + if (opt.no_action) + ret = -1; /* error present and not fixed */ + } + /* if option -n proceed despite errors, to display them all */ + if ((!ret || opt.no_action) && (fix_mftmirr(vol) < 0)) + ret = -1; + if ((!ret || opt.no_action) && (fix_upcase(vol) < 0)) + ret = -1; + if ((!ret || opt.no_action) && (set_dirty_flag(vol) < 0)) + ret = -1; + if ((!ret || opt.no_action) && (empty_journal(vol) < 0)) + ret = -1; + /* + * ntfs_umount() will invoke ntfs_device_free() for us. + * Ignore the returned error resulting from partial mounting. + */ + ntfs_umount(vol, 1); + return ret; +} + +/** + * main + */ +int main(int argc, char **argv) +{ + ntfs_volume *vol; + unsigned long mnt_flags; + unsigned long flags; + int ret = 1; /* failure */ + BOOL force = FALSE; + + ntfs_log_set_handler(ntfs_log_handler_outerr); + + parse_options(argc, argv); + + if (!ntfs_check_if_mounted(opt.volume, &mnt_flags)) { + if ((mnt_flags & NTFS_MF_MOUNTED) && + !(mnt_flags & NTFS_MF_READONLY) && !force) { + ntfs_log_error("Refusing to operate on read-write " + "mounted device %s.\n", opt.volume); + exit(1); + } + } else + ntfs_log_perror("Failed to determine whether %s is mounted", + opt.volume); + /* Attempt a full mount first. */ + flags = (opt.no_action ? NTFS_MNT_RDONLY : 0); + ntfs_log_info("Mounting volume... "); + vol = ntfs_mount(opt.volume, flags); + if (vol) { + ntfs_log_info(OK); + ntfs_log_info("Processing of $MFT and $MFTMirr completed " + "successfully.\n"); + } else { + ntfs_log_info(FAILED); + if (fix_mount() < 0) { + if (opt.no_action) + ntfs_log_info("No change made\n"); + exit(1); + } + vol = ntfs_mount(opt.volume, 0); + if (!vol) { + ntfs_log_perror("Remount failed"); + exit(1); + } + } + if (check_alternate_boot(vol)) { + ntfs_log_error("Error: Failed to fix the alternate boot sector\n"); + exit(1); + } + /* So the unmount does not clear it again. */ + + /* Porting note: The WasDirty flag was set here to prevent ntfs_unmount + * from clearing the dirty bit (which might have been set in + * fix_mount()). So the intention is to leave the dirty bit set. + * + * libntfs-3g does not automatically set or clear dirty flags on + * mount/unmount, this means that the assumption that the dirty flag is + * now set does not hold. So we need to set it if not already set. + * + * However clear the flag if requested to do so, at this stage + * mounting was successful. + */ + if (opt.clear_dirty) + vol->flags &= ~VOLUME_IS_DIRTY; + else + vol->flags |= VOLUME_IS_DIRTY; + if (!opt.no_action && ntfs_volume_write_flags(vol, vol->flags)) { + ntfs_log_error("Error: Failed to set volume dirty flag (%d " + "(%s))!\n", errno, strerror(errno)); + } + + /* Check NTFS version is ok for us (in $Volume) */ + ntfs_log_info("NTFS volume version is %i.%i.\n", vol->major_ver, + vol->minor_ver); + if (ntfs_version_is_supported(vol)) { + ntfs_log_error("Error: Unknown NTFS version.\n"); + goto error_exit; + } + if (opt.clear_bad_sectors && !opt.no_action) { + if (clear_badclus(vol)) { + ntfs_log_error("Error: Failed to un-mark bad sectors.\n"); + goto error_exit; + } + } + if (vol->major_ver >= 3) { + /* + * FIXME: If on NTFS 3.0+, check for presence of the usn + * journal and stamp it if present. + */ + } + /* FIXME: We should be marking the quota out of date, too. */ + /* That's all for now! */ + ntfs_log_info("NTFS partition %s was processed successfully.\n", + vol->dev->d_name); + /* Set return code to 0. */ + ret = 0; +error_exit: + if (ntfs_umount(vol, 0)) + ntfs_umount(vol, 1); + if (ret) + exit(ret); + return ret; +} + |