fsutil.c File Reference

#include "precomp.h"
#include "partlist.h"
#include "fsrec.h"
#include "bootcode.h"
#include "fsutil.h"
#include <fslib/vfatlib.h>
#include <fslib/btrfslib.h>
#include <debug.h>
#include <pshpack1.h>
#include <poppack.h>

Include dependency graph for fsutil.c:

Go to the source code of this file.

Classes
struct	_FAT_BOOTSECTOR
struct	_FAT32_BOOTSECTOR
struct	_BTRFS_BOOTSECTOR
struct	_NTFS_BOOTSECTOR
struct	_FILE_SYSTEM

Macros
#define	NDEBUG

Typedefs
typedef struct _FAT_BOOTSECTOR	FAT_BOOTSECTOR
typedef struct _FAT_BOOTSECTOR *	PFAT_BOOTSECTOR
typedef struct _FAT32_BOOTSECTOR	FAT32_BOOTSECTOR
typedef struct _FAT32_BOOTSECTOR *	PFAT32_BOOTSECTOR
typedef struct _BTRFS_BOOTSECTOR	BTRFS_BOOTSECTOR
typedef struct _BTRFS_BOOTSECTOR *	PBTRFS_BOOTSECTOR
typedef struct _NTFS_BOOTSECTOR	NTFS_BOOTSECTOR
typedef struct _NTFS_BOOTSECTOR *	PNTFS_BOOTSECTOR
typedef struct _FILE_SYSTEM	FILE_SYSTEM
typedef struct _FILE_SYSTEM *	PFILE_SYSTEM

Functions
	C_ASSERT (sizeof(FAT_BOOTSECTOR)==FAT_BOOTSECTOR_SIZE)
	C_ASSERT (sizeof(FAT32_BOOTSECTOR)==FAT32_BOOTSECTOR_SIZE)
	C_ASSERT (sizeof(BTRFS_BOOTSECTOR)==BTRFS_BOOTSECTOR_SIZE)
	C_ASSERT (sizeof(NTFS_BOOTSECTOR)==NTFS_BOOTSECTOR_SIZE)
BOOLEAN	GetRegisteredFileSystems (IN ULONG Index, OUT PCWSTR *FileSystemName)
static PFILE_SYSTEM	GetFileSystemByName (IN PCWSTR FileSystemName)
NTSTATUS	ChkdskFileSystem_UStr (_In_ PUNICODE_STRING DriveRoot, _In_ PCWSTR FileSystemName, _In_ BOOLEAN FixErrors, _In_ BOOLEAN Verbose, _In_ BOOLEAN CheckOnlyIfDirty, _In_ BOOLEAN ScanDrive, _In_opt_ PFMIFSCALLBACK Callback)
NTSTATUS	ChkdskFileSystem (_In_ PCWSTR DriveRoot, _In_ PCWSTR FileSystemName, _In_ BOOLEAN FixErrors, _In_ BOOLEAN Verbose, _In_ BOOLEAN CheckOnlyIfDirty, _In_ BOOLEAN ScanDrive, _In_opt_ PFMIFSCALLBACK Callback)
NTSTATUS	FormatFileSystem_UStr (_In_ PUNICODE_STRING DriveRoot, _In_ PCWSTR FileSystemName, _In_ FMIFS_MEDIA_FLAG MediaFlag, _In_opt_ PUNICODE_STRING Label, _In_ BOOLEAN QuickFormat, _In_ ULONG ClusterSize, _In_opt_ PFMIFSCALLBACK Callback)
NTSTATUS	FormatFileSystem (_In_ PCWSTR DriveRoot, _In_ PCWSTR FileSystemName, _In_ FMIFS_MEDIA_FLAG MediaFlag, _In_opt_ PCWSTR Label, _In_ BOOLEAN QuickFormat, _In_ ULONG ClusterSize, _In_opt_ PFMIFSCALLBACK Callback)
NTSTATUS	InstallFatBootCode (IN PCWSTR SrcPath, IN HANDLE DstPath, IN HANDLE RootPartition)
NTSTATUS	InstallFat32BootCode (IN PCWSTR SrcPath, IN HANDLE DstPath, IN HANDLE RootPartition)
NTSTATUS	InstallBtrfsBootCode (IN PCWSTR SrcPath, IN HANDLE DstPath, IN HANDLE RootPartition)
NTSTATUS	InstallNtfsBootCode (IN PCWSTR SrcPath, IN HANDLE DstPath, IN HANDLE RootPartition)
NTSTATUS	ChkdskPartition (_In_ PPARTENTRY PartEntry, _In_ BOOLEAN FixErrors, _In_ BOOLEAN Verbose, _In_ BOOLEAN CheckOnlyIfDirty, _In_ BOOLEAN ScanDrive, _In_opt_ PFMIFSCALLBACK Callback)
NTSTATUS	FormatPartition (_In_ PPARTENTRY PartEntry, _In_ PCWSTR FileSystemName, _In_ FMIFS_MEDIA_FLAG MediaFlag, _In_opt_ PCWSTR Label, _In_ BOOLEAN QuickFormat, _In_ ULONG ClusterSize, _In_opt_ PFMIFSCALLBACK Callback)
static FSVOL_OP	DoFormatting (_In_ PPARTENTRY PartEntry, _In_opt_ PVOID Context, _In_opt_ PFSVOL_CALLBACK FsVolCallback)
static FSVOL_OP	DoChecking (_In_ PPARTENTRY PartEntry, _In_opt_ PVOID Context, _In_opt_ PFSVOL_CALLBACK FsVolCallback)
static BOOLEAN	GetNextUnformattedPartition (IN PPARTLIST List, OUT PPARTENTRY *pPartEntry)
static BOOLEAN	GetNextUncheckedPartition (IN PPARTLIST List, OUT PPARTENTRY *pPartEntry)
BOOLEAN	FsVolCommitOpsQueue (_In_ PPARTLIST PartitionList, _In_ PPARTENTRY SystemPartition, _In_ PPARTENTRY InstallPartition, _In_opt_ PFSVOL_CALLBACK FsVolCallback, _In_opt_ PVOID Context)

Variables
static FILE_SYSTEM	RegisteredFileSystems []

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 29 of file fsutil.c.

Typedef Documentation

BTRFS_BOOTSECTOR

