ReactOS  0.4.15-dev-2996-gf777e6b
disksup.c File Reference
#include <ntoskrnl.h>
#include <debug.h>
#include <internal/hal.h>
#include <pshpack1.h>
#include <poppack.h>
Include dependency graph for disksup.c:

Go to the source code of this file.

Classes

struct  _REG_DISK_MOUNT_INFO
 

Macros

#define NDEBUG
 
#define AUTO_DRIVE   MAXULONG
 
#define PARTITION_MAGIC   0xaa55
 
#define EFI_PMBR_OSTYPE_EFI   0xEE
 

Typedefs

typedef struct _REG_DISK_MOUNT_INFO REG_DISK_MOUNT_INFO
 
typedef struct _REG_DISK_MOUNT_INFOPREG_DISK_MOUNT_INFO
 
typedef enum _DISK_MANAGER DISK_MANAGER
 
typedef enum _PARTITION_TYPE PARTITION_TYPE
 
typedef enum _PARTITION_TYPEPPARTITION_TYPE
 

Enumerations

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

Functions

NTSTATUS FASTCALL HalpQueryDriveLayout (IN PUNICODE_STRING DeviceName, OUT PDRIVE_LAYOUT_INFORMATION *LayoutInfo)
 
NTSTATUS HalpQueryPartitionType (IN PUNICODE_STRING DeviceName, IN PDRIVE_LAYOUT_INFORMATION LayoutInfo, OUT PPARTITION_TYPE PartitionType)
 
PULONG IopComputeHarddiskDerangements (IN ULONG DiskCount)
 
NTSTATUS HalpNextMountLetter (IN PUNICODE_STRING DeviceName, OUT PUCHAR DriveLetter)
 
NTSTATUS HalpSetMountLetter (IN PUNICODE_STRING DeviceName, UCHAR DriveLetter)
 
UCHAR HalpNextDriveLetter (IN PUNICODE_STRING DeviceName, IN PSTRING NtDeviceName, OUT PUCHAR NtSystemPath, BOOLEAN IsRemovable)
 
BOOLEAN HalpIsOldStyleFloppy (PUNICODE_STRING DeviceName)
 
NTSTATUS HalpDeleteMountLetter (UCHAR DriveLetter)
 
VOID HalpEnableAutomaticDriveLetterAssignment (VOID)
 
VOID FASTCALL xHalIoAssignDriveLetters (IN PLOADER_PARAMETER_BLOCK LoaderBlock, IN PSTRING NtDeviceName, OUT PUCHAR NtSystemPath, OUT PSTRING NtSystemPathString)
 
NTSTATUS NTAPI HalpGetFullGeometry (IN PDEVICE_OBJECT DeviceObject, OUT PDISK_GEOMETRY_EX Geometry)
 
BOOLEAN NTAPI HalpIsValidPartitionEntry (IN PPARTITION_DESCRIPTOR Entry, IN ULONGLONG MaxOffset, IN ULONGLONG MaxSector)
 
VOID NTAPI 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, IN 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, IN 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

const WCHAR DiskMountString [] = L"\\DosDevices\\%C:"
 

Macro Definition Documentation

◆ AUTO_DRIVE

#define AUTO_DRIVE   MAXULONG

Definition at line 21 of file disksup.c.

◆ EFI_PMBR_OSTYPE_EFI

#define EFI_PMBR_OSTYPE_EFI   0xEE

Definition at line 25 of file disksup.c.

◆ NDEBUG

#define NDEBUG

Definition at line 15 of file disksup.c.

◆ PARTITION_MAGIC

#define PARTITION_MAGIC   0xaa55

Definition at line 23 of file disksup.c.

Typedef Documentation

◆ DISK_MANAGER

◆ PARTITION_TYPE

◆ PPARTITION_TYPE

◆ PREG_DISK_MOUNT_INFO

◆ REG_DISK_MOUNT_INFO

Enumeration Type Documentation

◆ _DISK_MANAGER

Enumerator
NoDiskManager 
OntrackDiskManager 
EZ_Drive 

Definition at line 37 of file disksup.c.

38 {
41  EZ_Drive
42 } DISK_MANAGER;
enum _DISK_MANAGER DISK_MANAGER

◆ _PARTITION_TYPE

Enumerator
BootablePartition 
PrimaryPartition 
LogicalPartition 
FtPartition 
UnknownPartition 
DataPartition 

Definition at line 44 of file disksup.c.

45 {
enum _PARTITION_TYPE * PPARTITION_TYPE
enum _PARTITION_TYPE PARTITION_TYPE

Function Documentation

◆ FstubFixupEfiPartition()

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

Definition at line 1749 of file disksup.c.

1751 {
1752  ULONG PartitionMaxOffset, PartitionLength;
1753  PAGED_CODE();
1754 
1755  /* Compute partition length (according to MBR entry) */
1756  PartitionMaxOffset = GET_STARTING_SECTOR(PartitionDescriptor) + GET_PARTITION_LENGTH(PartitionDescriptor);
1757  /* In case the partition length goes beyond disk size... */
1758  if (PartitionMaxOffset > MaxOffset)
1759  {
1760  /* Resize partition to its maximum real length */
1761  PartitionLength = (ULONG)(PartitionMaxOffset - GET_STARTING_SECTOR(PartitionDescriptor));
1762  SET_PARTITION_LENGTH(PartitionDescriptor, PartitionLength);
1763  }
1764 }
#define GET_STARTING_SECTOR(p)
Definition: hal.h:253
#define SET_PARTITION_LENGTH(p, l)
Definition: hal.h:268
#define GET_PARTITION_LENGTH(p)
Definition: hal.h:262
unsigned int ULONG
Definition: retypes.h:1
#define PAGED_CODE()

Referenced by xHalIoReadPartitionTable().

◆ HalExamineMBR()

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

Definition at line 2681 of file disksup.c.

2685 {
2686  HALDISPATCH->HalExamineMBR(DeviceObject,
2687  SectorSize,
2688  MbrTypeIdentifier,
2689  MbrBuffer);
2690 }
_In_ PDEVICE_OBJECT DeviceObject
Definition: wdfdevice.h:2055
_In_ ULONG SectorSize
Definition: halfuncs.h:291
#define HALDISPATCH
Definition: haltypes.h:278

Referenced by CreatePartitionDeviceObjects(), DiskInitFdo(), IopCreateArcNamesDisk(), UpdateGeometry(), xHalIoReadPartitionTable(), xHalIoSetPartitionInformation(), and xHalIoWritePartitionTable().

◆ HalpCalculateChsValues()

VOID NTAPI 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 
)

Definition at line 1482 of file disksup.c.

1489 {
1490  LARGE_INTEGER FirstSector, SectorCount;
1491  ULONG LastSector, Remainder, SectorsPerCylinder;
1492  ULONG StartingCylinder, EndingCylinder;
1493  ULONG StartingTrack, EndingTrack;
1494  ULONG StartingSector, EndingSector;
1495  PAGED_CODE();
1496 
1497  /* Calculate the number of sectors for each cylinder */
1498  SectorsPerCylinder = SectorsPerTrack * NumberOfTracks;
1499 
1500  /* Calculate the first sector, and the sector count */
1501  FirstSector.QuadPart = PartitionOffset->QuadPart >> ShiftCount;
1502  SectorCount.QuadPart = PartitionLength->QuadPart >> ShiftCount;
1503 
1504  /* Now calculate the last sector */
1505  LastSector = FirstSector.LowPart + SectorCount.LowPart - 1;
1506 
1507  /* Calculate the first and last cylinders */
1508  StartingCylinder = FirstSector.LowPart / SectorsPerCylinder;
1509  EndingCylinder = LastSector / SectorsPerCylinder;
1510 
1511  /* Set the default number of cylinders */
1512  if (!ConventionalCylinders) ConventionalCylinders = 1024;
1513 
1514  /* Normalize the values */
1515  if (StartingCylinder >= ConventionalCylinders)
1516  {
1517  /* Set the maximum to 1023 */
1518  StartingCylinder = ConventionalCylinders - 1;
1519  }
1520  if (EndingCylinder >= ConventionalCylinders)
1521  {
1522  /* Set the maximum to 1023 */
1523  EndingCylinder = ConventionalCylinders - 1;
1524  }
1525 
1526  /* Calculate the starting head and sector that still remain */
1527  Remainder = FirstSector.LowPart % SectorsPerCylinder;
1528  StartingTrack = Remainder / SectorsPerTrack;
1529  StartingSector = Remainder % SectorsPerTrack;
1530 
1531  /* Calculate the ending head and sector that still remain */
1532  Remainder = LastSector % SectorsPerCylinder;
1533  EndingTrack = Remainder / SectorsPerTrack;
1534  EndingSector = Remainder % SectorsPerTrack;
1535 
1536  /* Set cylinder data for the MSB */
1537  PartitionDescriptor->StartingCylinderMsb = (UCHAR)StartingCylinder;
1538  PartitionDescriptor->EndingCylinderMsb = (UCHAR)EndingCylinder;
1539 
1540  /* Set the track data */
1541  PartitionDescriptor->StartingTrack = (UCHAR)StartingTrack;
1542  PartitionDescriptor->EndingTrack = (UCHAR)EndingTrack;
1543 
1544  /* Update cylinder data for the LSB */
1545  StartingCylinder = ((StartingSector + 1) & 0x3F) |
1546  ((StartingCylinder >> 2) & 0xC0);
1547  EndingCylinder = ((EndingSector + 1) & 0x3F) |
1548  ((EndingCylinder >> 2) & 0xC0);
1549 
1550  /* Set the cylinder data for the LSB */
1551  PartitionDescriptor->StartingCylinderLsb = (UCHAR)StartingCylinder;
1552  PartitionDescriptor->EndingCylinderLsb = (UCHAR)EndingCylinder;
1553 }
_In_ ULONG _In_ ULONG SectorsPerTrack
Definition: iofuncs.h:2070
unsigned char UCHAR
Definition: xmlstorage.h:181
ULONG LowPart
Definition: typedefs.h:106
ULONG SectorCount
Definition: part_xbox.c:31
unsigned int ULONG
Definition: retypes.h:1
LONGLONG QuadPart
Definition: typedefs.h:114
_In_ LARGE_INTEGER _Out_opt_ PLARGE_INTEGER Remainder
Definition: rtlfuncs.h:3044
#define PAGED_CODE()

Referenced by xHalIoWritePartitionTable().

◆ HalpDeleteMountLetter()

NTSTATUS HalpDeleteMountLetter ( UCHAR  DriveLetter)

Definition at line 766 of file disksup.c.

767 {
768  PIRP Irp;
769  KEVENT Event;
771  WCHAR Buffer[30];
777  UNICODE_STRING DosDevice, MountMgr;
779 
780  /* Setup the device name of the letter to delete */
781  swprintf(Buffer, L"\\DosDevices\\%c:", DriveLetter);
782  RtlInitUnicodeString(&DosDevice, Buffer);
783 
784  /* Allocate the input buffer for MountMgr */
785  InputBufferLength = DosDevice.Length + sizeof(MOUNTMGR_MOUNT_POINT);
787  if (InputBuffer == NULL)
788  {
790  }
791 
792  /* Fill it in */
794  InputBuffer->SymbolicLinkNameOffset = sizeof(MOUNTMGR_MOUNT_POINT);
795  InputBuffer->SymbolicLinkNameLength = DosDevice.Length;
796  RtlCopyMemory(&InputBuffer[1], DosDevice.Buffer, DosDevice.Length);
797 
798  /* Allocate big enough output buffer (we don't care about the output) */
800  if (OutputBuffer == NULL)
801  {
804  }
805 
806  /* Get the device pointer to the MountMgr */
807  RtlInitUnicodeString(&MountMgr, L"\\Device\\MountPointManager");
808  Status = IoGetDeviceObjectPointer(&MountMgr,
810  &FileObject,
811  &DeviceObject);
812  if (!NT_SUCCESS(Status))
813  {
816  return Status;
817  }
818 
819  /* Call the mount manager to delete the drive letter */
822  DeviceObject,
823  InputBuffer,
825  OutputBuffer,
826  0x1000,
827  FALSE,
828  &Event,
829  &IoStatusBlock);
830  if (Irp == NULL)
831  {
836  }
837 
839  if (Status == STATUS_PENDING)
840  {
842  Executive,
843  KernelMode,
844  FALSE,
845  NULL);
847  }
848 
852 
853  return Status;
854 }
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
struct _MOUNTMGR_MOUNT_POINT MOUNTMGR_MOUNT_POINT
LONG NTSTATUS
Definition: precomp.h:26
NTSTATUS NTAPI IoGetDeviceObjectPointer(IN PUNICODE_STRING ObjectName, IN ACCESS_MASK DesiredAccess, OUT PFILE_OBJECT *FileObject, OUT PDEVICE_OBJECT *DeviceObject)
Definition: device.c:1435
_In_ WDFREQUEST _In_ size_t _In_ size_t InputBufferLength
Definition: wdfio.h:318
#define swprintf
Definition: precomp.h:40
NTSTATUS NTAPI KeWaitForSingleObject(IN PVOID Object, IN KWAIT_REASON WaitReason, IN KPROCESSOR_MODE WaitMode, IN BOOLEAN Alertable, IN PLARGE_INTEGER Timeout OPTIONAL)
Definition: wait.c:416
_In_ PDEVICE_OBJECT DeviceObject
Definition: wdfdevice.h:2055
#define FALSE
Definition: types.h:117
_In_ PIRP Irp
Definition: csq.h:116
_In_ PVOID _In_ ULONG Event
Definition: iotypes.h:467
Definition: bufpool.h:45
_In_ WDFREQUEST _In_ WDFFILEOBJECT FileObject
Definition: wdfdevice.h:547
_Must_inspect_result_ _In_ WDFIOTARGET _In_opt_ WDFREQUEST _In_opt_ PWDF_MEMORY_DESCRIPTOR OutputBuffer
Definition: wdfiotarget.h:859
Status
Definition: gdiplustypes.h:24
_Must_inspect_result_ _In_ WDFIOTARGET _In_opt_ WDFREQUEST _In_opt_ PWDF_MEMORY_DESCRIPTOR InputBuffer
Definition: wdfiotarget.h:949
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define STATUS_PENDING
Definition: ntstatus.h:82
#define ObDereferenceObject
Definition: obfuncs.h:203
* PFILE_OBJECT
Definition: iotypes.h:1998
#define FILE_READ_ATTRIBUTES
Definition: nt_native.h:647
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
static const WCHAR L[]
Definition: oid.c:1250
#define TAG_FSTUB
Definition: tag.h:198
#define KeInitializeEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:477
static OUT PIO_STATUS_BLOCK IoStatusBlock
Definition: pipe.c:75
#define NULL
Definition: types.h:112
NTSTATUS NTAPI IoCallDriver(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: irp.c:1218
PIRP NTAPI IoBuildDeviceIoControlRequest(IN ULONG IoControlCode, IN PDEVICE_OBJECT DeviceObject, IN PVOID InputBuffer, IN ULONG InputBufferLength, IN PVOID OutputBuffer, IN ULONG OutputBufferLength, IN BOOLEAN InternalDeviceIoControl, IN PKEVENT Event, IN PIO_STATUS_BLOCK IoStatusBlock)
Definition: irp.c:881
unsigned int ULONG
Definition: retypes.h:1
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1099
#define IOCTL_MOUNTMGR_DELETE_POINTS
Definition: imports.h:124

Referenced by xHalIoAssignDriveLetters().

◆ HalpEnableAutomaticDriveLetterAssignment()

VOID HalpEnableAutomaticDriveLetterAssignment ( VOID  )

Definition at line 857 of file disksup.c.

858 {
859  PIRP Irp;
860  KEVENT Event;
862  UNICODE_STRING MountMgr;
866 
867  /* Get the device pointer to the MountMgr */
868  RtlInitUnicodeString(&MountMgr, L"\\Device\\MountPointManager");
869  Status = IoGetDeviceObjectPointer(&MountMgr,
871  &FileObject,
872  &DeviceObject);
873  if (!NT_SUCCESS(Status))
874  {
875  return;
876  }
877 
878  /* Just send an IOCTL to enable the feature */
881  DeviceObject,
882  NULL,
883  0,
884  NULL,
885  0,
886  FALSE,
887  &Event,
888  &IoStatusBlock);
889  if (Irp == NULL)
890  {
891  return;
892  }
893 
895  if (Status == STATUS_PENDING)
896  {
898  Executive,
899  KernelMode,
900  FALSE,
901  NULL);
903  }
904 
906 
907  return;
908 }
LONG NTSTATUS
Definition: precomp.h:26
#define IOCTL_MOUNTMGR_AUTO_DL_ASSIGNMENTS
Definition: mountmgr.h:36
NTSTATUS NTAPI IoGetDeviceObjectPointer(IN PUNICODE_STRING ObjectName, IN ACCESS_MASK DesiredAccess, OUT PFILE_OBJECT *FileObject, OUT PDEVICE_OBJECT *DeviceObject)
Definition: device.c:1435
NTSTATUS NTAPI KeWaitForSingleObject(IN PVOID Object, IN KWAIT_REASON WaitReason, IN KPROCESSOR_MODE WaitMode, IN BOOLEAN Alertable, IN PLARGE_INTEGER Timeout OPTIONAL)
Definition: wait.c:416
_In_ PDEVICE_OBJECT DeviceObject
Definition: wdfdevice.h:2055
#define FALSE
Definition: types.h:117
_In_ PIRP Irp
Definition: csq.h:116
_In_ PVOID _In_ ULONG Event
Definition: iotypes.h:467
_In_ WDFREQUEST _In_ WDFFILEOBJECT FileObject
Definition: wdfdevice.h:547
Status
Definition: gdiplustypes.h:24
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define STATUS_PENDING
Definition: ntstatus.h:82
#define ObDereferenceObject
Definition: obfuncs.h:203
* PFILE_OBJECT
Definition: iotypes.h:1998
#define FILE_READ_ATTRIBUTES
Definition: nt_native.h:647
static const WCHAR L[]
Definition: oid.c:1250
#define KeInitializeEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:477
static OUT PIO_STATUS_BLOCK IoStatusBlock
Definition: pipe.c:75
#define NULL
Definition: types.h:112
NTSTATUS NTAPI IoCallDriver(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: irp.c:1218
PIRP NTAPI IoBuildDeviceIoControlRequest(IN ULONG IoControlCode, IN PDEVICE_OBJECT DeviceObject, IN PVOID InputBuffer, IN ULONG InputBufferLength, IN PVOID OutputBuffer, IN ULONG OutputBufferLength, IN BOOLEAN InternalDeviceIoControl, IN PKEVENT Event, IN PIO_STATUS_BLOCK IoStatusBlock)
Definition: irp.c:881
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)

