vfatlib.c

Go to the documentation of this file.

/*
 * COPYRIGHT:   See COPYING in the top level directory
 * PROJECT:     ReactOS VFAT filesystem library
 * FILE:        lib\fslib\vfatlib\vfatlib.c
 * PURPOSE:     Main API
 * PROGRAMMERS: Casper S. Hornstrup (chorns@users.sourceforge.net)
 *              Aleksey Bragin (aleksey@reactos.org)
 *              Hermes Belusca-Maito (hermes.belusca@sfr.fr)
 */
/* fsck.fat.c - User interface
 
   Copyright (C) 1993 Werner Almesberger <werner.almesberger@lrc.di.epfl.ch>
   Copyright (C) 1998 Roman Hodek <Roman.Hodek@informatik.uni-erlangen.de>
   Copyright (C) 2008-2014 Daniel Baumann <mail@daniel-baumann.ch>
 
   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 3 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. If not, see <http://www.gnu.org/licenses/>.
 
   The complete text of the GNU General Public License
   can be found in /usr/share/common-licenses/GPL-3 file.
*/
 
/* INCLUDES *******************************************************************/
 
#include "vfatlib.h"
 
#define NDEBUG
#include <debug.h>
 
 
/* GLOBALS & FUNCTIONS ********************************************************/
 
PFMIFSCALLBACK ChkdskCallback = NULL;
ULONG FsCheckFlags;
PVOID FsCheckMemQueue;
ULONG FsCheckTotalFiles;
 