typedef struct _BTRFS_BOOTSECTOR BTRFS_BOOTSECTOR

FAT32_BOOTSECTOR

typedef struct _FAT32_BOOTSECTOR FAT32_BOOTSECTOR

FAT_BOOTSECTOR

typedef struct _FAT_BOOTSECTOR FAT_BOOTSECTOR

FILE_SYSTEM

typedef struct _FILE_SYSTEM FILE_SYSTEM

IFS_PROVIDER

NTFS_BOOTSECTOR

typedef struct _NTFS_BOOTSECTOR NTFS_BOOTSECTOR

PBTRFS_BOOTSECTOR

typedef struct _BTRFS_BOOTSECTOR * PBTRFS_BOOTSECTOR

PFAT32_BOOTSECTOR

typedef struct _FAT32_BOOTSECTOR * PFAT32_BOOTSECTOR

PFAT_BOOTSECTOR

typedef struct _FAT_BOOTSECTOR * PFAT_BOOTSECTOR

PFILE_SYSTEM

typedef struct _FILE_SYSTEM * PFILE_SYSTEM

PNTFS_BOOTSECTOR

typedef struct _NTFS_BOOTSECTOR * PNTFS_BOOTSECTOR

Function Documentation

C_ASSERT() [1/4]

C_ASSERT

(

sizeof(BTRFS_BOOTSECTOR)

= =BTRFS_BOOTSECTOR_SIZE

)

C_ASSERT() [2/4]

C_ASSERT

(

sizeof(FAT32_BOOTSECTOR)

= =FAT32_BOOTSECTOR_SIZE

)

C_ASSERT() [3/4]

C_ASSERT

(

sizeof(FAT_BOOTSECTOR)

= =FAT_BOOTSECTOR_SIZE

)

C_ASSERT() [4/4]

C_ASSERT

(

sizeof(NTFS_BOOTSECTOR)

= =NTFS_BOOTSECTOR_SIZE

)

ChkdskFileSystem()

NTSTATUS ChkdskFileSystem	(	_In_ PCWSTR	DriveRoot,
		_In_ PCWSTR	FileSystemName,
		_In_ BOOLEAN	FixErrors,
		_In_ BOOLEAN	Verbose,
		_In_ BOOLEAN	CheckOnlyIfDirty,
		_In_ BOOLEAN	ScanDrive,
		_In_opt_ PFMIFSCALLBACK	Callback
	)

Definition at line 287 of file fsutil.c.

{
    UNICODE_STRING DriveRootU;
 
    RtlInitUnicodeString(&DriveRootU, DriveRoot);
    return ChkdskFileSystem_UStr(&DriveRootU,
                                 FileSystemName,
                                 FixErrors,
                                 Verbose,
                                 CheckOnlyIfDirty,
                                 ScanDrive,
                                 Callback);
}

Referenced by ChkdskPartition().

ChkdskFileSystem_UStr()

NTSTATUS ChkdskFileSystem_UStr	(	_In_ PUNICODE_STRING	DriveRoot,
		_In_ PCWSTR	FileSystemName,
		_In_ BOOLEAN	FixErrors,
		_In_ BOOLEAN	Verbose,
		_In_ BOOLEAN	CheckOnlyIfDirty,
		_In_ BOOLEAN	ScanDrive,
		_In_opt_ PFMIFSCALLBACK	Callback
	)

ChkdskEx()

Definition at line 244 of file fsutil.c.

{
    PFILE_SYSTEM FileSystem;
    NTSTATUS Status;
    BOOLEAN Success;
 
    FileSystem = GetFileSystemByName(FileSystemName);
 
    if (!FileSystem || !FileSystem->ChkdskFunc)
    {
        // Success = FALSE;
        // Callback(DONE, 0, &Success);
        return STATUS_NOT_SUPPORTED;
    }
 
    Status = STATUS_SUCCESS;
    Success = FileSystem->ChkdskFunc(DriveRoot,
                                     Callback,
                                     FixErrors,
                                     Verbose,
                                     CheckOnlyIfDirty,
                                     ScanDrive,
                                     NULL,
                                     NULL,
                                     NULL,
                                     NULL,
                                     (PULONG)&Status);
    if (!Success)
        DPRINT1("ChkdskFunc() failed with Status 0x%lx\n", Status);
 
    // Callback(DONE, 0, &Success);
 
    return Status;
}

Referenced by ChkdskFileSystem().

ChkdskPartition()

NTSTATUS ChkdskPartition	(	_In_ PPARTENTRY	PartEntry,
		_In_ BOOLEAN	FixErrors,
		_In_ BOOLEAN	Verbose,
		_In_ BOOLEAN	CheckOnlyIfDirty,
		_In_ BOOLEAN	ScanDrive,
		_In_opt_ PFMIFSCALLBACK	Callback
	)

Definition at line 757 of file fsutil.c.

{
    PDISKENTRY DiskEntry = PartEntry->DiskEntry;
    // UNICODE_STRING PartitionRootPath;
    WCHAR PartitionRootPath[MAX_PATH]; // PathBuffer
 
    ASSERT(PartEntry->IsPartitioned && PartEntry->PartitionNumber != 0);
 
    /* Do not check a partition with an unknown file system */
    if (!*PartEntry->FileSystem)
        return STATUS_UNRECOGNIZED_VOLUME; // STATUS_NOT_SUPPORTED;
 
    /* Set PartitionRootPath */
    RtlStringCchPrintfW(PartitionRootPath, ARRAYSIZE(PartitionRootPath),
                        L"\\Device\\Harddisk%lu\\Partition%lu",
                        DiskEntry->DiskNumber,
                        PartEntry->PartitionNumber);
    DPRINT("PartitionRootPath: %S\n", PartitionRootPath);
 
    /* Check the partition */
    return ChkdskFileSystem(PartitionRootPath,
                            PartEntry->FileSystem,
                            FixErrors,
                            Verbose,
                            CheckOnlyIfDirty,
                            ScanDrive,
                            Callback);
}

Referenced by DoChecking().

DoChecking()

static FSVOL_OP DoChecking ( _In_ PPARTENTRY  PartEntry, _In_opt_ PVOID  Context, _In_opt_ PFSVOL_CALLBACK  FsVolCallback  )

static

Definition at line 966 of file fsutil.c.