Referenced by xHalIoAssignDriveLetters().

◆ HalpGetFullGeometry()

NTSTATUS NTAPI HalpGetFullGeometry ( IN PDEVICE_OBJECT  DeviceObject,
OUT PDISK_GEOMETRY_EX  Geometry 
)

Definition at line 1389 of file disksup.c.

1391 {
1392  PIRP Irp;
1394  PKEVENT Event;
1395  NTSTATUS Status;
1396 
1397  PAGED_CODE();
1398 
1399  /* Allocate a non-paged event */
1401  sizeof(KEVENT),
1402  TAG_FILE_SYSTEM);
1403  if (!Event) return STATUS_INSUFFICIENT_RESOURCES;
1404 
1405  /* Initialize it */
1407 
1408  /* Build the IRP */
1410  DeviceObject,
1411  NULL,
1412  0UL,
1413  Geometry,
1414  sizeof(DISK_GEOMETRY_EX),
1415  FALSE,
1416  Event,
1417  &IoStatusBlock);
1418  if (!Irp)
1419  {
1420  /* Fail, free the event */
1423  }
1424 
1425  /* Call the driver and check if it's pending */
1427  if (Status == STATUS_PENDING)
1428  {
1429  /* Wait on the driver */
1432  }
1433 
1434  /* Free the event and return the Status */
1436  return Status;
1437 }
#define TAG_FILE_SYSTEM
Definition: tag.h:50
#define IOCTL_DISK_GET_DRIVE_GEOMETRY_EX
Definition: ntddk_ex.h:208
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
LONG NTSTATUS
Definition: precomp.h:26
NTSTATUS NTAPI KeWaitForSingleObject(IN PVOID Object, IN KWAIT_REASON WaitReason, IN KPROCESSOR_MODE WaitMode, IN BOOLEAN Alertable, IN PLARGE_INTEGER Timeout OPTIONAL)
Definition: wait.c:416
_In_ PDEVICE_OBJECT DeviceObject
Definition: wdfdevice.h:2055
#define FALSE
Definition: types.h:117
_In_ PIRP Irp
Definition: csq.h:116
_In_ PVOID _In_ ULONG Event
Definition: iotypes.h:467
Status
Definition: gdiplustypes.h:24
#define STATUS_PENDING
Definition: ntstatus.h:82
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
#define KeInitializeEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:477
static OUT PIO_STATUS_BLOCK IoStatusBlock
Definition: pipe.c:75
#define NULL
Definition: types.h:112
NTSTATUS NTAPI IoCallDriver(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: irp.c:1218
PIRP NTAPI IoBuildDeviceIoControlRequest(IN ULONG IoControlCode, IN PDEVICE_OBJECT DeviceObject, IN PVOID InputBuffer, IN ULONG InputBufferLength, IN PVOID OutputBuffer, IN ULONG OutputBufferLength, IN BOOLEAN InternalDeviceIoControl, IN PKEVENT Event, IN PIO_STATUS_BLOCK IoStatusBlock)
Definition: irp.c:881
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1099
#define UL
Definition: tui.h:82
#define PAGED_CODE()

Referenced by xHalIoReadPartitionTable().

◆ HalpIsOldStyleFloppy()

BOOLEAN HalpIsOldStyleFloppy ( PUNICODE_STRING  DeviceName)

Definition at line 707 of file disksup.c.

708 {
709  PIRP Irp;
710  KEVENT Event;
712  MOUNTDEV_NAME DevName;
716  PAGED_CODE();
717 
718  /* Get the attached device object to our device */
721  &FileObject,
722  &DeviceObject)))
723  {
724  return FALSE;
725  }
726 
729 
730  /* Query its device name (ie, check floppy.sys implements MountMgr interface) */
733  DeviceObject,
734  NULL,
735  0,
736  &DevName,
737  sizeof(DevName),
738  FALSE,
739  &Event,
740  &IoStatusBlock);
741  if (Irp == NULL)
742  {
744  return FALSE;
745  }
746 
748  if (Status == STATUS_PENDING)
749  {
751  Executive,
752  KernelMode,
753  FALSE,
754  NULL);
756  }
757 
758  /* If status is not STATUS_BUFFER_OVERFLOW, it means
759  * it's pre-mountmgr driver, aka "Old style".
760  */
762  return (Status != STATUS_BUFFER_OVERFLOW);
763 }
LONG NTSTATUS
Definition: precomp.h:26
NTSTATUS NTAPI IoGetDeviceObjectPointer(IN PUNICODE_STRING ObjectName, IN ACCESS_MASK DesiredAccess, OUT PFILE_OBJECT *FileObject, OUT PDEVICE_OBJECT *DeviceObject)
Definition: device.c:1435
NTSTATUS NTAPI KeWaitForSingleObject(IN PVOID Object, IN KWAIT_REASON WaitReason, IN KPROCESSOR_MODE WaitMode, IN BOOLEAN Alertable, IN PLARGE_INTEGER Timeout OPTIONAL)
Definition: wait.c:416
#define IOCTL_MOUNTDEV_QUERY_DEVICE_NAME
Definition: imports.h:93
_In_ PDEVICE_OBJECT DeviceObject
Definition: wdfdevice.h:2055
_Must_inspect_result_ _In_ PWDFDEVICE_INIT _In_opt_ PCUNICODE_STRING DeviceName
Definition: wdfdevice.h:3272
#define FALSE
Definition: types.h:117
_In_ PIRP Irp
Definition: csq.h:116
_In_ PVOID _In_ ULONG Event
Definition: iotypes.h:467
_In_ WDFREQUEST _In_ WDFFILEOBJECT FileObject
Definition: wdfdevice.h:547
PDEVICE_OBJECT NTAPI IoGetAttachedDeviceReference(PDEVICE_OBJECT DeviceObject)
Definition: device.c:1406
Status
Definition: gdiplustypes.h:24
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define STATUS_PENDING
Definition: ntstatus.h:82
#define ObDereferenceObject
Definition: obfuncs.h:203
* PFILE_OBJECT
Definition: iotypes.h:1998
#define FILE_READ_ATTRIBUTES
Definition: nt_native.h:647
#define KeInitializeEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:477
#define STATUS_BUFFER_OVERFLOW
Definition: shellext.h:66
static OUT PIO_STATUS_BLOCK IoStatusBlock
Definition: pipe.c:75
#define NULL
Definition: types.h:112
NTSTATUS NTAPI IoCallDriver(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: irp.c:1218
PIRP NTAPI IoBuildDeviceIoControlRequest(IN ULONG IoControlCode, IN PDEVICE_OBJECT DeviceObject, IN PVOID InputBuffer, IN ULONG InputBufferLength, IN PVOID OutputBuffer, IN ULONG OutputBufferLength, IN BOOLEAN InternalDeviceIoControl, IN PKEVENT Event, IN PIO_STATUS_BLOCK IoStatusBlock)
Definition: irp.c:881
#define PAGED_CODE()

Referenced by xHalIoAssignDriveLetters().

◆ HalpIsValidPartitionEntry()

BOOLEAN NTAPI HalpIsValidPartitionEntry ( IN PPARTITION_DESCRIPTOR  Entry,
IN ULONGLONG  MaxOffset,
IN ULONGLONG  MaxSector 
)

Definition at line 1441 of file disksup.c.

1444 {
1445  ULONGLONG EndingSector;
1446  PAGED_CODE();
1447 
1448  /* Unused partitions are considered valid */
1449  if (Entry->PartitionType == PARTITION_ENTRY_UNUSED) return TRUE;
1450 
1451  /* Get the last sector of the partition */
1453 
1454  /* Check if it's more then the maximum sector */
1455  if (EndingSector > MaxSector)
1456  {
1457  /* Invalid partition */
1458  DPRINT1("FSTUB: entry is invalid\n");
1459  DPRINT1("FSTUB: offset %#08lx\n", GET_STARTING_SECTOR(Entry));
1460  DPRINT1("FSTUB: length %#08lx\n", GET_PARTITION_LENGTH(Entry));
1461  DPRINT1("FSTUB: end %#I64x\n", EndingSector);
1462  DPRINT1("FSTUB: max %#I64x\n", MaxSector);
1463  return FALSE;
1464  }
1465  else if (GET_STARTING_SECTOR(Entry) > MaxOffset)
1466  {
1467  /* Invalid partition */
1468  DPRINT1("FSTUB: entry is invalid\n");
1469  DPRINT1("FSTUB: offset %#08lx\n", GET_STARTING_SECTOR(Entry));
1470  DPRINT1("FSTUB: length %#08lx\n", GET_PARTITION_LENGTH(Entry));
1471  DPRINT1("FSTUB: end %#I64x\n", EndingSector);
1472  DPRINT1("FSTUB: maxOffset %#I64x\n", MaxOffset);
1473  return FALSE;
1474  }
1475 
1476  /* It's fine, return success */
1477  return TRUE;
1478 }
#define GET_STARTING_SECTOR(p)
Definition: hal.h:253
#define TRUE
Definition: types.h:120
#define PARTITION_ENTRY_UNUSED
Definition: disk.h:86
#define FALSE
Definition: types.h:117
#define GET_PARTITION_LENGTH(p)
Definition: hal.h:262
uint64_t ULONGLONG
Definition: typedefs.h:67
#define DPRINT1
Definition: precomp.h:8
base of all file and directory entries
Definition: entries.h:82
#define PAGED_CODE()

Referenced by xHalIoReadPartitionTable().

◆ HalpNextDriveLetter()

UCHAR HalpNextDriveLetter ( IN PUNICODE_STRING  DeviceName,
IN PSTRING  NtDeviceName,
OUT PUCHAR  NtSystemPath,
BOOLEAN  IsRemovable 
)

Definition at line 607 of file disksup.c.

611 {
612  UCHAR i;
613  WCHAR Buffer[40];
614  UCHAR DriveLetter;
615  UNICODE_STRING FloppyString, CdString, NtDeviceNameU, DosDevice;
616 
617  /* Quick path, ask directly the mount manager to assign the next
618  * free drive letter
619  */
620  if (NT_SUCCESS(HalpNextMountLetter(DeviceName, &DriveLetter)))
621  {
622  return DriveLetter;
623  }
624 
625  /* We'll allow MountMgr to fail only for non vital path */
626  if (NtDeviceName == NULL || NtSystemPath == NULL)
627  {
628  return -1;
629  }
630 
631  /* And for removable devices */
632  if (!IsRemovable)
633  {
634  return 0;
635  }
636 
637  /* Removable might be floppy or cdrom */
638  RtlInitUnicodeString(&FloppyString, L"\\Device\\Floppy");
639  RtlInitUnicodeString(&CdString, L"\\Device\\CdRom");
640 
641  /* If floppy, start at A */
642  if (RtlPrefixUnicodeString(&FloppyString, DeviceName, TRUE))
643  {
644  DriveLetter = 'A';
645  }
646  /* If CD start C */
647  else if (RtlPrefixUnicodeString(&CdString, DeviceName, TRUE))
648  {
649  DriveLetter = 'D';
650  }
651  /* For the rest start at C */
652  else
653  {
654  DriveLetter = 'C';
655  }
656 
657  /* Now, try to assign a drive letter manually with the MountMgr */
658  for (i = DriveLetter; i <= 'Z'; ++i)
659  {
661  {
662  /* If it worked, if we were managing system path, update manually */
663  if (NT_SUCCESS(RtlAnsiStringToUnicodeString(&NtDeviceNameU, NtDeviceName, TRUE)))
664  {
665  if (RtlEqualUnicodeString(&NtDeviceNameU, DeviceName, TRUE))
666  {
667  *NtSystemPath = i;
668  }
669 
670  RtlFreeUnicodeString(&NtDeviceNameU);
671  }
672 
673  return i;
674  }
675  }
676 
677  /* Last fall back, we're not on a PnP device... */
678  for (i = DriveLetter; i <= 'Z'; ++i)
679  {
680  /* We'll link manually, without MountMgr knowing anything about the device */
681  swprintf(Buffer, L"\\DosDevices\\%c:", i);
682  RtlInitUnicodeString(&DosDevice, Buffer);
683 
684  /* If linking worked, then the letter was free ;-) */
685  if (NT_SUCCESS(IoCreateSymbolicLink(&DosDevice, DeviceName)))
686  {
687  /* If it worked, if we were managing system path, update manually */
688  if (NT_SUCCESS(RtlAnsiStringToUnicodeString(&NtDeviceNameU, NtDeviceName, TRUE)))
689  {
690  if (RtlEqualUnicodeString(&NtDeviceNameU, DeviceName, TRUE))
691  {
692  *NtSystemPath = i;
693  }
694 
695  RtlFreeUnicodeString(&NtDeviceNameU);
696  }
697 
698  return i;
699  }
700  }
701 
702  /* We're done, nothing happened */
703  return 0;
704 }
#define TRUE
Definition: types.h:120
#define swprintf
Definition: precomp.h:40
_Must_inspect_result_ _In_ PWDFDEVICE_INIT _In_opt_ PCUNICODE_STRING DeviceName
Definition: wdfdevice.h:3272
Definition: bufpool.h:45
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
NTSYSAPI VOID NTAPI RtlFreeUnicodeString(PUNICODE_STRING UnicodeString)
NTSTATUS HalpSetMountLetter(IN PUNICODE_STRING DeviceName, UCHAR DriveLetter)
Definition: disksup.c:522
unsigned char UCHAR
Definition: xmlstorage.h:181
static const WCHAR L[]
Definition: oid.c:1250
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
NTSYSAPI NTSTATUS NTAPI RtlAnsiStringToUnicodeString(PUNICODE_STRING DestinationString, PANSI_STRING SourceString, BOOLEAN AllocateDestinationString)
#define NULL
Definition: types.h:112
NTSYSAPI BOOLEAN NTAPI RtlPrefixUnicodeString(IN PUNICODE_STRING String1, IN PUNICODE_STRING String2, IN BOOLEAN CaseInSensitive)
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
NTSTATUS HalpNextMountLetter(IN PUNICODE_STRING DeviceName, OUT PUCHAR DriveLetter)
Definition: disksup.c:441
NTSYSAPI BOOLEAN NTAPI RtlEqualUnicodeString(PUNICODE_STRING String1, PUNICODE_STRING String2, BOOLEAN CaseInSensitive)

Referenced by xHalIoAssignDriveLetters().

◆ HalpNextMountLetter()

NTSTATUS HalpNextMountLetter ( IN PUNICODE_STRING  DeviceName,
OUT PUCHAR  DriveLetter 
)

Definition at line 441 of file disksup.c.

443 {
444  PIRP Irp;
445  KEVENT Event;
447  UNICODE_STRING MountMgr;
453 
454  /* To get next mount letter, we need the MountMgr */
455  RtlInitUnicodeString(&MountMgr, L"\\Device\\MountPointManager");
456  Status = IoGetDeviceObjectPointer(&MountMgr,
458  &FileObject,
459  &DeviceObject);
460  if (!NT_SUCCESS(Status))
461  {
462  return Status;
463  }
464 
465  /* Allocate our input buffer */
468  TAG_FSTUB);
469  if (Target == NULL)
470  {
473  }
474 
475  /* And fill it with the device hat needs a drive letter */
476  Target->DeviceNameLength = DeviceName->Length;
477  RtlCopyMemory(&Target->DeviceName[0], DeviceName->Buffer, DeviceName->Length);
478 
479  /* Call the mount manager */
482  DeviceObject,
483  Target,
485  &LetterInfo,
486  sizeof(LetterInfo),
487  FALSE,
488  &Event,
489  &IoStatusBlock);
490  if (Irp == NULL)
491  {
495  }
496 
498  if (Status == STATUS_PENDING)
499  {
501  Executive,
502  KernelMode,
503  FALSE,
504  NULL);
506  }
507 
510 
511  DPRINT("Done: %d %c\n", LetterInfo.DriveLetterWasAssigned,
512  LetterInfo.CurrentDriveLetter);
513 
514  /* Return the drive letter the MountMgr potentially assigned */
515  *DriveLetter = LetterInfo.CurrentDriveLetter;
516 
517  /* Also return the success */
518  return Status;
519 }
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
LONG NTSTATUS
Definition: precomp.h:26
NTSTATUS NTAPI IoGetDeviceObjectPointer(IN PUNICODE_STRING ObjectName, IN ACCESS_MASK DesiredAccess, OUT PFILE_OBJECT *FileObject, OUT PDEVICE_OBJECT *DeviceObject)
Definition: device.c:1435
NTSTATUS NTAPI KeWaitForSingleObject(IN PVOID Object, IN KWAIT_REASON WaitReason, IN KPROCESSOR_MODE WaitMode, IN BOOLEAN Alertable, IN PLARGE_INTEGER Timeout OPTIONAL)
Definition: wait.c:416
_In_ PDEVICE_OBJECT DeviceObject
Definition: wdfdevice.h:2055
_Must_inspect_result_ _In_ PWDFDEVICE_INIT _In_opt_ PCUNICODE_STRING DeviceName
Definition: wdfdevice.h:3272
#define FALSE
Definition: types.h:117
_In_ PIRP Irp
Definition: csq.h:116
#define IOCTL_MOUNTMGR_NEXT_DRIVE_LETTER
Definition: mountmgr.h:34
_In_ PVOID _In_ ULONG Event
Definition: iotypes.h:467
_In_ WDFREQUEST _In_ WDFFILEOBJECT FileObject
Definition: wdfdevice.h:547
Status
Definition: gdiplustypes.h:24
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define STATUS_PENDING
Definition: ntstatus.h:82
#define ObDereferenceObject
Definition: obfuncs.h:203
* PFILE_OBJECT
Definition: iotypes.h:1998
#define FILE_READ_ATTRIBUTES
Definition: nt_native.h:647
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
static const WCHAR L[]
Definition: oid.c:1250
#define TAG_FSTUB
Definition: tag.h:198
#define KeInitializeEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:477
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:255
static OUT PIO_STATUS_BLOCK IoStatusBlock
Definition: pipe.c:75
#define NULL
Definition: types.h:112
NTSTATUS NTAPI IoCallDriver(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: irp.c:1218
_In_ WDFIOTARGET Target
Definition: wdfrequest.h:306
PIRP NTAPI IoBuildDeviceIoControlRequest(IN ULONG IoControlCode, IN PDEVICE_OBJECT DeviceObject, IN PVOID InputBuffer, IN ULONG InputBufferLength, IN PVOID OutputBuffer, IN ULONG OutputBufferLength, IN BOOLEAN InternalDeviceIoControl, IN PKEVENT Event, IN PIO_STATUS_BLOCK IoStatusBlock)
Definition: irp.c:881
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
#define DPRINT
Definition: sndvol32.h:71
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1099

Referenced by HalpNextDriveLetter().

◆ HalpQueryDriveLayout()

NTSTATUS FASTCALL HalpQueryDriveLayout ( IN PUNICODE_STRING  DeviceName,
OUT PDRIVE_LAYOUT_INFORMATION LayoutInfo 
)

Definition at line 56 of file disksup.c.

58 {
59  IO_STATUS_BLOCK StatusBlock;
62  KEVENT Event;
63  PIRP Irp;
67  PAGED_CODE();
68 
69  /* Get device pointers */
72  &FileObject,
73  &DeviceObject);
74  if (!NT_SUCCESS(Status))
75  {
76  return Status;
77  }
78 
79  /* Get attached device object */
82 
83  /* Do not handle removable media */
84  if (BooleanFlagOn(DeviceObject->Characteristics, FILE_REMOVABLE_MEDIA))
85  {
87  return STATUS_NO_MEDIA;
88  }
89 
90  /* We'll loop until our buffer is big enough */
91  Buffer = NULL;
92  BufferSize = 0x1000;
94  do
95  {
96  /* If we already had a buffer, it means it's not big
97  * enough, so free and multiply size by two
98  */
99  if (Buffer != NULL)
100  {
102  BufferSize *= 2;
103  }
104 
105  /* Allocate buffer for output buffer */
107  if (Buffer == NULL)
108  {
110  break;
111  }
112 
113  /* Build the IRP to query drive layout */
115  DeviceObject,
116  NULL,
117  0,
118  Buffer,
119  BufferSize,
120  FALSE,
121  &Event,
122  &StatusBlock);
123  if (Irp == NULL)
124  {
126  break;
127  }
128 
129  /* Call the driver and wait if appropriate */
131  if (Status == STATUS_PENDING)
132  {
134  Executive,
135  KernelMode,
136  FALSE,
137  NULL);
138  Status = StatusBlock.Status;
139  }
140  /* If buffer is too small, keep looping */
141  } while (Status == STATUS_BUFFER_TOO_SMALL);
142 
143  /* We're done with the device */
145 
146  /* If querying worked, then return the buffer to the caller */
147  if (NT_SUCCESS(Status))
148  {
149  ASSERT(Buffer != NULL);
150  *LayoutInfo = Buffer;
151  }
152  /* Else, release the buffer if still allocated and fail */
153  else
154  {
155  if (Buffer != NULL)
156  {
158  }
159  }
160 
161  return Status;
162 }
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
IN BOOLEAN OUT PSTR Buffer
Definition: progress.h:34
#define BooleanFlagOn(F, SF)
Definition: ext2fs.h:183
LONG NTSTATUS
Definition: precomp.h:26
NTSTATUS NTAPI IoGetDeviceObjectPointer(IN PUNICODE_STRING ObjectName, IN ACCESS_MASK DesiredAccess, OUT PFILE_OBJECT *FileObject, OUT PDEVICE_OBJECT *DeviceObject)
Definition: device.c:1435
NTSTATUS NTAPI KeWaitForSingleObject(IN PVOID Object, IN KWAIT_REASON WaitReason, IN KPROCESSOR_MODE WaitMode, IN BOOLEAN Alertable, IN PLARGE_INTEGER Timeout OPTIONAL)
Definition: wait.c:416
#define STATUS_BUFFER_TOO_SMALL
Definition: shellext.h:69
_In_ PDEVICE_OBJECT DeviceObject
Definition: wdfdevice.h:2055
_Must_inspect_result_ _In_ PWDFDEVICE_INIT _In_opt_ PCUNICODE_STRING DeviceName
Definition: wdfdevice.h:3272
#define FALSE
Definition: types.h:117
_In_ PIRP Irp
Definition: csq.h:116
#define FILE_REMOVABLE_MEDIA
Definition: nt_native.h:807
_In_ PVOID _In_ ULONG Event
Definition: iotypes.h:467
Definition: bufpool.h:45
_In_ WDFREQUEST _In_ WDFFILEOBJECT FileObject
Definition: wdfdevice.h:547
PDEVICE_OBJECT NTAPI IoGetAttachedDeviceReference(PDEVICE_OBJECT DeviceObject)
Definition: device.c:1406
Status
Definition: gdiplustypes.h:24
#define ASSERT(a)
Definition: mode.c:44
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define STATUS_PENDING
Definition: ntstatus.h:82
#define ObDereferenceObject
Definition: obfuncs.h:203
* PFILE_OBJECT
Definition: iotypes.h:1998
#define FILE_READ_ATTRIBUTES
Definition: nt_native.h:647
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
#define TAG_FSTUB
Definition: tag.h:198
#define IOCTL_DISK_GET_DRIVE_LAYOUT
Definition: ntdddisk.h:91
#define STATUS_NO_MEDIA
Definition: ntstatus.h:610
#define KeInitializeEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:477
#define STATUS_NO_MEMORY
Definition: ntstatus.h:260
#define NULL
Definition: types.h:112
NTSTATUS NTAPI IoCallDriver(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: irp.c:1218
PIRP NTAPI IoBuildDeviceIoControlRequest(IN ULONG IoControlCode, IN PDEVICE_OBJECT DeviceObject, IN PVOID InputBuffer, IN ULONG InputBufferLength, IN PVOID OutputBuffer, IN ULONG OutputBufferLength, IN BOOLEAN InternalDeviceIoControl, IN PKEVENT Event, IN PIO_STATUS_BLOCK IoStatusBlock)
Definition: irp.c:881
unsigned int ULONG
Definition: retypes.h:1
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1099
#define BufferSize
Definition: mmc.h:75
_In_ WDFMEMORY _Out_opt_ size_t * BufferSize
Definition: wdfmemory.h:251
#define PAGED_CODE()

Referenced by xHalIoAssignDriveLetters().

◆ HalpQueryPartitionType()

NTSTATUS HalpQueryPartitionType ( IN PUNICODE_STRING  DeviceName,
IN PDRIVE_LAYOUT_INFORMATION  LayoutInfo,
OUT PPARTITION_TYPE  PartitionType 
)

Definition at line 165 of file disksup.c.

168 {
169  USHORT i;
170  PIRP Irp;
171  KEVENT Event;
177 
178  PAGED_CODE();
179 
180  /* Get device pointers */
183  &FileObject,
184  &DeviceObject);
185  if (!NT_SUCCESS(Status))
186  {
187  return Status;
188  }
189 
190  /* Get attached device object */
193 
194  /* Assume logical partition for removable devices */
195  if (BooleanFlagOn(DeviceObject->Characteristics, FILE_REMOVABLE_MEDIA))
196  {
199  return STATUS_SUCCESS;
200  }
201 
202  /* For the others, query partition info */
205  DeviceObject,
206  NULL,
207  0,
208  &PartitionInfo,
209  sizeof(PartitionInfo),
210  FALSE,
211  &Event,
212  &IoStatusBlock);
213  if (Irp == NULL)
214  {
217  }
218 
220  if (Status == STATUS_PENDING)
221  {
223  Executive,
224  KernelMode,
225  FALSE,
226  NULL);
228  }
229 
230  /* We're done with the device */
232 
233  /* If we failed querying partition info, try to return something
234  * if caller didn't provide a precise layout, assume logical
235  * partition and fake success. Otherwise, just fail.
236  */
237  if (!NT_SUCCESS(Status))
238  {
239  if (LayoutInfo == NULL)
240  {
242  return STATUS_SUCCESS;
243  }
244 
245  return Status;
246  }
247 
248  /* First, handle non MBR style (easy cases) */
249  if (PartitionInfo.PartitionStyle != PARTITION_STYLE_MBR)
250  {
251  /* If not GPT, we don't know what it is */
252  if (PartitionInfo.PartitionStyle != PARTITION_STYLE_GPT)
253  {
255  return STATUS_SUCCESS;
256  }
257 
258  /* Check whether that's data partition */
259  if (RtlCompareMemory(&PartitionInfo.Gpt.PartitionType,
260  &PARTITION_BASIC_DATA_GUID,
261  sizeof(GUID)) == sizeof(GUID))
262  {
264  return STATUS_SUCCESS;
265  }
266 
267  /* Otherwise, we don't know */
269  return STATUS_SUCCESS;
270  }
271 
272  /* If we don't recognize partition type, return unknown */
273  if (!IsRecognizedPartition(PartitionInfo.Mbr.PartitionType))
274  {
276  return STATUS_SUCCESS;
277  }
278 
279  /* Check if that's a FT volume */
280  if (IsFTPartition(PartitionInfo.Mbr.PartitionType))
281  {
283  return STATUS_SUCCESS;
284  }
285 
286  /* If the caller didn't provide the complete layout, just return */
287  if (LayoutInfo == NULL)
288  {
290  return STATUS_SUCCESS;
291  }
292 
293  /* Now, evaluate the partition to the 4 in the input layout */
294  for (i = 0; i < 4; ++i)
295  {
296  /* If we find a partition matching */
297  if (LayoutInfo->PartitionEntry[i].StartingOffset.QuadPart == PartitionInfo.StartingOffset.QuadPart)
298  {
299  /* Return boot if boot flag is set */
300  if (PartitionInfo.Mbr.BootIndicator)
301  {
303  }
304  /* Primary otherwise */
305  else
306  {
308  }
309 
310  return STATUS_SUCCESS;
311  }
312  }
313 
314  /* Otherwise, assume logical */
316  return STATUS_SUCCESS;
317 }
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
#define BooleanFlagOn(F, SF)
Definition: ext2fs.h:183
LONG NTSTATUS
Definition: precomp.h:26
NTSTATUS NTAPI IoGetDeviceObjectPointer(IN PUNICODE_STRING ObjectName, IN ACCESS_MASK DesiredAccess, OUT PFILE_OBJECT *FileObject, OUT PDEVICE_OBJECT *DeviceObject)
Definition: device.c:1435
NTSTATUS NTAPI KeWaitForSingleObject(IN PVOID Object, IN KWAIT_REASON WaitReason, IN KPROCESSOR_MODE WaitMode, IN BOOLEAN Alertable, IN PLARGE_INTEGER Timeout OPTIONAL)
Definition: wait.c:416
_In_ PDEVICE_OBJECT DeviceObject
Definition: wdfdevice.h:2055
_Must_inspect_result_ _In_ PWDFDEVICE_INIT _In_opt_ PCUNICODE_STRING DeviceName
Definition: wdfdevice.h:3272
#define FALSE
Definition: types.h:117
_In_ PIRP Irp
Definition: csq.h:116
#define FILE_REMOVABLE_MEDIA
Definition: nt_native.h:807
_In_ PVOID _In_ ULONG Event
Definition: iotypes.h:467
_In_ WDFREQUEST _In_ WDFFILEOBJECT FileObject
Definition: wdfdevice.h:547
PDEVICE_OBJECT NTAPI IoGetAttachedDeviceReference(PDEVICE_OBJECT DeviceObject)
Definition: device.c:1406
Status
Definition: gdiplustypes.h:24
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define STATUS_PENDING
Definition: ntstatus.h:82
#define IsRecognizedPartition(PartitionType)
Definition: ntdddisk.h:342
#define ObDereferenceObject
Definition: obfuncs.h:203
_In_ ULONG _In_ struct _SET_PARTITION_INFORMATION_EX * PartitionInfo
Definition: iofuncs.h:2105
* PFILE_OBJECT
Definition: iotypes.h:1998
#define FILE_READ_ATTRIBUTES
Definition: nt_native.h:647
#define KeInitializeEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:477
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
unsigned short USHORT
Definition: pedump.c:61
#define IsFTPartition(PartitionType)
Definition: ntdddisk.h:307
static OUT PIO_STATUS_BLOCK IoStatusBlock
Definition: pipe.c:75
#define NULL
Definition: types.h:112
NTSTATUS NTAPI IoCallDriver(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: irp.c:1218
PIRP NTAPI IoBuildDeviceIoControlRequest(IN ULONG IoControlCode, IN PDEVICE_OBJECT DeviceObject, IN PVOID InputBuffer, IN ULONG InputBufferLength, IN PVOID OutputBuffer, IN ULONG OutputBufferLength, IN BOOLEAN InternalDeviceIoControl, IN PKEVENT Event, IN PIO_STATUS_BLOCK IoStatusBlock)
Definition: irp.c:881
CHAR PartitionType
Definition: part_xbox.c:32
#define STATUS_SUCCESS
Definition: shellext.h:65
#define RtlCompareMemory(s1, s2, l)
Definition: env_spec_w32.h:465
#define IOCTL_DISK_GET_PARTITION_INFO_EX
Definition: ntddk_ex.h:206
#define PAGED_CODE()

Referenced by xHalIoAssignDriveLetters().

◆ HalpSetMountLetter()

NTSTATUS HalpSetMountLetter ( IN PUNICODE_STRING  DeviceName,
UCHAR  DriveLetter 
)

Definition at line 522 of file disksup.c.

524 {
525  PIRP Irp;
526  KEVENT Event;
528  WCHAR Buffer[30];
533  UNICODE_STRING DosDevice, MountMgr;
535 
536  /* Setup the DosDevice name */
537  swprintf(Buffer, L"\\DosDevices\\%c:", DriveLetter);
538  RtlInitUnicodeString(&DosDevice, Buffer);
539 
540  /* Allocate the input buffer for the MountMgr */
541  InputBufferLength = DosDevice.Length + DeviceName->Length + sizeof(MOUNTMGR_CREATE_POINT_INPUT);
543  if (InputBuffer == NULL)
544  {
546  }
547 
548  /* Fill the input buffer */
549  InputBuffer->SymbolicLinkNameOffset = sizeof(MOUNTMGR_CREATE_POINT_INPUT);
550  InputBuffer->SymbolicLinkNameLength = DosDevice.Length;
551  InputBuffer->DeviceNameOffset = DosDevice.Length + sizeof(MOUNTMGR_CREATE_POINT_INPUT);
552  InputBuffer->DeviceNameLength = DeviceName->Length;
553  RtlCopyMemory(&InputBuffer[1], DosDevice.Buffer, DosDevice.Length);
554  RtlCopyMemory((PVOID)((ULONG_PTR)InputBuffer + InputBuffer->DeviceNameOffset),
555  DeviceName->Buffer,
556  DeviceName->Length);
557 
558  /* Get the MountMgr device pointer, to send the IOCTL */
559  RtlInitUnicodeString(&MountMgr, L"\\Device\\MountPointManager");
560  Status = IoGetDeviceObjectPointer(&MountMgr,
562  &FileObject,
563  &DeviceObject);
564  if (!NT_SUCCESS(Status))
565  {
567  return Status;
568  }
569 
570  /* Call the MountMgr */
573  DeviceObject,
574  InputBuffer,
576  NULL,
577  0,
578  FALSE,
579  &Event,
580  &IoStatusBlock);
581  if (Irp == NULL)
582  {
586  }
587 
589  if (Status == STATUS_PENDING)
590  {
592  Executive,
593  KernelMode,
594  FALSE,
595  NULL);
597  }
598 
601 
602  /* Return the MountMgr status */
603  return Status;
604 }
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
LONG NTSTATUS
Definition: precomp.h:26
#define IOCTL_MOUNTMGR_CREATE_POINT
Definition: imports.h:118
NTSTATUS NTAPI IoGetDeviceObjectPointer(IN PUNICODE_STRING ObjectName, IN ACCESS_MASK DesiredAccess, OUT PFILE_OBJECT *FileObject, OUT PDEVICE_OBJECT *DeviceObject)
Definition: device.c:1435
_In_ WDFREQUEST _In_ size_t _In_ size_t InputBufferLength
Definition: wdfio.h:318
#define swprintf
Definition: precomp.h:40
NTSTATUS NTAPI KeWaitForSingleObject(IN PVOID Object, IN KWAIT_REASON WaitReason, IN KPROCESSOR_MODE WaitMode, IN BOOLEAN Alertable, IN PLARGE_INTEGER Timeout OPTIONAL)
Definition: wait.c:416
uint32_t ULONG_PTR
Definition: typedefs.h:65
_In_ PDEVICE_OBJECT DeviceObject
Definition: wdfdevice.h:2055
_Must_inspect_result_ _In_ PWDFDEVICE_INIT _In_opt_ PCUNICODE_STRING DeviceName
Definition: wdfdevice.h:3272
#define FALSE
Definition: types.h:117
_In_ PIRP Irp
Definition: csq.h:116
_In_ PVOID _In_ ULONG Event
Definition: iotypes.h:467
Definition: bufpool.h:45
_In_ WDFREQUEST _In_ WDFFILEOBJECT FileObject
Definition: wdfdevice.h:547
Status
Definition: gdiplustypes.h:24
_Must_inspect_result_ _In_ WDFIOTARGET _In_opt_ WDFREQUEST _In_opt_ PWDF_MEMORY_DESCRIPTOR InputBuffer
Definition: wdfiotarget.h:949
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define STATUS_PENDING
Definition: ntstatus.h:82
#define ObDereferenceObject
Definition: obfuncs.h:203
* PFILE_OBJECT
Definition: iotypes.h:1998
#define FILE_READ_ATTRIBUTES
Definition: nt_native.h:647
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
static const WCHAR L[]
Definition: oid.c:1250
#define TAG_FSTUB
Definition: tag.h:198
struct _MOUNTMGR_CREATE_POINT_INPUT MOUNTMGR_CREATE_POINT_INPUT
#define KeInitializeEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:477
static OUT PIO_STATUS_BLOCK IoStatusBlock
Definition: pipe.c:75
#define NULL
Definition: types.h:112
NTSTATUS NTAPI IoCallDriver(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: irp.c:1218
PIRP NTAPI IoBuildDeviceIoControlRequest(IN ULONG IoControlCode, IN PDEVICE_OBJECT DeviceObject, IN PVOID InputBuffer, IN ULONG InputBufferLength, IN PVOID OutputBuffer, IN ULONG OutputBufferLength, IN BOOLEAN InternalDeviceIoControl, IN PKEVENT Event, IN PIO_STATUS_BLOCK IoStatusBlock)
Definition: irp.c:881
unsigned int ULONG
Definition: retypes.h:1
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1099

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 2747 of file disksup.c.

2751 {
2752  HALDISPATCH->HalIoAssignDriveLetters(LoaderBlock,
2753  NtDeviceName,
2754  NtSystemPath,
2755  NtSystemPathString);
2756 }
#define HALDISPATCH
Definition: haltypes.h:278

◆ IopComputeHarddiskDerangements()

PULONG IopComputeHarddiskDerangements ( IN ULONG  DiskCount)

Definition at line 320 of file disksup.c.

321 {
322  PIRP Irp;
323  KEVENT Event;
324  ULONG i, j, k;
325  PULONG Devices;
327  WCHAR Buffer[100];
328  UNICODE_STRING ArcName;
333 
334  /* No disks, nothing to do */
335  if (DiskCount == 0)
336  {
337  return NULL;
338  }
339 
340  /* Allocate a buffer big enough to hold all the disks */
342  sizeof(ULONG) * DiskCount,
343  TAG_FSTUB);
344  if (Devices == NULL)
345  {
346  return NULL;
347  }
348 
349  /* Now, we'll query all the disks */
350  for (i = 0; i < DiskCount; ++i)
351  {
352  /* Using their ARC name */
353  swprintf(Buffer, L"\\ArcName\\multi(0)disk(0)rdisk(%d)", i);
354  RtlInitUnicodeString(&ArcName, Buffer);
355  /* Get the attached DeviceObject */
357  {
360 
361  /* And query it for device number */
364  DeviceObject,
365  NULL,
366  0,
367  &DeviceNumber,
368  sizeof(DeviceNumber),
369  FALSE,
370  &Event,
371  &IoStatusBlock);
372  if (Irp != NULL)
373  {
375  if (Status == STATUS_PENDING)
376  {
378  Executive,
379  KernelMode,
380  FALSE,
381  NULL);
383  }
384 
386 
387  /* In case of a success remember device number */
388  if (NT_SUCCESS(Status))
389  {
390  Devices[i] = DeviceNumber.DeviceNumber;
391  /* Move on, not to fall into our default case */
392  continue;
393  }
394  }
395  else
396  {
398  }
399 
400  /* Default case, for failures, set -1 */
401  Devices[i] = -1;
402  }
403  }
404 
405  /* Now, we'll check all device numbers */
406  for (i = 0; i < DiskCount; ++i)
407  {
408  /* First of all, check if we're at the right place */
409  for (j = 0; j < DiskCount; ++j)
410  {
411  if (Devices[j] == i)
412  {
413  break;
414  }
415  }
416 
417  /* If not, perform the change */
418  if (j >= DiskCount)
419  {
420  k = 0;
421  while (Devices[k] != -1)
422  {
423  if (++k >= DiskCount)
424  {
425  break;
426  }
427  }
428 
429  if (k < DiskCount)
430  {
431  Devices[k] = i;
432  }
433  }
434  }
435 
436  /* Return our device derangement map */
437  return Devices;
438 }
LONG NTSTATUS
Definition: precomp.h:26
#define POOL_COLD_ALLOCATION
NTSTATUS NTAPI IoGetDeviceObjectPointer(IN PUNICODE_STRING ObjectName, IN ACCESS_MASK DesiredAccess, OUT PFILE_OBJECT *FileObject, OUT PDEVICE_OBJECT *DeviceObject)
Definition: device.c:1435
#define swprintf
Definition: precomp.h:40
NTSTATUS NTAPI KeWaitForSingleObject(IN PVOID Object, IN KWAIT_REASON WaitReason, IN KPROCESSOR_MODE WaitMode, IN BOOLEAN Alertable, IN PLARGE_INTEGER Timeout OPTIONAL)
Definition: wait.c:416
_In_ PDEVICE_OBJECT DeviceObject
Definition: wdfdevice.h:2055
#define FALSE
Definition: types.h:117
_In_ PIRP Irp
Definition: csq.h:116
_In_ PVOID _In_ ULONG Event
Definition: iotypes.h:467
Definition: bufpool.h:45
#define IOCTL_STORAGE_GET_DEVICE_NUMBER
Definition: ntddstor.h:143
_In_ WDFREQUEST _In_ WDFFILEOBJECT FileObject
Definition: wdfdevice.h:547
PDEVICE_OBJECT NTAPI IoGetAttachedDeviceReference(PDEVICE_OBJECT DeviceObject)
Definition: device.c:1406
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
Definition: glfuncs.h:250
Status
Definition: gdiplustypes.h:24
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define STATUS_PENDING
Definition: ntstatus.h:82
#define ObDereferenceObject
Definition: obfuncs.h:203
* PFILE_OBJECT
Definition: iotypes.h:1998
#define FILE_READ_ATTRIBUTES
Definition: nt_native.h:647
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
static const WCHAR L[]
Definition: oid.c:1250
#define TAG_FSTUB
Definition: tag.h:198
#define KeInitializeEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:477
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
static OUT PIO_STATUS_BLOCK IoStatusBlock
Definition: pipe.c:75
unsigned int * PULONG
Definition: retypes.h:1
#define NULL
Definition: types.h:112
NTSTATUS NTAPI IoCallDriver(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: irp.c:1218
PIRP NTAPI IoBuildDeviceIoControlRequest(IN ULONG IoControlCode, IN PDEVICE_OBJECT DeviceObject, IN PVOID InputBuffer, IN ULONG InputBufferLength, IN PVOID OutputBuffer, IN ULONG OutputBufferLength, IN BOOLEAN InternalDeviceIoControl, IN PKEVENT Event, IN PIO_STATUS_BLOCK IoStatusBlock)
Definition: irp.c:881
unsigned int ULONG
Definition: retypes.h:1
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
_In_ PCHAR _In_ ULONG DeviceNumber
Definition: classpnp.h:1229
int k
Definition: mpi.c:3369

Referenced by xHalIoAssignDriveLetters().

◆ IoReadPartitionTable()

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

Definition at line 2697 of file disksup.c.

2701 {
2702  return HALDISPATCH->HalIoReadPartitionTable(DeviceObject,
2703  SectorSize,
2705  PartitionBuffer);
2706 }
_In_ PDEVICE_OBJECT DeviceObject
Definition: wdfdevice.h:2055
_In_ ULONG _In_ BOOLEAN _Out_ struct _DRIVE_LAYOUT_INFORMATION ** PartitionBuffer
Definition: iofuncs.h:2052
_In_ ULONG _In_ BOOLEAN ReturnRecognizedPartitions
Definition: iofuncs.h:2050
_In_ ULONG SectorSize
Definition: halfuncs.h:291
#define HALDISPATCH
Definition: haltypes.h:278

◆ IoSetPartitionInformation()

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

Definition at line 2713 of file disksup.c.

2717 {
2718  return HALDISPATCH->HalIoSetPartitionInformation(DeviceObject,
2719  SectorSize,
2721  PartitionType);
2722 }
_In_ ULONG _In_ ULONG PartitionNumber
Definition: iofuncs.h:2060
_In_ PDEVICE_OBJECT DeviceObject
Definition: wdfdevice.h:2055
CHAR PartitionType
Definition: part_xbox.c:32
_In_ ULONG SectorSize
Definition: halfuncs.h:291
#define HALDISPATCH
Definition: haltypes.h:278

◆ 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 2729 of file disksup.c.

2734 {
2735  return HALDISPATCH->HalIoWritePartitionTable(DeviceObject,
2736  SectorSize,
2738  NumberOfHeads,
2739  PartitionBuffer);
2740 }
_In_ ULONG _In_ ULONG _In_ ULONG NumberOfHeads
Definition: iofuncs.h:2070
_In_ PDEVICE_OBJECT DeviceObject
Definition: wdfdevice.h:2055
_In_ ULONG _In_ ULONG SectorsPerTrack
Definition: iofuncs.h:2070
_In_ ULONG _In_ BOOLEAN _Out_ struct _DRIVE_LAYOUT_INFORMATION ** PartitionBuffer
Definition: iofuncs.h:2052
_In_ ULONG SectorSize
Definition: halfuncs.h:291
#define HALDISPATCH
Definition: haltypes.h:278

◆ xHalExamineMBR()

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

Definition at line 1643 of file disksup.c.

1647 {
1649  PUCHAR Buffer;
1650  ULONG BufferSize;
1651  KEVENT Event;
1653  PIRP Irp;
1654  PPARTITION_DESCRIPTOR PartitionDescriptor;
1655  NTSTATUS Status;
1656  PIO_STACK_LOCATION IoStackLocation;
1657 
1658  Offset.QuadPart = 0;
1659 
1660  /* Assume failure */
1661  *MbrBuffer = NULL;
1662 
1663  /* Normalize the buffer size */
1664  BufferSize = max(512, SectorSize);
1665 
1666  /* Allocate the buffer */
1669  TAG_FILE_SYSTEM);
1670  if (!Buffer) return;
1671 
1672  /* Initialize the Event */
1674 
1675  /* Build the IRP */
1677  DeviceObject,
1678  Buffer,
1679  BufferSize,
1680  &Offset,
1681  &Event,
1682  &IoStatusBlock);
1683  if (!Irp)
1684  {
1685  /* Failed */
1687  return;
1688  }
1689 
1690  /* Make sure to override volume verification */
1691  IoStackLocation = IoGetNextIrpStackLocation(Irp);
1692  IoStackLocation->Flags |= SL_OVERRIDE_VERIFY_VOLUME;
1693 
1694  /* Call the driver */
1696  if (Status == STATUS_PENDING)
1697  {
1698  /* Wait for completion */
1701  }
1702 
1703  /* Check driver Status */
1704  if (NT_SUCCESS(Status))
1705  {
1706  /* Validate the MBR Signature */
1708  {
1709  /* Failed */
1711  return;
1712  }
1713 
1714  /* Get the partition entry */
1715  PartitionDescriptor = (PPARTITION_DESCRIPTOR)&Buffer[PARTITION_TABLE_OFFSET];
1716 
1717  /* Make sure it's what the caller wanted */
1718  if (PartitionDescriptor->PartitionType != MbrTypeIdentifier)
1719  {
1720  /* It's not, free our buffer */
1722  }
1723  else
1724  {
1725  /* Check for OnTrack Disk Manager 6.0 / EZ-Drive partitions */
1726 
1727  if (PartitionDescriptor->PartitionType == PARTITION_DM)
1728  {
1729  /* Return our buffer, but at sector 63 */
1730  *(PULONG)Buffer = 63;
1731  *MbrBuffer = Buffer;
1732  }
1733  else if (PartitionDescriptor->PartitionType == PARTITION_EZDRIVE)
1734  {
1735  /* EZ-Drive, return the buffer directly */
1736  *MbrBuffer = Buffer;
1737  }
1738  else
1739  {
1740  /* Otherwise crash on debug builds */
1741  ASSERT(PartitionDescriptor->PartitionType == PARTITION_EZDRIVE);
1742  }
1743  }
1744  }
1745 }
#define TAG_FILE_SYSTEM
Definition: tag.h:50
#define max(a, b)
Definition: svc.c:63
PIRP NTAPI IoBuildSynchronousFsdRequest(IN ULONG MajorFunction, IN PDEVICE_OBJECT DeviceObject, IN PVOID Buffer, IN ULONG Length, IN PLARGE_INTEGER StartingOffset, IN PKEVENT Event, IN PIO_STATUS_BLOCK IoStatusBlock)
Definition: irp.c:1069
IN BOOLEAN OUT PSTR Buffer
Definition: progress.h:34
unsigned char * PUCHAR
Definition: retypes.h:3
#define PARTITION_EZDRIVE
Definition: ntdddisk.h:289
LONG NTSTATUS
Definition: precomp.h:26
#define PARTITION_TABLE_OFFSET
Definition: hal.h:244
NTSTATUS NTAPI KeWaitForSingleObject(IN PVOID Object, IN KWAIT_REASON WaitReason, IN KPROCESSOR_MODE WaitMode, IN BOOLEAN Alertable, IN PLARGE_INTEGER Timeout OPTIONAL)
Definition: wait.c:416
_In_ PDEVICE_OBJECT DeviceObject
Definition: wdfdevice.h:2055
#define FALSE
Definition: types.h:117
_In_ PIRP Irp
Definition: csq.h:116
unsigned short * PUINT16
Definition: basetsd.h:194
_In_ PVOID _In_ ULONG Event
Definition: iotypes.h:467
#define SL_OVERRIDE_VERIFY_VOLUME
Definition: iotypes.h:1823
Definition: bufpool.h:45
Status
Definition: gdiplustypes.h:24
#define PARTITION_DM
Definition: ntdddisk.h:288
#define ASSERT(a)
Definition: mode.c:44
#define BOOT_RECORD_SIGNATURE
Definition: parttest.c:17
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define STATUS_PENDING
Definition: ntstatus.h:82
UCHAR PartitionType
Definition: hal.h:283
struct _PARTITION_DESCRIPTOR * PPARTITION_DESCRIPTOR
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
#define BOOT_SIGNATURE_OFFSET
Definition: hal.h:245
#define PAGE_SIZE
Definition: env_spec_w32.h:49
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetNextIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2695
_In_ ULONG _In_ ULONG Offset
Definition: ntddpcm.h:101
#define KeInitializeEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:477
static OUT PIO_STATUS_BLOCK IoStatusBlock
Definition: pipe.c:75
unsigned int * PULONG
Definition: retypes.h:1
#define NULL
Definition: types.h:112
NTSTATUS NTAPI IoCallDriver(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: irp.c:1218
#define IRP_MJ_READ
Definition: rdpdr.c:46
unsigned int ULONG
Definition: retypes.h:1
_In_ ULONG SectorSize
Definition: halfuncs.h:291
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1099
#define BufferSize
Definition: mmc.h:75
_In_ WDFMEMORY _Out_opt_ size_t * BufferSize
Definition: wdfmemory.h:251

◆ xHalGetPartialGeometry()

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

Definition at line 1557 of file disksup.c.

1560 {
1561  PDISK_GEOMETRY DiskGeometry = NULL;
1563  PKEVENT Event = NULL;
1564  PIRP Irp;
1565  NTSTATUS Status;
1566 
1567  /* Set defaults */
1568  *ConventionalCylinders = 0;
1569  *DiskSize = 0;
1570 
1571  /* Allocate the structure in nonpaged pool */
1572  DiskGeometry = ExAllocatePoolWithTag(NonPagedPool,
1573  sizeof(DISK_GEOMETRY),
1574  TAG_FILE_SYSTEM);
1575  if (!DiskGeometry) goto Cleanup;
1576 
1577  /* Allocate the status block in nonpaged pool */
1579  sizeof(IO_STATUS_BLOCK),
1580  TAG_FILE_SYSTEM);
1581  if (!IoStatusBlock) goto Cleanup;
1582 
1583  /* Allocate the event in nonpaged pool too */
1585  sizeof(KEVENT),
1586  TAG_FILE_SYSTEM);
1587  if (!Event) goto Cleanup;
1588 
1589  /* Initialize the event */
1591 
1592  /* Build the IRP */
1594  DeviceObject,
1595  NULL,
1596  0,
1597  DiskGeometry,
1598  sizeof(DISK_GEOMETRY),
1599  FALSE,
1600  Event,
1601  IoStatusBlock);
1602  if (!Irp) goto Cleanup;
1603 
1604  /* Now call the driver */
1606  if (Status == STATUS_PENDING)
1607  {
1608  /* Wait for it to complete */
1611  }
1612 
1613  /* Check driver status */
1614  if (NT_SUCCESS(Status))
1615  {
1616  /* Return the cylinder count */
1617  *ConventionalCylinders = DiskGeometry->Cylinders.LowPart;
1618 
1619  /* Make sure it's not larger then 1024 */
1620  if (DiskGeometry->Cylinders.LowPart >= 1024)
1621  {
1622  /* Otherwise, normalize the value */
1623  *ConventionalCylinders = 1024;
1624  }
1625 
1626  /* Calculate the disk size */
1627  *DiskSize = DiskGeometry->Cylinders.QuadPart *
1628  DiskGeometry->TracksPerCylinder *
1629  DiskGeometry->SectorsPerTrack *
1630  DiskGeometry->BytesPerSector;
1631  }
1632 
1633 Cleanup:
1634  /* Free all the pointers */
1637  if (DiskGeometry) ExFreePoolWithTag(DiskGeometry, TAG_FILE_SYSTEM);
1638  return;
1639 }
#define TAG_FILE_SYSTEM
Definition: tag.h:50
LONG NTSTATUS
Definition: precomp.h:26
ULONG BytesPerSector
Definition: ntdddisk.h:409
ULONG TracksPerCylinder
Definition: ntdddisk.h:407
NTSTATUS NTAPI KeWaitForSingleObject(IN PVOID Object, IN KWAIT_REASON WaitReason, IN KPROCESSOR_MODE WaitMode, IN BOOLEAN Alertable, IN PLARGE_INTEGER Timeout OPTIONAL)
Definition: wait.c:416
_In_ PDEVICE_OBJECT DeviceObject
Definition: wdfdevice.h:2055
#define FALSE
Definition: types.h:117
_In_ PIRP Irp
Definition: csq.h:116
Status
Definition: gdiplustypes.h:24
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define STATUS_PENDING
Definition: ntstatus.h:82
LARGE_INTEGER Cylinders
Definition: ntdddisk.h:405
ULONG SectorsPerTrack
Definition: ntdddisk.h:408
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
ULONG LowPart
Definition: typedefs.h:106
static const WCHAR Cleanup[]
Definition: register.c:80
#define KeInitializeEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:477
static OUT PIO_STATUS_BLOCK IoStatusBlock
Definition: pipe.c:75
#define NULL
Definition: types.h:112
NTSTATUS NTAPI IoCallDriver(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: irp.c:1218
PIRP NTAPI IoBuildDeviceIoControlRequest(IN ULONG IoControlCode, IN PDEVICE_OBJECT DeviceObject, IN PVOID InputBuffer, IN ULONG InputBufferLength, IN PVOID OutputBuffer, IN ULONG OutputBufferLength, IN BOOLEAN InternalDeviceIoControl, IN PKEVENT Event, IN PIO_STATUS_BLOCK IoStatusBlock)
Definition: irp.c:881
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1099
#define IOCTL_DISK_GET_DRIVE_GEOMETRY
Definition: cdrw_usr.h:169
LONGLONG QuadPart
Definition: typedefs.h:114

Referenced by xHalIoWritePartitionTable().

◆ xHalIoAssignDriveLetters()

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

Definition at line 912 of file disksup.c.

916 {
917  USHORT i;
918  PULONG Devices;
920  WCHAR Buffer[50];
922  UCHAR DriveLetter;
923  BOOLEAN SystemFound;
924  IO_STATUS_BLOCK StatusBlock;
926  ANSI_STRING StringA1, StringA2;
927  PSTR Buffer1, Buffer2, LoadOptions;
929  PDRIVE_LAYOUT_INFORMATION LayoutInfo;
930  PCONFIGURATION_INFORMATION ConfigInfo;
931  UNICODE_STRING StringU1, StringU2, StringU3;
932  ULONG Increment, DiskCount, RealDiskCount, HarddiskCount, PartitionCount, SystemPartition;
933 
934  PAGED_CODE();
935 
936  /* Get our disk count */
937  ConfigInfo = IoGetConfigurationInformation();
938  DiskCount = ConfigInfo->DiskCount;
939  RealDiskCount = 0;
940 
941  /* Allocate two generic string buffers we'll use and reuser later on */
944  if (Buffer1 == NULL || Buffer2 == NULL)
945  {
946  KeBugCheck(ASSIGN_DRIVE_LETTERS_FAILED);
947  }
948 
949  /* In case of a remote boot, setup system path */
950  if (IoRemoteBootClient)
951  {
952  PSTR Last, Saved;
953 
954  /* Find last \ */
955  Last = strrchr(LoaderBlock->NtBootPathName, '\\');
956  Saved = NULL;
957  /* Misformed name, fail */
958  if (Last == NULL)
959  {
960  KeBugCheck(ASSIGN_DRIVE_LETTERS_FAILED);
961  }
962 
963  /* In case the name was terminated by a \... */
964  if (Last[1] == ANSI_NULL)
965  {
966  /* Erase it, save position and find the previous \ */
967  *Last = ANSI_NULL;
968  Saved = Last;
969  Last = strrchr(LoaderBlock->NtBootPathName, '\\');
970  *Saved = '\\';
971  }
972 
973  /* Misformed name, fail */
974  if (Last == NULL)
975  {
976  KeBugCheck(ASSIGN_DRIVE_LETTERS_FAILED);
977  }
978 
979  /* For a remote boot, assign X drive letter */
980  NtSystemPath[0] = 'X';
981  NtSystemPath[1] = ':';
982  /* And copy the end of the boot path */
983  strcpy((PSTR)&NtSystemPath[2], Last);
984 
985  /* If we had to remove the trailing \, remove it here too */
986  if (Saved != NULL)
987  {
988  NtSystemPath[strlen((PSTR)NtSystemPath) - 1] = ANSI_NULL;
989  }
990 
991  /* Setup output string */
992  RtlInitString(NtSystemPathString, (PSTR)NtSystemPath);
993  }
994 
995  /* For each of our disks, create the physical device DOS device */
996  Increment = 0;
997  if (DiskCount != 0)
998  {
999  for (i = 0; i < DiskCount; ++i)
1000  {
1001  /* Setup the origin name */
1002  sprintf(Buffer1, "\\Device\\Harddisk%d\\Partition%d", i, 0);
1003  RtlInitAnsiString(&StringA1, Buffer1);
1004  if (!NT_SUCCESS(RtlAnsiStringToUnicodeString(&StringU1, &StringA1, TRUE)))
1005  {
1006  /* We cannot fail */
1007  KeBugCheck(ASSIGN_DRIVE_LETTERS_FAILED);
1008  }
1009 
1010  /* Open the device */
1012  &StringU1,
1014  NULL,
1015  NULL);
1019  &StatusBlock,
1022  if (NT_SUCCESS(Status))
1023  {
1024  /* If we managed, create the link */
1025  sprintf(Buffer2, "\\DosDevices\\PhysicalDrive%d", i);
1026  RtlInitAnsiString(&StringA2, Buffer2);
1027  Status = RtlAnsiStringToUnicodeString(&StringU2, &StringA2, TRUE);
1028  if (NT_SUCCESS(Status))
1029  {
1030  IoCreateSymbolicLink(&StringU2, &StringU1);
1031  RtlFreeUnicodeString(&StringU2);
1032  }
1033 
1035 
1036  RealDiskCount = i + 1;
1037  }
1038 
1039  RtlFreeUnicodeString(&StringU1);
1040 
1041  if (!NT_SUCCESS(Status))
1042  {
1043  if (Increment < 50)
1044  {
1045  ++Increment;
1046  ++DiskCount;
1047  }
1048  }
1049  }
1050  }
1051 
1052  /* We done for our buffers */
1053  ExFreePoolWithTag(Buffer1, TAG_FSTUB);
1054  ExFreePoolWithTag(Buffer2, TAG_FSTUB);
1055 
1056  /* Upcase our load options, if any */
1057  if (LoaderBlock->LoadOptions != NULL)
1058  {
1059  LoadOptions = _strupr(LoaderBlock->LoadOptions);
1060  }
1061  else
1062  {
1063  LoadOptions = NULL;
1064  }
1065 
1066  /* If we boot with /MININT (system hive as volatile) option, assign X letter to boot device */
1067  if (LoadOptions != NULL &&
1068  strstr(LoadOptions, "MININT") != 0 &&
1069  NT_SUCCESS(RtlAnsiStringToUnicodeString(&StringU1, NtDeviceName, TRUE)))
1070  {
1071  if (NT_SUCCESS(HalpSetMountLetter(&StringU1, 'X')))
1072  {
1073  *NtSystemPath = 'X';
1074  }
1075 
1076  RtlFreeUnicodeString(&StringU1);
1077  }
1078 
1079  /* Compute our disks derangements */
1080  DiskCount -= Increment;
1081  if (RealDiskCount > DiskCount)
1082  {
1083  DiskCount = RealDiskCount;
1084  }
1085  Devices = IopComputeHarddiskDerangements(DiskCount);
1086 
1087  /* Now, start browsing all our disks for assigning drive letters
1088  * Here, we'll only handle boot partition and primary partitions
1089  */
1090  HarddiskCount = 0;
1091  for (i = 0; i < DiskCount; ++i)
1092  {
1093  /* Get device ID according to derangements map */
1094  if (Devices != NULL)
1095  {
1096  HarddiskCount = Devices[i];
1097  }
1098 
1099  /* Query disk layout */
1100  swprintf(Buffer, L"\\Device\\Harddisk%d\\Partition0", HarddiskCount);
1101  RtlInitUnicodeString(&StringU1, Buffer);
1102  if (!NT_SUCCESS(HalpQueryDriveLayout(&StringU1, &LayoutInfo)))
1103  {
1104  LayoutInfo = NULL;
1105  }
1106 
1107  /* Assume we didn't find system */
1108  SystemFound = FALSE;
1109  swprintf(Buffer, L"\\Device\\Harddisk%d\\Partition%d", HarddiskCount, 1);
1110  RtlInitUnicodeString(&StringU1, Buffer);
1111  /* Query partition info for our disk */
1112  if (!NT_SUCCESS(HalpQueryPartitionType(&StringU1, LayoutInfo, &PartitionType)))
1113  {
1114  /* It failed, retry for all the partitions */
1115  for (PartitionCount = 1; ; ++PartitionCount)
1116  {
1117  swprintf(Buffer, L"\\Device\\Harddisk%d\\Partition%d", HarddiskCount, PartitionCount);
1118  RtlInitUnicodeString(&StringU1, Buffer);
1119  if (!NT_SUCCESS(HalpQueryPartitionType(&StringU1, LayoutInfo, &PartitionType)))
1120  {
1121  break;
1122  }
1123 
1124  /* We found a primary partition, assign a drive letter */
1126  {
1127  HalpNextDriveLetter(&StringU1, NtDeviceName, NtSystemPath, 0);
1128  break;
1129  }
1130  }
1131  }
1132  else
1133  {
1134  /* All right */
1135  for (PartitionCount = 2; ; ++PartitionCount)
1136  {
1137  /* If our partition is bootable (MBR) or data (GPT), that's system partition */
1139  {
1140  SystemFound = TRUE;
1141 
1142  /* Assign a drive letter and stop here if MBR */
1143  HalpNextDriveLetter(&StringU1, NtDeviceName, NtSystemPath, 0);
1145  {
1146  break;
1147  }
1148  }
1149 
1150  /* Keep looping on all the partitions */
1151  swprintf(Buffer, L"\\Device\\Harddisk%d\\Partition%d", HarddiskCount, PartitionCount);
1152  RtlInitUnicodeString(&StringU1, Buffer);
1153  if (!NT_SUCCESS(HalpQueryPartitionType(&StringU1, LayoutInfo, &PartitionType)))
1154  {
1155  /* Mount every primary partition if we didn't find system */
1156  if (!SystemFound)
1157  {
1158  for (PartitionCount = 1; ; ++PartitionCount)
1159  {
1160  swprintf(Buffer, L"\\Device\\Harddisk%d\\Partition%d", HarddiskCount, PartitionCount);
1161  RtlInitUnicodeString(&StringU1, Buffer);
1162  if (!NT_SUCCESS(HalpQueryPartitionType(&StringU1, LayoutInfo, &PartitionType)))
1163  {
1164  break;
1165  }
1166 
1168  {
1169  HalpNextDriveLetter(&StringU1, NtDeviceName, NtSystemPath, 0);
1170  break;
1171  }
1172  }
1173  }
1174 
1175  break;
1176  }
1177  }
1178  }
1179 
1180  /* Free layout, we'll reallocate it for next device */
1181  if (LayoutInfo != NULL)
1182  {
1183  ExFreePoolWithTag(LayoutInfo, TAG_FSTUB);
1184  }
1185 
1186  HarddiskCount = i + 1;
1187  }
1188 
1189  /* Now, assign logical partitions */
1190  for (i = 0; i < DiskCount; ++i)
1191  {
1192  /* Get device ID according to derangements map */
1193  if (Devices != NULL)
1194  {
1195  HarddiskCount = Devices[i];
1196  }
1197  else
1198  {
1199  HarddiskCount = i;
1200  }
1201 
1202  /* Query device layout */
1203  swprintf(Buffer, L"\\Device\\Harddisk%d\\Partition0", HarddiskCount);
1204  RtlInitUnicodeString(&StringU1, Buffer);
1205  if (!NT_SUCCESS(HalpQueryDriveLayout(&StringU1, &LayoutInfo)))
1206  {
1207  LayoutInfo = NULL;
1208  }
1209 
1210  /* And assign drive letter to logical partitions */
1211  for (PartitionCount = 1; ; ++PartitionCount)
1212  {
1213  swprintf(Buffer, L"\\Device\\Harddisk%d\\Partition%d", HarddiskCount, PartitionCount);
1214  RtlInitUnicodeString(&StringU1, Buffer);
1215  if (!NT_SUCCESS(HalpQueryPartitionType(&StringU1, LayoutInfo, &PartitionType)))
1216  {
1217  break;
1218  }
1219 
1221  {
1222  HalpNextDriveLetter(&StringU1, NtDeviceName, NtSystemPath, 0);
1223  }
1224  }
1225 
1226  /* Free layout, we'll reallocate it for next device */
1227  if (LayoutInfo != NULL)
1228  {
1229  ExFreePoolWithTag(LayoutInfo, 0);
1230  }
1231  }
1232 
1233  /* Now, assign drive letters to everything else */
1234  for (i = 0; i < DiskCount; ++i)
1235  {
1236  /* Get device ID according to derangements map */
1237  if (Devices != NULL)
1238  {
1239  HarddiskCount = Devices[i];
1240  }
1241  else
1242  {
1243  HarddiskCount = i;
1244  }
1245 
1246  /* Query device layout */
1247  swprintf(Buffer, L"\\Device\\Harddisk%d\\Partition0", HarddiskCount);
1248  RtlInitUnicodeString(&StringU1, Buffer);
1249  if (!NT_SUCCESS(HalpQueryDriveLayout(&StringU1, &LayoutInfo)))
1250  {
1251  LayoutInfo = NULL;
1252  }
1253 
1254  /* Save system partition if any */
1255  SystemPartition = 0;
1256  for (PartitionCount = 1; ; ++PartitionCount)
1257  {
1258  swprintf(Buffer, L"\\Device\\Harddisk%d\\Partition%d", HarddiskCount, PartitionCount);
1259  RtlInitUnicodeString(&StringU1, Buffer);
1260  if (!NT_SUCCESS(HalpQueryPartitionType(&StringU1, LayoutInfo, &PartitionType)))
1261  {
1262  break;
1263  }
1264 
1266  {
1267  SystemPartition = PartitionCount;
1268  }
1269  }
1270 
1271  /* And assign drive letter to anything but system partition */
1272  for (PartitionCount = 1; ; ++PartitionCount)
1273  {
1274  if (PartitionCount != SystemPartition)
1275  {
1276  swprintf(Buffer, L"\\Device\\Harddisk%d\\Partition%d", HarddiskCount, PartitionCount);
1277  RtlInitUnicodeString(&StringU1, Buffer);
1278  if (!NT_SUCCESS(HalpQueryPartitionType(&StringU1, LayoutInfo, &PartitionType)))
1279  {
1280  if (LayoutInfo != NULL)
1281  {
1282  ExFreePoolWithTag(LayoutInfo, 0);
1283  }
1284 
1285  break;
1286  }
1287 
1289  {
1290  HalpNextDriveLetter(&StringU1, NtDeviceName, NtSystemPath, 0);
1291  }
1292  }
1293  }
1294  }
1295 
1296  /* We're done with disks, if we have a device map, free it */
1297  if (Devices != NULL)
1298  {
1299  ExFreePoolWithTag(Devices, TAG_FSTUB);
1300  }
1301 
1302  /* Now, assign drive letter to floppy drives */
1303  for (i = 0; i < ConfigInfo->FloppyCount; ++i)
1304  {
1305  swprintf(Buffer, L"\\Device\\Floppy%d", i);
1306  RtlInitUnicodeString(&StringU1, Buffer);
1307  if (HalpIsOldStyleFloppy(&StringU1))
1308  {
1309  HalpNextDriveLetter(&StringU1, NtDeviceName, NtSystemPath, TRUE);
1310  }
1311  }
1312 
1313  /* And CD drives */
1314  for (i = 0; i < ConfigInfo->CdRomCount; ++i)
1315  {
1316  swprintf(Buffer, L"\\Device\\CdRom%d", i);
1317  RtlInitUnicodeString(&StringU1, Buffer);
1318  HalpNextDriveLetter(&StringU1, NtDeviceName, NtSystemPath, TRUE);
1319  }
1320 
1321  /* If not remote boot, handle NtDeviceName */
1322  if (!IoRemoteBootClient && NT_SUCCESS(RtlAnsiStringToUnicodeString(&StringU1, NtDeviceName, TRUE)))
1323  {
1324  /* Assign it a drive letter */
1325  DriveLetter = HalpNextDriveLetter(&StringU1, NULL, NULL, TRUE);
1326  if (DriveLetter != 0)
1327  {
1328  if (DriveLetter != 0xFF)
1329  {
1330  *NtSystemPath = DriveLetter;
1331  }
1332  }
1333  /* If it fails through mount manager, retry manually */
1334  else
1335  {
1336  RtlInitUnicodeString(&StringU2, L"\\Device\\Floppy");
1337  RtlInitUnicodeString(&StringU3, L"\\Device\\CdRom");
1338 
1339  if (RtlPrefixUnicodeString(&StringU2, &StringU1, TRUE))
1340  {
1341  DriveLetter = 'A';
1342  }
1343  else if (RtlPrefixUnicodeString(&StringU3, &StringU1, TRUE))
1344  {
1345  DriveLetter = 'D';
1346  }
1347  else
1348  {
1349  DriveLetter = 'C';
1350  }
1351 
1352  /* Try any drive letter */
1353  while (HalpSetMountLetter(&StringU1, DriveLetter) != STATUS_SUCCESS)
1354  {
1355  ++DriveLetter;
1356 
1357  if (DriveLetter > 'Z')
1358  {
1359  break;
1360  }
1361  }
1362 
1363  /* If we're beyond Z (ie, no slot left) */
1364  if (DriveLetter > 'Z')
1365  {
1366  /* Delete Z, and reuse it for system */
1367  HalpDeleteMountLetter('Z');
1368  HalpSetMountLetter(&StringU1, 'Z');
1369  *NtSystemPath = 'Z';
1370  }
1371  else
1372  {
1373  /* Return matching drive letter */
1374  *NtSystemPath = DriveLetter;
1375  }
1376  }
1377 
1378  RtlFreeUnicodeString(&StringU1);
1379  }
1380 
1381  /* Enable auto assignement for mountmgr */
1383 }
IN PUNICODE_STRING IN POBJECT_ATTRIBUTES ObjectAttributes
Definition: conport.c:35
#define OBJ_CASE_INSENSITIVE
Definition: winternl.h:228
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
PCONFIGURATION_INFORMATION NTAPI IoGetConfigurationInformation(VOID)
Definition: iorsrce.c:830
#define TRUE
Definition: types.h:120
NTSYSAPI NTSTATUS NTAPI ZwClose(_In_ HANDLE Handle)
char * strstr(char *String1, char *String2)
Definition: utclib.c:653
LONG NTSTATUS
Definition: precomp.h:26
VOID HalpEnableAutomaticDriveLetterAssignment(VOID)
Definition: disksup.c:857
_Check_return_ _CRTIMP _CONST_RETURN char *__cdecl strrchr(_In_z_ const char *_Str, _In_ int _Ch)
#define swprintf
Definition: precomp.h:40
NTSTATUS HalpDeleteMountLetter(UCHAR DriveLetter)
Definition: disksup.c:766
#define FILE_SHARE_READ
Definition: compat.h:136
NTSTATUS HalpQueryPartitionType(IN PUNICODE_STRING DeviceName, IN PDRIVE_LAYOUT_INFORMATION LayoutInfo, OUT PPARTITION_TYPE PartitionType)
Definition: disksup.c:165
NTSYSAPI VOID NTAPI RtlInitAnsiString(PANSI_STRING DestinationString, PCSZ SourceString)
#define sprintf(buf, format,...)
Definition: sprintf.c:55
HANDLE FileHandle
Definition: stats.c:38
#define FALSE
Definition: types.h:117
#define ANSI_NULL
DECLSPEC_NORETURN VOID NTAPI KeBugCheck(ULONG BugCheckCode)
Definition: bug.c:1427
#define FILE_READ_DATA
Definition: nt_native.h:628
unsigned char BOOLEAN
Definition: bufpool.h:45
Status
Definition: gdiplustypes.h:24
UCHAR HalpNextDriveLetter(IN PUNICODE_STRING DeviceName, IN PSTRING NtDeviceName, OUT PUCHAR NtSystemPath, BOOLEAN IsRemovable)
Definition: disksup.c:607
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
NTSYSAPI VOID NTAPI RtlFreeUnicodeString(PUNICODE_STRING UnicodeString)
static PPARTENTRY SystemPartition
Definition: usetup.c:61
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
NTSYSAPI NTSTATUS NTAPI ZwOpenFile(_Out_ PHANDLE FileHandle, _In_ ACCESS_MASK DesiredAccess, _In_ POBJECT_ATTRIBUTES ObjectAttributes, _Out_ PIO_STATUS_BLOCK IoStatusBlock, _In_ ULONG ShareAccess, _In_ ULONG OpenOptions)
NTSTATUS HalpSetMountLetter(IN PUNICODE_STRING DeviceName, UCHAR DriveLetter)
Definition: disksup.c:522
unsigned char UCHAR
Definition: xmlstorage.h:181
static const WCHAR L[]
Definition: oid.c:1250
#define TAG_FSTUB
Definition: tag.h:198
#define SYNCHRONIZE
Definition: nt_native.h:61
NTSYSAPI VOID NTAPI RtlInitString(PSTRING DestinationString, PCSZ SourceString)
_CRTIMP char *__cdecl _strupr(_Inout_z_ char *_String)
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
unsigned short USHORT
Definition: pedump.c:61
NTSYSAPI NTSTATUS NTAPI RtlAnsiStringToUnicodeString(PUNICODE_STRING DestinationString, PANSI_STRING SourceString, BOOLEAN AllocateDestinationString)
signed char * PSTR
Definition: retypes.h:7
unsigned int * PULONG
Definition: retypes.h:1
#define NULL
Definition: types.h:112
PULONG IopComputeHarddiskDerangements(IN ULONG DiskCount)
Definition: disksup.c:320
NTSYSAPI BOOLEAN NTAPI RtlPrefixUnicodeString(IN PUNICODE_STRING String1, IN PUNICODE_STRING String2, IN BOOLEAN CaseInSensitive)
BOOLEAN HalpIsOldStyleFloppy(PUNICODE_STRING DeviceName)
Definition: disksup.c:707
#define FILE_SYNCHRONOUS_IO_NONALERT
Definition: from_kernel.h:31
char * strcpy(char *DstString, const char *SrcString)
Definition: utclib.c:388
CHAR PartitionType
Definition: part_xbox.c:32
unsigned int ULONG
Definition: retypes.h:1
NTSTATUS FASTCALL HalpQueryDriveLayout(IN PUNICODE_STRING DeviceName, OUT PDRIVE_LAYOUT_INFORMATION *LayoutInfo)
Definition: disksup.c:56
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
#define InitializeObjectAttributes(p, n, a, r, s)
Definition: reg.c:106
#define STATUS_SUCCESS
Definition: shellext.h:65
enum _PARTITION_TYPE PARTITION_TYPE
IN OUT PLONG IN OUT PLONG Addend IN OUT PLONG IN LONG Increment
Definition: CrNtStubs.h:42
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1099
#define PAGED_CODE()
BOOLEAN IoRemoteBootClient
Definition: init.c:68

