disksup.c File Reference

#include <ntoskrnl.h>
#include <internal/hal.h>
#include <debug.h>

Include dependency graph for disksup.c:

Go to the source code of this file.

Macros
#define	NDEBUG
#define	EFI_PMBR_OSTYPE_EFI   0xEE

Typedefs
typedef enum _DISK_MANAGER	DISK_MANAGER
typedef enum _PARTITION_TYPE	PARTITION_TYPE
typedef enum _PARTITION_TYPE *	PPARTITION_TYPE

Enumerations
enum	_DISK_MANAGER { NoDiskManager , OntrackDiskManager , EZ_Drive }
enum	_PARTITION_TYPE {   BootablePartition , PrimaryPartition , LogicalPartition , FtPartition ,   UnknownPartition , DataPartition }

Functions
static NTSTATUS	HalpQueryDriveLayout (_In_ PUNICODE_STRING DeviceName, _Outptr_ PDRIVE_LAYOUT_INFORMATION *LayoutInfo)
static NTSTATUS	HalpQueryPartitionType (_In_ PUNICODE_STRING DeviceName, _In_opt_ PDRIVE_LAYOUT_INFORMATION LayoutInfo, _Out_ PPARTITION_TYPE PartitionType)
static PULONG	IopComputeHarddiskDerangements (_In_ ULONG DiskCount)
static NTSTATUS	HalpNextMountLetter (_In_ PUNICODE_STRING DeviceName, _Out_ PUCHAR DriveLetter)
static NTSTATUS	HalpSetMountLetter (_In_ PUNICODE_STRING DeviceName, _In_ UCHAR DriveLetter)
static UCHAR	HalpNextDriveLetter (_In_ PUNICODE_STRING DeviceName, _In_ PSTRING NtDeviceName, _Out_ PUCHAR NtSystemPath, _In_ BOOLEAN IsRemovable)
static BOOLEAN	HalpIsOldStyleFloppy (_In_ PUNICODE_STRING DeviceName)
static NTSTATUS	HalpDeleteMountLetter (_In_ UCHAR DriveLetter)
static VOID	HalpEnableAutomaticDriveLetterAssignment (VOID)
VOID FASTCALL	xHalIoAssignDriveLetters (IN PLOADER_PARAMETER_BLOCK LoaderBlock, IN PSTRING NtDeviceName, OUT PUCHAR NtSystemPath, OUT PSTRING NtSystemPathString)
static NTSTATUS	HalpGetFullGeometry (_In_ PDEVICE_OBJECT DeviceObject, _Out_ PDISK_GEOMETRY_EX Geometry)
static BOOLEAN	HalpIsValidPartitionEntry (_In_ PPARTITION_DESCRIPTOR Entry, _In_ ULONGLONG MaxOffset, _In_ ULONGLONG MaxSector)
static VOID	HalpCalculateChsValues (_In_ PLARGE_INTEGER PartitionOffset, _In_ PLARGE_INTEGER PartitionLength, _In_ CCHAR ShiftCount, _In_ ULONG SectorsPerTrack, _In_ ULONG NumberOfTracks, _In_ ULONG ConventionalCylinders, _Out_ PPARTITION_DESCRIPTOR PartitionDescriptor)
VOID FASTCALL	xHalGetPartialGeometry (IN PDEVICE_OBJECT DeviceObject, IN PULONG ConventionalCylinders, IN PLONGLONG DiskSize)
VOID FASTCALL	xHalExamineMBR (IN PDEVICE_OBJECT DeviceObject, IN ULONG SectorSize, IN ULONG MbrTypeIdentifier, OUT PVOID *MbrBuffer)
VOID NTAPI	FstubFixupEfiPartition (IN PPARTITION_DESCRIPTOR PartitionDescriptor, IN ULONGLONG MaxOffset)
NTSTATUS FASTCALL	xHalIoReadPartitionTable (IN PDEVICE_OBJECT DeviceObject, IN ULONG SectorSize, IN BOOLEAN ReturnRecognizedPartitions, OUT PDRIVE_LAYOUT_INFORMATION *PartitionBuffer)
NTSTATUS FASTCALL	xHalIoSetPartitionInformation (IN PDEVICE_OBJECT DeviceObject, IN ULONG SectorSize, IN ULONG PartitionNumber, IN ULONG PartitionType)
NTSTATUS FASTCALL	xHalIoWritePartitionTable (IN PDEVICE_OBJECT DeviceObject, IN ULONG SectorSize, IN ULONG SectorsPerTrack, IN ULONG NumberOfHeads, IN PDRIVE_LAYOUT_INFORMATION PartitionBuffer)
VOID FASTCALL	HalExamineMBR (IN PDEVICE_OBJECT DeviceObject, IN ULONG SectorSize, IN ULONG MbrTypeIdentifier, OUT PVOID *MbrBuffer)
NTSTATUS FASTCALL	IoReadPartitionTable (IN PDEVICE_OBJECT DeviceObject, IN ULONG SectorSize, IN BOOLEAN ReturnRecognizedPartitions, OUT PDRIVE_LAYOUT_INFORMATION *PartitionBuffer)
NTSTATUS FASTCALL	IoSetPartitionInformation (IN PDEVICE_OBJECT DeviceObject, IN ULONG SectorSize, IN ULONG PartitionNumber, IN ULONG PartitionType)
NTSTATUS FASTCALL	IoWritePartitionTable (IN PDEVICE_OBJECT DeviceObject, IN ULONG SectorSize, IN ULONG SectorsPerTrack, IN ULONG NumberOfHeads, IN PDRIVE_LAYOUT_INFORMATION PartitionBuffer)
VOID FASTCALL	IoAssignDriveLetters (IN PLOADER_PARAMETER_BLOCK LoaderBlock, IN PSTRING NtDeviceName, OUT PUCHAR NtSystemPath, OUT PSTRING NtSystemPathString)

Variables
static const UNICODE_STRING	FloppyPrefix = RTL_CONSTANT_STRING(L"\\Device\\Floppy")
static const UNICODE_STRING	CdPrefix = RTL_CONSTANT_STRING(L"\\Device\\CdRom")

Macro Definition Documentation

EFI_PMBR_OSTYPE_EFI

#define EFI_PMBR_OSTYPE_EFI   0xEE

Definition at line 21 of file disksup.c.

NDEBUG

#define NDEBUG

Definition at line 17 of file disksup.c.

Typedef Documentation

DISK_MANAGER

typedef enum _DISK_MANAGER DISK_MANAGER

PARTITION_TYPE

typedef enum _PARTITION_TYPE PARTITION_TYPE

PPARTITION_TYPE

typedef enum _PARTITION_TYPE * PPARTITION_TYPE

Enumeration Type Documentation

_DISK_MANAGER

enum _DISK_MANAGER

Enumerator
NoDiskManager
OntrackDiskManager
EZ_Drive

Definition at line 23 of file disksup.c.

{
    NoDiskManager,
    OntrackDiskManager,
    EZ_Drive
} DISK_MANAGER;

_PARTITION_TYPE

enum _PARTITION_TYPE

Enumerator
BootablePartition
PrimaryPartition
LogicalPartition
FtPartition
UnknownPartition
DataPartition

Definition at line 30 of file disksup.c.

{
    BootablePartition,
    PrimaryPartition,
    LogicalPartition,
    FtPartition,
    UnknownPartition,
    DataPartition
} PARTITION_TYPE, *PPARTITION_TYPE;

Function Documentation

FstubFixupEfiPartition()

VOID NTAPI FstubFixupEfiPartition	(	IN PPARTITION_DESCRIPTOR	PartitionDescriptor,
		IN ULONGLONG	MaxOffset
	)

Definition at line 1635 of file disksup.c.

{
    ULONG PartitionMaxOffset, PartitionLength;
    PAGED_CODE();
 
    /* Compute partition length (according to MBR entry) */
    PartitionMaxOffset = GET_STARTING_SECTOR(PartitionDescriptor) + GET_PARTITION_LENGTH(PartitionDescriptor);
    /* In case the partition length goes beyond disk size... */
    if (PartitionMaxOffset > MaxOffset)
    {
        /* Resize partition to its maximum real length */
        PartitionLength = (ULONG)(PartitionMaxOffset - GET_STARTING_SECTOR(PartitionDescriptor));
        SET_PARTITION_LENGTH(PartitionDescriptor, PartitionLength);
    }
}

Referenced by xHalIoReadPartitionTable().

HalExamineMBR()

VOID FASTCALL HalExamineMBR	(	IN PDEVICE_OBJECT	DeviceObject,
		IN ULONG	SectorSize,
		IN ULONG	MbrTypeIdentifier,
		OUT PVOID *	MbrBuffer
	)

Definition at line 2565 of file disksup.c.

{
    HALDISPATCH->HalExamineMBR(DeviceObject,
                               SectorSize,
                               MbrTypeIdentifier,
                               MbrBuffer);
}

HalpCalculateChsValues()

static VOID HalpCalculateChsValues ( _In_ PLARGE_INTEGER  PartitionOffset, _In_ PLARGE_INTEGER  PartitionLength, _In_ CCHAR  ShiftCount, _In_ ULONG  SectorsPerTrack, _In_ ULONG  NumberOfTracks, _In_ ULONG  ConventionalCylinders, _Out_ PPARTITION_DESCRIPTOR  PartitionDescriptor  )

static

Definition at line 1366 of file disksup.c.

{
    LARGE_INTEGER FirstSector, SectorCount;
    ULONG LastSector, Remainder, SectorsPerCylinder;
    ULONG StartingCylinder, EndingCylinder;
    ULONG StartingTrack, EndingTrack;
    ULONG StartingSector, EndingSector;
 
    PAGED_CODE();
 
    /* Calculate the number of sectors for each cylinder */
    SectorsPerCylinder = SectorsPerTrack * NumberOfTracks;
 
    /* Calculate the first sector, and the sector count */
    FirstSector.QuadPart = PartitionOffset->QuadPart >> ShiftCount;
    SectorCount.QuadPart = PartitionLength->QuadPart >> ShiftCount;
 
    /* Now calculate the last sector */
    LastSector = FirstSector.LowPart + SectorCount.LowPart - 1;
 
    /* Calculate the first and last cylinders */
    StartingCylinder = FirstSector.LowPart / SectorsPerCylinder;
    EndingCylinder = LastSector / SectorsPerCylinder;
 
    /* Set the default number of cylinders */
    if (!ConventionalCylinders) ConventionalCylinders = 1024;
 
    /* Normalize the values */
    if (StartingCylinder >= ConventionalCylinders)
    {
        /* Set the maximum to 1023 */
        StartingCylinder = ConventionalCylinders - 1;
    }
    if (EndingCylinder >= ConventionalCylinders)
    {
        /* Set the maximum to 1023 */
        EndingCylinder = ConventionalCylinders - 1;
    }
 
    /* Calculate the starting head and sector that still remain */
    Remainder = FirstSector.LowPart % SectorsPerCylinder;
    StartingTrack = Remainder / SectorsPerTrack;
    StartingSector = Remainder % SectorsPerTrack;
 
    /* Calculate the ending head and sector that still remain */
    Remainder = LastSector % SectorsPerCylinder;
    EndingTrack = Remainder / SectorsPerTrack;
    EndingSector = Remainder % SectorsPerTrack;
 
    /* Set cylinder data for the MSB */
    PartitionDescriptor->StartingCylinderMsb = (UCHAR)StartingCylinder;
    PartitionDescriptor->EndingCylinderMsb = (UCHAR)EndingCylinder;
 
    /* Set the track data */
    PartitionDescriptor->StartingTrack = (UCHAR)StartingTrack;
    PartitionDescriptor->EndingTrack = (UCHAR)EndingTrack;
 
    /* Update cylinder data for the LSB */
    StartingCylinder = ((StartingSector + 1) & 0x3F) |
                       ((StartingCylinder >> 2) & 0xC0);
    EndingCylinder = ((EndingSector + 1) & 0x3F) |
                     ((EndingCylinder >> 2) & 0xC0);
 
    /* Set the cylinder data for the LSB */
    PartitionDescriptor->StartingCylinderLsb = (UCHAR)StartingCylinder;
    PartitionDescriptor->EndingCylinderLsb = (UCHAR)EndingCylinder;
}

Referenced by xHalIoWritePartitionTable().

HalpDeleteMountLetter()

static NTSTATUS HalpDeleteMountLetter ( _In_ UCHAR  DriveLetter )

static

Definition at line 743 of file disksup.c.

