hal.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_PARTITION_DESCRIPTOR
struct	_BOOT_SECTOR_INFO
struct	_PARTITION_TABLE
struct	_DISK_LAYOUT
struct	_PTE

Macros
#define	DISK_SIGNATURE_OFFSET   0x1B8
#define	PARTITION_TABLE_OFFSET   0x1BE
#define	BOOT_SIGNATURE_OFFSET   (0x200 - 2)
#define	BOOT_RECORD_SIGNATURE   0xAA55
#define	NUM_PARTITION_TABLE_ENTRIES   4
#define	GET_STARTING_SECTOR(p)
#define	GET_ENDING_S_OF_CHS(p)    ((UCHAR)((p)->EndingCylinderLsb & 0x3F))
#define	GET_PARTITION_LENGTH(p)
#define	SET_PARTITION_LENGTH(p, l)

Typedefs
typedef struct _PARTITION_DESCRIPTOR	PARTITION_DESCRIPTOR
typedef struct _PARTITION_DESCRIPTOR *	PPARTITION_DESCRIPTOR
typedef struct _BOOT_SECTOR_INFO	BOOT_SECTOR_INFO
typedef struct _BOOT_SECTOR_INFO *	PBOOT_SECTOR_INFO
typedef struct _PARTITION_TABLE	PARTITION_TABLE
typedef struct _PARTITION_TABLE *	PPARTITION_TABLE
typedef struct _DISK_LAYOUT	DISK_LAYOUT
typedef struct _DISK_LAYOUT *	PDISK_LAYOUT
typedef struct _PTE	PTE
typedef struct _PTE *	PPTE

