vfatlib.c File Reference

#include "vfatlib.h"
#include <debug.h>

Include dependency graph for vfatlib.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
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)
VOID	UpdateProgress (PFORMAT_CONTEXT Context, ULONG Increment)
VOID	VfatPrintV (PCHAR Format, va_list args)
VOID	VfatPrint (PCHAR Format,...)
BOOLEAN NTAPI	VfatChkdsk (IN PUNICODE_STRING DriveRoot, IN PFMIFSCALLBACK Callback, IN BOOLEAN FixErrors, IN BOOLEAN Verbose, IN BOOLEAN CheckOnlyIfDirty, IN BOOLEAN ScanDrive, IN PVOID pUnknown1, IN PVOID pUnknown2, IN PVOID pUnknown3, IN PVOID pUnknown4, IN PULONG ExitStatus)

Variables
PFMIFSCALLBACK	ChkdskCallback = NULL
ULONG	FsCheckFlags
PVOID	FsCheckMemQueue
ULONG	FsCheckTotalFiles

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 37 of file vfatlib.c.

Function Documentation

UpdateProgress()

VOID UpdateProgress	(	PFORMAT_CONTEXT	Context,
		ULONG	Increment
	)

Definition at line 364 of file vfatlib.c.

{
    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);
        }
    }
}

Referenced by Fat12WriteBootSector(), Fat12WriteFAT(), Fat12WriteRootDirectory(), Fat16WriteBootSector(), Fat16WriteFAT(), Fat16WriteRootDirectory(), Fat32WriteBootSector(), Fat32WriteFAT(), Fat32WriteFsInfo(), Fat32WriteRootDirectory(), and FatWipeSectors().

VfatChkdsk()

BOOLEAN NTAPI VfatChkdsk	(	IN PUNICODE_STRING	DriveRoot,
		IN PFMIFSCALLBACK	Callback,
		IN BOOLEAN	FixErrors,
		IN BOOLEAN	Verbose,
		IN BOOLEAN	CheckOnlyIfDirty,
		IN BOOLEAN	ScanDrive,
		IN PVOID	pUnknown1,
		IN PVOID	pUnknown2,
		IN PVOID	pUnknown3,
		IN PVOID	pUnknown4,
		IN PULONG	ExitStatus
	)

Definition at line 417 of file vfatlib.c.

{
    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;
    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");
        }
    }
 
#ifdef __REACTOS__
    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);
#else
    VfatPrint("%wZ: %u files, %lu/%lu clusters\n", DriveRoot,
        FsCheckTotalFiles, fs.data_clusters - free_clusters, fs.data_clusters);
#endif
    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);
}

VfatFormat()

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
	)

Definition at line 50 of file vfatlib.c.

{
    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);
}

VfatPrint()

VOID VfatPrint	(	PCHAR	Format,
			...
	)

Definition at line 405 of file vfatlib.c.

{
    va_list args;
 
    va_start(args, Format);
    VfatPrintV(Format, args);
    va_end(args);
}

Referenced by rename_file(), and VfatChkdsk().

VfatPrintV()

VOID VfatPrintV	(	PCHAR	Format,
		va_list	args
	)

Definition at line 385 of file vfatlib.c.

{
    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);
}

Referenced by die(), pdie(), and VfatPrint().

Variable Documentation

ChkdskCallback

PFMIFSCALLBACK ChkdskCallback = NULL

Definition at line 43 of file vfatlib.c.

Referenced by CheckVolume(), ChkDskNow(), FsVolCallback(), StartCheck(), VfatChkdsk(), VfatPrintV(), and wmain().

FsCheckFlags

ULONG FsCheckFlags

Definition at line 44 of file vfatlib.c.

Referenced by fs_flush(), fs_write(), and VfatChkdsk().

FsCheckMemQueue

PVOID FsCheckMemQueue

Definition at line 45 of file vfatlib.c.

Referenced by VfatChkdsk().

FsCheckTotalFiles

ULONG FsCheckTotalFiles

Definition at line 46 of file vfatlib.c.

Referenced by VfatChkdsk().