{
    FSVOL_OP Result;
    NTSTATUS Status = STATUS_SUCCESS;
    CHECK_VOLUME_INFO ChkInfo = {0};
 
    ASSERT(PartEntry->IsPartitioned && PartEntry->PartitionNumber != 0);
 
    ASSERT(*PartEntry->FileSystem);
 
    ChkInfo.PartEntry = PartEntry;
 
RetryCheck:
    Result = FsVolCallback(Context,
                           FSVOLNOTIFY_STARTCHECK,
                           (ULONG_PTR)&ChkInfo,
                           FSVOL_CHECK);
    if (Result != FSVOL_DOIT)
        goto EndCheck;
 
    /* Check the partition */
    Status = ChkdskPartition(PartEntry,
                             ChkInfo.FixErrors,
                             ChkInfo.Verbose,
                             ChkInfo.CheckOnlyIfDirty,
                             ChkInfo.ScanDrive,
                             ChkInfo.Callback);
 
    /* If volume checking succeeded, or if it is not supported
     * with the current file system, disable checks on the volume */
    if (NT_SUCCESS(Status) || (Status == STATUS_NOT_SUPPORTED))
        PartEntry->NeedsCheck = FALSE;
 
    if (!NT_SUCCESS(Status))
    {
        // ChkInfo.NtPathPartition = PathBuffer;
        ChkInfo.ErrorStatus = Status;
 
        Result = FsVolCallback(Context,
                               FSVOLNOTIFY_CHECKERROR,
                               (ULONG_PTR)&ChkInfo,
                               0);
        if (Result == FSVOL_RETRY)
            goto RetryCheck;
        // else if (Result == FSVOL_ABORT || Result == FSVOL_SKIP), stop.
 
        // PartEntry->NeedsCheck = FALSE;
    }
 
EndCheck:
    /* This notification is always sent, even in case of error or abort */
    ChkInfo.ErrorStatus = Status;
    FsVolCallback(Context,
                  FSVOLNOTIFY_ENDCHECK,
                  (ULONG_PTR)&ChkInfo,
                  0);
    return Result;
}

Referenced by FsVolCommitOpsQueue().

DoFormatting()

static FSVOL_OP DoFormatting ( _In_ PPARTENTRY  PartEntry, _In_opt_ PVOID  Context, _In_opt_ PFSVOL_CALLBACK  FsVolCallback  )

static

Definition at line 910 of file fsutil.c.

{
    FSVOL_OP Result;
    NTSTATUS Status = STATUS_SUCCESS;
    FORMAT_VOLUME_INFO FmtInfo = {0};
 
    ASSERT(PartEntry->IsPartitioned && PartEntry->PartitionNumber != 0);
 
    FmtInfo.PartEntry = PartEntry;
 
RetryFormat:
    Result = FsVolCallback(Context,
                           FSVOLNOTIFY_STARTFORMAT,
                           (ULONG_PTR)&FmtInfo,
                           FSVOL_FORMAT);
    if (Result != FSVOL_DOIT)
        goto EndFormat;
 
    ASSERT(FmtInfo.FileSystemName && *FmtInfo.FileSystemName);
 
    /* Format the partition */
    Status = FormatPartition(PartEntry,
                             FmtInfo.FileSystemName,
                             FmtInfo.MediaFlag,
                             FmtInfo.Label,
                             FmtInfo.QuickFormat,
                             FmtInfo.ClusterSize,
                             FmtInfo.Callback);
    if (!NT_SUCCESS(Status))
    {
        // FmtInfo.NtPathPartition = PathBuffer;
        FmtInfo.ErrorStatus = Status;
 
        Result = FsVolCallback(Context,
                               FSVOLNOTIFY_FORMATERROR,
                               (ULONG_PTR)&FmtInfo,
                               0);
        if (Result == FSVOL_RETRY)
            goto RetryFormat;
        // else if (Result == FSVOL_ABORT || Result == FSVOL_SKIP), stop.
    }
 
EndFormat:
    /* This notification is always sent, even in case of error or abort */
    FmtInfo.ErrorStatus = Status;
    FsVolCallback(Context,
                  FSVOLNOTIFY_ENDFORMAT,
                  (ULONG_PTR)&FmtInfo,
                  0);
    return Result;
}

Referenced by FsVolCommitOpsQueue().

FormatFileSystem()

NTSTATUS FormatFileSystem	(	_In_ PCWSTR	DriveRoot,
		_In_ PCWSTR	FileSystemName,
		_In_ FMIFS_MEDIA_FLAG	MediaFlag,
		_In_opt_ PCWSTR	Label,
		_In_ BOOLEAN	QuickFormat,
		_In_ ULONG	ClusterSize,
		_In_opt_ PFMIFSCALLBACK	Callback
	)

Definition at line 376 of file fsutil.c.

{
    UNICODE_STRING DriveRootU;
    UNICODE_STRING LabelU;
 
    RtlInitUnicodeString(&DriveRootU, DriveRoot);
    RtlInitUnicodeString(&LabelU, Label);
 
    return FormatFileSystem_UStr(&DriveRootU,
                                 FileSystemName,
                                 MediaFlag,
                                 &LabelU,
                                 QuickFormat,
                                 ClusterSize,
                                 Callback);
}

Referenced by FormatPartition(), and InstallFatBootcodeToFloppy().

FormatFileSystem_UStr()

NTSTATUS FormatFileSystem_UStr	(	_In_ PUNICODE_STRING	DriveRoot,
		_In_ PCWSTR	FileSystemName,
		_In_ FMIFS_MEDIA_FLAG	MediaFlag,
		_In_opt_ PUNICODE_STRING	Label,
		_In_ BOOLEAN	QuickFormat,
		_In_ ULONG	ClusterSize,
		_In_opt_ PFMIFSCALLBACK	Callback
	)

FormatEx()

Definition at line 311 of file fsutil.c.