Functions
VOID FASTCALL	xHalExamineMBR (IN PDEVICE_OBJECT DeviceObject, IN ULONG SectorSize, IN ULONG MbrTypeIdentifier, OUT PVOID *MbrBuffer)
VOID FASTCALL	xHalIoAssignDriveLetters (IN PLOADER_PARAMETER_BLOCK LoaderBlock, IN PSTRING NtDeviceName, OUT PUCHAR NtSystemPath, OUT PSTRING NtSystemPathString)
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 NTAPI	xHalHaltSystem (VOID)
VOID NTAPI	xHalEndOfBoot (VOID)
VOID NTAPI	xHalSetWakeEnable (IN BOOLEAN Enable)
UCHAR NTAPI	xHalVectorToIDTEntry (IN ULONG Vector)
NTSTATUS NTAPI	xHalGetInterruptTranslator (IN INTERFACE_TYPE ParentInterfaceType, IN ULONG ParentBusNumber, IN INTERFACE_TYPE BridgeInterfaceType, IN USHORT Size, IN USHORT Version, OUT PTRANSLATOR_INTERFACE Translator, OUT PULONG BridgeBusNumber)
PBUS_HANDLER FASTCALL	xHalHandlerForBus (IN INTERFACE_TYPE InterfaceType, IN ULONG BusNumber)
VOID FASTCALL	xHalReferenceHandler (IN PBUS_HANDLER BusHandler)
NTSTATUS NTAPI	xHalInitPnpDriver (VOID)
NTSTATUS NTAPI	xHalInitPowerManagement (IN PPM_DISPATCH_TABLE PmDriverDispatchTable, OUT PPM_DISPATCH_TABLE *PmHalDispatchTable)
NTSTATUS NTAPI	xHalStartMirroring (VOID)
NTSTATUS NTAPI	xHalEndMirroring (IN ULONG PassNumber)
NTSTATUS NTAPI	xHalMirrorPhysicalMemory (IN PHYSICAL_ADDRESS PhysicalAddress, IN LARGE_INTEGER NumberOfBytes)
NTSTATUS NTAPI	xHalQueryBusSlots (IN PBUS_HANDLER BusHandler, IN ULONG BufferSize, OUT PULONG SlotNumbers, OUT PULONG ReturnedLength)
NTSTATUS NTAPI	xHalSetSystemInformation (IN HAL_SET_INFORMATION_CLASS InformationClass, IN ULONG BufferSize, IN PVOID Buffer)
NTSTATUS NTAPI	xHalQuerySystemInformation (IN HAL_QUERY_INFORMATION_CLASS InformationClass, IN ULONG BufferSize, IN OUT PVOID Buffer, OUT PULONG ReturnedLength)
VOID NTAPI	xHalLocateHiberRanges (IN PVOID MemoryMap)
NTSTATUS NTAPI	xHalRegisterBusHandler (IN INTERFACE_TYPE InterfaceType, IN BUS_DATA_TYPE ConfigSpace, IN ULONG BusNumber, IN INTERFACE_TYPE ParentInterfaceType, IN ULONG ParentBusNumber, IN ULONG ContextSize, IN PINSTALL_BUS_HANDLER InstallCallback, OUT PBUS_HANDLER *BusHandler)
VOID NTAPI	xHalSetWakeAlarm (IN ULONGLONG AlartTime, IN PTIME_FIELDS TimeFields)
BOOLEAN NTAPI	xHalTranslateBusAddress (IN INTERFACE_TYPE InterfaceType, IN ULONG BusNumber, IN PHYSICAL_ADDRESS BusAddress, IN OUT PULONG AddressSpace, OUT PPHYSICAL_ADDRESS TranslatedAddress)
NTSTATUS NTAPI	xHalAllocateMapRegisters (IN PADAPTER_OBJECT AdapterObject, IN ULONG Unknown, IN ULONG Unknown2, PMAP_REGISTER_ENTRY Registers)
NTSTATUS NTAPI	xKdSetupPciDeviceForDebugging (IN PVOID LoaderBlock OPTIONAL, IN OUT PDEBUG_DEVICE_DESCRIPTOR PciDevice)
NTSTATUS NTAPI	xKdReleasePciDeviceForDebugging (IN OUT PDEBUG_DEVICE_DESCRIPTOR PciDevice)
PVOID NTAPI	xKdGetAcpiTablePhase (IN struct _LOADER_PARAMETER_BLOCK *LoaderBlock, IN ULONG Signature)
PVOID NTAPI	MatchAll (IN PHYSICAL_ADDRESS PhysicalAddress, IN ULONG NumberPages, IN BOOLEAN FlushCurrentTLB)
VOID NTAPI	xKdUnmapVirtualAddress (IN PVOID VirtualAddress, IN ULONG NumberPages, IN BOOLEAN FlushCurrentTLB)

Macro Definition Documentation

BOOT_RECORD_SIGNATURE

#define BOOT_RECORD_SIGNATURE   0xAA55

Definition at line 247 of file hal.h.

BOOT_SIGNATURE_OFFSET

#define BOOT_SIGNATURE_OFFSET   (0x200 - 2)

Definition at line 245 of file hal.h.

DISK_SIGNATURE_OFFSET

#define DISK_SIGNATURE_OFFSET   0x1B8

Definition at line 243 of file hal.h.

GET_ENDING_S_OF_CHS

#define GET_ENDING_S_OF_CHS

(

p

)

((UCHAR)((p)->EndingCylinderLsb & 0x3F))

Definition at line 259 of file hal.h.

GET_PARTITION_LENGTH

#define GET_PARTITION_LENGTH

(

p

)

Value:

    ((ULONG)((p)->PartitionLengthLsb0) +            \
     (ULONG)((p)->PartitionLengthLsb1 << 8 ) +      \
     (ULONG)((p)->PartitionLengthMsb0 << 16) +      \
     (ULONG)((p)->PartitionLengthMsb1 << 24))

Definition at line 262 of file hal.h.

GET_STARTING_SECTOR

#define GET_STARTING_SECTOR

(

p

)