BOOLEAN
NTAPI
VfatFormat(
    _In_ PUNICODE_STRING DriveRoot,
    _In_ PFMIFSCALLBACK Callback,
    _In_ BOOLEAN QuickFormat,
    _In_ BOOLEAN BackwardCompatible,
    _In_ MEDIA_TYPE MediaType,
    _In_ PUNICODE_STRING Label,
    _In_ ULONG ClusterSize)
{
    OBJECT_ATTRIBUTES ObjectAttributes;
    DISK_GEOMETRY DiskGeometry;
    IO_STATUS_BLOCK Iosb;
    HANDLE FileHandle;
    PARTITION_INFORMATION_EX PartitionInfo;
    FORMAT_CONTEXT Context;
    FAT_TYPE FatType = FAT_UNKNOWN;
    NTSTATUS Status, LockStatus;
 
    DPRINT("VfatFormat(DriveRoot '%wZ')\n", DriveRoot);
 
    // FIXME:
    UNREFERENCED_PARAMETER(BackwardCompatible);
    UNREFERENCED_PARAMETER(MediaType);
 
    Context.TotalSectorCount = 0;
    Context.CurrentSectorCount = 0;
    Context.Callback = Callback;
    Context.Success = FALSE;
    Context.Percent = 0;
 
    InitializeObjectAttributes(&ObjectAttributes,
                               DriveRoot,
                               0,
                               NULL,
                               NULL);
 
    Status = NtOpenFile(&FileHandle,
                        FILE_GENERIC_READ | FILE_GENERIC_WRITE | SYNCHRONIZE,
                        &ObjectAttributes,
                        &Iosb,
                        FILE_SHARE_READ,
                        FILE_SYNCHRONOUS_IO_ALERT);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("NtOpenFile() failed with status 0x%08x\n", Status);
        return FALSE;
    }
 
    Status = NtDeviceIoControlFile(FileHandle,
                                   NULL,
                                   NULL,
                                   NULL,
                                   &Iosb,
                                   IOCTL_DISK_GET_DRIVE_GEOMETRY,
                                   NULL,
                                   0,
                                   &DiskGeometry,
                                   sizeof(DISK_GEOMETRY));
    if (!NT_SUCCESS(Status))
    {
        DPRINT("IOCTL_DISK_GET_DRIVE_GEOMETRY failed with status 0x%08x\n", Status);
        NtClose(FileHandle);
        return FALSE;
    }
 
    if (DiskGeometry.MediaType == FixedMedia)
    {
        DPRINT("Cylinders %I64d\n", DiskGeometry.Cylinders.QuadPart);
        DPRINT("TracksPerCylinder %ld\n", DiskGeometry.TracksPerCylinder);
        DPRINT("SectorsPerTrack %ld\n", DiskGeometry.SectorsPerTrack);
        DPRINT("BytesPerSector %ld\n", DiskGeometry.BytesPerSector);
        DPRINT("DiskSize %I64d\n",
               DiskGeometry.Cylinders.QuadPart *
               (ULONGLONG)DiskGeometry.TracksPerCylinder *
               (ULONGLONG)DiskGeometry.SectorsPerTrack *
               (ULONGLONG)DiskGeometry.BytesPerSector);
 
        Status = NtDeviceIoControlFile(FileHandle,
                                       NULL,
                                       NULL,
                                       NULL,
                                       &Iosb,
                                       IOCTL_DISK_GET_PARTITION_INFO_EX,
                                       NULL,
                                       0,
                                       &PartitionInfo,
                                       sizeof(PARTITION_INFORMATION_EX));
        if (!NT_SUCCESS(Status))
        {
            DPRINT("IOCTL_DISK_GET_PARTITION_INFO_EX failed with status 0x%08x\n", Status);
            NtClose(FileHandle);
            return FALSE;
        }
    }
    else
    {
        PartitionInfo.PartitionStyle = PARTITION_STYLE_MBR;
        PartitionInfo.Mbr.PartitionType = 0;
        PartitionInfo.StartingOffset.QuadPart = 0ULL;
        PartitionInfo.PartitionLength.QuadPart =
            DiskGeometry.Cylinders.QuadPart *
            (ULONGLONG)DiskGeometry.TracksPerCylinder *
            (ULONGLONG)DiskGeometry.SectorsPerTrack *
            (ULONGLONG)DiskGeometry.BytesPerSector;
        PartitionInfo.Mbr.HiddenSectors = 0;
        PartitionInfo.PartitionNumber = 0;
        PartitionInfo.Mbr.BootIndicator = FALSE;
        PartitionInfo.RewritePartition = FALSE;
        PartitionInfo.Mbr.RecognizedPartition = FALSE;
    }
 
    /* If it already has a FAT FS, we'll use that type.
     * If it doesn't, we will determine the FAT type based on size and offset */
 
    if (PartitionInfo.PartitionStyle == PARTITION_STYLE_MBR)
    {
        if (PartitionInfo.Mbr.PartitionType == PARTITION_FAT_12)
        {
            FatType = FAT_12;
        }
        else if (PartitionInfo.Mbr.PartitionType == PARTITION_FAT_16 ||
                 PartitionInfo.Mbr.PartitionType == PARTITION_HUGE ||
                 PartitionInfo.Mbr.PartitionType == PARTITION_XINT13)
        {
            FatType = FAT_16;
        }
        else if (PartitionInfo.Mbr.PartitionType == PARTITION_FAT32 ||
                 PartitionInfo.Mbr.PartitionType == PARTITION_FAT32_XINT13)
        {
            FatType = FAT_32;
        }
 
        if (FatType == FAT_UNKNOWN)
        {
            /* Determine the correct type based upon size and offset (copied from usetup) */
            if (PartitionInfo.PartitionLength.QuadPart < (4200LL * 1024LL))
            {
                /* FAT12 CHS partition (disk is smaller than 4.1MB) */
                FatType = FAT_12;
            }
            else if (PartitionInfo.StartingOffset.QuadPart < (1024LL * 255LL * 63LL * 512LL))
            {
                /* Partition starts below the 8.4GB boundary ==> CHS partition */
 
                if (PartitionInfo.PartitionLength.QuadPart < (32LL * 1024LL * 1024LL))
                {
                    /* FAT16 CHS partition (partition size < 32MB) */
                    FatType = FAT_16;
                }
                else if (PartitionInfo.PartitionLength.QuadPart < (512LL * 1024LL * 1024LL))
                {
                    /* FAT16 CHS partition (partition size < 512MB) */
                    FatType = FAT_16;
                }
                else
                {
                    /* FAT32 CHS partition (partition size >= 512MB) */
                    FatType = FAT_32;
                }
            }
            else
            {
                /* Partition starts above the 8.4GB boundary ==> LBA partition */
 
                if (PartitionInfo.PartitionLength.QuadPart < (512LL * 1024LL * 1024LL))
                {
                    /* FAT16 LBA partition (partition size < 512MB) */
                    FatType = FAT_16;
                }
                else
                {
                    /* FAT32 LBA partition (partition size >= 512MB) */
                    FatType = FAT_32;
                }
            }
        }
 
        DPRINT("PartitionType 0x%x\n", PartitionInfo.Mbr.PartitionType);
        DPRINT("StartingOffset %I64d\n", PartitionInfo.StartingOffset.QuadPart);
        DPRINT("PartitionLength %I64d\n", PartitionInfo.PartitionLength.QuadPart);
        DPRINT("HiddenSectors %lu\n", PartitionInfo.Mbr.HiddenSectors);
        DPRINT("PartitionNumber %d\n", PartitionInfo.PartitionNumber);
        DPRINT("BootIndicator 0x%x\n", PartitionInfo.Mbr.BootIndicator);
        DPRINT("RewritePartition %d\n", PartitionInfo.RewritePartition);
        DPRINT("RecognizedPartition %d\n", PartitionInfo.Mbr.RecognizedPartition);
    }
    else if (PartitionInfo.PartitionStyle == PARTITION_STYLE_GPT)
    {
        if (PartitionInfo.PartitionLength.QuadPart < (4200LL * 1024LL))
        {
            /* FAT12 CHS partition (disk is smaller than 4.1MB) */
            FatType = FAT_12;
        }
        else if (PartitionInfo.PartitionLength.QuadPart < (512LL * 1024LL * 1024LL))
        {
            /* FAT16 partition (partition size < 512MB) */
            FatType = FAT_16;
        }
        else if (PartitionInfo.PartitionLength.QuadPart <= (32LL * 1024LL * 1024LL * 1024LL))
        {
            /* FAT32 partition (partition size < 32GB) */
            FatType = FAT_32;
        }
        else
        {
            DPRINT1("The partition ist too large (> 32 GB) for the FAT file system!\n");
            NtClose(FileHandle);
            return FALSE;
        }
 
        DPRINT("StartingOffset %I64d\n", PartitionInfo.StartingOffset.QuadPart);
        DPRINT("PartitionLength %I64d\n", PartitionInfo.PartitionLength.QuadPart);
        DPRINT("PartitionNumber %d\n", PartitionInfo.PartitionNumber);
        DPRINT("RewritePartition %d\n", PartitionInfo.RewritePartition);
    }
 
    if (Callback != NULL)
    {
        Context.Percent = 0;
        Callback(PROGRESS, 0, (PVOID)&Context.Percent);
    }
 
    LockStatus = NtFsControlFile(FileHandle,
                                 NULL,
                                 NULL,
                                 NULL,
                                 &Iosb,
                                 FSCTL_LOCK_VOLUME,
                                 NULL,
                                 0,
                                 NULL,
                                 0);
    if (!NT_SUCCESS(LockStatus))
    {
        DPRINT1("WARNING: Failed to lock volume for formatting! Format may fail! (Status: 0x%x)\n", LockStatus);
    }
 
    if (FatType == FAT_12)
    {
        /* FAT12 */
        Status = Fat12Format(FileHandle,
                             &PartitionInfo,
                             &DiskGeometry,
                             Label,
                             QuickFormat,
                             ClusterSize,
                             &Context);
    }
    else if (FatType == FAT_16)
    {
        /* FAT16 */
        Status = Fat16Format(FileHandle,
                             &PartitionInfo,
                             &DiskGeometry,
                             Label,
                             QuickFormat,
                             ClusterSize,
                             &Context);
    }
    else if (FatType == FAT_32)
    {
        /* FAT32 */
        Status = Fat32Format(FileHandle,
                             &PartitionInfo,
                             &DiskGeometry,
                             Label,
                             QuickFormat,
                             ClusterSize,
                             &Context);
    }
    else
    {
        Status = STATUS_INVALID_PARAMETER;
    }
 
    /* Attempt to dismount formatted volume */
    LockStatus = NtFsControlFile(FileHandle,
                                 NULL,
                                 NULL,
                                 NULL,
                                 &Iosb,
                                 FSCTL_DISMOUNT_VOLUME,
                                 NULL,
                                 0,
                                 NULL,
                                 0);
    if (!NT_SUCCESS(LockStatus))
    {
        DPRINT1("Failed to umount volume (Status: 0x%x)\n", LockStatus);
    }
 
    LockStatus = NtFsControlFile(FileHandle,
                                 NULL,
                                 NULL,
                                 NULL,
                                 &Iosb,
                                 FSCTL_UNLOCK_VOLUME,
                                 NULL,
                                 0,
                                 NULL,
                                 0);
    if (!NT_SUCCESS(LockStatus))
    {
        DPRINT1("Failed to unlock volume (Status: 0x%x)\n", LockStatus);
    }
 
    NtClose(FileHandle);
 
    DPRINT("VfatFormat() done. Status 0x%08x\n", Status);
    return NT_SUCCESS(Status);
}
 
 
VOID
UpdateProgress(PFORMAT_CONTEXT Context,
               ULONG Increment)
{
    ULONG NewPercent;
 
    Context->CurrentSectorCount += (ULONGLONG)Increment;
 
    NewPercent = (Context->CurrentSectorCount * 100ULL) / Context->TotalSectorCount;
 
    if (NewPercent > Context->Percent)
    {
        Context->Percent = NewPercent;
        if (Context->Callback != NULL)
        {
            Context->Callback(PROGRESS, 0, &Context->Percent);
        }
    }
}
 
 
VOID
VfatPrintV(PCHAR Format, va_list args)
{
    TEXTOUTPUT TextOut;
    CHAR TextBuf[512];
 
    _vsnprintf(TextBuf, sizeof(TextBuf), Format, args);
 
    /* Prepare parameters */
    TextOut.Lines = 1;
    TextOut.Output = TextBuf;
 
    DPRINT1("VfatPrint -- %s", TextBuf);
 
    /* Do the callback */
    if (ChkdskCallback)
        ChkdskCallback(OUTPUT, 0, &TextOut);
}
 
 
VOID
VfatPrint(PCHAR Format, ...)
{
    va_list args;
 
    va_start(args, Format);
    VfatPrintV(Format, args);
    va_end(args);
}
 
 
BOOLEAN
NTAPI
VfatChkdsk(
    _In_ PUNICODE_STRING DriveRoot,
    _In_ PFMIFSCALLBACK Callback,
    _In_ BOOLEAN FixErrors,
    _In_ BOOLEAN Verbose,
    _In_ BOOLEAN CheckOnlyIfDirty,
    _In_ BOOLEAN ScanDrive,
    _In_opt_ PVOID pUnknown1,
    _In_opt_ PVOID pUnknown2,
    _In_opt_ PVOID pUnknown3,
    _In_opt_ PVOID pUnknown4,
    _Out_ PULONG ExitStatus)
{
    BOOLEAN verify;
    BOOLEAN salvage_files;
    ULONG free_clusters;
    DOS_FS fs;
    NTSTATUS Status;
    WCHAR DriveLetter[2] = L"0";
 
    UNREFERENCED_PARAMETER(pUnknown1);
    UNREFERENCED_PARAMETER(pUnknown2);
    UNREFERENCED_PARAMETER(pUnknown3);
    UNREFERENCED_PARAMETER(pUnknown4);
 
    RtlZeroMemory(&fs, sizeof(fs));
 
    /* Store callback pointer */
    ChkdskCallback = Callback;
    FsCheckMemQueue = NULL;
 
    /* Set parameters */
    FsCheckFlags = 0;
    if (Verbose)
        FsCheckFlags |= FSCHECK_VERBOSE | FSCHECK_LIST_FILES;
    if (FixErrors)
        FsCheckFlags |= FSCHECK_READ_WRITE;
 
    FsCheckTotalFiles = 0;
 
    verify = TRUE;
    salvage_files = TRUE;
 
    /* Open filesystem and lock it */
    Status = fs_open(DriveRoot, FsCheckFlags & FSCHECK_READ_WRITE);
    if (Status == STATUS_ACCESS_DENIED)
    {
        /* We failed to lock, ask the caller whether we should continue */
        if (Callback(VOLUMEINUSE, 0, NULL))
        {
            Status = STATUS_SUCCESS;
        }
    }
    if (!NT_SUCCESS(Status))
    {
        fs_close(FALSE);
        *ExitStatus = (ULONG)STATUS_DISK_CORRUPT_ERROR;
        return FALSE;
    }
 
    if (CheckOnlyIfDirty && !fs_isdirty())
    {
        /* Unlock volume if required */
        if (FsCheckFlags & FSCHECK_READ_WRITE)
            fs_lock(FALSE);
 
        /* No need to check FS */
        Status = (fs_close(FALSE) == 0 ? STATUS_SUCCESS : STATUS_DISK_CORRUPT_ERROR);
        *ExitStatus = (ULONG)Status;
        return (Status == STATUS_SUCCESS);
    }
    else if (CheckOnlyIfDirty && fs_isdirty())
    {
        if (!(FsCheckFlags & FSCHECK_READ_WRITE) && !(FsCheckFlags & FSCHECK_INTERACTIVE))
        {
            fs_close(FALSE);
            *ExitStatus = (ULONG)STATUS_DISK_CORRUPT_ERROR;
            return FALSE;
        }
    }
 
    read_boot(&fs);
 
    if (verify)
        VfatPrint("Starting check/repair pass.\n");
 
    while (read_fat(&fs), scan_root(&fs))
        qfree(&FsCheckMemQueue);
 
    if (ScanDrive)
        fix_bad(&fs);
 
    if (salvage_files)
        reclaim_file(&fs);
    else
        reclaim_free(&fs);
 
    free_clusters = update_free(&fs);
    file_unused();
    qfree(&FsCheckMemQueue);
    if (verify)
    {
        FsCheckTotalFiles = 0;
        VfatPrint("Starting verification pass.\n");
        read_fat(&fs);
        scan_root(&fs);
        reclaim_free(&fs);
        qfree(&FsCheckMemQueue);
    }
 
    if (fs_changed())
    {
        if (FsCheckFlags & FSCHECK_READ_WRITE)
        {
            if (FsCheckFlags & FSCHECK_INTERACTIVE)
            {
                FixErrors = get_key("yn", "Perform changes ? (y/n)") == 'y';
                if (FixErrors)
                    FsCheckFlags |= FSCHECK_READ_WRITE;
                else
                    FsCheckFlags &= ~FSCHECK_READ_WRITE;
            }
            else
                VfatPrint("Performing changes.\n");
        }
        else
        {
            VfatPrint("Leaving filesystem unchanged.\n");
        }
    }
 
    if (DriveRoot->Buffer[0] == '\\' && DriveRoot->Buffer[1] == '?' &&
        DriveRoot->Buffer[2] == '?' && DriveRoot->Buffer[3] == '\\')
    {
        DriveLetter[0] = DriveRoot->Buffer[4] & 0x5F; // 0x5f for Uppercase letter
        VfatPrint("Chkdsk complete for Volume %S.\n", DriveLetter);
        VfatPrint("%10u files on disk.\n\n", FsCheckTotalFiles);
        VfatPrint("%10u bytes per cluster.\n", fs.cluster_size);
        VfatPrint("%10lu total clusters on the disk.\n", fs.data_clusters);
        VfatPrint("%10lu clusters available on the disk.\n", free_clusters);
    }
    else
        VfatPrint("%wZ: %u files, %lu/%lu clusters\n", DriveRoot,
            FsCheckTotalFiles, fs.data_clusters - free_clusters, fs.data_clusters);
 
    if (FsCheckFlags & FSCHECK_READ_WRITE)
    {
        /* Dismount the volume */
        fs_dismount();
 
        /* Unlock the volume */
        fs_lock(FALSE);
    }
 
    // https://technet.microsoft.com/en-us/library/cc730714.aspx
    // https://support.microsoft.com/en-us/kb/265533
 
    /* Close the volume */
    Status = (fs_close(FsCheckFlags & FSCHECK_READ_WRITE) == 0 ? STATUS_SUCCESS : STATUS_DISK_CORRUPT_ERROR);
    *ExitStatus = (ULONG)Status;
    return (Status == STATUS_SUCCESS);
}
 
/* EOF */