{
    PFILE_SYSTEM FileSystem;
    BOOLEAN Success;
    BOOLEAN BackwardCompatible = FALSE; // Default to latest FS versions.
    MEDIA_TYPE MediaType;
 
    FileSystem = GetFileSystemByName(FileSystemName);
 
    if (!FileSystem || !FileSystem->FormatFunc)
    {
        // Success = FALSE;
        // Callback(DONE, 0, &Success);
        return STATUS_NOT_SUPPORTED;
    }
 
    /* Set the BackwardCompatible flag in case we format with older FAT12/16 */
    if (_wcsicmp(FileSystemName, L"FAT") == 0)
        BackwardCompatible = TRUE;
    // else if (_wcsicmp(FileSystemName, L"FAT32") == 0)
        // BackwardCompatible = FALSE;
 
    /* Convert the FMIFS MediaFlag to a NT MediaType */
    // FIXME: Actually covert all the possible flags.
    switch (MediaFlag)
    {
    case FMIFS_FLOPPY:
        MediaType = F5_320_1024; // FIXME: This is hardfixed!
        break;
    case FMIFS_REMOVABLE:
        MediaType = RemovableMedia;
        break;
    case FMIFS_HARDDISK:
        MediaType = FixedMedia;
        break;
    default:
        DPRINT1("Unknown FMIFS MediaFlag %d, converting 1-to-1 to NT MediaType\n",
                MediaFlag);
        MediaType = (MEDIA_TYPE)MediaFlag;
        break;
    }
 
    Success = FileSystem->FormatFunc(DriveRoot,
                                     Callback,
                                     QuickFormat,
                                     BackwardCompatible,
                                     MediaType,
                                     Label,
                                     ClusterSize);
    if (!Success)
        DPRINT1("FormatFunc() failed\n");
 
    // Callback(DONE, 0, &Success);
 
    return (Success ? STATUS_SUCCESS : STATUS_UNSUCCESSFUL);
}

Referenced by FormatFileSystem().

FormatPartition()

NTSTATUS FormatPartition	(	_In_ PPARTENTRY	PartEntry,
		_In_ PCWSTR	FileSystemName,
		_In_ FMIFS_MEDIA_FLAG	MediaFlag,
		_In_opt_ PCWSTR	Label,
		_In_ BOOLEAN	QuickFormat,
		_In_ ULONG	ClusterSize,
		_In_opt_ PFMIFSCALLBACK	Callback
	)

Definition at line 793 of file fsutil.c.

{
    NTSTATUS Status;
    PDISKENTRY DiskEntry = PartEntry->DiskEntry;
    UCHAR PartitionType;
    // UNICODE_STRING PartitionRootPath;
    WCHAR PartitionRootPath[MAX_PATH]; // PathBuffer
 
    ASSERT(PartEntry->IsPartitioned && PartEntry->PartitionNumber != 0);
 
    if (!FileSystemName || !*FileSystemName)
    {
        DPRINT1("No file system specified?\n");
        return STATUS_UNRECOGNIZED_VOLUME;
    }
 
    /*
     * Prepare the partition for formatting (for MBR disks, reset the
     * partition type), and adjust the file system name in case of FAT
     * vs. FAT32, depending on the geometry of the partition.
     */
 
// FIXME: Do this only if QuickFormat == FALSE? What about FAT handling?
 
    /*
     * Retrieve a partition type as a hint only. It will be used to determine
     * whether to actually use FAT12/16 or FAT32 file system, depending on the
     * geometry of the partition. If the partition resides on an MBR disk,
     * the partition style will be reset to this value as well, unless the
     * partition is OEM.
     */
    PartitionType = FileSystemToMBRPartitionType(FileSystemName,
                                                 PartEntry->StartSector.QuadPart,
                                                 PartEntry->SectorCount.QuadPart);
    if (PartitionType == PARTITION_ENTRY_UNUSED)
    {
        /* Unknown file system */
        DPRINT1("Unknown file system '%S'\n", FileSystemName);
        return STATUS_UNRECOGNIZED_VOLUME;
    }
 
    /* Reset the MBR partition type, unless this is an OEM partition */
    if (DiskEntry->DiskStyle == PARTITION_STYLE_MBR)
    {
        if (!IsOEMPartition(PartEntry->PartitionType))
            SetMBRPartitionType(PartEntry, PartitionType);
    }
 
    /*
     * Adjust the file system name in case of FAT vs. FAT32, according to
     * the type of partition returned by FileSystemToMBRPartitionType().
     */
    if (_wcsicmp(FileSystemName, L"FAT") == 0)
    {
        if ((PartitionType == PARTITION_FAT32) ||
            (PartitionType == PARTITION_FAT32_XINT13))
        {
            FileSystemName = L"FAT32";
        }
    }
 
    /* Commit the partition changes to the disk */
    Status = WritePartitions(DiskEntry);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("WritePartitions(disk %lu) failed, Status 0x%08lx\n",
                DiskEntry->DiskNumber, Status);
        return STATUS_PARTITION_FAILURE;
    }
 
    /* Set PartitionRootPath */
    RtlStringCchPrintfW(PartitionRootPath, ARRAYSIZE(PartitionRootPath),
                        L"\\Device\\Harddisk%lu\\Partition%lu",
                        DiskEntry->DiskNumber,
                        PartEntry->PartitionNumber);
    DPRINT("PartitionRootPath: %S\n", PartitionRootPath);
 
    /* Format the partition */
    Status = FormatFileSystem(PartitionRootPath,
                              FileSystemName,
                              MediaFlag,
                              Label,
                              QuickFormat,
                              ClusterSize,
                              Callback);
    if (!NT_SUCCESS(Status))
        return Status;
 
//
// TODO: Here, call a partlist.c function that update the actual
// FS name and the label fields of the volume.
//
    PartEntry->FormatState = Formatted;
 
    /* Set the new partition's file system proper */
    RtlStringCbCopyW(PartEntry->FileSystem,
                     sizeof(PartEntry->FileSystem),
                     FileSystemName);
 
    PartEntry->New = FALSE;
 
    return STATUS_SUCCESS;
}

Referenced by DoFormatting().

FsVolCommitOpsQueue()

BOOLEAN FsVolCommitOpsQueue	(	_In_ PPARTLIST	PartitionList,
		_In_ PPARTENTRY	SystemPartition,
		_In_ PPARTENTRY	InstallPartition,
		_In_opt_ PFSVOL_CALLBACK	FsVolCallback,
		_In_opt_ PVOID	Context
	)

HACK!!

END HACK!!

Definition at line 1137 of file fsutil.c.