Value:

    ((ULONG)((p)->StartingSectorLsb0) +         \
     (ULONG)((p)->StartingSectorLsb1 << 8 ) +   \
     (ULONG)((p)->StartingSectorMsb0 << 16) +   \
     (ULONG)((p)->StartingSectorMsb1 << 24))

Definition at line 253 of file hal.h.

NUM_PARTITION_TABLE_ENTRIES

#define NUM_PARTITION_TABLE_ENTRIES   4

Definition at line 248 of file hal.h.

PARTITION_TABLE_OFFSET

#define PARTITION_TABLE_OFFSET   0x1BE

Definition at line 244 of file hal.h.

SET_PARTITION_LENGTH

#define SET_PARTITION_LENGTH	(		p,
			l
	)

Value:

    ((p)->PartitionLengthLsb0 =  (l) & 0xFF,        \
     (p)->PartitionLengthLsb1 = ((l) >> 8 ) & 0xFF, \
     (p)->PartitionLengthMsb0 = ((l) >> 16) & 0xFF, \
     (p)->PartitionLengthMsb1 = ((l) >> 24) & 0xFF)

Definition at line 268 of file hal.h.

Typedef Documentation

BOOT_SECTOR_INFO

typedef struct _BOOT_SECTOR_INFO BOOT_SECTOR_INFO

DISK_LAYOUT

typedef struct _DISK_LAYOUT DISK_LAYOUT

PARTITION_DESCRIPTOR

typedef struct _PARTITION_DESCRIPTOR PARTITION_DESCRIPTOR

PARTITION_TABLE

typedef struct _PARTITION_TABLE PARTITION_TABLE

PBOOT_SECTOR_INFO

typedef struct _BOOT_SECTOR_INFO * PBOOT_SECTOR_INFO

PDISK_LAYOUT

typedef struct _DISK_LAYOUT * PDISK_LAYOUT

PPARTITION_DESCRIPTOR

typedef struct _PARTITION_DESCRIPTOR * PPARTITION_DESCRIPTOR

PPARTITION_TABLE

typedef struct _PARTITION_TABLE * PPARTITION_TABLE

PPTE

typedef struct _PTE * PPTE

PTE

typedef struct _PTE PTE

Function Documentation

MatchAll()

PVOID NTAPI MatchAll	(	IN PHYSICAL_ADDRESS	PhysicalAddress,
		IN ULONG	NumberPages,
		IN BOOLEAN	FlushCurrentTLB
	)

Definition at line 277 of file halstub.c.

{
    return NULL;
}

xHalAllocateMapRegisters()

NTSTATUS NTAPI xHalAllocateMapRegisters	(	IN PADAPTER_OBJECT	AdapterObject,
		IN ULONG	Unknown,
		IN ULONG	Unknown2,
		PMAP_REGISTER_ENTRY	Registers
	)

Definition at line 242 of file halstub.c.

{
    PAGED_CODE();
 
    return STATUS_NOT_IMPLEMENTED;
}

xHalEndMirroring()

NTSTATUS NTAPI xHalEndMirroring

(

IN ULONG

PassNumber

)

Definition at line 146 of file halstub.c.

{
    return STATUS_NOT_SUPPORTED;
}

xHalEndOfBoot()

VOID NTAPI xHalEndOfBoot

(

VOID

)

Definition at line 88 of file halstub.c.

{
    PAGED_CODE();
 
    /* Nothing */
    return;
}

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

xHalGetInterruptTranslator()

NTSTATUS NTAPI xHalGetInterruptTranslator	(	IN INTERFACE_TYPE	ParentInterfaceType,
		IN ULONG	ParentBusNumber,
		IN INTERFACE_TYPE	BridgeInterfaceType,
		IN USHORT	Size,
		IN USHORT	Version,
		OUT PTRANSLATOR_INTERFACE	Translator,
		OUT PULONG	BridgeBusNumber
	)

Definition at line 156 of file translate.c.