◆ xHalIoReadPartitionTable()

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

Definition at line 1768 of file disksup.c.

1772 {
1773  KEVENT Event;
1775  PIRP Irp;
1776  PPARTITION_DESCRIPTOR PartitionDescriptor;
1777  CCHAR Entry;
1778  NTSTATUS Status;
1780  PUCHAR Buffer = NULL;
1781  ULONG BufferSize = 2048, InputSize;
1782  PDRIVE_LAYOUT_INFORMATION DriveLayoutInfo = NULL;
1783  LONG j = -1, i = -1, k;
1784  DISK_GEOMETRY_EX DiskGeometryEx;
1785  LONGLONG EndSector, MaxSector, StartOffset;
1786  LARGE_INTEGER Offset, VolumeOffset;
1787  BOOLEAN IsPrimary = TRUE, IsEzDrive = FALSE, MbrFound = FALSE;
1788  BOOLEAN IsValid, IsEmpty = TRUE;
1789  PVOID MbrBuffer;
1790  PIO_STACK_LOCATION IoStackLocation;
1792  LARGE_INTEGER HiddenSectors64;
1793 
1794  PAGED_CODE();
1795 
1796  VolumeOffset.QuadPart = Offset.QuadPart = 0;
1797 
1798  /* Allocate the buffer */
1800  BufferSize,
1801  TAG_FILE_SYSTEM);
1803 
1804  /* Normalize the buffer size */
1805  InputSize = max(512, SectorSize);
1806 
1807  /* Check for EZ-Drive */
1808  HalExamineMBR(DeviceObject, InputSize, PARTITION_EZDRIVE, &MbrBuffer);
1809  if (MbrBuffer)
1810  {
1811  /* EZ-Drive found, bias the offset */
1812  IsEzDrive = TRUE;
1813  ExFreePoolWithTag(MbrBuffer, TAG_FILE_SYSTEM);
1814  Offset.QuadPart = 512;
1815  }
1816 
1817  /* Get drive geometry */
1818  Status = HalpGetFullGeometry(DeviceObject, &DiskGeometryEx);
1819  if (!NT_SUCCESS(Status))
1820  {
1822  *PartitionBuffer = NULL;
1823  return Status;
1824  }
1825 
1826  /* Get the end and maximum sector */
1827  EndSector = DiskGeometryEx.DiskSize.QuadPart / DiskGeometryEx.Geometry.BytesPerSector;
1828  MaxSector = EndSector << 1;
1829  DPRINT("FSTUB: DiskSize = %#I64x, MaxSector = %#I64x\n",
1830  DiskGeometryEx.DiskSize, MaxSector);
1831 
1832  /* Allocate our buffer */
1834  if (!Buffer)
1835  {
1836  /* Fail, free the input buffer */
1838  *PartitionBuffer = NULL;
1840  }
1841 
1842  /* Start partition loop */
1843  do
1844  {
1845  /* Assume the partition is valid */
1846  IsValid = TRUE;
1847 
1848  /* Initialize the event */
1850 
1851  /* Clear the buffer and build the IRP */
1852  RtlZeroMemory(Buffer, InputSize);
1854  DeviceObject,
1855  Buffer,
1856  InputSize,
1857  &Offset,
1858  &Event,
1859  &IoStatusBlock);
1860  if (!Irp)
1861  {
1862  /* Failed */
1864  break;
1865  }
1866 
1867  /* Make sure to disable volume verification */
1868  IoStackLocation = IoGetNextIrpStackLocation(Irp);
1869  IoStackLocation->Flags |= SL_OVERRIDE_VERIFY_VOLUME;
1870 
1871  /* Call the driver */
1873  if (Status == STATUS_PENDING)
1874  {
1875  /* Wait for completion */
1878  }
1879 
1880  /* Normalize status code and check for failure */
1882  if (!NT_SUCCESS(Status)) break;
1883 
1884  /* If we biased for EZ-Drive, unbias now */
1885  if (IsEzDrive && (Offset.QuadPart == 512)) Offset.QuadPart = 0;
1886 
1887  /* Make sure this is a valid MBR */
1889  {
1890  /* It's not, fail */
1891  DPRINT1("FSTUB: (IoReadPartitionTable) No 0xaa55 found in "
1892  "partition table %d\n", j + 1);
1893  break;
1894  }
1895 
1896  /* At this point we have a valid MBR */
1897  MbrFound = TRUE;
1898 
1899  /* Check if we weren't given an offset */
1900  if (!Offset.QuadPart)
1901  {
1902  /* Then read the signature off the disk */
1903  (*PartitionBuffer)->Signature = *(PUINT32)&Buffer[DISK_SIGNATURE_OFFSET];
1904  }
1905 
1906  /* Get the partition descriptor array */
1907  PartitionDescriptor = (PPARTITION_DESCRIPTOR)&Buffer[PARTITION_TABLE_OFFSET];
1908 
1909  /* Start looping partitions */
1910  j++;
1911  DPRINT("FSTUB: Partition Table %d:\n", j);
1912  for (Entry = 1, k = 0; Entry <= NUM_PARTITION_TABLE_ENTRIES; Entry++, PartitionDescriptor++)
1913  {
1914  /* Get the partition type */
1915  PartitionType = PartitionDescriptor->PartitionType;
1916 
1917  /* Print debug messages */
1918  DPRINT("Partition Entry %d,%d: type %#x %s\n",
1919  j,
1920  Entry,
1921  PartitionType,
1922  (PartitionDescriptor->ActiveFlag) ? "Active" : "");
1923  DPRINT("\tOffset %#08lx for %#08lx Sectors\n",
1924  GET_STARTING_SECTOR(PartitionDescriptor),
1925  GET_PARTITION_LENGTH(PartitionDescriptor));
1926 
1927  /* Check whether we're facing a protective MBR */
1929  {
1930  /* Partition length might be bigger than disk size */
1931  FstubFixupEfiPartition(PartitionDescriptor, DiskGeometryEx.DiskSize.QuadPart);
1932  }
1933 
1934  /* Make sure that the partition is valid, unless it's the first */
1935  if (!(HalpIsValidPartitionEntry(PartitionDescriptor,
1936  DiskGeometryEx.DiskSize.QuadPart,
1937  MaxSector)) && (j == 0))
1938  {
1939  /* It's invalid, so fail */
1940  IsValid = FALSE;
1941  break;
1942  }
1943 
1944  /* Check if it's a container */
1946  {
1947  /* Increase the count of containers */
1948  if (++k != 1)
1949  {
1950  /* More then one table is invalid */
1951  DPRINT1("FSTUB: Multiple container partitions found in "
1952  "partition table %d\n - table is invalid\n",
1953  j);
1954  IsValid = FALSE;
1955  break;
1956  }
1957  }
1958 
1959  /* Check if the partition is supposedly empty */
1960  if (IsEmpty)
1961  {
1962  /* But check if it actually has a start and/or length */
1963  if ((GET_STARTING_SECTOR(PartitionDescriptor)) ||
1964  (GET_PARTITION_LENGTH(PartitionDescriptor)))
1965  {
1966  /* So then it's not really empty */
1967  IsEmpty = FALSE;
1968  }
1969  }
1970 
1971  /* Check if the caller wanted only recognized partitions */
1973  {
1974  /* Then check if this one is unused, or a container */
1977  {
1978  /* Skip it, since the caller doesn't want it */
1979  continue;
1980  }
1981  }
1982 
1983  /* Increase the structure count and check if they can fit */
1984  if ((sizeof(DRIVE_LAYOUT_INFORMATION) +
1985  (++i * sizeof(PARTITION_INFORMATION))) >
1986  BufferSize)
1987  {
1988  /* Allocate a new buffer that's twice as big */
1989  DriveLayoutInfo = ExAllocatePoolWithTag(NonPagedPool,
1990  BufferSize << 1,
1991  TAG_FILE_SYSTEM);
1992  if (!DriveLayoutInfo)
1993  {
1994  /* Out of memory, undo this extra structure */
1995  --i;
1997  break;
1998  }
1999 
2000  /* Copy the contents of the old buffer */
2001  RtlMoveMemory(DriveLayoutInfo,
2002  *PartitionBuffer,
2003  BufferSize);
2004 
2005  /* Free the old buffer and set this one as the new one */
2007  *PartitionBuffer = DriveLayoutInfo;
2008 
2009  /* Double the size */
2010  BufferSize <<= 1;
2011  }
2012 
2013  /* Now get the current structure being filled and initialize it */
2014  PartitionInfo = &(*PartitionBuffer)->PartitionEntry[i];
2015  PartitionInfo->PartitionType = PartitionType;
2016  PartitionInfo->RewritePartition = FALSE;
2017 
2018  /* Check if we're dealing with a partition that's in use */
2020  {
2021  /* Check if it's bootable */
2022  PartitionInfo->BootIndicator = PartitionDescriptor->
2023  ActiveFlag & 0x80 ?
2024  TRUE : FALSE;
2025 
2026  /* Check if its' a container */
2028  {
2029  /* Then don't recognize it and use the volume offset */
2030  PartitionInfo->RecognizedPartition = FALSE;
2031  StartOffset = VolumeOffset.QuadPart;
2032  }
2033  else
2034  {
2035  /* Then recognize it and use the partition offset */
2036  PartitionInfo->RecognizedPartition = TRUE;
2037  StartOffset = Offset.QuadPart;
2038  }
2039 
2040  /* Get the starting offset */
2041  PartitionInfo->StartingOffset.QuadPart =
2042  StartOffset +
2043  UInt32x32To64(GET_STARTING_SECTOR(PartitionDescriptor),
2044  SectorSize);
2045 
2046  /* Calculate the number of hidden sectors */
2047  HiddenSectors64.QuadPart = (PartitionInfo->
2048  StartingOffset.QuadPart -
2049  StartOffset) /
2050  SectorSize;
2051  PartitionInfo->HiddenSectors = HiddenSectors64.LowPart;
2052 
2053  /* Get the partition length */
2054  PartitionInfo->PartitionLength.QuadPart =
2055  UInt32x32To64(GET_PARTITION_LENGTH(PartitionDescriptor),
2056  SectorSize);
2057 
2058  /* Get the partition number */
2059  /* FIXME: REACTOS HACK -- Needed for xHalIoAssignDriveLetters() */
2060  PartitionInfo->PartitionNumber = (!IsContainerPartition(PartitionType)) ? i + 1 : 0;
2061  }
2062  else
2063  {
2064  /* Otherwise, clear all the relevant fields */
2065  PartitionInfo->BootIndicator = FALSE;
2066  PartitionInfo->RecognizedPartition = FALSE;
2067  PartitionInfo->StartingOffset.QuadPart = 0;
2068  PartitionInfo->PartitionLength.QuadPart = 0;
2069  PartitionInfo->HiddenSectors = 0;
2070 
2071  /* FIXME: REACTOS HACK -- Needed for xHalIoAssignDriveLetters() */
2072  PartitionInfo->PartitionNumber = 0;
2073  }
2074  }
2075 
2076  /* Finish debug log, and check for failure */
2077  DPRINT("\n");
2078  if (!NT_SUCCESS(Status)) break;
2079 
2080  /* Also check if we hit an invalid entry here */
2081  if (!IsValid)
2082  {
2083  /* We did, so break out of the loop minus one entry */
2084  j--;
2085  break;
2086  }
2087 
2088  /* Reset the offset */
2089  Offset.QuadPart = 0;
2090 
2091  /* Go back to the descriptor array and loop it */
2092  PartitionDescriptor = (PPARTITION_DESCRIPTOR)&Buffer[PARTITION_TABLE_OFFSET];
2093  for (Entry = 1; Entry <= NUM_PARTITION_TABLE_ENTRIES; Entry++, PartitionDescriptor++)
2094  {
2095  /* Check if this is a container partition, since we skipped them */
2096  if (IsContainerPartition(PartitionDescriptor->PartitionType))
2097  {
2098  /* Get its offset */
2099  Offset.QuadPart = VolumeOffset.QuadPart +
2100  UInt32x32To64(
2101  GET_STARTING_SECTOR(PartitionDescriptor),
2102  SectorSize);
2103 
2104  /* If this is a primary partition, this is the volume offset */
2105  if (IsPrimary) VolumeOffset = Offset;
2106 
2107  /* Also update the maximum sector */
2108  MaxSector = GET_PARTITION_LENGTH(PartitionDescriptor);
2109  DPRINT1("FSTUB: MaxSector now = %I64d\n", MaxSector);
2110  break;
2111  }
2112  }
2113 
2114  /* Loop the next partitions, which are not primary anymore */
2115  IsPrimary = FALSE;
2116  } while (Offset.HighPart | Offset.LowPart);
2117 
2118  /* Check if this is a removable device that's probably a super-floppy */
2119  if ((DiskGeometryEx.Geometry.MediaType == RemovableMedia) &&
2120  (j == 0) && (MbrFound) && (IsEmpty))
2121  {
2122  PBOOT_SECTOR_INFO BootSectorInfo = (PBOOT_SECTOR_INFO)Buffer;
2123 
2124  /* Read the jump bytes to detect super-floppy */
2125  if ((BootSectorInfo->JumpByte[0] == 0xeb) ||
2126  (BootSectorInfo->JumpByte[0] == 0xe9))
2127  {
2128  /* Super floppes don't have typical MBRs, so skip them */
2129  DPRINT1("FSTUB: Jump byte %#x found along with empty partition "
2130  "table - disk is a super floppy and has no valid MBR\n",
2131  BootSectorInfo->JumpByte);
2132  j = -1;
2133  }
2134  }
2135 
2136  /* Check if we're still at partition -1 */
2137  if (j == -1)
2138  {
2139  /* The likely cause is the super floppy detection above */
2140  if ((MbrFound) || (DiskGeometryEx.Geometry.MediaType == RemovableMedia))
2141  {
2142  /* Print out debugging information */
2143  DPRINT1("FSTUB: Drive %#p has no valid MBR. Make it into a "
2144  "super-floppy\n",
2145  DeviceObject);
2146  DPRINT1("FSTUB: Drive has %I64d sectors and is %#016I64x "
2147  "bytes large\n",
2148  EndSector, DiskGeometryEx.DiskSize);
2149 
2150  /* We should at least have some sectors */
2151  if (EndSector > 0)
2152  {
2153  /* Get the entry we'll use */
2154  PartitionInfo = &(*PartitionBuffer)->PartitionEntry[0];
2155 
2156  /* Fill it out with data for a super-floppy */
2157  PartitionInfo->RewritePartition = FALSE;
2158  PartitionInfo->RecognizedPartition = TRUE;
2159  PartitionInfo->PartitionType = PARTITION_FAT_16;
2160  PartitionInfo->BootIndicator = FALSE;
2161  PartitionInfo->HiddenSectors = 0;
2162  PartitionInfo->StartingOffset.QuadPart = 0;
2163  PartitionInfo->PartitionLength = DiskGeometryEx.DiskSize;
2164 
2165  /* FIXME: REACTOS HACK -- Needed for xHalIoAssignDriveLetters() */
2166  PartitionInfo->PartitionNumber = 0;
2167 
2168  /* Set the signature and set the count back to 0 */
2169  (*PartitionBuffer)->Signature = 1;
2170  i = 0;
2171  }
2172  }
2173  else
2174  {
2175  /* Otherwise, this isn't a super floppy, so set an invalid count */
2176  i = -1;
2177  }
2178  }
2179 
2180  /* Set the partition count */
2181  (*PartitionBuffer)->PartitionCount = ++i;
2182 
2183  /* If we have no count, delete the signature */
2184  if (!i) (*PartitionBuffer)->Signature = 0;
2185 
2186  /* Free the buffer and check for success */
2188  if (!NT_SUCCESS(Status))
2189  {
2191  *PartitionBuffer = NULL;
2192  }
2193 
2194  /* Return status */
2195  return Status;
2196 }
#define TAG_FILE_SYSTEM
Definition: tag.h:50
#define max(a, b)
Definition: svc.c:63
#define GET_STARTING_SECTOR(p)
Definition: hal.h:253
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
#define EFI_PMBR_OSTYPE_EFI
Definition: disksup.c:25
_In_ PFCB _In_ LONGLONG StartingOffset
Definition: cdprocs.h:290
struct _Entry Entry
Definition: kefuncs.h:627
PIRP NTAPI IoBuildSynchronousFsdRequest(IN ULONG MajorFunction, IN PDEVICE_OBJECT DeviceObject, IN PVOID Buffer, IN ULONG Length, IN PLARGE_INTEGER StartingOffset, IN PKEVENT Event, IN PIO_STATUS_BLOCK IoStatusBlock)
Definition: irp.c:1069
unsigned int * PUINT32
Definition: basetsd.h:127
#define TRUE
Definition: types.h:120
UCHAR JumpByte[1]
Definition: hal.h:302
unsigned char * PUCHAR
Definition: retypes.h:3
#define PARTITION_EZDRIVE
Definition: ntdddisk.h:289
LONG NTSTATUS
Definition: precomp.h:26
#define PARTITION_TABLE_OFFSET
Definition: hal.h:244
#define IsContainerPartition(PartitionType)
Definition: ntdddisk.h:316
ULONG BytesPerSector
Definition: ntdddisk.h:409
NTSTATUS NTAPI KeWaitForSingleObject(IN PVOID Object, IN KWAIT_REASON WaitReason, IN KPROCESSOR_MODE WaitMode, IN BOOLEAN Alertable, IN PLARGE_INTEGER Timeout OPTIONAL)
Definition: wait.c:416
#define RtlMoveMemory(Destination, Source, Length)
Definition: typedefs.h:264
LARGE_INTEGER DiskSize
Definition: winioctl.h:331
#define PARTITION_ENTRY_UNUSED
Definition: disk.h:86
_In_ PDEVICE_OBJECT DeviceObject
Definition: wdfdevice.h:2055
#define FALSE
Definition: types.h:117
_In_ PIRP Irp
Definition: csq.h:116
long LONG
Definition: pedump.c:60
unsigned short * PUINT16
Definition: basetsd.h:194
DISK_GEOMETRY Geometry
Definition: winioctl.h:330
_In_ PVOID _In_ ULONG Event
Definition: iotypes.h:467
_In_ ULONG _In_ BOOLEAN _Out_ struct _DRIVE_LAYOUT_INFORMATION ** PartitionBuffer
Definition: iofuncs.h:2052
unsigned char BOOLEAN
#define SL_OVERRIDE_VERIFY_VOLUME
Definition: iotypes.h:1823
Definition: bufpool.h:45
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
Definition: glfuncs.h:250
Status
Definition: gdiplustypes.h:24
int64_t LONGLONG
Definition: typedefs.h:68
#define GET_PARTITION_LENGTH(p)
Definition: hal.h:262
#define BOOT_RECORD_SIGNATURE
Definition: parttest.c:17
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define STATUS_PENDING
Definition: ntstatus.h:82
char CCHAR
Definition: typedefs.h:51
UCHAR PartitionType
Definition: hal.h:283
struct _PARTITION_DESCRIPTOR * PPARTITION_DESCRIPTOR
_In_ ULONG _In_ struct _SET_PARTITION_INFORMATION_EX * PartitionInfo
Definition: iofuncs.h:2105
MEDIA_TYPE MediaType
Definition: ntdddisk.h:406
#define PARTITION_FAT_16
Definition: disk.h:90
VOID NTAPI FstubFixupEfiPartition(IN PPARTITION_DESCRIPTOR PartitionDescriptor, IN ULONGLONG MaxOffset)
Definition: disksup.c:1749
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
unsigned char UCHAR
Definition: xmlstorage.h:181
BOOLEAN NTAPI HalpIsValidPartitionEntry(IN PPARTITION_DESCRIPTOR Entry, IN ULONGLONG MaxOffset, IN ULONGLONG MaxSector)
Definition: disksup.c:1441
_In_ ULONG _In_ BOOLEAN ReturnRecognizedPartitions
Definition: iofuncs.h:2050
#define BOOT_SIGNATURE_OFFSET
Definition: hal.h:245
ULONG LowPart
Definition: typedefs.h:106
NTSTATUS NTAPI HalpGetFullGeometry(IN PDEVICE_OBJECT DeviceObject, OUT PDISK_GEOMETRY_EX Geometry)
Definition: disksup.c:1389
#define STATUS_NO_DATA_DETECTED
Definition: udferr_usr.h:131
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetNextIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2695
UCHAR ActiveFlag
Definition: hal.h:279
_In_ ULONG _In_ ULONG Offset
Definition: ntddpcm.h:101
#define KeInitializeEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:477
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
static OUT PIO_STATUS_BLOCK IoStatusBlock
Definition: pipe.c:75
#define NULL
Definition: types.h:112
NTSTATUS NTAPI IoCallDriver(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: irp.c:1218
#define DPRINT1
Definition: precomp.h:8
#define IRP_MJ_READ
Definition: rdpdr.c:46
CHAR PartitionType
Definition: part_xbox.c:32
#define NUM_PARTITION_TABLE_ENTRIES
Definition: hal.h:248
unsigned int ULONG
Definition: retypes.h:1
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
VOID FASTCALL HalExamineMBR(IN PDEVICE_OBJECT DeviceObject, IN ULONG SectorSize, IN ULONG MbrTypeIdentifier, OUT PVOID *MbrBuffer)
Definition: disksup.c:2681
#define STATUS_SUCCESS
Definition: shellext.h:65
_In_ ULONG SectorSize
Definition: halfuncs.h:291
#define DPRINT
Definition: sndvol32.h:71
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1099
#define UInt32x32To64(a, b)
Definition: intsafe.h:252
#define DISK_SIGNATURE_OFFSET
Definition: hal.h:243
int k
Definition: mpi.c:3369
base of all file and directory entries
Definition: entries.h:82
struct _BOOT_SECTOR_INFO * PBOOT_SECTOR_INFO
_In_ WDFMEMORY _Out_opt_ size_t * BufferSize
Definition: wdfmemory.h:251
LONGLONG QuadPart
Definition: typedefs.h:114
#define PAGED_CODE()

◆ xHalIoSetPartitionInformation()

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

Definition at line 2200 of file disksup.c.

2204 {
2205  PIRP Irp;
2206  KEVENT Event;
2208  NTSTATUS Status;
2209  LARGE_INTEGER Offset, VolumeOffset;
2210  PUCHAR Buffer = NULL;
2211  ULONG BufferSize;
2212  ULONG i = 0;
2213  ULONG Entry;
2214  PPARTITION_DESCRIPTOR PartitionDescriptor;
2215  BOOLEAN IsPrimary = TRUE, IsEzDrive = FALSE;
2216  PVOID MbrBuffer;
2217  PIO_STACK_LOCATION IoStackLocation;
2218 
2219  PAGED_CODE();
2220 
2221  VolumeOffset.QuadPart = Offset.QuadPart = 0;
2222 
2223  /* Normalize the buffer size */
2224  BufferSize = max(512, SectorSize);
2225 
2226  /* Check for EZ-Drive */
2228  if (MbrBuffer)
2229  {
2230  /* EZ-Drive found, bias the offset */
2231  IsEzDrive = TRUE;
2232  ExFreePoolWithTag(MbrBuffer, TAG_FILE_SYSTEM);
2233  Offset.QuadPart = 512;
2234  }
2235 
2236  /* Allocate our partition buffer */
2239 
2240  /* Initialize the event we'll use and loop partitions */
2242  do
2243  {
2244  /* Reset the event since we reuse it */
2245  KeClearEvent(&Event);
2246 
2247  /* Build the read IRP */
2249  DeviceObject,
2250  Buffer,
2251  BufferSize,
2252  &Offset,
2253  &Event,
2254  &IoStatusBlock);
2255  if (!Irp)
2256  {
2257  /* Fail */
2259  break;
2260  }
2261 
2262  /* Make sure to disable volume verification */
2263  IoStackLocation = IoGetNextIrpStackLocation(Irp);
2264  IoStackLocation->Flags |= SL_OVERRIDE_VERIFY_VOLUME;
2265 
2266  /* Call the driver */
2268  if (Status == STATUS_PENDING)
2269  {
2270  /* Wait for completion */
2273  }
2274 
2275  /* Check for failure */
2276  if (!NT_SUCCESS(Status)) break;
2277 
2278  /* If we biased for EZ-Drive, unbias now */
2279  if (IsEzDrive && (Offset.QuadPart == 512)) Offset.QuadPart = 0;
2280 
2281  /* Make sure this is a valid MBR */
2283  {
2284  /* It's not, fail */
2286  break;
2287  }
2288 
2289  /* Get the partition descriptors and loop them */
2290  PartitionDescriptor = (PPARTITION_DESCRIPTOR)&Buffer[PARTITION_TABLE_OFFSET];
2291  for (Entry = 1; Entry <= NUM_PARTITION_TABLE_ENTRIES; Entry++, PartitionDescriptor++)
2292  {
2293  /* Check if it's unused or a container partition */
2294  if ((PartitionDescriptor->PartitionType == PARTITION_ENTRY_UNUSED) ||
2295  (IsContainerPartition(PartitionDescriptor->PartitionType)))
2296  {
2297  /* Go to the next one */
2298  continue;
2299  }
2300 
2301  /* It's a valid partition, so increase the partition count */
2302  if (++i == PartitionNumber)
2303  {
2304  /* We found a match, set the type */
2305  PartitionDescriptor->PartitionType = (UCHAR)PartitionType;
2306 
2307  /* Reset the reusable event */
2308  KeClearEvent(&Event);
2309 
2310  /* Build the write IRP */
2312  DeviceObject,
2313  Buffer,
2314  BufferSize,
2315  &Offset,
2316  &Event,
2317  &IoStatusBlock);
2318  if (!Irp)
2319  {
2320  /* Fail */
2322  break;
2323  }
2324 
2325  /* Disable volume verification */
2326  IoStackLocation = IoGetNextIrpStackLocation(Irp);
2327  IoStackLocation->Flags |= SL_OVERRIDE_VERIFY_VOLUME;
2328 
2329  /* Call the driver */
2331  if (Status == STATUS_PENDING)
2332  {
2333  /* Wait for completion */
2335  Executive,
2336  KernelMode,
2337  FALSE,
2338  NULL);
2340  }
2341 
2342  /* We're done, break out of the loop */
2343  break;
2344  }
2345  }
2346 
2347  /* If we looped all the partitions, break out */
2348  if (Entry <= NUM_PARTITION_TABLE_ENTRIES) break;
2349 
2350  /* Nothing found yet, get the partition array again */
2351  PartitionDescriptor = (PPARTITION_DESCRIPTOR)&Buffer[PARTITION_TABLE_OFFSET];
2352  for (Entry = 1; Entry <= NUM_PARTITION_TABLE_ENTRIES; Entry++, PartitionDescriptor++)
2353  {
2354  /* Check if this was a container partition (we skipped these) */
2355  if (IsContainerPartition(PartitionDescriptor->PartitionType))
2356  {
2357  /* Update the partition offset */
2358  Offset.QuadPart = VolumeOffset.QuadPart +
2359  GET_STARTING_SECTOR(PartitionDescriptor) *
2360  SectorSize;
2361 
2362  /* If this was the primary partition, update the volume too */
2363  if (IsPrimary) VolumeOffset = Offset;
2364  break;
2365  }
2366  }
2367 
2368  /* Check if we already searched all the partitions */
2370  {
2371  /* Then we failed to find a good MBR */
2373  break;
2374  }
2375 
2376  /* Loop the next partitions, which are not primary anymore */
2377  IsPrimary = FALSE;
2378  } while (i < PartitionNumber);
2379 
2380  /* Everything done, cleanup */
2382  return Status;
2383 }
#define TAG_FILE_SYSTEM
Definition: tag.h:50
#define max(a, b)
Definition: svc.c:63
#define GET_STARTING_SECTOR(p)
Definition: hal.h:253
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
struct _Entry Entry
Definition: kefuncs.h:627
PIRP NTAPI IoBuildSynchronousFsdRequest(IN ULONG MajorFunction, IN PDEVICE_OBJECT DeviceObject, IN PVOID Buffer, IN ULONG Length, IN PLARGE_INTEGER StartingOffset, IN PKEVENT Event, IN PIO_STATUS_BLOCK IoStatusBlock)
Definition: irp.c:1069
#define TRUE
Definition: types.h:120
unsigned char * PUCHAR
Definition: retypes.h:3
#define PARTITION_EZDRIVE
Definition: ntdddisk.h:289
LONG NTSTATUS
Definition: precomp.h:26
#define STATUS_BAD_MASTER_BOOT_RECORD
Definition: ntstatus.h:405
#define PARTITION_TABLE_OFFSET
Definition: hal.h:244
#define IsContainerPartition(PartitionType)
Definition: ntdddisk.h:316
_In_ ULONG _In_ ULONG PartitionNumber
Definition: iofuncs.h:2060
NTSTATUS NTAPI KeWaitForSingleObject(IN PVOID Object, IN KWAIT_REASON WaitReason, IN KPROCESSOR_MODE WaitMode, IN BOOLEAN Alertable, IN PLARGE_INTEGER Timeout OPTIONAL)
Definition: wait.c:416
#define PARTITION_ENTRY_UNUSED
Definition: disk.h:86
_In_ PDEVICE_OBJECT DeviceObject
Definition: wdfdevice.h:2055
#define FALSE
Definition: types.h:117
_In_ PIRP Irp
Definition: csq.h:116
unsigned short * PUINT16
Definition: basetsd.h:194
_In_ PVOID _In_ ULONG Event
Definition: iotypes.h:467
unsigned char BOOLEAN
#define SL_OVERRIDE_VERIFY_VOLUME
Definition: iotypes.h:1823
Definition: bufpool.h:45
Status
Definition: gdiplustypes.h:24
#define BOOT_RECORD_SIGNATURE
Definition: parttest.c:17
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define STATUS_PENDING
Definition: ntstatus.h:82
UCHAR PartitionType
Definition: hal.h:283
struct _PARTITION_DESCRIPTOR * PPARTITION_DESCRIPTOR
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
unsigned char UCHAR
Definition: xmlstorage.h:181
#define BOOT_SIGNATURE_OFFSET
Definition: hal.h:245
#define PAGE_SIZE
Definition: env_spec_w32.h:49
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetNextIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2695
_In_ ULONG _In_ ULONG Offset
Definition: ntddpcm.h:101
#define KeInitializeEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:477
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
static OUT PIO_STATUS_BLOCK IoStatusBlock
Definition: pipe.c:75
#define NULL
Definition: types.h:112
NTSTATUS NTAPI IoCallDriver(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: irp.c:1218
#define IRP_MJ_READ
Definition: rdpdr.c:46
CHAR PartitionType
Definition: part_xbox.c:32
#define NUM_PARTITION_TABLE_ENTRIES
Definition: hal.h:248
unsigned int ULONG
Definition: retypes.h:1
VOID FASTCALL HalExamineMBR(IN PDEVICE_OBJECT DeviceObject, IN ULONG SectorSize, IN ULONG MbrTypeIdentifier, OUT PVOID *MbrBuffer)
Definition: disksup.c:2681
#define IRP_MJ_WRITE
Definition: rdpdr.c:47
_In_ ULONG SectorSize
Definition: halfuncs.h:291
VOID NTAPI KeClearEvent(IN PKEVENT Event)
Definition: eventobj.c:22
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1099
base of all file and directory entries
Definition: entries.h:82
#define BufferSize
Definition: mmc.h:75
_In_ WDFMEMORY _Out_opt_ size_t * BufferSize
Definition: wdfmemory.h:251
LONGLONG QuadPart
Definition: typedefs.h:114
#define PAGED_CODE()

◆ 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 2387 of file disksup.c.

2392 {
2393  KEVENT Event;
2395  PIRP Irp;
2397  ULONG BufferSize;
2398  PUCHAR Buffer;
2399  PPTE Entry;
2400  PPARTITION_TABLE PartitionTable;
2401  LARGE_INTEGER Offset, NextOffset, ExtendedOffset, SectorOffset;
2402  LARGE_INTEGER StartOffset, PartitionLength;
2403  ULONG i, j;
2404  CCHAR k;
2405  BOOLEAN IsEzDrive = FALSE, IsSuperFloppy = FALSE, DoRewrite = FALSE, IsMbr;
2406  ULONG ConventionalCylinders;
2407  LONGLONG DiskSize;
2409  PVOID MbrBuffer;
2411  PIO_STACK_LOCATION IoStackLocation;
2414 
2415  PAGED_CODE();
2416 
2417  ExtendedOffset.QuadPart = NextOffset.QuadPart = Offset.QuadPart = 0;
2418 
2419  /* Normalize the buffer size */
2420  BufferSize = max(512, SectorSize);
2421 
2422  /* Get the partial drive geometry */
2423  xHalGetPartialGeometry(DeviceObject, &ConventionalCylinders, &DiskSize);
2424 
2425  /* Check for EZ-Drive */
2427  if (MbrBuffer)
2428  {
2429  /* EZ-Drive found, bias the offset */
2430  IsEzDrive = TRUE;
2431  ExFreePoolWithTag(MbrBuffer, TAG_FILE_SYSTEM);
2432  Offset.QuadPart = 512;
2433  }
2434 
2435  /* Get the number of bits to shift to multiply by the sector size */
2436  for (k = 0; k < 32; k++) if ((SectorSize >> k) == 1) break;
2437 
2438  /* Check if there's only one partition */
2439  if (PartitionBuffer->PartitionCount == 1)
2440  {
2441  /* Check if it has no starting offset or hidden sectors */
2442  if (!(PartitionInfo->StartingOffset.QuadPart) &&
2443  !(PartitionInfo->HiddenSectors))
2444  {
2445  /* Then it's a super floppy */
2446  IsSuperFloppy = TRUE;
2447 
2448  /* Which also means it must be non-bootable FAT-16 */
2449  if ((PartitionInfo->PartitionNumber) ||
2450  (PartitionInfo->PartitionType != PARTITION_FAT_16) ||
2451  (PartitionInfo->BootIndicator))
2452  {
2453  /* It's not, so we fail */
2454  return STATUS_INVALID_PARAMETER;
2455  }
2456 
2457  /* Check if it needs a rewrite, and disable EZ-Drive for sure */
2458  if (PartitionInfo->RewritePartition) DoRewrite = TRUE;
2459  IsEzDrive = FALSE;
2460  }
2461  }
2462 
2463  /* Count the number of partition tables */
2465 
2466  /* Allocate our partition buffer */
2469 
2470  /* Loop the entries */
2472  for (i = 0; i < DiskLayout->TableCount; i++)
2473  {
2474  /* Set if this is the MBR partition */
2475  IsMbr= (BOOLEAN)!i;
2476 
2477  /* Initialize th event */
2479 
2480  /* Build the read IRP */
2482  DeviceObject,
2483  Buffer,
2484  BufferSize,
2485  &Offset,
2486  &Event,
2487  &IoStatusBlock);
2488  if (!Irp)
2489  {
2490  /* Fail */
2492  break;
2493  }
2494 
2495  /* Make sure to disable volume verification */
2496  IoStackLocation = IoGetNextIrpStackLocation(Irp);
2497  IoStackLocation->Flags |= SL_OVERRIDE_VERIFY_VOLUME;
2498 
2499  /* Call the driver */
2501  if (Status == STATUS_PENDING)
2502  {
2503  /* Wait for completion */
2506  }
2507 
2508  /* Check for failure */
2509  if (!NT_SUCCESS(Status)) break;
2510 
2511  /* If we biased for EZ-Drive, unbias now */
2512  if (IsEzDrive && (Offset.QuadPart == 512)) Offset.QuadPart = 0;
2513 
2514  /* Check if this is a normal disk */
2515  if (!IsSuperFloppy)
2516  {
2517  /* Set the boot record signature */
2519 
2520  /* By default, don't require a rewrite */
2521  DoRewrite = FALSE;
2522 
2523  /* Check if we don't have an offset */
2524  if (!Offset.QuadPart)
2525  {
2526  /* Check if the signature doesn't match */
2527  if (*(PUINT32)&Buffer[DISK_SIGNATURE_OFFSET] != PartitionBuffer->Signature)
2528  {
2529  /* Then write the signature and now we need a rewrite */
2531  DoRewrite = TRUE;
2532  }
2533  }
2534 
2535  /* Loop the partition table entries */
2536  PartitionTable = &DiskLayout->PartitionTable[i];
2537  for (j = 0; j < NUM_PARTITION_TABLE_ENTRIES; j++)
2538  {
2539  /* Get the current entry and type */
2540  TableEntry = &PartitionTable->PartitionEntry[j];
2541  PartitionType = TableEntry->PartitionType;
2542 
2543  /* Check if the entry needs a rewrite */
2544  if (TableEntry->RewritePartition)
2545  {
2546  /* Then we need one too */
2547  DoRewrite = TRUE;
2548 
2549  /* Save the type and if it's a bootable partition */
2550  Entry[j].PartitionType = TableEntry->PartitionType;
2551  Entry[j].ActiveFlag = TableEntry->BootIndicator ? 0x80 : 0;
2552 
2553  /* Make sure it's used */
2555  {
2556  /* Make sure it's not a container (unless primary) */
2557  if ((IsMbr) || !(IsContainerPartition(PartitionType)))
2558  {
2559  /* Use the partition offset */
2560  StartOffset.QuadPart = Offset.QuadPart;
2561  }
2562  else
2563  {
2564  /* Use the extended logical partition offset */
2565  StartOffset.QuadPart = ExtendedOffset.QuadPart;
2566  }
2567 
2568  /* Set the sector offset */
2569  SectorOffset.QuadPart = TableEntry->
2570  StartingOffset.QuadPart -
2571  StartOffset.QuadPart;
2572 
2573  /* Now calculate the starting sector */
2574  StartOffset.QuadPart = SectorOffset.QuadPart >> k;
2575  Entry[j].StartingSector = StartOffset.LowPart;
2576 
2577  /* As well as the length */
2578  PartitionLength.QuadPart = TableEntry->PartitionLength.
2579  QuadPart >> k;
2580  Entry[j].PartitionLength = PartitionLength.LowPart;
2581 
2582  /* Calculate the CHS values */
2583  HalpCalculateChsValues(&TableEntry->StartingOffset,
2584  &TableEntry->PartitionLength,
2585  k,
2587  NumberOfHeads,
2588  ConventionalCylinders,
2590  &Entry[j]);
2591  }
2592  else
2593  {
2594  /* Otherwise set up an empty entry */
2595  Entry[j].StartingSector = 0;
2596  Entry[j].PartitionLength = 0;
2597  Entry[j].StartingTrack = 0;
2598  Entry[j].EndingTrack = 0;
2599  Entry[j].StartingCylinder = 0;
2600  Entry[j].EndingCylinder = 0;
2601  }
2602  }
2603 
2604  /* Check if this is a container partition */
2606  {
2607  /* Then update the offset to use */
2608  NextOffset = TableEntry->StartingOffset;
2609  }
2610  }
2611  }
2612 
2613  /* Check if we need to write back the buffer */
2614  if (DoRewrite)
2615  {
2616  /* We don't need to do this again */
2617  DoRewrite = FALSE;
2618 
2619  /* Initialize the event */
2621 
2622  /* If we unbiased for EZ-Drive, rebias now */
2623  if (IsEzDrive && !Offset.QuadPart) Offset.QuadPart = 512;
2624 
2625  /* Build the write IRP */
2627  DeviceObject,
2628  Buffer,
2629  BufferSize,
2630  &Offset,
2631  &Event,
2632  &IoStatusBlock);
2633  if (!Irp)
2634  {
2635  /* Fail */
2637  break;
2638  }
2639 
2640  /* Make sure to disable volume verification */
2641  IoStackLocation = IoGetNextIrpStackLocation(Irp);
2642  IoStackLocation->Flags |= SL_OVERRIDE_VERIFY_VOLUME;
2643 
2644  /* Call the driver */
2646  if (Status == STATUS_PENDING)
2647  {
2648  /* Wait for completion */
2650  Executive,
2651  KernelMode,
2652  FALSE,
2653  NULL);
2655  }
2656 
2657  /* Check for failure */
2658  if (!NT_SUCCESS(Status)) break;
2659 
2660  /* If we biased for EZ-Drive, unbias now */
2661  if (IsEzDrive && (Offset.QuadPart == 512)) Offset.QuadPart = 0;
2662  }
2663 
2664  /* Update the partition offset and set the extended offset if needed */
2665  Offset = NextOffset;
2666  if (IsMbr) ExtendedOffset = NextOffset;
2667  }
2668 
2669  /* If we had a buffer, free it, then return status */
2671  return Status;
2672 }
#define TAG_FILE_SYSTEM
Definition: tag.h:50
#define max(a, b)
Definition: svc.c:63
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
_In_ PFCB _In_ LONGLONG StartingOffset
Definition: cdprocs.h:290
struct _Entry Entry
Definition: kefuncs.h:627
Definition: hal.h:332
struct _PTE * PPTE
PIRP NTAPI IoBuildSynchronousFsdRequest(IN ULONG MajorFunction, IN PDEVICE_OBJECT DeviceObject, IN PVOID Buffer, IN ULONG Length, IN PLARGE_INTEGER StartingOffset, IN PKEVENT Event, IN PIO_STATUS_BLOCK IoStatusBlock)
Definition: irp.c:1069
IN BOOLEAN OUT PSTR Buffer
Definition: progress.h:34
unsigned int * PUINT32
Definition: basetsd.h:127
#define TRUE
Definition: types.h:120
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
VOID NTAPI 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)
Definition: disksup.c:1482
unsigned char * PUCHAR
Definition: retypes.h:3
#define PARTITION_EZDRIVE
Definition: ntdddisk.h:289
LONG NTSTATUS
Definition: precomp.h:26
#define PARTITION_TABLE_OFFSET
Definition: hal.h:244
#define IsContainerPartition(PartitionType)
Definition: ntdddisk.h:316
_In_ ULONG _In_ ULONG _In_ ULONG NumberOfHeads
Definition: iofuncs.h:2070
NTSTATUS NTAPI KeWaitForSingleObject(IN PVOID Object, IN KWAIT_REASON WaitReason, IN KPROCESSOR_MODE WaitMode, IN BOOLEAN Alertable, IN PLARGE_INTEGER Timeout OPTIONAL)
Definition: wait.c:416
struct _DISK_LAYOUT * PDISK_LAYOUT
PARTITION_INFORMATION PartitionEntry[4]
Definition: hal.h:319
#define PARTITION_ENTRY_UNUSED
Definition: disk.h:86
_In_ PDEVICE_OBJECT DeviceObject
Definition: wdfdevice.h:2055
_In_ ULONG _In_ ULONG SectorsPerTrack
Definition: iofuncs.h:2070
#define FALSE
Definition: types.h:117
_In_ PIRP Irp
Definition: csq.h:116
unsigned short * PUINT16
Definition: basetsd.h:194
_In_ PVOID _In_ ULONG Event
Definition: iotypes.h:467
_In_ ULONG _In_ BOOLEAN _Out_ struct _DRIVE_LAYOUT_INFORMATION ** PartitionBuffer
Definition: iofuncs.h:2052
#define SectorOffset(L)
Definition: cdprocs.h:1622
unsigned char BOOLEAN
#define SL_OVERRIDE_VERIFY_VOLUME
Definition: iotypes.h:1823
Definition: bufpool.h:45
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
Definition: glfuncs.h:250
Status
Definition: gdiplustypes.h:24
int64_t LONGLONG
Definition: typedefs.h:68
#define BOOT_RECORD_SIGNATURE
Definition: parttest.c:17
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define STATUS_PENDING
Definition: ntstatus.h:82
char CCHAR
Definition: typedefs.h:51
ULONG TableCount
Definition: hal.h:324
_In_ ULONG _In_ struct _SET_PARTITION_INFORMATION_EX * PartitionInfo
Definition: iofuncs.h:2105
PARTITION_TABLE PartitionTable[1]
Definition: hal.h:326
#define PARTITION_FAT_16
Definition: disk.h:90
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
unsigned char UCHAR
Definition: xmlstorage.h:181
#define BOOT_SIGNATURE_OFFSET
Definition: hal.h:245
ULONG LowPart
Definition: typedefs.h:106
#define PAGE_SIZE
Definition: env_spec_w32.h:49
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetNextIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2695
_In_ ULONG _In_ ULONG Offset
Definition: ntddpcm.h:101
VOID FASTCALL xHalGetPartialGeometry(IN PDEVICE_OBJECT DeviceObject, IN PULONG ConventionalCylinders, IN PLONGLONG DiskSize)
Definition: disksup.c:1557
BOOLEAN IsSuperFloppy(IN PDISKENTRY DiskEntry)
Definition: partlist.c:501
#define KeInitializeEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:477
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
static OUT PIO_STATUS_BLOCK IoStatusBlock
Definition: pipe.c:75
#define NULL
Definition: types.h:112
NTSTATUS NTAPI IoCallDriver(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: irp.c:1218
_Must_inspect_result_ typedef _In_ ULONG TableEntry
Definition: iotypes.h:4303
#define IRP_MJ_READ
Definition: rdpdr.c:46
#define BOOLEAN
Definition: pedump.c:73
CHAR PartitionType
Definition: part_xbox.c:32
ret QuadPart
Definition: rtlfuncs.h:3089
#define NUM_PARTITION_TABLE_ENTRIES
Definition: hal.h:248
unsigned int ULONG
Definition: retypes.h:1
VOID FASTCALL HalExamineMBR(IN PDEVICE_OBJECT DeviceObject, IN ULONG SectorSize, IN ULONG MbrTypeIdentifier, OUT PVOID *MbrBuffer)
Definition: disksup.c:2681
#define IRP_MJ_WRITE
Definition: rdpdr.c:47
#define STATUS_SUCCESS
Definition: shellext.h:65
_In_ ULONG SectorSize
Definition: halfuncs.h:291
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1099
#define DISK_SIGNATURE_OFFSET
Definition: hal.h:243
int k
Definition: mpi.c:3369
base of all file and directory entries
Definition: entries.h:82
#define BufferSize
Definition: mmc.h:75
_In_ WDFMEMORY _Out_opt_ size_t * BufferSize
Definition: wdfmemory.h:251
LONGLONG QuadPart
Definition: typedefs.h:114
#define PAGED_CODE()

Variable Documentation

◆ DiskMountString

const WCHAR DiskMountString[] = L"\\DosDevices\\%C:"

Definition at line 19 of file disksup.c.