{
    BOOLEAN Success = TRUE; // Suppose success originally.
    FSVOL_OP Result;
    PPARTENTRY PartEntry;
 
    /* Machine state for the format step */
    typedef enum _FORMATMACHINESTATE
    {
        Start,
        FormatSystemVolume,
        FormatInstallVolume,
        FormatOtherVolume,
        FormatDone
    } FORMATMACHINESTATE;
    FORMATMACHINESTATE FormatState, OldFormatState;
    static const PCSTR FormatStateNames[] = {
        "Start",
        "FormatSystemVolume",
        "FormatInstallVolume",
        "FormatOtherVolume",
        "FormatDone"
    };
 
    ASSERT(PartitionList && InstallPartition && SystemPartition);
 
    /* Commit all partition changes to all the disks */
    if (!WritePartitionsToDisk(PartitionList))
    {
        DPRINT("WritePartitionsToDisk() failed\n");
        /* Result = */ FsVolCallback(Context,
                            FSVOLNOTIFY_PARTITIONERROR,
                            STATUS_PARTITION_FAILURE, // FIXME
                            0);
        return FALSE;
    }
 
//
// FIXME: Should we do the following here, or in the caller?
//
    /*
     * In all cases, whether or not we are going to perform a formatting,
     * we must perform a file system check of both the system and the
     * installation volumes.
     */
    SystemPartition->NeedsCheck = TRUE;
    InstallPartition->NeedsCheck = TRUE;
 
    Result = FsVolCallback(Context,
                           FSVOLNOTIFY_STARTQUEUE,
                           0, 0);
    if (Result == FSVOL_ABORT)
        return FALSE;
 
    /*
     * Commit the Format queue
     */
 
    Result = FsVolCallback(Context,
                           FSVOLNOTIFY_STARTSUBQUEUE,
                           FSVOL_FORMAT,
                           0);
    if (Result == FSVOL_ABORT)
        return FALSE;
    if (Result == FSVOL_SKIP)
        goto StartCheckQueue;
    /* Reset the formatter machine state */
    FormatState = Start;
NextFormat:
    PartEntry = NULL;
    OldFormatState = FormatState;
    switch (FormatState)
    {
        case Start:
        {
            /*
             * We start by formatting the system volume in case it is new
             * (it didn't exist before) and is not the same as the installation
             * volume. Otherwise we just require a file system check on it,
             * and start by formatting the installation volume instead.
             */
            ASSERT(SystemPartition->IsPartitioned);
            if (SystemPartition != InstallPartition)
            {
                PartEntry = SystemPartition;
 
                if (PartEntry->FormatState == Unformatted)
                {
                    // TODO: Should we let the user use a custom file system,
                    // or should we always use FAT(32) for it?
                    // For "compatibility", FAT(32) would be best indeed.
 
                    FormatState = FormatSystemVolume;
                    DPRINT1("FormatState: %s --> %s\n",
                            FormatStateNames[OldFormatState], FormatStateNames[FormatState]);
                    break;
                }
 
                /* The system volume is separate, so it had better be formatted! */
                ASSERT((PartEntry->FormatState == Preformatted) ||
                       (PartEntry->FormatState == Formatted));
 
                /* Require a file system check on the system volume too */
                PartEntry->NeedsCheck = TRUE;
            }
            __fallthrough;
        }
 
        case FormatSystemVolume:
        {
            PartEntry = InstallPartition;
 
            FormatState = FormatInstallVolume;
            DPRINT1("FormatState: %s --> %s\n",
                    FormatStateNames[OldFormatState], FormatStateNames[FormatState]);
            break;
        }
 
        case FormatInstallVolume:
        case FormatOtherVolume:
        {
            BOOLEAN Found = GetNextUnformattedPartition(PartitionList, &PartEntry);
            if (Found) ASSERT(PartEntry);
 
            FormatState = (PartEntry ? FormatOtherVolume : FormatDone);
            DPRINT1("FormatState: %s --> %s\n",
                    FormatStateNames[OldFormatState], FormatStateNames[FormatState]);
            if (Found)
                break;
            __fallthrough;
        }
 
        case FormatDone:
        {
            DPRINT1("FormatState: FormatDone\n");
            Success = TRUE;
            goto EndFormat;
        }
        DEFAULT_UNREACHABLE;
    }
 
    ASSERT(PartEntry);
    Result = DoFormatting(PartEntry, Context, FsVolCallback);
    if (Result == FSVOL_ABORT)
    {
        Success = FALSE;
        goto Quit;
    }
    /* Schedule a check for this volume */
    PartEntry->NeedsCheck = TRUE;
    /* Go to the next volume to be formatted */
    goto NextFormat;
 
EndFormat:
    FsVolCallback(Context,
                  FSVOLNOTIFY_ENDSUBQUEUE,
                  FSVOL_FORMAT,
                  0);
 
 
    /*
     * Commit the CheckFS queue
     */
 
StartCheckQueue:
    Result = FsVolCallback(Context,
                           FSVOLNOTIFY_STARTSUBQUEUE,
                           FSVOL_CHECK,
                           0);
    if (Result == FSVOL_ABORT)
        return FALSE;
 
NextCheck:
    if (!GetNextUncheckedPartition(PartitionList, &PartEntry))
    {
        Success = TRUE;
        goto EndCheck;
    }
 
    ASSERT(PartEntry);
    Result = DoChecking(PartEntry, Context, FsVolCallback);
    if (Result == FSVOL_ABORT)
    {
        Success = FALSE;
        goto Quit;
    }
    /* Go to the next volume to be checked */
    goto NextCheck;
 
EndCheck:
    FsVolCallback(Context,
                  FSVOLNOTIFY_ENDSUBQUEUE,
                  FSVOL_CHECK,
                  0);
 
 
Quit:
    /* All the queues have been committed */
    FsVolCallback(Context,
                  FSVOLNOTIFY_ENDQUEUE,
                  Success,
                  0);
    return Success;
}

Referenced by StartPartitionOperationsPage().

GetFileSystemByName()

static PFILE_SYSTEM GetFileSystemByName ( IN PCWSTR  FileSystemName )

static

GetProvider()

Definition at line 197 of file fsutil.c.