{
    PAGED_CODE();
 
    ASSERT(Version == HAL_IRQ_TRANSLATOR_VERSION);
    ASSERT(Size >= sizeof(TRANSLATOR_INTERFACE));
 
    /* Only (E)ISA interfaces are supported */
    if (BridgeInterfaceType == Internal || BridgeInterfaceType >= MicroChannel)
    {
        return STATUS_NOT_IMPLEMENTED;
    }
 
    /* Fill in output struct */
    Translator->Size = sizeof(TRANSLATOR_INTERFACE);
    Translator->Version = HAL_IRQ_TRANSLATOR_VERSION;
    /* In case caller set interface to undefined, faulty it to ISA */
    Translator->Context = UlongToPtr((BridgeInterfaceType == InterfaceTypeUndefined) ? Isa : BridgeInterfaceType);
    Translator->InterfaceReference = FstubTranslatorNull;
    Translator->InterfaceDereference = FstubTranslatorNull;
    Translator->TranslateResources = FstubTranslateResource;
    Translator->TranslateResourceRequirements = FstubTranslateRequirement;
 
    return STATUS_SUCCESS;
}

xHalHaltSystem()

VOID NTAPI xHalHaltSystem

(

VOID

)

Definition at line 39 of file halstub.c.

{
    /* Halt execution */
    while (TRUE);
}

xHalHandlerForBus()

PBUS_HANDLER FASTCALL xHalHandlerForBus	(	IN INTERFACE_TYPE	InterfaceType,
		IN ULONG	BusNumber
	)

Definition at line 106 of file halstub.c.

{
    return NULL;
}

xHalInitPnpDriver()

NTSTATUS NTAPI xHalInitPnpDriver

(

VOID

)

Definition at line 122 of file halstub.c.

{
    return STATUS_NOT_SUPPORTED;
}

xHalInitPowerManagement()

NTSTATUS NTAPI xHalInitPowerManagement	(	IN PPM_DISPATCH_TABLE	PmDriverDispatchTable,
		OUT PPM_DISPATCH_TABLE *	PmHalDispatchTable
	)

Definition at line 129 of file halstub.c.

{
    return STATUS_NOT_SUPPORTED;
}

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 17 of file halstub.c.

{
    return IoReadPartitionTable(DeviceObject,
                                SectorSize,
                                ReturnRecognizedPartitions,
                                PartitionBuffer);
}

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

xHalLocateHiberRanges()

VOID NTAPI xHalLocateHiberRanges

(

IN PVOID

MemoryMap

)

Definition at line 196 of file halstub.c.

{
    /* Nothing */
    return;
}

xHalMirrorPhysicalMemory()

NTSTATUS NTAPI xHalMirrorPhysicalMemory	(	IN PHYSICAL_ADDRESS	PhysicalAddress,
		IN LARGE_INTEGER	NumberOfBytes
	)

Definition at line 153 of file halstub.c.

{
    return STATUS_NOT_SUPPORTED;
}

xHalQueryBusSlots()

NTSTATUS NTAPI xHalQueryBusSlots	(	IN PBUS_HANDLER	BusHandler,
		IN ULONG	BufferSize,
		OUT PULONG	SlotNumbers,
		OUT PULONG	ReturnedLength
	)

Definition at line 161 of file halstub.c.

{
    PAGED_CODE();
 
    return STATUS_NOT_SUPPORTED;
}

xHalQuerySystemInformation()

NTSTATUS NTAPI xHalQuerySystemInformation	(	IN HAL_QUERY_INFORMATION_CLASS	InformationClass,
		IN ULONG	BufferSize,
		IN OUT PVOID	Buffer,
		OUT PULONG	ReturnedLength
	)

Definition at line 184 of file halstub.c.

{
    PAGED_CODE();
 
    return STATUS_INVALID_LEVEL;
}

xHalReferenceHandler()

VOID FASTCALL xHalReferenceHandler

(

IN PBUS_HANDLER

BusHandler

)

Definition at line 114 of file halstub.c.

{
    /* Nothing */
    return;
}

xHalRegisterBusHandler()