{
    PIRP Irp;
    KEVENT Event;
    NTSTATUS Status;
    WCHAR Buffer[30];
    ULONG InputBufferLength;
    PFILE_OBJECT FileObject;
    PDEVICE_OBJECT DeviceObject;
    IO_STATUS_BLOCK IoStatusBlock;
    PMOUNTMGR_MOUNT_POINT InputBuffer;
    UNICODE_STRING DosDevice, MountMgr;
    PMOUNTMGR_MOUNT_POINTS OutputBuffer;
 
    /* Setup the device name of the letter to delete */
    swprintf(Buffer, L"\\DosDevices\\%c:", DriveLetter);
    RtlInitUnicodeString(&DosDevice, Buffer);
 
    /* Allocate the input buffer for the MountMgr */
    InputBufferLength = DosDevice.Length + sizeof(MOUNTMGR_MOUNT_POINT);
    InputBuffer = ExAllocatePoolWithTag(PagedPool, InputBufferLength, TAG_FSTUB);
    if (InputBuffer == NULL)
    {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* Fill it in */
    RtlZeroMemory(InputBuffer, InputBufferLength);
    InputBuffer->SymbolicLinkNameOffset = sizeof(MOUNTMGR_MOUNT_POINT);
    InputBuffer->SymbolicLinkNameLength = DosDevice.Length;
    RtlCopyMemory(&InputBuffer[1], DosDevice.Buffer, DosDevice.Length);
 
    /* Allocate big enough output buffer (we don't care about the output) */
    OutputBuffer = ExAllocatePoolWithTag(PagedPool, 0x1000, TAG_FSTUB);
    if (OutputBuffer == NULL)
    {
        ExFreePoolWithTag(InputBuffer, TAG_FSTUB);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* Get the device pointer to the MountMgr */
    RtlInitUnicodeString(&MountMgr, L"\\Device\\MountPointManager");
    Status = IoGetDeviceObjectPointer(&MountMgr,
                                      FILE_READ_ATTRIBUTES,
                                      &FileObject,
                                      &DeviceObject);
    if (!NT_SUCCESS(Status))
    {
        ExFreePoolWithTag(OutputBuffer, TAG_FSTUB);
        ExFreePoolWithTag(InputBuffer, TAG_FSTUB);
        return Status;
    }
 
    /* Call the MountMgr to delete the drive letter */
    KeInitializeEvent(&Event, NotificationEvent, FALSE);
    Irp = IoBuildDeviceIoControlRequest(IOCTL_MOUNTMGR_DELETE_POINTS,
                                        DeviceObject,
                                        InputBuffer,
                                        InputBufferLength,
                                        OutputBuffer,
                                        0x1000,
                                        FALSE,
                                        &Event,
                                        &IoStatusBlock);
    if (Irp == NULL)
    {
        ObDereferenceObject(FileObject);
        ExFreePoolWithTag(OutputBuffer, TAG_FSTUB);
        ExFreePoolWithTag(InputBuffer, TAG_FSTUB);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    Status = IoCallDriver(DeviceObject, Irp);
    if (Status == STATUS_PENDING)
    {
        KeWaitForSingleObject(&Event,
                              Executive,
                              KernelMode,
                              FALSE,
                              NULL);
        Status = IoStatusBlock.Status;
    }
 
    ObDereferenceObject(FileObject);
    ExFreePoolWithTag(OutputBuffer, TAG_FSTUB);
    ExFreePoolWithTag(InputBuffer, TAG_FSTUB);
 
    return Status;
}

Referenced by xHalIoAssignDriveLetters().

HalpEnableAutomaticDriveLetterAssignment()

static VOID HalpEnableAutomaticDriveLetterAssignment ( VOID  )

static

Definition at line 835 of file disksup.c.

{
    PIRP Irp;
    KEVENT Event;
    NTSTATUS Status;
    UNICODE_STRING MountMgr;
    PFILE_OBJECT FileObject;
    PDEVICE_OBJECT DeviceObject;
    IO_STATUS_BLOCK IoStatusBlock;
 
    /* Get the device pointer to the MountMgr */
    RtlInitUnicodeString(&MountMgr, L"\\Device\\MountPointManager");
    Status = IoGetDeviceObjectPointer(&MountMgr,
                                      FILE_READ_ATTRIBUTES,
                                      &FileObject,
                                      &DeviceObject);
    if (!NT_SUCCESS(Status))
    {
        return;
    }
 
    /* Just send an IOCTL to enable the feature */
    KeInitializeEvent(&Event, NotificationEvent, FALSE);
    Irp = IoBuildDeviceIoControlRequest(IOCTL_MOUNTMGR_AUTO_DL_ASSIGNMENTS,
                                        DeviceObject,
                                        NULL,
                                        0,
                                        NULL,
                                        0,
                                        FALSE,
                                        &Event,
                                        &IoStatusBlock);
    if (Irp == NULL)
    {
        return;
    }
 
    Status = IoCallDriver(DeviceObject, Irp);
    if (Status == STATUS_PENDING)
    {
        KeWaitForSingleObject(&Event,
                              Executive,
                              KernelMode,
                              FALSE,
                              NULL);
        Status = IoStatusBlock.Status;
    }
 
    ObDereferenceObject(FileObject);
 
    return;
}

Referenced by xHalIoAssignDriveLetters().

HalpGetFullGeometry()

static NTSTATUS HalpGetFullGeometry ( _In_ PDEVICE_OBJECT  DeviceObject, _Out_ PDISK_GEOMETRY_EX  Geometry  )

static

Definition at line 1271 of file disksup.c.

{
    PIRP Irp;
    IO_STATUS_BLOCK IoStatusBlock;
    PKEVENT Event;
    NTSTATUS Status;
 
    PAGED_CODE();
 
    /* Allocate a non-paged event */
    Event = ExAllocatePoolWithTag(NonPagedPool,
                                  sizeof(KEVENT),
                                  TAG_FILE_SYSTEM);
    if (!Event) return STATUS_INSUFFICIENT_RESOURCES;
 
    /* Initialize it */
    KeInitializeEvent(Event, NotificationEvent, FALSE);
 
    /* Build the IRP */
    Irp = IoBuildDeviceIoControlRequest(IOCTL_DISK_GET_DRIVE_GEOMETRY_EX,
                                        DeviceObject,
                                        NULL,
                                        0UL,
                                        Geometry,
                                        sizeof(DISK_GEOMETRY_EX),
                                        FALSE,
                                        Event,
                                        &IoStatusBlock);
    if (!Irp)
    {
        /* Fail, free the event */
        ExFreePoolWithTag(Event, TAG_FILE_SYSTEM);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* Call the driver and check if it's pending */
    Status = IoCallDriver(DeviceObject, Irp);
    if (Status == STATUS_PENDING)
    {
        /* Wait on the driver */
        KeWaitForSingleObject(Event, Executive, KernelMode, FALSE, NULL);
        Status = IoStatusBlock.Status;
    }
 
    /* Free the event and return the Status */
    ExFreePoolWithTag(Event, TAG_FILE_SYSTEM);
    return Status;
}

Referenced by xHalIoReadPartitionTable().

HalpIsOldStyleFloppy()

static BOOLEAN HalpIsOldStyleFloppy ( _In_ PUNICODE_STRING  DeviceName )

static

Definition at line 683 of file disksup.c.

{
    PIRP Irp;
    KEVENT Event;
    NTSTATUS Status;
    MOUNTDEV_NAME DevName;
    PFILE_OBJECT FileObject;
    PDEVICE_OBJECT DeviceObject;
    IO_STATUS_BLOCK IoStatusBlock;
 
    PAGED_CODE();
 
    /* Get the attached device object to our device */
    Status = IoGetDeviceObjectPointer(DeviceName,
                                      FILE_READ_ATTRIBUTES,
                                      &FileObject,
                                      &DeviceObject);
    if (!NT_SUCCESS(Status))
        return FALSE;
 
    DeviceObject = IoGetAttachedDeviceReference(FileObject->DeviceObject);
    ObDereferenceObject(FileObject);
 
    /* Query its device name (verifies that the floppy driver
     * for this device implements the MountMgr interface) */
    KeInitializeEvent(&Event, NotificationEvent, FALSE);
    Irp = IoBuildDeviceIoControlRequest(IOCTL_MOUNTDEV_QUERY_DEVICE_NAME,
                                        DeviceObject,
                                        NULL,
                                        0,
                                        &DevName,
                                        sizeof(DevName),
                                        FALSE,
                                        &Event,
                                        &IoStatusBlock);
    if (Irp == NULL)
    {
        ObDereferenceObject(DeviceObject);
        return FALSE;
    }
 
    Status = IoCallDriver(DeviceObject, Irp);
    if (Status == STATUS_PENDING)
    {
        KeWaitForSingleObject(&Event,
                              Executive,
                              KernelMode,
                              FALSE,
                              NULL);
        Status = IoStatusBlock.Status;
    }
 
    /* If status is not STATUS_BUFFER_OVERFLOW, it means
     * it's a pre-MountMgr driver, aka "Old style" */
    ObDereferenceObject(DeviceObject);
    return (Status != STATUS_BUFFER_OVERFLOW);
}

Referenced by xHalIoAssignDriveLetters().

HalpIsValidPartitionEntry()

static BOOLEAN HalpIsValidPartitionEntry ( _In_ PPARTITION_DESCRIPTOR  Entry, _In_ ULONGLONG  MaxOffset, _In_ ULONGLONG  MaxSector  )

static

Definition at line 1323 of file disksup.c.

{
    ULONGLONG EndingSector;
 
    PAGED_CODE();
 
    /* Unused partitions are considered valid */
    if (Entry->PartitionType == PARTITION_ENTRY_UNUSED)
        return TRUE;
 
    /* Get the last sector of the partition */
    EndingSector = GET_STARTING_SECTOR(Entry) + GET_PARTITION_LENGTH(Entry);
 
    /* Check if it's more than the maximum sector */
    if (EndingSector > MaxSector)
    {
        /* Invalid partition */
        DPRINT1("FSTUB: entry is invalid\n");
        DPRINT1("FSTUB: offset %#08lx\n", GET_STARTING_SECTOR(Entry));
        DPRINT1("FSTUB: length %#08lx\n", GET_PARTITION_LENGTH(Entry));
        DPRINT1("FSTUB: end %#I64x\n", EndingSector);
        DPRINT1("FSTUB: max %#I64x\n", MaxSector);
        return FALSE;
    }
    else if (GET_STARTING_SECTOR(Entry) > MaxOffset)
    {
        /* Invalid partition */
        DPRINT1("FSTUB: entry is invalid\n");
        DPRINT1("FSTUB: offset %#08lx\n", GET_STARTING_SECTOR(Entry));
        DPRINT1("FSTUB: length %#08lx\n", GET_PARTITION_LENGTH(Entry));
        DPRINT1("FSTUB: end %#I64x\n", EndingSector);
        DPRINT1("FSTUB: maxOffset %#I64x\n", MaxOffset);
        return FALSE;
    }
 
    /* It's fine, return success */
    return TRUE;
}

Referenced by xHalIoReadPartitionTable().

HalpNextDriveLetter()

static UCHAR HalpNextDriveLetter ( _In_ PUNICODE_STRING  DeviceName, _In_ PSTRING  NtDeviceName, _Out_ PUCHAR  NtSystemPath, _In_ BOOLEAN  IsRemovable  )

static

Definition at line 604 of file disksup.c.

{
    UCHAR i;
    WCHAR Buffer[40];
    UCHAR DriveLetter;
    UNICODE_STRING NtDeviceNameU, DosDevice;
 
    /* Quick path, ask directly the MountMgr
     * to assign the next free drive letter */
    if (NT_SUCCESS(HalpNextMountLetter(DeviceName, &DriveLetter)))
        return DriveLetter;
 
    /* We'll allow the MountMgr to fail only for non vital path */
    if (NtDeviceName == NULL || NtSystemPath == NULL)
        return 0xFF;
 
    /* And for removable devices */
    if (!IsRemovable)
        return 0;
 
    /* The removable device might be a floppy or CD-ROM */
 
    if (RtlPrefixUnicodeString(&FloppyPrefix, DeviceName, TRUE))
        DriveLetter = 'A'; /* If floppy, start at A */
    else if (RtlPrefixUnicodeString(&CdPrefix, DeviceName, TRUE))
        DriveLetter = 'D'; /* If CD-ROM, start at D */
    else
        DriveLetter = 'C'; /* Otherwise, start at C */
 
    /* Now, try to assign a drive letter manually with the MountMgr */
    for (i = DriveLetter; i <= 'Z'; ++i)
    {
        if (NT_SUCCESS(HalpSetMountLetter(DeviceName, i)))
        {
            /* If it worked, if we were managing system path, update manually */
            if (NT_SUCCESS(RtlAnsiStringToUnicodeString(&NtDeviceNameU, NtDeviceName, TRUE)))
            {
                if (RtlEqualUnicodeString(&NtDeviceNameU, DeviceName, TRUE))
                    *NtSystemPath = i;
 
                RtlFreeUnicodeString(&NtDeviceNameU);
            }
 
            return i;
        }
    }
 
    /* Last fall back, we're not on a PnP device... */
    for (i = DriveLetter; i <= 'Z'; ++i)
    {
        /* We'll link manually, without the MountMgr knowing anything about the device */
        swprintf(Buffer, L"\\DosDevices\\%c:", i);
        RtlInitUnicodeString(&DosDevice, Buffer);
 
        /* If linking worked, the letter was free ;-) */
        if (NT_SUCCESS(IoCreateSymbolicLink(&DosDevice, DeviceName)))
        {
            /* If it worked, if we were managing system path, update manually */
            if (NT_SUCCESS(RtlAnsiStringToUnicodeString(&NtDeviceNameU, NtDeviceName, TRUE)))
            {
                if (RtlEqualUnicodeString(&NtDeviceNameU, DeviceName, TRUE))
                    *NtSystemPath = i;
 
                RtlFreeUnicodeString(&NtDeviceNameU);
            }
 
            return i;
        }
    }
 
    /* We're done, nothing happened */
    return 0;
}

Referenced by xHalIoAssignDriveLetters().

HalpNextMountLetter()

static NTSTATUS HalpNextMountLetter ( _In_ PUNICODE_STRING  DeviceName, _Out_ PUCHAR  DriveLetter  )

static

Definition at line 436 of file disksup.c.

{
    PIRP Irp;
    KEVENT Event;
    NTSTATUS Status;
    UNICODE_STRING MountMgr;
    PFILE_OBJECT FileObject;
    PDEVICE_OBJECT DeviceObject;
    IO_STATUS_BLOCK IoStatusBlock;
    PMOUNTMGR_DRIVE_LETTER_TARGET Target;
    MOUNTMGR_DRIVE_LETTER_INFORMATION LetterInfo;
 
    /* To get next mount letter, we need the MountMgr */
    RtlInitUnicodeString(&MountMgr, L"\\Device\\MountPointManager");
    Status = IoGetDeviceObjectPointer(&MountMgr,
                                      FILE_READ_ATTRIBUTES,
                                      &FileObject,
                                      &DeviceObject);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    /* Allocate our input buffer */
    Target = ExAllocatePoolWithTag(PagedPool,
                                   DeviceName->Length + FIELD_OFFSET(MOUNTMGR_DRIVE_LETTER_TARGET, DeviceName),
                                   TAG_FSTUB);
    if (Target == NULL)
    {
        ObDereferenceObject(FileObject);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* And fill it with the device hat needs a drive letter */
    Target->DeviceNameLength = DeviceName->Length;
    RtlCopyMemory(&Target->DeviceName[0], DeviceName->Buffer, DeviceName->Length);
 
    /* Call the MountMgr */
    KeInitializeEvent(&Event, NotificationEvent, FALSE);
    Irp = IoBuildDeviceIoControlRequest(IOCTL_MOUNTMGR_NEXT_DRIVE_LETTER,
                                        DeviceObject,
                                        Target,
                                        DeviceName->Length + FIELD_OFFSET(MOUNTMGR_DRIVE_LETTER_TARGET, DeviceName),
                                        &LetterInfo,
                                        sizeof(LetterInfo),
                                        FALSE,
                                        &Event,
                                        &IoStatusBlock);
    if (Irp == NULL)
    {
        ExFreePoolWithTag(Target, TAG_FSTUB);
        ObDereferenceObject(FileObject);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    Status = IoCallDriver(DeviceObject, Irp);
    if (Status == STATUS_PENDING)
    {
        KeWaitForSingleObject(&Event,
                              Executive,
                              KernelMode,
                              FALSE,
                              NULL);
        Status = IoStatusBlock.Status;
    }
 
    ExFreePoolWithTag(Target, TAG_FSTUB);
    ObDereferenceObject(FileObject);
 
    DPRINT("Done: %d %c\n", LetterInfo.DriveLetterWasAssigned,
                            LetterInfo.CurrentDriveLetter);
 
    /* Return the drive letter the MountMgr potentially assigned */
    *DriveLetter = LetterInfo.CurrentDriveLetter;
 
    /* Also return the success */
    return Status;
}

Referenced by HalpNextDriveLetter().

HalpQueryDriveLayout()

static NTSTATUS HalpQueryDriveLayout ( _In_ PUNICODE_STRING  DeviceName, _Outptr_ PDRIVE_LAYOUT_INFORMATION *  LayoutInfo  )

static

Definition at line 46 of file disksup.c.

{
    IO_STATUS_BLOCK StatusBlock;
    PDEVICE_OBJECT DeviceObject = NULL;
    PFILE_OBJECT FileObject;
    KEVENT Event;
    PIRP Irp;
    NTSTATUS Status;
    ULONG BufferSize;
    PDRIVE_LAYOUT_INFORMATION Buffer;
 
    PAGED_CODE();
 
    /* Get device pointers */
    Status = IoGetDeviceObjectPointer(DeviceName,
                                      FILE_READ_ATTRIBUTES,
                                      &FileObject,
                                      &DeviceObject);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    /* Get attached device object */
    DeviceObject = IoGetAttachedDeviceReference(FileObject->DeviceObject);
    ObDereferenceObject(FileObject);
 
    /* Do not handle removable media */
    if (BooleanFlagOn(DeviceObject->Characteristics, FILE_REMOVABLE_MEDIA))
    {
        ObDereferenceObject(DeviceObject);
        return STATUS_NO_MEDIA;
    }
 
    /* We'll loop until our buffer is big enough */
    Buffer = NULL;
    BufferSize = 0x1000;
    KeInitializeEvent(&Event, NotificationEvent, FALSE);
    do
    {
        /* If we already had a buffer, it means it's not
         * big enough, so free and multiply size by two */
        if (Buffer != NULL)
        {
            ExFreePoolWithTag(Buffer, TAG_FSTUB);
            BufferSize *= 2;
        }
 
        /* Allocate buffer for output buffer */
        Buffer = ExAllocatePoolWithTag(NonPagedPool, BufferSize, TAG_FSTUB);
        if (Buffer == NULL)
        {
            Status = STATUS_NO_MEMORY;
            break;
        }
 
        /* Build the IRP to query drive layout */
        Irp = IoBuildDeviceIoControlRequest(IOCTL_DISK_GET_DRIVE_LAYOUT,
                                            DeviceObject,
                                            NULL,
                                            0,
                                            Buffer,
                                            BufferSize,
                                            FALSE,
                                            &Event,
                                            &StatusBlock);
        if (Irp == NULL)
        {
            Status = STATUS_INSUFFICIENT_RESOURCES;
            break;
        }
 
        /* Call the driver and wait if appropriate */
        Status = IoCallDriver(DeviceObject, Irp);
        if (Status == STATUS_PENDING)
        {
            KeWaitForSingleObject(&Event,
                                  Executive,
                                  KernelMode,
                                  FALSE,
                                  NULL);
            Status = StatusBlock.Status;
        }
        /* If buffer is too small, keep looping */
    } while (Status == STATUS_BUFFER_TOO_SMALL);
 
    /* We're done with the device */
    ObDereferenceObject(DeviceObject);
 
    /* If querying worked, return the buffer to the caller */
    if (NT_SUCCESS(Status))
    {
        ASSERT(Buffer != NULL);
        *LayoutInfo = Buffer;
    }
    /* Else, release the buffer if still allocated and fail */
    else
    {
        if (Buffer != NULL)
        {
            ExFreePoolWithTag(Buffer, TAG_FSTUB);
        }
    }
 
    return Status;
}

Referenced by xHalIoAssignDriveLetters().

HalpQueryPartitionType()

static NTSTATUS HalpQueryPartitionType ( _In_ PUNICODE_STRING  DeviceName, _In_opt_ PDRIVE_LAYOUT_INFORMATION  LayoutInfo, _Out_ PPARTITION_TYPE  PartitionType  )

static

Definition at line 156 of file disksup.c.

{
    USHORT i;
    PIRP Irp;
    KEVENT Event;
    NTSTATUS Status;
    PFILE_OBJECT FileObject;
    PDEVICE_OBJECT DeviceObject;
    IO_STATUS_BLOCK IoStatusBlock;
    PARTITION_INFORMATION_EX PartitionInfo;
 
    PAGED_CODE();
 
    /* Get device pointers */
    Status = IoGetDeviceObjectPointer(DeviceName,
                                      FILE_READ_ATTRIBUTES,
                                      &FileObject,
                                      &DeviceObject);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    /* Get attached device object */
    DeviceObject = IoGetAttachedDeviceReference(FileObject->DeviceObject);
    ObDereferenceObject(FileObject);
 
    /* Assume logical partition for removable devices */
    if (BooleanFlagOn(DeviceObject->Characteristics, FILE_REMOVABLE_MEDIA))
    {
        ObDereferenceObject(DeviceObject);
        *PartitionType = LogicalPartition;
        return STATUS_SUCCESS;
    }
 
    /* For the others, query partition info */
    KeInitializeEvent(&Event, NotificationEvent, FALSE);
    Irp = IoBuildDeviceIoControlRequest(IOCTL_DISK_GET_PARTITION_INFO_EX,
                                        DeviceObject,
                                        NULL,
                                        0,
                                        &PartitionInfo,
                                        sizeof(PartitionInfo),
                                        FALSE,
                                        &Event,
                                        &IoStatusBlock);
    if (Irp == NULL)
    {
        ObDereferenceObject(DeviceObject);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    Status = IoCallDriver(DeviceObject, Irp);
    if (Status == STATUS_PENDING)
    {
        KeWaitForSingleObject(&Event,
                              Executive,
                              KernelMode,
                              FALSE,
                              NULL);
        Status = IoStatusBlock.Status;
    }
 
    /* We're done with the device */
    ObDereferenceObject(DeviceObject);
 
    /* If we failed querying partition info, try to return something
     * if caller didn't provide a precise layout, assume logical
     * partition and fake success. Otherwise, just fail. */
    if (!NT_SUCCESS(Status))
    {
        if (LayoutInfo == NULL)
        {
            *PartitionType = LogicalPartition;
            return STATUS_SUCCESS;
        }
 
        return Status;
    }
 
    /* First, handle non-MBR style (easy case) */
    if (PartitionInfo.PartitionStyle != PARTITION_STYLE_MBR)
    {
        /* If not GPT, we don't know what it is */
        if (PartitionInfo.PartitionStyle != PARTITION_STYLE_GPT)
        {
            *PartitionType = UnknownPartition;
            return STATUS_SUCCESS;
        }
 
        /* Check whether this is a data partition */
        if (IsEqualGUID(&PartitionInfo.Gpt.PartitionType, &PARTITION_BASIC_DATA_GUID))
        {
            *PartitionType = DataPartition;
            return STATUS_SUCCESS;
        }
 
        /* Otherwise, we don't know */
        *PartitionType = UnknownPartition;
        return STATUS_SUCCESS;
    }
 
    /* If we don't recognize partition type, return unknown */
    if (!IsRecognizedPartition(PartitionInfo.Mbr.PartitionType))
    {
        *PartitionType = UnknownPartition;
        return STATUS_SUCCESS;
    }
 
    /* Check if that's a FT volume */
    if (IsFTPartition(PartitionInfo.Mbr.PartitionType))
    {
        *PartitionType = FtPartition;
        return STATUS_SUCCESS;
    }
 
    /* If the caller didn't provide the complete layout, just return */
    if (LayoutInfo == NULL)
    {
        *PartitionType = LogicalPartition;
        return STATUS_SUCCESS;
    }
 
    /* Now, evaluate the partition to those in the input layout */
    for (i = 0; i < NUM_PARTITION_TABLE_ENTRIES; ++i)
    {
        /* If we find a partition matching */
        if (LayoutInfo->PartitionEntry[i].StartingOffset.QuadPart == PartitionInfo.StartingOffset.QuadPart)
        {
            /* Return boot if boot flag is set */
            if (PartitionInfo.Mbr.BootIndicator)
            {
                *PartitionType = BootablePartition;
            }
            /* Primary otherwise */
            else
            {
                *PartitionType = PrimaryPartition;
            }
 
            return STATUS_SUCCESS;
        }
    }
 
    /* Otherwise, assume logical */
    *PartitionType = LogicalPartition;
    return STATUS_SUCCESS;
}

Referenced by xHalIoAssignDriveLetters().

HalpSetMountLetter()

static NTSTATUS HalpSetMountLetter ( _In_ PUNICODE_STRING  DeviceName, _In_ UCHAR  DriveLetter  )

static

Definition at line 518 of file disksup.c.

{
    PIRP Irp;
    KEVENT Event;
    NTSTATUS Status;
    WCHAR Buffer[30];
    ULONG InputBufferLength;
    PFILE_OBJECT FileObject;
    PDEVICE_OBJECT DeviceObject;
    IO_STATUS_BLOCK IoStatusBlock;
    UNICODE_STRING DosDevice, MountMgr;
    PMOUNTMGR_CREATE_POINT_INPUT InputBuffer;
 
    /* Setup the DosDevice name */
    swprintf(Buffer, L"\\DosDevices\\%c:", DriveLetter);
    RtlInitUnicodeString(&DosDevice, Buffer);
 
    /* Allocate the input buffer for the MountMgr */
    InputBufferLength = DosDevice.Length + DeviceName->Length + sizeof(MOUNTMGR_CREATE_POINT_INPUT);
    InputBuffer = ExAllocatePoolWithTag(PagedPool, InputBufferLength, TAG_FSTUB);
    if (InputBuffer == NULL)
    {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* Fill the input buffer */
    InputBuffer->SymbolicLinkNameOffset = sizeof(MOUNTMGR_CREATE_POINT_INPUT);
    InputBuffer->SymbolicLinkNameLength = DosDevice.Length;
    InputBuffer->DeviceNameOffset = DosDevice.Length + sizeof(MOUNTMGR_CREATE_POINT_INPUT);
    InputBuffer->DeviceNameLength = DeviceName->Length;
    RtlCopyMemory(&InputBuffer[1], DosDevice.Buffer, DosDevice.Length);
    RtlCopyMemory((PVOID)((ULONG_PTR)InputBuffer + InputBuffer->DeviceNameOffset),
                  DeviceName->Buffer,
                  DeviceName->Length);
 
    /* Get the MountMgr device pointer, to send the IOCTL */
    RtlInitUnicodeString(&MountMgr, L"\\Device\\MountPointManager");
    Status = IoGetDeviceObjectPointer(&MountMgr,
                                      FILE_READ_ATTRIBUTES,
                                      &FileObject,
                                      &DeviceObject);
    if (!NT_SUCCESS(Status))
    {
        ExFreePoolWithTag(InputBuffer, TAG_FSTUB);
        return Status;
    }
 
    /* Call the MountMgr */
    KeInitializeEvent(&Event, NotificationEvent, FALSE);
    Irp = IoBuildDeviceIoControlRequest(IOCTL_MOUNTMGR_CREATE_POINT,
                                        DeviceObject,
                                        InputBuffer,
                                        InputBufferLength,
                                        NULL,
                                        0,
                                        FALSE,
                                        &Event,
                                        &IoStatusBlock);
    if (Irp == NULL)
    {
        ObDereferenceObject(FileObject);
        ExFreePoolWithTag(InputBuffer, TAG_FSTUB);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    Status = IoCallDriver(DeviceObject, Irp);
    if (Status == STATUS_PENDING)
    {
        KeWaitForSingleObject(&Event,
                              Executive,
                              KernelMode,
                              FALSE,
                              NULL);
        Status = IoStatusBlock.Status;
    }
 
    ObDereferenceObject(FileObject);
    ExFreePoolWithTag(InputBuffer, TAG_FSTUB);
 
    /* Return the MountMgr status */
    return Status;
}

Referenced by HalpNextDriveLetter(), and xHalIoAssignDriveLetters().

IoAssignDriveLetters()

VOID FASTCALL IoAssignDriveLetters	(	IN PLOADER_PARAMETER_BLOCK	LoaderBlock,
		IN PSTRING	NtDeviceName,
		OUT PUCHAR	NtSystemPath,
		OUT PSTRING	NtSystemPathString
	)

Definition at line 2631 of file disksup.c.

{
    HALDISPATCH->HalIoAssignDriveLetters(LoaderBlock,
                                         NtDeviceName,
                                         NtSystemPath,
                                         NtSystemPathString);
}

IopComputeHarddiskDerangements()

static PULONG IopComputeHarddiskDerangements ( _In_ ULONG  DiskCount )

static

Definition at line 309 of file disksup.c.

{
    PIRP Irp;
    KEVENT Event;
    ULONG i, j, k;
    PULONG Devices;
    NTSTATUS Status;
    WCHAR Buffer[100];
    UNICODE_STRING ArcName;
    PFILE_OBJECT FileObject;
    PDEVICE_OBJECT DeviceObject;
    IO_STATUS_BLOCK IoStatusBlock;
    STORAGE_DEVICE_NUMBER DeviceNumber;
 
    /* No disks, nothing to do */
    if (DiskCount == 0)
    {
        return NULL;
    }
 
    /* Allocate a buffer big enough to hold all the disks */
    Devices = ExAllocatePoolWithTag(PagedPool | POOL_COLD_ALLOCATION,
                                    sizeof(ULONG) * DiskCount,
                                    TAG_FSTUB);
    if (Devices == NULL)
    {
        return NULL;
    }
 
    /* Now, we'll query all the disks */
    for (i = 0; i < DiskCount; ++i)
    {
        /* Using their ARC name */
        swprintf(Buffer, L"\\ArcName\\multi(0)disk(0)rdisk(%d)", i);
        RtlInitUnicodeString(&ArcName, Buffer);
 
        /* Get the attached DeviceObject */
        Status = IoGetDeviceObjectPointer(&ArcName,
                                          FILE_READ_ATTRIBUTES,
                                          &FileObject,
                                          &DeviceObject);
        if (NT_SUCCESS(Status))
        {
            DeviceObject = IoGetAttachedDeviceReference(FileObject->DeviceObject);
            ObDereferenceObject(FileObject);
 
            /* And query it for device number */
            KeInitializeEvent(&Event, NotificationEvent, FALSE);
            Irp = IoBuildDeviceIoControlRequest(IOCTL_STORAGE_GET_DEVICE_NUMBER,
                                                DeviceObject,
                                                NULL,
                                                0,
                                                &DeviceNumber,
                                                sizeof(DeviceNumber),
                                                FALSE,
                                                &Event,
                                                &IoStatusBlock);
            if (Irp != NULL)
            {
                Status = IoCallDriver(DeviceObject, Irp);
                if (Status == STATUS_PENDING)
                {
                    KeWaitForSingleObject(&Event,
                                          Executive,
                                          KernelMode,
                                          FALSE,
                                          NULL);
                    Status = IoStatusBlock.Status;
                }
 
                ObDereferenceObject(DeviceObject);
 
                /* In case of a success remember device number */
                if (NT_SUCCESS(Status))
                {
                    Devices[i] = DeviceNumber.DeviceNumber;
                    /* Move on, not to fall into our default case */
                    continue;
                }
            }
            else
            {
                ObDereferenceObject(DeviceObject);
            }
 
            /* Default case, for failures, set -1 */
            Devices[i] = -1;
        }
    }
 
    /* Now, we'll check all device numbers */
    for (i = 0; i < DiskCount; ++i)
    {
        /* First of all, check if we're at the right place */
        for (j = 0; j < DiskCount; ++j)
        {
            if (Devices[j] == i)
            {
                break;
            }
        }
 
        /* If not, perform the change */
        if (j >= DiskCount)
        {
            k = 0;
            while (Devices[k] != -1)
            {
                if (++k >= DiskCount)
                {
                    break;
                }
            }
 
            if (k < DiskCount)
            {
                Devices[k] = i;
            }
        }
    }
 
    /* Return our device derangement map */
    return Devices;
}

Referenced by xHalIoAssignDriveLetters().

IoReadPartitionTable()

NTSTATUS FASTCALL IoReadPartitionTable	(	IN PDEVICE_OBJECT	DeviceObject,
		IN ULONG	SectorSize,
		IN BOOLEAN	ReturnRecognizedPartitions,
		OUT PDRIVE_LAYOUT_INFORMATION *	PartitionBuffer
	)

Definition at line 2581 of file disksup.c.

{
    return HALDISPATCH->HalIoReadPartitionTable(DeviceObject,
                                                SectorSize,
                                                ReturnRecognizedPartitions,
                                                PartitionBuffer);
}

IoSetPartitionInformation()

NTSTATUS FASTCALL IoSetPartitionInformation	(	IN PDEVICE_OBJECT	DeviceObject,
		IN ULONG	SectorSize,
		IN ULONG	PartitionNumber,
		IN ULONG	PartitionType
	)

Definition at line 2597 of file disksup.c.

{
    return HALDISPATCH->HalIoSetPartitionInformation(DeviceObject,
                                                     SectorSize,
                                                     PartitionNumber,
                                                     PartitionType);
}

IoWritePartitionTable()

NTSTATUS FASTCALL IoWritePartitionTable	(	IN PDEVICE_OBJECT	DeviceObject,
		IN ULONG	SectorSize,
		IN ULONG	SectorsPerTrack,
		IN ULONG	NumberOfHeads,
		IN PDRIVE_LAYOUT_INFORMATION	PartitionBuffer
	)

Definition at line 2613 of file disksup.c.

{
    return HALDISPATCH->HalIoWritePartitionTable(DeviceObject,
                                                 SectorSize,
                                                 SectorsPerTrack,
                                                 NumberOfHeads,
                                                 PartitionBuffer);
}

xHalExamineMBR()

VOID FASTCALL xHalExamineMBR	(	IN PDEVICE_OBJECT	DeviceObject,
		IN ULONG	SectorSize,
		IN ULONG	MbrTypeIdentifier,
		OUT PVOID *	MbrBuffer
	)

Definition at line 1529 of file disksup.c.

{
    LARGE_INTEGER Offset;
    PUCHAR Buffer;
    ULONG BufferSize;
    KEVENT Event;
    IO_STATUS_BLOCK IoStatusBlock;
    PIRP Irp;
    PPARTITION_DESCRIPTOR PartitionDescriptor;
    NTSTATUS Status;
    PIO_STACK_LOCATION IoStackLocation;
 
    Offset.QuadPart = 0;
 
    /* Assume failure */
    *MbrBuffer = NULL;
 
    /* Normalize the buffer size */
    BufferSize = max(512, SectorSize);
 
    /* Allocate the buffer */
    Buffer = ExAllocatePoolWithTag(NonPagedPool,
                                   max(PAGE_SIZE, BufferSize),
                                   TAG_FILE_SYSTEM);
    if (!Buffer) return;
 
    /* Initialize the Event */
    KeInitializeEvent(&Event, NotificationEvent, FALSE);
 
    /* Build the IRP */
    Irp = IoBuildSynchronousFsdRequest(IRP_MJ_READ,
                                       DeviceObject,
                                       Buffer,
                                       BufferSize,
                                       &Offset,
                                       &Event,
                                       &IoStatusBlock);
    if (!Irp)
    {
        /* Failed */
        ExFreePoolWithTag(Buffer, TAG_FILE_SYSTEM);
        return;
    }
 
    /* Make sure to override volume verification */
    IoStackLocation = IoGetNextIrpStackLocation(Irp);
    IoStackLocation->Flags |= SL_OVERRIDE_VERIFY_VOLUME;
 
    /* Call the driver */
    Status = IoCallDriver(DeviceObject, Irp);
    if (Status == STATUS_PENDING)
    {
        /* Wait for completion */
        KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
        Status = IoStatusBlock.Status;
    }
 
    /* Check driver status */
    if (NT_SUCCESS(Status))
    {
        /* Validate the MBR Signature */
        if (*(PUINT16)&Buffer[BOOT_SIGNATURE_OFFSET] != BOOT_RECORD_SIGNATURE)
        {
            /* Failed */
            ExFreePoolWithTag(Buffer, TAG_FILE_SYSTEM);
            return;
        }
 
        /* Get the partition entry */
        PartitionDescriptor = (PPARTITION_DESCRIPTOR)&Buffer[PARTITION_TABLE_OFFSET];
 
        /* Make sure it's what the caller wanted */
        if (PartitionDescriptor->PartitionType != MbrTypeIdentifier)
        {
            /* It's not, free our buffer */
            ExFreePoolWithTag(Buffer, TAG_FILE_SYSTEM);
        }
        else
        {
            /* Check for OnTrack Disk Manager 6.0 / EZ-Drive partitions */
 
            if (PartitionDescriptor->PartitionType == PARTITION_DM)
            {
                /* Return our buffer, but at sector 63 */
                *(PULONG)Buffer = 63;
                *MbrBuffer = Buffer;
            }
            else if (PartitionDescriptor->PartitionType == PARTITION_EZDRIVE)
            {
                /* EZ-Drive, return the buffer directly */
                *MbrBuffer = Buffer;
            }
            else
            {
                /* Otherwise crash on debug builds */
                ASSERT(PartitionDescriptor->PartitionType == PARTITION_EZDRIVE);
            }
        }
    }
}

xHalGetPartialGeometry()

VOID FASTCALL xHalGetPartialGeometry	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PULONG	ConventionalCylinders,
		IN PLONGLONG	DiskSize
	)

Definition at line 1443 of file disksup.c.

{
    PDISK_GEOMETRY DiskGeometry = NULL;
    PIO_STATUS_BLOCK IoStatusBlock = NULL;
    PKEVENT Event = NULL;
    PIRP Irp;
    NTSTATUS Status;
 
    /* Set defaults */
    *ConventionalCylinders = 0;
    *DiskSize = 0;
 
    /* Allocate the structure in nonpaged pool */
    DiskGeometry = ExAllocatePoolWithTag(NonPagedPool,
                                         sizeof(DISK_GEOMETRY),
                                         TAG_FILE_SYSTEM);
    if (!DiskGeometry) goto Cleanup;
 
    /* Allocate the status block in nonpaged pool */
    IoStatusBlock = ExAllocatePoolWithTag(NonPagedPool,
                                          sizeof(IO_STATUS_BLOCK),
                                          TAG_FILE_SYSTEM);
    if (!IoStatusBlock) goto Cleanup;
 
    /* Allocate the event in nonpaged pool too */
    Event = ExAllocatePoolWithTag(NonPagedPool,
                                  sizeof(KEVENT),
                                  TAG_FILE_SYSTEM);
    if (!Event) goto Cleanup;
 
    /* Initialize the event */
    KeInitializeEvent(Event, NotificationEvent, FALSE);
 
    /* Build the IRP */
    Irp = IoBuildDeviceIoControlRequest(IOCTL_DISK_GET_DRIVE_GEOMETRY,
                                        DeviceObject,
                                        NULL,
                                        0,
                                        DiskGeometry,
                                        sizeof(DISK_GEOMETRY),
                                        FALSE,
                                        Event,
                                        IoStatusBlock);
    if (!Irp) goto Cleanup;
 
    /* Now call the driver */
    Status = IoCallDriver(DeviceObject, Irp);
    if (Status == STATUS_PENDING)
    {
        /* Wait for it to complete */
        KeWaitForSingleObject(Event, Executive, KernelMode, FALSE, NULL);
        Status = IoStatusBlock->Status;
    }
 
    /* Check driver status */
    if (NT_SUCCESS(Status))
    {
        /* Return the cylinder count */
        *ConventionalCylinders = DiskGeometry->Cylinders.LowPart;
 
        /* Make sure it's not larger than 1024 */
        if (DiskGeometry->Cylinders.LowPart >= 1024)
        {
            /* Otherwise, normalize the value */
            *ConventionalCylinders = 1024;
        }
 
        /* Calculate the disk size */
        *DiskSize = DiskGeometry->Cylinders.QuadPart *
                    DiskGeometry->TracksPerCylinder *
                    DiskGeometry->SectorsPerTrack *
                    DiskGeometry->BytesPerSector;
    }
 
Cleanup:
    /* Free all the pointers */
    if (Event) ExFreePoolWithTag(Event, TAG_FILE_SYSTEM);
    if (IoStatusBlock) ExFreePoolWithTag(IoStatusBlock, TAG_FILE_SYSTEM);
    if (DiskGeometry) ExFreePoolWithTag(DiskGeometry, TAG_FILE_SYSTEM);
    return;
}

Referenced by xHalIoWritePartitionTable().

xHalIoAssignDriveLetters()

VOID FASTCALL xHalIoAssignDriveLetters	(	IN PLOADER_PARAMETER_BLOCK	LoaderBlock,
		IN PSTRING	NtDeviceName,
		OUT PUCHAR	NtSystemPath,
		OUT PSTRING	NtSystemPathString
	)

Definition at line 890 of file disksup.c.

{
    PULONG Devices;
    NTSTATUS Status;
    HANDLE FileHandle;
    UCHAR DriveLetter;
    BOOLEAN BootableFound;
    IO_STATUS_BLOCK StatusBlock;
    PARTITION_TYPE PartitionType;
    PSTR LoadOptions;
    OBJECT_ATTRIBUTES ObjectAttributes;
    PDRIVE_LAYOUT_INFORMATION LayoutInfo;
    PCONFIGURATION_INFORMATION ConfigInfo;
    UNICODE_STRING DeviceName;
    ULONG i, Increment, DiskCount, RealDiskCount, HarddiskCount, PartitionCount;
    ULONG SkipPartition;
    PWSTR Buffer2;
    WCHAR Buffer[sizeof("\\Device\\Harddisk4294967295\\Partition4294967295")];
 
    PAGED_CODE();
 
    /* Get our disk count */
    ConfigInfo = IoGetConfigurationInformation();
    DiskCount = ConfigInfo->DiskCount;
    RealDiskCount = 0;
 
    /* Allocate a generic string buffer we'll use later on */
    Buffer2 = ExAllocatePoolWithTag(NonPagedPool, 40 * sizeof(WCHAR), TAG_FSTUB);
    if (Buffer2 == NULL)
    {
        /* We cannot fail */
        KeBugCheck(ASSIGN_DRIVE_LETTERS_FAILED);
    }
 
    /* In case of a remote boot, setup the system path */
    if (IoRemoteBootClient)
    {
        PSTR Last, Saved;
 
        /* Find the last separator */
        Last = strrchr(LoaderBlock->NtBootPathName, '\\');
        Saved = NULL;
        if (Last == NULL)
        {
            /* Misformed name, fail */
            KeBugCheck(ASSIGN_DRIVE_LETTERS_FAILED);
        }
 
        /* In case the name was terminated by a separator... */
        if (Last[1] == ANSI_NULL)
        {
            /* Erase it, save its position and find the previous separator */
            *Last = ANSI_NULL;
            Saved = Last;
            Last = strrchr(LoaderBlock->NtBootPathName, '\\');
            *Saved = '\\';
        }
 
        if (Last == NULL)
        {
            /* Misformed name, fail */
            KeBugCheck(ASSIGN_DRIVE_LETTERS_FAILED);
        }
 
        /* For a remote boot, assign X drive letter */
        NtSystemPath[0] = 'X';
        NtSystemPath[1] = ':';
        /* And copy the end of the boot path */
        strcpy((PSTR)&NtSystemPath[2], Last);
 
        /* If we had to remove the trailing separator, remove it here too */
        if (Saved != NULL)
        {
            NtSystemPath[strlen((PSTR)NtSystemPath) - 1] = ANSI_NULL;
        }
 
        /* Setup the system path string */
        RtlInitString(NtSystemPathString, (PSTR)NtSystemPath);
    }
 
    /* For each disk, create the physical drive DOS device */
    Increment = 0;
    for (i = 0; i < DiskCount; ++i)
    {
        /* Setup the device name */
        swprintf(Buffer, L"\\Device\\Harddisk%d\\Partition0", i);
        RtlInitUnicodeString(&DeviceName, Buffer);
 
        /* Open the device */
        InitializeObjectAttributes(&ObjectAttributes,
                                   &DeviceName,
                                   OBJ_CASE_INSENSITIVE,
                                   NULL,
                                   NULL);
        Status = ZwOpenFile(&FileHandle,
                            SYNCHRONIZE | FILE_READ_DATA,
                            &ObjectAttributes,
                            &StatusBlock,
                            FILE_SHARE_READ,
                            FILE_SYNCHRONOUS_IO_NONALERT);
        if (NT_SUCCESS(Status))
        {
            /* If we succeeded, create the link */
            UNICODE_STRING LinkName;
            swprintf(Buffer2, L"\\DosDevices\\PhysicalDrive%d", i);
            RtlInitUnicodeString(&LinkName, Buffer2);
 
            IoCreateSymbolicLink(&LinkName, &DeviceName);
            ZwClose(FileHandle);
 
            RealDiskCount = i + 1;
        }
        else
        {
            /* Try to cope with holes in the \Device\HarddiskX namespace */
            if (Increment < 50)
            {
                ++Increment;
                ++DiskCount;
            }
        }
    }
 
    /* We are done with the buffer */
    ExFreePoolWithTag(Buffer2, TAG_FSTUB);
 
    /* Upcase the load options, if any */
    if (LoaderBlock->LoadOptions != NULL)
        LoadOptions = _strupr(LoaderBlock->LoadOptions);
    else
        LoadOptions = NULL;
 
    /* If we boot with MININT option (system hive as volatile),
     * assign the X letter to the OS boot volume. */
    if (LoadOptions != NULL &&
        strstr(LoadOptions, "MININT") != NULL &&
        NT_SUCCESS(RtlAnsiStringToUnicodeString(&DeviceName, NtDeviceName, TRUE)))
    {
        if (NT_SUCCESS(HalpSetMountLetter(&DeviceName, 'X')))
            *NtSystemPath = 'X';
 
        RtlFreeUnicodeString(&DeviceName);
    }
 
    /* Compute the disks derangements */
    DiskCount -= Increment;
    DiskCount = max(DiskCount, RealDiskCount);
    Devices = IopComputeHarddiskDerangements(DiskCount);
 
    /* Now, start browsing all the disks for assigning drive letters.
     * Here, we'll only handle the bootable and primary partitions. */
    for (i = 0; i < DiskCount; ++i)
    {
        /* Get the device ID from the derangements map */
        HarddiskCount = (Devices ? Devices[i] : i);
 
        /* Query the disk layout */
        swprintf(Buffer, L"\\Device\\Harddisk%d\\Partition0", HarddiskCount);
        RtlInitUnicodeString(&DeviceName, Buffer);
        Status = HalpQueryDriveLayout(&DeviceName, &LayoutInfo);
        if (!NT_SUCCESS(Status))
            LayoutInfo = NULL;
 
        /* Assume we didn't find a bootable partition */
        BootableFound = FALSE;
        for (PartitionCount = 1; ; ++PartitionCount)
        {
            swprintf(Buffer, L"\\Device\\Harddisk%d\\Partition%d", HarddiskCount, PartitionCount);
            RtlInitUnicodeString(&DeviceName, Buffer);
            Status = HalpQueryPartitionType(&DeviceName, LayoutInfo, &PartitionType);
            if (!NT_SUCCESS(Status))
            {
                /* It failed, retry for all the partitions */
                break;
            }
 
            /* If the partition is bootable (MBR) or data (GPT), we've found it */
            if (PartitionType == BootablePartition || PartitionType == DataPartition)
            {
                BootableFound = TRUE;
 
                /* Assign a drive letter and stop here if MBR */
                HalpNextDriveLetter(&DeviceName, NtDeviceName, NtSystemPath, FALSE);
                if (PartitionType == BootablePartition)
                    break;
            }
            /* Keep looping on all the partitions */
        }
 
        /* Mount every primary partition if we didn't find a bootable partition */
        if (!BootableFound)
        {
            for (PartitionCount = 1; ; ++PartitionCount)
            {
                swprintf(Buffer, L"\\Device\\Harddisk%d\\Partition%d", HarddiskCount, PartitionCount);
                RtlInitUnicodeString(&DeviceName, Buffer);
                Status = HalpQueryPartitionType(&DeviceName, LayoutInfo, &PartitionType);
                if (!NT_SUCCESS(Status))
                    break;
 
                /* We found a primary partition, assign a drive letter */
                if (PartitionType == PrimaryPartition)
                {
                    HalpNextDriveLetter(&DeviceName, NtDeviceName, NtSystemPath, FALSE);
                    break;
                }
            }
        }
 
        /* Free the layout, we'll reallocate it for the next disk */
        if (LayoutInfo != NULL)
            ExFreePoolWithTag(LayoutInfo, TAG_FSTUB);
    }
 
    /* Now, assign drive letters to logical partitions */
    for (i = 0; i < DiskCount; ++i)
    {
        /* Get the device ID from the derangements map */
        HarddiskCount = (Devices ? Devices[i] : i);
 
        /* Query the disk layout */
        swprintf(Buffer, L"\\Device\\Harddisk%d\\Partition0", HarddiskCount);
        RtlInitUnicodeString(&DeviceName, Buffer);
        Status = HalpQueryDriveLayout(&DeviceName, &LayoutInfo);
        if (!NT_SUCCESS(Status))
            LayoutInfo = NULL;
 
        /* And assign drive letters to logical partitions */
        for (PartitionCount = 1; ; ++PartitionCount)
        {
            swprintf(Buffer, L"\\Device\\Harddisk%d\\Partition%d", HarddiskCount, PartitionCount);
            RtlInitUnicodeString(&DeviceName, Buffer);
            Status = HalpQueryPartitionType(&DeviceName, LayoutInfo, &PartitionType);
            if (!NT_SUCCESS(Status))
                break;
 
            if (PartitionType == LogicalPartition)
            {
                HalpNextDriveLetter(&DeviceName, NtDeviceName, NtSystemPath, FALSE);
            }
        }
 
        /* Free the layout, we'll reallocate it for the next disk */
        if (LayoutInfo != NULL)
            ExFreePoolWithTag(LayoutInfo, TAG_FSTUB);
    }
 
    /* Now, assign drive letters to everything else */
    for (i = 0; i < DiskCount; ++i)
    {
        /* Get the device ID from the derangements map */
        HarddiskCount = (Devices ? Devices[i] : i);
 
        /* Query the disk layout */
        swprintf(Buffer, L"\\Device\\Harddisk%d\\Partition0", HarddiskCount);
        RtlInitUnicodeString(&DeviceName, Buffer);
        Status = HalpQueryDriveLayout(&DeviceName, &LayoutInfo);
        if (!NT_SUCCESS(Status))
            LayoutInfo = NULL;
 
        /* Save the bootable or first primary (MBR) partition, if any */
        SkipPartition = 0;
        for (PartitionCount = 1; ; ++PartitionCount)
        {
            swprintf(Buffer, L"\\Device\\Harddisk%d\\Partition%d", HarddiskCount, PartitionCount);
            RtlInitUnicodeString(&DeviceName, Buffer);
            Status = HalpQueryPartitionType(&DeviceName, LayoutInfo, &PartitionType);
            if (!NT_SUCCESS(Status))
                break;
 
            if ((PartitionType == BootablePartition) ||
                ((PartitionType == PrimaryPartition) && (SkipPartition == 0)))
            {
                SkipPartition = PartitionCount;
            }
        }
 
        /* And assign a drive letter to anything but the bootable partition */
        for (PartitionCount = 1; ; ++PartitionCount)
        {
            if (PartitionCount == SkipPartition)
                continue;
 
            swprintf(Buffer, L"\\Device\\Harddisk%d\\Partition%d", HarddiskCount, PartitionCount);
            RtlInitUnicodeString(&DeviceName, Buffer);
            Status = HalpQueryPartitionType(&DeviceName, LayoutInfo, &PartitionType);
            if (!NT_SUCCESS(Status))
                break;
 
            if (PartitionType == PrimaryPartition || PartitionType == FtPartition)
            {
                HalpNextDriveLetter(&DeviceName, NtDeviceName, NtSystemPath, FALSE);
            }
        }
 
        /* Free the layout, we'll reallocate it for the next disk */
        if (LayoutInfo != NULL)
            ExFreePoolWithTag(LayoutInfo, TAG_FSTUB);
    }
 
    /* We're done with the disks; free the derangements map */
    if (Devices != NULL)
        ExFreePoolWithTag(Devices, TAG_FSTUB);
 
    /* Now, assign drive letters to floppy devices:
     * first for legacy, then for MountMgr-aware ones. */
    for (i = 0; i < ConfigInfo->FloppyCount; ++i)
    {
        swprintf(Buffer, L"\\Device\\Floppy%d", i);
        RtlInitUnicodeString(&DeviceName, Buffer);
        if (HalpIsOldStyleFloppy(&DeviceName)) // Legacy device
            HalpNextDriveLetter(&DeviceName, NtDeviceName, NtSystemPath, TRUE);
    }
    for (i = 0; i < ConfigInfo->FloppyCount; ++i)
    {
        swprintf(Buffer, L"\\Device\\Floppy%d", i);
        RtlInitUnicodeString(&DeviceName, Buffer);
        if (!HalpIsOldStyleFloppy(&DeviceName)) // MountMgr-aware device
            HalpNextDriveLetter(&DeviceName, NtDeviceName, NtSystemPath, TRUE);
    }
 
    /* And CD-ROM drives */
    for (i = 0; i < ConfigInfo->CdRomCount; ++i)
    {
        swprintf(Buffer, L"\\Device\\CdRom%d", i);
        RtlInitUnicodeString(&DeviceName, Buffer);
        HalpNextDriveLetter(&DeviceName, NtDeviceName, NtSystemPath, TRUE);
    }
 
    /* If not remote boot, handle NtDeviceName */
    if (!IoRemoteBootClient && NT_SUCCESS(RtlAnsiStringToUnicodeString(&DeviceName, NtDeviceName, TRUE)))
    {
        /* Assign it a drive letter */
        DriveLetter = HalpNextDriveLetter(&DeviceName, NULL, NULL, TRUE);
        if (DriveLetter != 0)
        {
            if (DriveLetter != 0xFF)
                *NtSystemPath = DriveLetter;
        }
        /* If it fails through the MountMgr, retry manually */
        else
        {
            if (RtlPrefixUnicodeString(&FloppyPrefix, &DeviceName, TRUE))
                DriveLetter = 'A'; /* If floppy, start at A */
            else if (RtlPrefixUnicodeString(&CdPrefix, &DeviceName, TRUE))
                DriveLetter = 'D'; /* If CD-ROM, start at D */
            else
                DriveLetter = 'C'; /* Otherwise, start at C */
 
            /* Try any drive letter */
            while (HalpSetMountLetter(&DeviceName, DriveLetter) != STATUS_SUCCESS)
            {
                ++DriveLetter;
                if (DriveLetter > 'Z')
                    break;
            }
 
            /* If we're beyond Z (no letter left), delete Z and
             * reuse it for the OS boot volume (SystemRoot) */
            if (DriveLetter > 'Z')
            {
                DriveLetter = 'Z';
                HalpDeleteMountLetter(DriveLetter);
                HalpSetMountLetter(&DeviceName, DriveLetter);
            }
 
            /* Return the matching drive letter */
            *NtSystemPath = DriveLetter;
        }
 
        RtlFreeUnicodeString(&DeviceName);
    }
 
    /* Enable auto assignment for MountMgr */
    HalpEnableAutomaticDriveLetterAssignment();
}

xHalIoReadPartitionTable()

NTSTATUS FASTCALL xHalIoReadPartitionTable	(	IN PDEVICE_OBJECT	DeviceObject,
		IN ULONG	SectorSize,
		IN BOOLEAN	ReturnRecognizedPartitions,
		OUT PDRIVE_LAYOUT_INFORMATION *	PartitionBuffer
	)

Definition at line 1654 of file disksup.c.

{
    KEVENT Event;
    IO_STATUS_BLOCK IoStatusBlock;
    PIRP Irp;
    PPARTITION_DESCRIPTOR PartitionDescriptor;
    CCHAR Entry;
    NTSTATUS Status;
    PPARTITION_INFORMATION PartitionInfo;
    PUCHAR Buffer = NULL;
    ULONG BufferSize = 2048, InputSize;
    PDRIVE_LAYOUT_INFORMATION DriveLayoutInfo = NULL;
    LONG j = -1, i = -1, k;
    DISK_GEOMETRY_EX DiskGeometryEx;
    LONGLONG EndSector, MaxSector, StartOffset;
    LARGE_INTEGER Offset, VolumeOffset;
    BOOLEAN IsPrimary = TRUE, IsEzDrive = FALSE, MbrFound = FALSE;
    BOOLEAN IsValid, IsEmpty = TRUE;
    PVOID MbrBuffer;
    PIO_STACK_LOCATION IoStackLocation;
    UCHAR PartitionType;
    LARGE_INTEGER HiddenSectors64;
 
    PAGED_CODE();
 
    VolumeOffset.QuadPart = Offset.QuadPart = 0;
 
    /* Allocate the buffer */
    *PartitionBuffer = ExAllocatePoolWithTag(NonPagedPool,
                                             BufferSize,
                                             TAG_FILE_SYSTEM);
    if (!(*PartitionBuffer)) return STATUS_INSUFFICIENT_RESOURCES;
 
    /* Normalize the buffer size */
    InputSize = max(512, SectorSize);
 
    /* Check for EZ-Drive */
    HalExamineMBR(DeviceObject, InputSize, PARTITION_EZDRIVE, &MbrBuffer);
    if (MbrBuffer)
    {
        /* EZ-Drive found, bias the offset */
        IsEzDrive = TRUE;
        ExFreePoolWithTag(MbrBuffer, TAG_FILE_SYSTEM);
        Offset.QuadPart = 512;
    }
 
    /* Get drive geometry */
    Status = HalpGetFullGeometry(DeviceObject, &DiskGeometryEx);
    if (!NT_SUCCESS(Status))
    {
        ExFreePoolWithTag(*PartitionBuffer, TAG_FILE_SYSTEM);
        *PartitionBuffer = NULL;
        return Status;
    }
 
    /* Get the end and maximum sector */
    EndSector = DiskGeometryEx.DiskSize.QuadPart / DiskGeometryEx.Geometry.BytesPerSector;
    MaxSector = EndSector << 1;
    DPRINT("FSTUB: DiskSize = %#I64x, MaxSector = %#I64x\n",
            DiskGeometryEx.DiskSize, MaxSector);
 
    /* Allocate our buffer */
    Buffer = ExAllocatePoolWithTag(NonPagedPoolCacheAligned, InputSize, TAG_FILE_SYSTEM);
    if (!Buffer)
    {
        /* Fail, free the input buffer */
        ExFreePoolWithTag(*PartitionBuffer, TAG_FILE_SYSTEM);
        *PartitionBuffer = NULL;
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* Start partition loop */
    do
    {
        /* Assume the partition is valid */
        IsValid = TRUE;
 
        /* Initialize the event */
        KeInitializeEvent(&Event, NotificationEvent, FALSE);
 
        /* Clear the buffer and build the IRP */
        RtlZeroMemory(Buffer, InputSize);
        Irp = IoBuildSynchronousFsdRequest(IRP_MJ_READ,
                                           DeviceObject,
                                           Buffer,
                                           InputSize,
                                           &Offset,
                                           &Event,
                                           &IoStatusBlock);
        if (!Irp)
        {
            /* Failed */
            Status = STATUS_INSUFFICIENT_RESOURCES;
            break;
        }
 
        /* Make sure to disable volume verification */
        IoStackLocation = IoGetNextIrpStackLocation(Irp);
        IoStackLocation->Flags |= SL_OVERRIDE_VERIFY_VOLUME;
 
        /* Call the driver */
        Status = IoCallDriver(DeviceObject, Irp);
        if (Status == STATUS_PENDING)
        {
            /* Wait for completion */
            KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
            Status = IoStatusBlock.Status;
        }
 
        /* Normalize status code and check for failure */
        if (Status == STATUS_NO_DATA_DETECTED) Status = STATUS_SUCCESS;
        if (!NT_SUCCESS(Status)) break;
 
        /* If we biased for EZ-Drive, unbias now */
        if (IsEzDrive && (Offset.QuadPart == 512)) Offset.QuadPart = 0;
 
        /* Make sure this is a valid MBR */
        if (*(PUINT16)&Buffer[BOOT_SIGNATURE_OFFSET] != BOOT_RECORD_SIGNATURE)
        {
            /* It's not, fail */
            DPRINT1("FSTUB: (IoReadPartitionTable) No 0xaa55 found in "
                    "partition table %d\n", j + 1);
            break;
        }
 
        /* At this point we have a valid MBR */
        MbrFound = TRUE;
 
        /* Check if we weren't given an offset */
        if (!Offset.QuadPart)
        {
            /* Then read the signature off the disk */
            (*PartitionBuffer)->Signature = *(PUINT32)&Buffer[DISK_SIGNATURE_OFFSET];
        }
 
        /* Get the partition descriptor array */
        PartitionDescriptor = (PPARTITION_DESCRIPTOR)&Buffer[PARTITION_TABLE_OFFSET];
 
        /* Start looping partitions */
        j++;
        DPRINT("FSTUB: Partition Table %d:\n", j);
        for (Entry = 1, k = 0; Entry <= NUM_PARTITION_TABLE_ENTRIES; Entry++, PartitionDescriptor++)
        {
            /* Get the partition type */
            PartitionType = PartitionDescriptor->PartitionType;
 
            /* Print debug messages */
            DPRINT("Partition Entry %d,%d: type %#x %s\n",
                    j,
                    Entry,
                    PartitionType,
                    (PartitionDescriptor->ActiveFlag) ? "Active" : "");
            DPRINT("\tOffset %#08lx for %#08lx Sectors\n",
                    GET_STARTING_SECTOR(PartitionDescriptor),
                    GET_PARTITION_LENGTH(PartitionDescriptor));
 
            /* Check whether we're facing a protective MBR */
            if (PartitionType == EFI_PMBR_OSTYPE_EFI)
            {
                /* Partition length might be bigger than disk size */
                FstubFixupEfiPartition(PartitionDescriptor, DiskGeometryEx.DiskSize.QuadPart);
            }
 
            /* Make sure that the partition is valid, unless it's the first */
            if (!(HalpIsValidPartitionEntry(PartitionDescriptor,
                                            DiskGeometryEx.DiskSize.QuadPart,
                                            MaxSector)) && (j == 0))
            {
                /* It's invalid, so fail */
                IsValid = FALSE;
                break;
            }
 
            /* Check if it's a container */
            if (IsContainerPartition(PartitionType))
            {
                /* Increase the count of containers */
                if (++k != 1)
                {
                    /* More than one table is invalid */
                    DPRINT1("FSTUB: Multiple container partitions found in "
                            "partition table %d\n - table is invalid\n",
                            j);
                    IsValid = FALSE;
                    break;
                }
            }
 
            /* Check if the partition is supposedly empty */
            if (IsEmpty)
            {
                /* But check if it actually has a start and/or length */
                if ((GET_STARTING_SECTOR(PartitionDescriptor)) ||
                    (GET_PARTITION_LENGTH(PartitionDescriptor)))
                {
                    /* So then it's not really empty */
                    IsEmpty = FALSE;
                }
            }
 
            /* Check if the caller wanted only recognized partitions */
            if (ReturnRecognizedPartitions)
            {
                /* Then check if this one is unused, or a container */
                if ((PartitionType == PARTITION_ENTRY_UNUSED) ||
                    IsContainerPartition(PartitionType))
                {
                    /* Skip it, since the caller doesn't want it */
                    continue;
                }
            }
 
            /* Increase the structure count and check if they can fit */
            if ((sizeof(DRIVE_LAYOUT_INFORMATION) +
                 (++i * sizeof(PARTITION_INFORMATION))) >
                BufferSize)
            {
                /* Allocate a new buffer that's twice as big */
                DriveLayoutInfo = ExAllocatePoolWithTag(NonPagedPool,
                                                        BufferSize << 1,
                                                        TAG_FILE_SYSTEM);
                if (!DriveLayoutInfo)
                {
                    /* Out of memory, undo this extra structure */
                    --i;
                    Status = STATUS_INSUFFICIENT_RESOURCES;
                    break;
                }
 
                /* Copy the contents of the old buffer */
                RtlMoveMemory(DriveLayoutInfo,
                              *PartitionBuffer,
                              BufferSize);
 
                /* Free the old buffer and set this one as the new one */
                ExFreePoolWithTag(*PartitionBuffer, TAG_FILE_SYSTEM);
                *PartitionBuffer = DriveLayoutInfo;
 
                /* Double the size */
                BufferSize <<= 1;
            }
 
            /* Now get the current structure being filled and initialize it */
            PartitionInfo = &(*PartitionBuffer)->PartitionEntry[i];
            PartitionInfo->PartitionType = PartitionType;
            PartitionInfo->RewritePartition = FALSE;
 
            /* Check if we're dealing with a partition that's in use */
            if (PartitionType != PARTITION_ENTRY_UNUSED)
            {
                /* Check if it's bootable */
                PartitionInfo->BootIndicator = !!(PartitionDescriptor->ActiveFlag & 0x80);
 
                /* Check if it's a container */
                if (IsContainerPartition(PartitionType))
                {
                    /* Then don't recognize it and use the volume offset */
                    PartitionInfo->RecognizedPartition = FALSE;
                    StartOffset = VolumeOffset.QuadPart;
                }
                else
                {
                    /* Then recognize it and use the partition offset */
                    PartitionInfo->RecognizedPartition = TRUE;
                    StartOffset = Offset.QuadPart;
                }
 
                /* Get the starting offset */
                PartitionInfo->StartingOffset.QuadPart =
                    StartOffset +
                    UInt32x32To64(GET_STARTING_SECTOR(PartitionDescriptor),
                                  SectorSize);
 
                /* Calculate the number of hidden sectors */
                HiddenSectors64.QuadPart = (PartitionInfo->
                                            StartingOffset.QuadPart -
                                            StartOffset) /
                                            SectorSize;
                PartitionInfo->HiddenSectors = HiddenSectors64.LowPart;
 
                /* Get the partition length */
                PartitionInfo->PartitionLength.QuadPart =
                    UInt32x32To64(GET_PARTITION_LENGTH(PartitionDescriptor),
                                  SectorSize);
 
                /* Get the partition number */
                /* FIXME: REACTOS HACK -- Needed for xHalIoAssignDriveLetters() */
                PartitionInfo->PartitionNumber = (!IsContainerPartition(PartitionType)) ? i + 1 : 0;
            }
            else
            {
                /* Otherwise, clear all the relevant fields */
                PartitionInfo->BootIndicator = FALSE;
                PartitionInfo->RecognizedPartition = FALSE;
                PartitionInfo->StartingOffset.QuadPart = 0;
                PartitionInfo->PartitionLength.QuadPart = 0;
                PartitionInfo->HiddenSectors = 0;
 
                /* FIXME: REACTOS HACK -- Needed for xHalIoAssignDriveLetters() */
                PartitionInfo->PartitionNumber = 0;
            }
        }
 
        /* Finish debug log, and check for failure */
        DPRINT("\n");
        if (!NT_SUCCESS(Status)) break;
 
        /* Also check if we hit an invalid entry here */
        if (!IsValid)
        {
            /* We did, so break out of the loop minus one entry */
            j--;
            break;
        }
 
        /* Reset the offset */
        Offset.QuadPart = 0;
 
        /* Go back to the descriptor array and loop it */
        PartitionDescriptor = (PPARTITION_DESCRIPTOR)&Buffer[PARTITION_TABLE_OFFSET];
        for (Entry = 1; Entry <= NUM_PARTITION_TABLE_ENTRIES; Entry++, PartitionDescriptor++)
        {
            /* Check if this is a container partition, since we skipped them */
            if (IsContainerPartition(PartitionDescriptor->PartitionType))
            {
                /* Get its offset */
                Offset.QuadPart = VolumeOffset.QuadPart +
                                  UInt32x32To64(
                                     GET_STARTING_SECTOR(PartitionDescriptor),
                                     SectorSize);
 
                /* If this is a primary partition, this is the volume offset */
                if (IsPrimary) VolumeOffset = Offset;
 
                /* Also update the maximum sector */
                MaxSector = GET_PARTITION_LENGTH(PartitionDescriptor);
                DPRINT1("FSTUB: MaxSector now = %I64d\n", MaxSector);
                break;
            }
        }
 
        /* Loop the next partitions, which are not primary anymore */
        IsPrimary = FALSE;
    } while (Offset.HighPart | Offset.LowPart);
 
    /* Check if this is a removable device that's probably a super-floppy */
    if ((DiskGeometryEx.Geometry.MediaType == RemovableMedia) &&
        (j == 0) && (MbrFound) && (IsEmpty))
    {
        PBOOT_SECTOR_INFO BootSectorInfo = (PBOOT_SECTOR_INFO)Buffer;
 
        /* Read the jump bytes to detect super-floppy */
        if ((BootSectorInfo->JumpByte[0] == 0xeb) ||
            (BootSectorInfo->JumpByte[0] == 0xe9))
        {
            /* Super floppes don't have typical MBRs, so skip them */
            DPRINT1("FSTUB: Jump byte %#x found along with empty partition "
                    "table - disk is a super floppy and has no valid MBR\n",
                    BootSectorInfo->JumpByte);
            j = -1;
        }
    }
 
    /* Check if we're still at partition -1 */
    if (j == -1)
    {
        /* The likely cause is the super floppy detection above */
        if ((MbrFound) || (DiskGeometryEx.Geometry.MediaType == RemovableMedia))
        {
            /* Print out debugging information */
            DPRINT1("FSTUB: Drive %#p has no valid MBR. Make it into a "
                    "super-floppy\n",
                    DeviceObject);
            DPRINT1("FSTUB: Drive has %I64d sectors and is %#016I64x "
                    "bytes large\n",
                    EndSector, DiskGeometryEx.DiskSize);
 
            /* We should at least have some sectors */
            if (EndSector > 0)
            {
                /* Get the entry we'll use */
                PartitionInfo = &(*PartitionBuffer)->PartitionEntry[0];
 
                /* Fill it out with data for a super-floppy */
                PartitionInfo->RewritePartition = FALSE;
                PartitionInfo->RecognizedPartition = TRUE;
                PartitionInfo->PartitionType = PARTITION_FAT_16;
                PartitionInfo->BootIndicator = FALSE;
                PartitionInfo->HiddenSectors = 0;
                PartitionInfo->StartingOffset.QuadPart = 0;
                PartitionInfo->PartitionLength = DiskGeometryEx.DiskSize;
 
                /* FIXME: REACTOS HACK -- Needed for xHalIoAssignDriveLetters() */
                PartitionInfo->PartitionNumber = 0;
 
                /* Set the signature and set the count back to 0 */
                (*PartitionBuffer)->Signature = 1;
                i = 0;
            }
        }
        else
        {
            /* Otherwise, this isn't a super floppy, so set an invalid count */
            i = -1;
        }
    }
 
    /* Set the partition count */
    (*PartitionBuffer)->PartitionCount = ++i;
 
    /* If we have no count, delete the signature */
    if (!i) (*PartitionBuffer)->Signature = 0;
 
    /* Free the buffer and check for success */
    if (Buffer) ExFreePoolWithTag(Buffer, TAG_FILE_SYSTEM);
    if (!NT_SUCCESS(Status))
    {
        ExFreePoolWithTag(*PartitionBuffer, TAG_FILE_SYSTEM);
        *PartitionBuffer = NULL;
    }
 
    /* Return status */
    return Status;
}

xHalIoSetPartitionInformation()

NTSTATUS FASTCALL xHalIoSetPartitionInformation	(	IN PDEVICE_OBJECT	DeviceObject,
		IN ULONG	SectorSize,
		IN ULONG	PartitionNumber,
		IN ULONG	PartitionType
	)

Definition at line 2084 of file disksup.c.

{
    PIRP Irp;
    KEVENT Event;
    IO_STATUS_BLOCK IoStatusBlock;
    NTSTATUS Status;
    LARGE_INTEGER Offset, VolumeOffset;
    PUCHAR Buffer = NULL;
    ULONG BufferSize;
    ULONG i = 0;
    ULONG Entry;
    PPARTITION_DESCRIPTOR PartitionDescriptor;
    BOOLEAN IsPrimary = TRUE, IsEzDrive = FALSE;
    PVOID MbrBuffer;
    PIO_STACK_LOCATION IoStackLocation;
 
    PAGED_CODE();
 
    VolumeOffset.QuadPart = Offset.QuadPart = 0;
 
    /* Normalize the buffer size */
    BufferSize = max(512, SectorSize);
 
    /* Check for EZ-Drive */
    HalExamineMBR(DeviceObject, BufferSize, PARTITION_EZDRIVE, &MbrBuffer);
    if (MbrBuffer)
    {
        /* EZ-Drive found, bias the offset */
        IsEzDrive = TRUE;
        ExFreePoolWithTag(MbrBuffer, TAG_FILE_SYSTEM);
        Offset.QuadPart = 512;
    }
 
    /* Allocate our partition buffer */
    Buffer = ExAllocatePoolWithTag(NonPagedPoolCacheAligned, PAGE_SIZE, TAG_FILE_SYSTEM);
    if (!Buffer) return STATUS_INSUFFICIENT_RESOURCES;
 
    /* Initialize the event we'll use and loop partitions */
    KeInitializeEvent(&Event, NotificationEvent, FALSE);
    do
    {
        /* Reset the event since we reuse it */
        KeClearEvent(&Event);
 
        /* Build the read IRP */
        Irp = IoBuildSynchronousFsdRequest(IRP_MJ_READ,
                                           DeviceObject,
                                           Buffer,
                                           BufferSize,
                                           &Offset,
                                           &Event,
                                           &IoStatusBlock);
        if (!Irp)
        {
            /* Fail */
            Status = STATUS_INSUFFICIENT_RESOURCES;
            break;
        }
 
        /* Make sure to disable volume verification */
        IoStackLocation = IoGetNextIrpStackLocation(Irp);
        IoStackLocation->Flags |= SL_OVERRIDE_VERIFY_VOLUME;
 
        /* Call the driver */
        Status = IoCallDriver(DeviceObject, Irp);
        if (Status == STATUS_PENDING)
        {
            /* Wait for completion */
            KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
            Status = IoStatusBlock.Status;
        }
 
        /* Check for failure */
        if (!NT_SUCCESS(Status)) break;
 
        /* If we biased for EZ-Drive, unbias now */
        if (IsEzDrive && (Offset.QuadPart == 512)) Offset.QuadPart = 0;
 
        /* Make sure this is a valid MBR */
        if (*(PUINT16)&Buffer[BOOT_SIGNATURE_OFFSET] != BOOT_RECORD_SIGNATURE)
        {
            /* It's not, fail */
            Status = STATUS_BAD_MASTER_BOOT_RECORD;
            break;
        }
 
        /* Get the partition descriptors and loop them */
        PartitionDescriptor = (PPARTITION_DESCRIPTOR)&Buffer[PARTITION_TABLE_OFFSET];
        for (Entry = 1; Entry <= NUM_PARTITION_TABLE_ENTRIES; Entry++, PartitionDescriptor++)
        {
            /* Check if it's unused or a container partition */
            if ((PartitionDescriptor->PartitionType == PARTITION_ENTRY_UNUSED) ||
                (IsContainerPartition(PartitionDescriptor->PartitionType)))
            {
                /* Go to the next one */
                continue;
            }
 
            /* It's a valid partition, so increase the partition count */
            if (++i == PartitionNumber)
            {
                /* We found a match, set the type */
                PartitionDescriptor->PartitionType = (UCHAR)PartitionType;
 
                /* Reset the reusable event */
                KeClearEvent(&Event);
 
                /* Build the write IRP */
                Irp = IoBuildSynchronousFsdRequest(IRP_MJ_WRITE,
                                                   DeviceObject,
                                                   Buffer,
                                                   BufferSize,
                                                   &Offset,
                                                   &Event,
                                                   &IoStatusBlock);
                if (!Irp)
                {
                    /* Fail */
                    Status = STATUS_INSUFFICIENT_RESOURCES;
                    break;
                }
 
                /* Disable volume verification */
                IoStackLocation = IoGetNextIrpStackLocation(Irp);
                IoStackLocation->Flags |= SL_OVERRIDE_VERIFY_VOLUME;
 
                /* Call the driver */
                Status = IoCallDriver(DeviceObject, Irp);
                if (Status == STATUS_PENDING)
                {
                    /* Wait for completion */
                    KeWaitForSingleObject(&Event,
                                          Executive,
                                          KernelMode,
                                          FALSE,
                                          NULL);
                    Status = IoStatusBlock.Status;
                }
 
                /* We're done, break out of the loop */
                break;
            }
        }
 
        /* If we looped all the partitions, break out */
        if (Entry <= NUM_PARTITION_TABLE_ENTRIES) break;
 
        /* Nothing found yet, get the partition array again */
        PartitionDescriptor = (PPARTITION_DESCRIPTOR)&Buffer[PARTITION_TABLE_OFFSET];
        for (Entry = 1; Entry <= NUM_PARTITION_TABLE_ENTRIES; Entry++, PartitionDescriptor++)
        {
            /* Check if this was a container partition (we skipped these) */
            if (IsContainerPartition(PartitionDescriptor->PartitionType))
            {
                /* Update the partition offset */
                Offset.QuadPart = VolumeOffset.QuadPart +
                                  GET_STARTING_SECTOR(PartitionDescriptor) *
                                  SectorSize;
 
                /* If this was the primary partition, update the volume too */
                if (IsPrimary) VolumeOffset = Offset;
                break;
            }
        }
 
        /* Check if we already searched all the partitions */
        if (Entry > NUM_PARTITION_TABLE_ENTRIES)
        {
            /* Then we failed to find a good MBR */
            Status = STATUS_BAD_MASTER_BOOT_RECORD;
            break;
        }
 
        /* Loop the next partitions, which are not primary anymore */
        IsPrimary = FALSE;
    } while (i < PartitionNumber);
 
    /* Everything done, cleanup */
    if (Buffer) ExFreePoolWithTag(Buffer, TAG_FILE_SYSTEM);
    return Status;
}

xHalIoWritePartitionTable()

NTSTATUS FASTCALL xHalIoWritePartitionTable	(	IN PDEVICE_OBJECT	DeviceObject,
		IN ULONG	SectorSize,
		IN ULONG	SectorsPerTrack,
		IN ULONG	NumberOfHeads,
		IN PDRIVE_LAYOUT_INFORMATION	PartitionBuffer
	)

Definition at line 2271 of file disksup.c.

{
    KEVENT Event;
    IO_STATUS_BLOCK IoStatusBlock;
    PIRP Irp;
    NTSTATUS Status = STATUS_SUCCESS;
    ULONG BufferSize;
    PUCHAR Buffer;
    PPTE Entry;
    PPARTITION_TABLE PartitionTable;
    LARGE_INTEGER Offset, NextOffset, ExtendedOffset, SectorOffset;
    LARGE_INTEGER StartOffset, PartitionLength;
    ULONG i, j;
    CCHAR k;
    BOOLEAN IsEzDrive = FALSE, IsSuperFloppy = FALSE, DoRewrite = FALSE, IsMbr;
    ULONG ConventionalCylinders;
    LONGLONG DiskSize;
    PDISK_LAYOUT DiskLayout = (PDISK_LAYOUT)PartitionBuffer;
    PVOID MbrBuffer;
    UCHAR PartitionType;
    PIO_STACK_LOCATION IoStackLocation;
    PPARTITION_INFORMATION PartitionInfo = PartitionBuffer->PartitionEntry;
    PPARTITION_INFORMATION TableEntry;
 
    PAGED_CODE();
 
    ExtendedOffset.QuadPart = NextOffset.QuadPart = Offset.QuadPart = 0;
 
    /* Normalize the buffer size */
    BufferSize = max(512, SectorSize);
 
    /* Get the partial drive geometry */
    xHalGetPartialGeometry(DeviceObject, &ConventionalCylinders, &DiskSize);
 
    /* Check for EZ-Drive */
    HalExamineMBR(DeviceObject, BufferSize, PARTITION_EZDRIVE, &MbrBuffer);
    if (MbrBuffer)
    {
        /* EZ-Drive found, bias the offset */
        IsEzDrive = TRUE;
        ExFreePoolWithTag(MbrBuffer, TAG_FILE_SYSTEM);
        Offset.QuadPart = 512;
    }
 
    /* Get the number of bits to shift to multiply by the sector size */
    for (k = 0; k < 32; k++) if ((SectorSize >> k) == 1) break;
 
    /* Check if there's only one partition */
    if (PartitionBuffer->PartitionCount == 1)
    {
        /* Check if it has no starting offset or hidden sectors */
        if (!(PartitionInfo->StartingOffset.QuadPart) &&
            !(PartitionInfo->HiddenSectors))
        {
            /* Then it's a super floppy */
            IsSuperFloppy = TRUE;
 
            /* Which also means it must be non-bootable FAT-16 */
            if ((PartitionInfo->PartitionNumber) ||
                (PartitionInfo->PartitionType != PARTITION_FAT_16) ||
                (PartitionInfo->BootIndicator))
            {
                /* It's not, so we fail */
                return STATUS_INVALID_PARAMETER;
            }
 
            /* Check if it needs a rewrite, and disable EZ-Drive for sure */
            if (PartitionInfo->RewritePartition) DoRewrite = TRUE;
            IsEzDrive = FALSE;
        }
    }
 
    /* Count the number of partition tables */
    DiskLayout->TableCount = (PartitionBuffer->PartitionCount + NUM_PARTITION_TABLE_ENTRIES - 1) / NUM_PARTITION_TABLE_ENTRIES;
 
    /* Allocate our partition buffer */
    Buffer = ExAllocatePoolWithTag(NonPagedPoolCacheAligned, PAGE_SIZE, TAG_FILE_SYSTEM);
    if (!Buffer) return STATUS_INSUFFICIENT_RESOURCES;
 
    /* Loop the entries */
    Entry = (PPTE)&Buffer[PARTITION_TABLE_OFFSET];
    for (i = 0; i < DiskLayout->TableCount; i++)
    {
        /* Set if this is the MBR partition */
        IsMbr= (BOOLEAN)!i;
 
        /* Initialize th event */
        KeInitializeEvent(&Event, NotificationEvent, FALSE);
 
        /* Build the read IRP */
        Irp = IoBuildSynchronousFsdRequest(IRP_MJ_READ,
                                           DeviceObject,
                                           Buffer,
                                           BufferSize,
                                           &Offset,
                                           &Event,
                                           &IoStatusBlock);
        if (!Irp)
        {
            /* Fail */
            Status = STATUS_INSUFFICIENT_RESOURCES;
            break;
        }
 
        /* Make sure to disable volume verification */
        IoStackLocation = IoGetNextIrpStackLocation(Irp);
        IoStackLocation->Flags |= SL_OVERRIDE_VERIFY_VOLUME;
 
        /* Call the driver */
        Status = IoCallDriver(DeviceObject, Irp);
        if (Status == STATUS_PENDING)
        {
            /* Wait for completion */
            KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
            Status = IoStatusBlock.Status;
        }
 
        /* Check for failure */
        if (!NT_SUCCESS(Status)) break;
 
        /* If we biased for EZ-Drive, unbias now */
        if (IsEzDrive && (Offset.QuadPart == 512)) Offset.QuadPart = 0;
 
        /* Check if this is a normal disk */
        if (!IsSuperFloppy)
        {
            /* Set the boot record signature */
            *(PUINT16)&Buffer[BOOT_SIGNATURE_OFFSET] = BOOT_RECORD_SIGNATURE;
 
            /* By default, don't require a rewrite */
            DoRewrite = FALSE;
 
            /* Check if we don't have an offset */
            if (!Offset.QuadPart)
            {
                /* Check if the signature doesn't match */
                if (*(PUINT32)&Buffer[DISK_SIGNATURE_OFFSET] != PartitionBuffer->Signature)
                {
                    /* Then write the signature and now we need a rewrite */
                    *(PUINT32)&Buffer[DISK_SIGNATURE_OFFSET] = PartitionBuffer->Signature;
                    DoRewrite = TRUE;
                }
            }
 
            /* Loop the partition table entries */
            PartitionTable = &DiskLayout->PartitionTable[i];
            for (j = 0; j < NUM_PARTITION_TABLE_ENTRIES; j++)
            {
                /* Get the current entry and type */
                TableEntry = &PartitionTable->PartitionEntry[j];
                PartitionType = TableEntry->PartitionType;
 
                /* Check if the entry needs a rewrite */
                if (TableEntry->RewritePartition)
                {
                    /* Then we need one too */
                    DoRewrite = TRUE;
 
                    /* Save the type and if it's a bootable partition */
                    Entry[j].PartitionType = TableEntry->PartitionType;
                    Entry[j].ActiveFlag = TableEntry->BootIndicator ? 0x80 : 0;
 
                    /* Make sure it's used */
                    if (PartitionType != PARTITION_ENTRY_UNUSED)
                    {
                        /* Make sure it's not a container (unless primary) */
                        if ((IsMbr) || !(IsContainerPartition(PartitionType)))
                        {
                            /* Use the partition offset */
                            StartOffset.QuadPart = Offset.QuadPart;
                        }
                        else
                        {
                            /* Use the extended logical partition offset */
                            StartOffset.QuadPart = ExtendedOffset.QuadPart;
                        }
 
                        /* Set the sector offset */
                        SectorOffset.QuadPart = TableEntry->
                                                StartingOffset.QuadPart -
                                                StartOffset.QuadPart;
 
                        /* Now calculate the starting sector */
                        StartOffset.QuadPart = SectorOffset.QuadPart >> k;
                        Entry[j].StartingSector = StartOffset.LowPart;
 
                        /* As well as the length */
                        PartitionLength.QuadPart = TableEntry->PartitionLength.
                                                   QuadPart >> k;
                        Entry[j].PartitionLength = PartitionLength.LowPart;
 
                        /* Calculate the CHS values */
                        HalpCalculateChsValues(&TableEntry->StartingOffset,
                                               &TableEntry->PartitionLength,
                                               k,
                                               SectorsPerTrack,
                                               NumberOfHeads,
                                               ConventionalCylinders,
                                               (PPARTITION_DESCRIPTOR)
                                               &Entry[j]);
                    }
                    else
                    {
                        /* Otherwise set up an empty entry */
                        Entry[j].StartingSector = 0;
                        Entry[j].PartitionLength = 0;
                        Entry[j].StartingTrack = 0;
                        Entry[j].EndingTrack = 0;
                        Entry[j].StartingCylinder = 0;
                        Entry[j].EndingCylinder = 0;
                    }
                }
 
                /* Check if this is a container partition */
                if (IsContainerPartition(PartitionType))
                {
                    /* Then update the offset to use */
                    NextOffset = TableEntry->StartingOffset;
                }
            }
        }
 
        /* Check if we need to write back the buffer */
        if (DoRewrite)
        {
            /* We don't need to do this again */
            DoRewrite = FALSE;
 
            /* Initialize the event */
            KeInitializeEvent(&Event, NotificationEvent, FALSE);
 
            /* If we unbiased for EZ-Drive, rebias now */
            if (IsEzDrive && !Offset.QuadPart) Offset.QuadPart = 512;
 
            /* Build the write IRP */
            Irp = IoBuildSynchronousFsdRequest(IRP_MJ_WRITE,
                                               DeviceObject,
                                               Buffer,
                                               BufferSize,
                                               &Offset,
                                               &Event,
                                               &IoStatusBlock);
            if (!Irp)
            {
                /* Fail */
                Status = STATUS_INSUFFICIENT_RESOURCES;
                break;
            }
 
            /* Make sure to disable volume verification */
            IoStackLocation = IoGetNextIrpStackLocation(Irp);
            IoStackLocation->Flags |= SL_OVERRIDE_VERIFY_VOLUME;
 
            /* Call the driver */
            Status = IoCallDriver(DeviceObject, Irp);
            if (Status == STATUS_PENDING)
            {
                /* Wait for completion */
                KeWaitForSingleObject(&Event,
                                      Executive,
                                      KernelMode,
                                      FALSE,
                                      NULL);
                Status = IoStatusBlock.Status;
            }
 
            /* Check for failure */
            if (!NT_SUCCESS(Status)) break;
 
            /* If we biased for EZ-Drive, unbias now */
            if (IsEzDrive && (Offset.QuadPart == 512)) Offset.QuadPart = 0;
        }
 
        /* Update the partition offset and set the extended offset if needed */
        Offset = NextOffset;
        if (IsMbr) ExtendedOffset = NextOffset;
    }
 
    /* If we had a buffer, free it, then return status */
    if (Buffer) ExFreePoolWithTag(Buffer, TAG_FILE_SYSTEM);
    return Status;
}

Variable Documentation

CdPrefix

const UNICODE_STRING CdPrefix = RTL_CONSTANT_STRING(L"\\Device\\CdRom")

static

Definition at line 41 of file disksup.c.

Referenced by HalpNextDriveLetter(), and xHalIoAssignDriveLetters().

FloppyPrefix

const UNICODE_STRING FloppyPrefix = RTL_CONSTANT_STRING(L"\\Device\\Floppy")

static

Definition at line 40 of file disksup.c.

Referenced by HalpNextDriveLetter(), and xHalIoAssignDriveLetters().