{
#if 0 // Reenable when the list of registered FSes will again be dynamic
 
    PLIST_ENTRY ListEntry;
    PFILE_SYSTEM_ITEM Item;
 
    ListEntry = List->ListHead.Flink;
    while (ListEntry != &List->ListHead)
    {
        Item = CONTAINING_RECORD(ListEntry, FILE_SYSTEM_ITEM, ListEntry);
        if (Item->FileSystemName &&
            (_wcsicmp(FileSystemName, Item->FileSystemName) == 0))
        {
            return Item;
        }
 
        ListEntry = ListEntry->Flink;
    }
 
#else
 
    ULONG Count = ARRAYSIZE(RegisteredFileSystems);
    PFILE_SYSTEM FileSystems = RegisteredFileSystems;
 
    ASSERT(FileSystems && Count != 0);
 
    while (Count--)
    {
        if (FileSystems->FileSystemName &&
            (_wcsicmp(FileSystemName, FileSystems->FileSystemName) == 0))
        {
            return FileSystems;
        }
 
        ++FileSystems;
    }
 
#endif
 
    return NULL;
}

Referenced by ChkdskFileSystem_UStr(), and FormatFileSystem_UStr().

GetNextUncheckedPartition()

static BOOLEAN GetNextUncheckedPartition ( IN PPARTLIST  List, OUT PPARTENTRY *  pPartEntry  )

static

Definition at line 1083 of file fsutil.c.

{
    PLIST_ENTRY Entry1, Entry2;
    PDISKENTRY DiskEntry;
    PPARTENTRY PartEntry;
 
    for (Entry1 = List->DiskListHead.Flink;
         Entry1 != &List->DiskListHead;
         Entry1 = Entry1->Flink)
    {
        DiskEntry = CONTAINING_RECORD(Entry1,
                                      DISKENTRY,
                                      ListEntry);
 
        if (DiskEntry->DiskStyle == PARTITION_STYLE_GPT)
        {
            DPRINT("GPT-partitioned disk detected, not currently supported by SETUP!\n");
            continue;
        }
 
        for (Entry2 = DiskEntry->PrimaryPartListHead.Flink;
             Entry2 != &DiskEntry->PrimaryPartListHead;
             Entry2 = Entry2->Flink)
        {
            PartEntry = CONTAINING_RECORD(Entry2, PARTENTRY, ListEntry);
            if (PartEntry->IsPartitioned && PartEntry->NeedsCheck)
            {
                ASSERT(DiskEntry == PartEntry->DiskEntry);
                *pPartEntry = PartEntry;
                return TRUE;
            }
        }
 
        for (Entry2 = DiskEntry->LogicalPartListHead.Flink;
             Entry2 != &DiskEntry->LogicalPartListHead;
             Entry2 = Entry2->Flink)
        {
            PartEntry = CONTAINING_RECORD(Entry2, PARTENTRY, ListEntry);
            if (PartEntry->IsPartitioned && PartEntry->NeedsCheck)
            {
                ASSERT(DiskEntry == PartEntry->DiskEntry);
                *pPartEntry = PartEntry;
                return TRUE;
            }
        }
    }
 
    *pPartEntry = NULL;
    return FALSE;
}

Referenced by FsVolCommitOpsQueue().

GetNextUnformattedPartition()

static BOOLEAN GetNextUnformattedPartition ( IN PPARTLIST  List, OUT PPARTENTRY *  pPartEntry  )

static

Definition at line 1029 of file fsutil.c.

{
    PLIST_ENTRY Entry1, Entry2;
    PDISKENTRY DiskEntry;
    PPARTENTRY PartEntry;
 
    for (Entry1 = List->DiskListHead.Flink;
         Entry1 != &List->DiskListHead;
         Entry1 = Entry1->Flink)
    {
        DiskEntry = CONTAINING_RECORD(Entry1,
                                      DISKENTRY,
                                      ListEntry);
 
        if (DiskEntry->DiskStyle == PARTITION_STYLE_GPT)
        {
            DPRINT("GPT-partitioned disk detected, not currently supported by SETUP!\n");
            continue;
        }
 
        for (Entry2 = DiskEntry->PrimaryPartListHead.Flink;
             Entry2 != &DiskEntry->PrimaryPartListHead;
             Entry2 = Entry2->Flink)
        {
            PartEntry = CONTAINING_RECORD(Entry2, PARTENTRY, ListEntry);
            if (PartEntry->IsPartitioned && PartEntry->New)
            {
                ASSERT(DiskEntry == PartEntry->DiskEntry);
                *pPartEntry = PartEntry;
                return TRUE;
            }
        }
 
        for (Entry2 = DiskEntry->LogicalPartListHead.Flink;
             Entry2 != &DiskEntry->LogicalPartListHead;
             Entry2 = Entry2->Flink)
        {
            PartEntry = CONTAINING_RECORD(Entry2, PARTENTRY, ListEntry);
            if (PartEntry->IsPartitioned && PartEntry->New)
            {
                ASSERT(DiskEntry == PartEntry->DiskEntry);
                *pPartEntry = PartEntry;
                return TRUE;
            }
        }
    }
 
    *pPartEntry = NULL;
    return FALSE;
}

Referenced by FsVolCommitOpsQueue().

GetRegisteredFileSystems()

BOOLEAN GetRegisteredFileSystems	(	IN ULONG	Index,
		OUT PCWSTR *	FileSystemName
	)

QueryAvailableFileSystemFormat()

Definition at line 182 of file fsutil.c.

{
    if (Index >= ARRAYSIZE(RegisteredFileSystems))
        return FALSE;
 
    *FileSystemName = RegisteredFileSystems[Index].FileSystemName;
 
    return TRUE;
}

Referenced by InitializeFileSystemList().

InstallBtrfsBootCode()

NTSTATUS InstallBtrfsBootCode	(	IN PCWSTR	SrcPath,
		IN HANDLE	DstPath,
		IN HANDLE	RootPartition
	)

Definition at line 585 of file fsutil.c.