NTSTATUS NTAPI xHalRegisterBusHandler	(	IN INTERFACE_TYPE	InterfaceType,
		IN BUS_DATA_TYPE	ConfigSpace,
		IN ULONG	BusNumber,
		IN INTERFACE_TYPE	ParentInterfaceType,
		IN ULONG	ParentBusNumber,
		IN ULONG	ContextSize,
		IN PINSTALL_BUS_HANDLER	InstallCallback,
		OUT PBUS_HANDLER *	BusHandler
	)

Definition at line 204 of file halstub.c.

{
    PAGED_CODE();
 
    return STATUS_NOT_SUPPORTED;
}

xHalSetSystemInformation()

NTSTATUS NTAPI xHalSetSystemInformation	(	IN HAL_SET_INFORMATION_CLASS	InformationClass,
		IN ULONG	BufferSize,
		IN PVOID	Buffer
	)

Definition at line 173 of file halstub.c.

{
    PAGED_CODE();
 
    return STATUS_INVALID_LEVEL;
}

xHalSetWakeAlarm()

VOID NTAPI xHalSetWakeAlarm	(	IN ULONGLONG	AlartTime,
		IN PTIME_FIELDS	TimeFields
	)

Definition at line 220 of file halstub.c.

{
    /* Nothing */
    return;
}

xHalSetWakeEnable()

VOID NTAPI xHalSetWakeEnable

(

IN BOOLEAN

Enable

)

Definition at line 98 of file halstub.c.

{
    /* Nothing */
    return;
}

xHalStartMirroring()

NTSTATUS NTAPI xHalStartMirroring

(

VOID

)

Definition at line 137 of file halstub.c.

{
    PAGED_CODE();
 
    return STATUS_NOT_SUPPORTED;
}

xHalTranslateBusAddress()

BOOLEAN NTAPI xHalTranslateBusAddress	(	IN INTERFACE_TYPE	InterfaceType,
		IN ULONG	BusNumber,
		IN PHYSICAL_ADDRESS	BusAddress,
		IN OUT PULONG	AddressSpace,
		OUT PPHYSICAL_ADDRESS	TranslatedAddress
	)

Definition at line 229 of file halstub.c.

{
    KeBugCheckEx(HAL_INITIALIZATION_FAILED, 0, 0, 0, 0);
 
    return FALSE;
}

xHalVectorToIDTEntry()

UCHAR NTAPI xHalVectorToIDTEntry

(

IN ULONG

Vector

)

Definition at line 31 of file halstub.c.

{
    /* Return the vector */
    return (UCHAR)Vector;
}

xKdGetAcpiTablePhase()

PVOID NTAPI xKdGetAcpiTablePhase	(	IN struct _LOADER_PARAMETER_BLOCK *	LoaderBlock,
		IN ULONG	Signature
	)

Definition at line 269 of file halstub.c.

{
    return NULL;
}

xKdReleasePciDeviceForDebugging()

NTSTATUS NTAPI xKdReleasePciDeviceForDebugging

(

IN OUT PDEBUG_DEVICE_DESCRIPTOR

PciDevice

)

Definition at line 262 of file halstub.c.

{
    return STATUS_NOT_IMPLEMENTED;
}

xKdSetupPciDeviceForDebugging()

NTSTATUS NTAPI xKdSetupPciDeviceForDebugging	(	IN PVOID LoaderBlock	OPTIONAL,
		IN OUT PDEBUG_DEVICE_DESCRIPTOR	PciDevice
	)

Definition at line 254 of file halstub.c.

{
    return STATUS_NOT_IMPLEMENTED;
}

xKdUnmapVirtualAddress()

VOID NTAPI xKdUnmapVirtualAddress	(	IN PVOID	VirtualAddress,
		IN ULONG	NumberPages,
		IN BOOLEAN	FlushCurrentTLB
	)

Definition at line 286 of file halstub.c.

{
    /* Nothing */
    return;
}