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_opt_ PVOID pUnknown1, _In_opt_ PVOID pUnknown2, _In_opt_ PVOID pUnknown3, _In_opt_ PVOID pUnknown4, _Out_ 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_opt_ PVOID	pUnknown1,
		_In_opt_ PVOID	pUnknown2,
		_In_opt_ PVOID	pUnknown3,
		_In_opt_ PVOID	pUnknown4,
		_Out_ 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 | 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);
}

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().