{
    NTSTATUS Status;
    NTSTATUS LockStatus;
    UNICODE_STRING Name;
    IO_STATUS_BLOCK IoStatusBlock;
    LARGE_INTEGER FileOffset;
    PARTITION_INFORMATION_EX PartInfo;
    BOOTCODE NewBootSector = {0};
 
    /* Allocate and read the new bootsector from SrcPath */
    RtlInitUnicodeString(&Name, SrcPath);
    Status = ReadBootCodeFromFile(&NewBootSector,
                                  &Name,
                                  BTRFS_BOOTSECTOR_SIZE);
    if (!NT_SUCCESS(Status))
        return Status;
 
    /*
     * The BTRFS driver requires the volume to be locked in order to modify
     * the first sectors of the partition, even though they are outside the
     * file-system space / in the reserved area (they are situated before
     * the super-block at 0x1000) and is in principle allowed by the NT
     * storage stack.
     * So we lock here in order to write the bootsector at sector 0.
     * If locking fails, we ignore and continue nonetheless.
     */
    LockStatus = NtFsControlFile(DstPath,
                                 NULL,
                                 NULL,
                                 NULL,
                                 &IoStatusBlock,
                                 FSCTL_LOCK_VOLUME,
                                 NULL,
                                 0,
                                 NULL,
                                 0);
    if (!NT_SUCCESS(LockStatus))
    {
        DPRINT1("WARNING: Failed to lock BTRFS volume for writing bootsector! Operations may fail! (Status 0x%lx)\n", LockStatus);
    }
 
    /* Obtain partition info and write it to the bootsector */
    Status = NtDeviceIoControlFile(RootPartition,
                                   NULL,
                                   NULL,
                                   NULL,
                                   &IoStatusBlock,
                                   IOCTL_DISK_GET_PARTITION_INFO_EX,
                                   NULL,
                                   0,
                                   &PartInfo,
                                   sizeof(PartInfo));
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("IOCTL_DISK_GET_PARTITION_INFO_EX failed (Status %lx)\n", Status);
        goto Quit;
    }
 
    /* Write new bootsector to RootPath */
    ((PBTRFS_BOOTSECTOR)NewBootSector.BootCode)->PartitionStartLBA =
        PartInfo.StartingOffset.QuadPart / SECTORSIZE;
 
    /* Write sector 0 */
    FileOffset.QuadPart = 0ULL;
    Status = NtWriteFile(DstPath,
                         NULL,
                         NULL,
                         NULL,
                         &IoStatusBlock,
                         NewBootSector.BootCode,
                         NewBootSector.Length,
                         &FileOffset,
                         NULL);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("NtWriteFile() failed (Status %lx)\n", Status);
        goto Quit;
    }
 
Quit:
    /* Unlock the volume */
    LockStatus = NtFsControlFile(DstPath,
                                 NULL,
                                 NULL,
                                 NULL,
                                 &IoStatusBlock,
                                 FSCTL_UNLOCK_VOLUME,
                                 NULL,
                                 0,
                                 NULL,
                                 0);
    if (!NT_SUCCESS(LockStatus))
    {
        DPRINT1("Failed to unlock BTRFS volume (Status 0x%lx)\n", LockStatus);
    }
 
    /* Free the new bootsector */
    FreeBootCode(&NewBootSector);
 
    return Status;
}

Referenced by InstallBtrfsBootcodeToPartition().

InstallFat32BootCode()

NTSTATUS InstallFat32BootCode	(	IN PCWSTR	SrcPath,
		IN HANDLE	DstPath,
		IN HANDLE	RootPartition
	)

Definition at line 464 of file fsutil.c.

{
    NTSTATUS Status;
    UNICODE_STRING Name;
    IO_STATUS_BLOCK IoStatusBlock;
    LARGE_INTEGER FileOffset;
    USHORT BackupBootSector = 0;
    BOOTCODE OrigBootSector = {0};
    BOOTCODE NewBootSector  = {0};
 
    /* Allocate and read the current original partition bootsector */
    Status = ReadBootCodeByHandle(&OrigBootSector,
                                  RootPartition,
                                  FAT32_BOOTSECTOR_SIZE);
    if (!NT_SUCCESS(Status))
        return Status;
 
    /* Allocate and read the new bootsector (2 sectors) from SrcPath */
    RtlInitUnicodeString(&Name, SrcPath);
    Status = ReadBootCodeFromFile(&NewBootSector,
                                  &Name,
                                  2 * FAT32_BOOTSECTOR_SIZE);
    if (!NT_SUCCESS(Status))
    {
        FreeBootCode(&OrigBootSector);
        return Status;
    }
 
    /* Adjust the bootsector (copy a part of the FAT32 BPB) */
    RtlCopyMemory(&((PFAT32_BOOTSECTOR)NewBootSector.BootCode)->OemName,
                  &((PFAT32_BOOTSECTOR)OrigBootSector.BootCode)->OemName,
                  FIELD_OFFSET(FAT32_BOOTSECTOR, BootCodeAndData) -
                  FIELD_OFFSET(FAT32_BOOTSECTOR, OemName));
 
    /*
     * We know we copy the boot code to a file only when DstPath != RootPartition,
     * otherwise the boot code is copied to the specified root partition.
     */
    if (DstPath != RootPartition)
    {
        /* Copy to a file: Disable the backup bootsector */
        ((PFAT32_BOOTSECTOR)NewBootSector.BootCode)->BackupBootSector = 0;
    }
    else
    {
        /* Copy to a disk: Get the location of the backup bootsector */
        BackupBootSector = ((PFAT32_BOOTSECTOR)OrigBootSector.BootCode)->BackupBootSector;
    }
 
    /* Free the original bootsector */
    FreeBootCode(&OrigBootSector);
 
    /* Write the first sector of the new bootcode to DstPath sector 0 */
    FileOffset.QuadPart = 0ULL;
    Status = NtWriteFile(DstPath,
                         NULL,
                         NULL,
                         NULL,
                         &IoStatusBlock,
                         NewBootSector.BootCode,
                         FAT32_BOOTSECTOR_SIZE,
                         &FileOffset,
                         NULL);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("NtWriteFile() failed (Status %lx)\n", Status);
        FreeBootCode(&NewBootSector);
        return Status;
    }
 
    if (DstPath == RootPartition)
    {
        /* Copy to a disk: Write the backup bootsector */
        if ((BackupBootSector != 0x0000) && (BackupBootSector != 0xFFFF))
        {
            FileOffset.QuadPart = (ULONGLONG)((ULONG)BackupBootSector * FAT32_BOOTSECTOR_SIZE);
            Status = NtWriteFile(DstPath,
                                 NULL,
                                 NULL,
                                 NULL,
                                 &IoStatusBlock,
                                 NewBootSector.BootCode,
                                 FAT32_BOOTSECTOR_SIZE,
                                 &FileOffset,
                                 NULL);
            if (!NT_SUCCESS(Status))
            {
                DPRINT1("NtWriteFile() failed (Status %lx)\n", Status);
                FreeBootCode(&NewBootSector);
                return Status;
            }
        }
    }
 
    /* Write the second sector of the new bootcode to boot disk sector 14 */
    // FileOffset.QuadPart = (ULONGLONG)(14 * FAT32_BOOTSECTOR_SIZE);
    FileOffset.QuadPart = 14 * FAT32_BOOTSECTOR_SIZE;
    Status = NtWriteFile(DstPath,   // or really RootPartition ???
                         NULL,
                         NULL,
                         NULL,
                         &IoStatusBlock,
                         ((PUCHAR)NewBootSector.BootCode + FAT32_BOOTSECTOR_SIZE),
                         FAT32_BOOTSECTOR_SIZE,
                         &FileOffset,
                         NULL);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("NtWriteFile() failed (Status %lx)\n", Status);
    }
 
    /* Free the new bootsector */
    FreeBootCode(&NewBootSector);
 
    return Status;
}

Referenced by InstallFatBootcodeToPartition().

InstallFatBootCode()

NTSTATUS InstallFatBootCode	(	IN PCWSTR	SrcPath,
		IN HANDLE	DstPath,
		IN HANDLE	RootPartition
	)

Definition at line 406 of file fsutil.c.

{
    NTSTATUS Status;
    UNICODE_STRING Name;
    IO_STATUS_BLOCK IoStatusBlock;
    LARGE_INTEGER FileOffset;
    BOOTCODE OrigBootSector = {0};
    BOOTCODE NewBootSector  = {0};
 
    /* Allocate and read the current original partition bootsector */
    Status = ReadBootCodeByHandle(&OrigBootSector,
                                  RootPartition,
                                  FAT_BOOTSECTOR_SIZE);
    if (!NT_SUCCESS(Status))
        return Status;
 
    /* Allocate and read the new bootsector from SrcPath */
    RtlInitUnicodeString(&Name, SrcPath);
    Status = ReadBootCodeFromFile(&NewBootSector,
                                  &Name,
                                  FAT_BOOTSECTOR_SIZE);
    if (!NT_SUCCESS(Status))
    {
        FreeBootCode(&OrigBootSector);
        return Status;
    }
 
    /* Adjust the bootsector (copy a part of the FAT12/16 BPB) */
    RtlCopyMemory(&((PFAT_BOOTSECTOR)NewBootSector.BootCode)->OemName,
                  &((PFAT_BOOTSECTOR)OrigBootSector.BootCode)->OemName,
                  FIELD_OFFSET(FAT_BOOTSECTOR, BootCodeAndData) -
                  FIELD_OFFSET(FAT_BOOTSECTOR, OemName));
 
    /* Free the original bootsector */
    FreeBootCode(&OrigBootSector);
 
    /* Write the new bootsector to DstPath */
    FileOffset.QuadPart = 0ULL;
    Status = NtWriteFile(DstPath,
                         NULL,
                         NULL,
                         NULL,
                         &IoStatusBlock,
                         NewBootSector.BootCode,
                         NewBootSector.Length,
                         &FileOffset,
                         NULL);
 
    /* Free the new bootsector */
    FreeBootCode(&NewBootSector);
 
    return Status;
}

InstallNtfsBootCode()

NTSTATUS InstallNtfsBootCode	(	IN PCWSTR	SrcPath,
		IN HANDLE	DstPath,
		IN HANDLE	RootPartition
	)

Definition at line 692 of file fsutil.c.

{
    NTSTATUS Status;
    UNICODE_STRING Name;
    IO_STATUS_BLOCK IoStatusBlock;
    LARGE_INTEGER FileOffset;
    BOOTCODE OrigBootSector = {0};
    BOOTCODE NewBootSector  = {0};
 
    /* Allocate and read the current original partition bootsector */
    Status = ReadBootCodeByHandle(&OrigBootSector, RootPartition, NTFS_BOOTSECTOR_SIZE);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("InstallNtfsBootCode: Status %lx\n", Status);
        return Status;
    }
 
    /* Allocate and read the new bootsector (16 sectors) from SrcPath */
    RtlInitUnicodeString(&Name, SrcPath);
    Status = ReadBootCodeFromFile(&NewBootSector, &Name, NTFS_BOOTSECTOR_SIZE);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("InstallNtfsBootCode: Status %lx\n", Status);
        FreeBootCode(&OrigBootSector);
        return Status;
    }
 
    /* Adjust the bootsector (copy a part of the NTFS BPB) */
    RtlCopyMemory(&((PNTFS_BOOTSECTOR)NewBootSector.BootCode)->OEMID,
                  &((PNTFS_BOOTSECTOR)OrigBootSector.BootCode)->OEMID,
                  FIELD_OFFSET(NTFS_BOOTSECTOR, BootStrap) - FIELD_OFFSET(NTFS_BOOTSECTOR, OEMID));
 
    /* Write sector 0 */
    FileOffset.QuadPart = 0ULL;
    Status = NtWriteFile(DstPath,
                         NULL,
                         NULL,
                         NULL,
                         &IoStatusBlock,
                         NewBootSector.BootCode,
                         NewBootSector.Length,
                         &FileOffset,
                         NULL);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("NtWriteFile() failed (Status %lx)\n", Status);
        goto Quit;
    }
 
Quit:
    /* Free the new bootsector */
    FreeBootCode(&NewBootSector);
 
    return Status;
}

Referenced by InstallNtfsBootcodeToPartition().

Variable Documentation

RegisteredFileSystems

FILE_SYSTEM RegisteredFileSystems[]

static

Initial value:

=
{
    
    { L"FAT"  , VfatFormat, VfatChkdsk },
    { L"FAT32", VfatFormat, VfatChkdsk },
 
 
 
 
    { L"BTRFS", BtrfsFormat, BtrfsChkdsk },
 
 
 
 
 
}

Definition at line 159 of file fsutil.c.

Referenced by BlImgStartBootApplication(), GetFileSystemByName(), and GetRegisteredFileSystems().