drivesup.c File Reference

#include "ntos.h"
#include "zwapi.h"
#include "hal.h"
#include "ntdddisk.h"
#include "haldisp.h"
#include "ntddft.h"
#include "mountmgr.h"
#include "stdio.h"
#include <setupblk.h>
#include "drivesup.h"

Go to the source code of this file.

Classes
struct	_BOOT_SECTOR_INFO
Defines
#define	DebugPrint(x)   DrivesupDebugPrint x
#define	GET_STARTING_SECTOR(p)
#define	GET_PARTITION_LENGTH(p)
#define	BOOTABLE_PARTITION   0
#define	PRIMARY_PARTITION   1
#define	LOGICAL_PARTITION   2
#define	FT_PARTITION   3
#define	OTHER_PARTITION   4
#define	GET_STARTING_SECTOR(p)
#define	WHICH_BIT(Data, Bit)
#define	WHICH_BIT(Data, Bit)
Typedefs
typedef _BOOT_SECTOR_INFO	BOOT_SECTOR_INFO
typedef _BOOT_SECTOR_INFO *	PBOOT_SECTOR_INFO
Functions
VOID	DrivesupDebugPrint (ULONG DebugPrintLevel, PCCHAR DebugMessage,...)
VOID	HalpCalculateChsValues (IN PLARGE_INTEGER PartitionOffset, IN PLARGE_INTEGER PartitionLength, IN CCHAR ShiftCount, IN ULONG SectorsPerTrack, IN ULONG NumberOfTracks, IN ULONG ConventionalCylinders, OUT PPARTITION_DESCRIPTOR PartitionDescriptor)
NTSTATUS	HalpQueryPartitionType (IN PUNICODE_STRING DeviceName, IN PDRIVE_LAYOUT_INFORMATION DriveLayout, OUT PULONG PartitionType)
NTSTATUS	HalpQueryDriveLayout (IN PUNICODE_STRING DeviceName, OUT PDRIVE_LAYOUT_INFORMATION *DriveLayout)
VOID FASTCALL	xHalGetPartialGeometry (IN PDEVICE_OBJECT DeviceObject, IN PULONG ConventionalCylinders, IN PLONGLONG DiskSize)
NTSTATUS	HalpGetFullGeometry (IN PDEVICE_OBJECT DeviceObject, IN PDISK_GEOMETRY Geometry, OUT PULONGLONG RealSectorCount)
BOOLEAN	HalpIsValidPartitionEntry (PPARTITION_DESCRIPTOR Entry, ULONGLONG MaxOffset, ULONGLONG MaxSector)
NTSTATUS	HalpNextMountLetter (IN PUNICODE_STRING DeviceName, OUT PUCHAR DriveLetter)
UCHAR	HalpNextDriveLetter (IN PUNICODE_STRING DeviceName, IN PSTRING NtDeviceName, OUT PUCHAR NtSystemPath, IN BOOLEAN UseHardLinksIfNecessary)
VOID	HalpEnableAutomaticDriveLetterAssignment ()
NTSTATUS	HalpSetMountLetter (IN PUNICODE_STRING DeviceName, IN UCHAR DriveLetter)
BOOLEAN	HalpIsOldStyleFloppy (IN PUNICODE_STRING DeviceName)
VOID FASTCALL	xHalExamineMBR (IN PDEVICE_OBJECT DeviceObject, IN ULONG SectorSize, IN ULONG MBRTypeIdentifier, OUT PVOID *Buffer)
VOID FASTCALL	xHalIoAssignDriveLetters (IN struct _LOADER_PARAMETER_BLOCK *LoaderBlock, IN PSTRING NtDeviceName, OUT PUCHAR NtSystemPath, OUT PSTRING NtSystemPathString)
NTSTATUS FASTCALL	xHalIoReadPartitionTable (IN PDEVICE_OBJECT DeviceObject, IN ULONG SectorSize, IN BOOLEAN ReturnRecognizedPartitions, OUT struct _DRIVE_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 struct _DRIVE_LAYOUT_INFORMATION *PartitionBuffer)
NTSTATUS FASTCALL	xHalIoClearPartitionTable (IN PDEVICE_OBJECT DeviceObject, IN ULONG SectorSize, IN ULONG SectorsPerTrack, IN ULONG NumberOfHeads)
Variables
ULONG	DrivesupDebug = 0
ULONG	DrivesupBreakIn = FALSE
PUCHAR	DiskPartitionName = "\\Device\\Harddisk%d\\Partition%d"
PUCHAR	RegistryKeyName = DISK_REGISTRY_KEY

---

Define Documentation

#define BOOTABLE_PARTITION   0

Definition at line 699 of file drivesup.c. Referenced by HalpQueryPartitionType(), and xHalIoAssignDriveLetters().

#define DebugPrint (  x   )     DrivesupDebugPrint x

Definition at line 52 of file drivesup.c. Referenced by Calc323Dim_Data8To8_Lut16(), Calc324Dim_Data8To8_Lut16(), Calc423Dim_Data8To8_Lut16(), Calc424Dim_Data8To8_Lut16(), CalcNDim_Data8To8_Lut16(), CMMConcatInitPrivate(), CMMInitPrivate(), CombiMatrix(), CreateCombi(), DoMatrixForCube16(), DoOnlyMatrixForCube(), DoOnlyMatrixForCube16(), Extract_MFT_Xlut(), Extract_TRC_Alut(), ExtractAllLuts(), Fill_inverse_byte_ALUT_from_CurveTag(), Fill_inverse_ushort_ALUT_from_CurveTag(), FindCalcRoutine(), HalpIsValidPartitionEntry(), IopCallDriverAddDevice(), IopCallDriverAddDeviceQueryRoutine(), IopChangeDeviceObjectFromRegistryProperties(), IopProcessCriticalDevice(), IopProcessCriticalDeviceRoutine(), IopProcessNewDeviceNode(), MapperCallback(), MapperConstructRootEnumTree(), MapperMarkKey(), MapperPeripheralCallback(), MapperPhantomizeDetectedComPorts(), MapperProcessFirmwareTree(), MapperSeedKey(), MapperTranslatePnPId(), MyAdd_NL_AToB0Tag_mft1(), MyAdd_NL_AToB0Tag_mft2(), MyAdd_NL_CopyrightTag(), PnPBiosCheckForHardwareDisabled(), PnPBiosCopyDeviceParamKey(), PnPBiosCopyIoDecode(), PnPBiosEliminateDupes(), PnPBiosFindMatchingDevNode(), PnPBiosGetBiosInfo(), PnPBiosIoResourceListToCmResourceList(), PnPBiosTranslateInfo(), PnPBiosWriteInfo(), PrepareCombiLUTs(), and xHalIoReadPartitionTable().

#define FT_PARTITION   3

Definition at line 702 of file drivesup.c. Referenced by HalpQueryPartitionType(), and xHalIoAssignDriveLetters().

#define GET_PARTITION_LENGTH (  p   )

Value: ( \ (ULONG) (p->PartitionLengthLsb0) + \ (ULONG) (p->PartitionLengthLsb1 << 8) + \ (ULONG) (p->PartitionLengthMsb0 << 16) + \ (ULONG) (p->PartitionLengthMsb1 << 24) ) Definition at line 64 of file drivesup.c. Referenced by HalpIsValidPartitionEntry(), and xHalIoReadPartitionTable().

#define GET_STARTING_SECTOR (  p   )

Value: ( \ (ULONG) (p->StartingSectorLsb0) + \ (ULONG) (p->StartingSectorLsb1 << 8) + \ (ULONG) (p->StartingSectorMsb0 << 16) + \ (ULONG) (p->StartingSectorMsb1 << 24) ) Definition at line 58 of file drivesup.c.

#define GET_STARTING_SECTOR (  p   )

Value: ( \ (ULONG) (p->StartingSectorLsb0) + \ (ULONG) (p->StartingSectorLsb1 << 8) + \ (ULONG) (p->StartingSectorMsb0 << 16) + \ (ULONG) (p->StartingSectorMsb1 << 24) ) Definition at line 58 of file drivesup.c. Referenced by HalpIsValidPartitionEntry(), xHalIoReadPartitionTable(), and xHalIoSetPartitionInformation().

#define LOGICAL_PARTITION   2

Definition at line 701 of file drivesup.c. Referenced by HalpQueryPartitionType(), and xHalIoAssignDriveLetters().

#define OTHER_PARTITION   4

Definition at line 703 of file drivesup.c. Referenced by HalpQueryPartitionType().

#define PRIMARY_PARTITION   1

Definition at line 700 of file drivesup.c. Referenced by HalpQueryPartitionType(), and xHalIoAssignDriveLetters().

#define WHICH_BIT (  Data, Bit   )

Value: { \ for (Bit = 0; Bit < 32; Bit++) { \ if ((Data >> Bit) == 1) { \ break; \ } \ } \ }

#define WHICH_BIT (  Data, Bit   )

Value: { \ for (Bit = 0; Bit < 32; Bit++) { \ if ((Data >> Bit) == 1) { \ break; \ } \ } \ } Referenced by xHalIoClearPartitionTable(), and xHalIoWritePartitionTable().

---

Typedef Documentation

typedef struct _BOOT_SECTOR_INFO BOOT_SECTOR_INFO

typedef struct _BOOT_SECTOR_INFO * PBOOT_SECTOR_INFO

Referenced by xHalIoReadPartitionTable().

---

Function Documentation

VOID DrivesupDebugPrint (  ULONG  DebugPrintLevel, PCCHAR  DebugMessage,   ... )

Definition at line 3882 of file drivesup.c. References DbgPrint, DebugMessage, and DrivesupDebug. 03889 : 03890 03891 Debug print for all SCSI drivers 03892 03893 Arguments: 03894 03895 Debug print level between 0 and 3, with 3 being the most verbose. 03896 03897 Return Value: 03898 03899 None 03900 03901 --*/ 03902 03903 { 03904 UCHAR DrivesupBuffer[256]; 03905 03906 va_list ap; 03907 03908 va_start(ap, DebugMessage); 03909 03910 03911 if (DebugPrintLevel <= DrivesupDebug) { 03912 03913 _vsnprintf(DrivesupBuffer, 256, DebugMessage, ap); 03914 03915 DbgPrint(DrivesupBuffer); 03916 } 03917 03918 va_end(ap); 03919 03920 } // end DrivesupDebugPrint() } // end DrivesupDebugPrint()

VOID HalpCalculateChsValues (  IN PLARGE_INTEGER  PartitionOffset, IN PLARGE_INTEGER  PartitionLength, IN CCHAR  ShiftCount, IN ULONG  SectorsPerTrack, IN ULONG  NumberOfTracks, IN ULONG  ConventionalCylinders, OUT PPARTITION_DESCRIPTOR  PartitionDescriptor )

Definition at line 546 of file drivesup.c. References PAGED_CODE. Referenced by xHalIoWritePartitionTable(). : This routine will determine the cylinder, head, and sector (CHS) values that should be placed in a partition table entry, given the partition's location on the disk and its size. The values calculated are packed into int13 format -- the high two bits of the sector byte contain bits 8 and 9 of the 10 bit cylinder value, the low 6 bits of the sector byte contain the 6 bit sector value; the cylinder byte contains the low 8 bits of the cylinder value; and the head byte contains the 8-bit head value. Both the start and end CHS values are calculated. Arguments: PartitionOffset - Byte offset of the partition, relative to the entire physical disk. PartitionLength - Size in bytes of the partition. ShiftCount - Shift count to convert from byte counts to sector counts. SectorsPerTrack - Number of sectors in a track on the media on which the partition resides. NumberOfTracks - Number of tracks in a cylinder on the media on which the partition resides. ConventionalCylinders - The "normalized" disk cylinders. We will never set the cylinders greater than this. PartitionDescriptor - Structure to be filled in with the start and end CHS values. Other fields in the structure are not referenced or modified. Return Value: None. Note: The Cylinder and Head values are 0-based but the Sector value is 1-based. If the start or end cylinder overflows 10 bits (ie, > 1023), CHS values will be set to all 1's. No checking is done on the SectorsPerTrack and NumberOfTrack values. --*/ { ULONG startSector, sectorCount, endSector; ULONG sectorsPerCylinder; ULONG remainder; ULONG startC, startH, startS, endC, endH, endS; LARGE_INTEGER tempInt; PAGED_CODE(); // // Calculate the number of sectors in a cylinder. This is the // number of heads multiplied by the number of sectors per track. // sectorsPerCylinder = SectorsPerTrack * NumberOfTracks; // // Convert byte offset/count to sector offset/count. // tempInt.QuadPart = PartitionOffset->QuadPart >> ShiftCount; startSector = tempInt.LowPart; tempInt.QuadPart = PartitionLength->QuadPart >> ShiftCount; sectorCount = tempInt.LowPart; endSector = startSector + sectorCount - 1; startC = startSector / sectorsPerCylinder; endC = endSector / sectorsPerCylinder; if (!ConventionalCylinders) { ConventionalCylinders = 1024; } // // Set these values so that win95 is happy. // if (startC >= ConventionalCylinders) { startC = ConventionalCylinders - 1; } if (endC >= ConventionalCylinders) { endC = ConventionalCylinders - 1; } // // Calculate the starting track and sector. // remainder = startSector % sectorsPerCylinder; startH = remainder / SectorsPerTrack; startS = remainder % SectorsPerTrack; // // Calculate the ending track and sector. // remainder = endSector % sectorsPerCylinder; endH = remainder / SectorsPerTrack; endS = remainder % SectorsPerTrack; // // Pack the result into the caller's structure. // // low 8 bits of the cylinder => C value PartitionDescriptor->StartingCylinderMsb = (UCHAR) startC; PartitionDescriptor->EndingCylinderMsb = (UCHAR) endC; // 8 bits of head value => H value PartitionDescriptor->StartingTrack = (UCHAR) startH; PartitionDescriptor->EndingTrack = (UCHAR) endH; // bits 8-9 of cylinder and 6 bits of the sector => S value PartitionDescriptor->StartingCylinderLsb = (UCHAR) (((startS + 1) & 0x3f) | ((startC >> 2) & 0xc0)); PartitionDescriptor->EndingCylinderLsb = (UCHAR) (((endS + 1) & 0x3f) | ((endC >> 2) & 0xc0)); }

VOID HalpEnableAutomaticDriveLetterAssignment (   )

Definition at line 1022 of file drivesup.c. References Executive, FALSE, IoBuildDeviceIoControlRequest(), IoCallDriver, IoGetDeviceObjectPointer(), KeInitializeEvent, KernelMode, KeWaitForSingleObject(), NT_SUCCESS, NTSTATUS(), NULL, ObDereferenceObject, and RtlInitUnicodeString(). Referenced by xHalIoAssignDriveLetters(). : This routine enables automatic drive letter assignment by the mount point manager. Arguments: None. Return Value: None. --*/ { UNICODE_STRING name; PFILE_OBJECT fileObject; PDEVICE_OBJECT deviceObject; KEVENT event; PIRP irp; IO_STATUS_BLOCK ioStatus; NTSTATUS status; RtlInitUnicodeString(&name, MOUNTMGR_DEVICE_NAME); status = IoGetDeviceObjectPointer(&name, FILE_READ_ATTRIBUTES, &fileObject, &deviceObject); if (!NT_SUCCESS(status)) { return; } KeInitializeEvent(&event, NotificationEvent, FALSE); irp = IoBuildDeviceIoControlRequest(IOCTL_MOUNTMGR_AUTO_DL_ASSIGNMENTS, deviceObject, NULL, 0, NULL, 0, FALSE, &event, &ioStatus); if (!irp) { ObDereferenceObject(fileObject); return; } status = IoCallDriver(deviceObject, irp); if (status == STATUS_PENDING) { KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL); status = ioStatus.Status; } ObDereferenceObject(fileObject); }

NTSTATUS HalpGetFullGeometry (  IN PDEVICE_OBJECT  DeviceObject, IN PDISK_GEOMETRY  Geometry, OUT PULONGLONG  RealSectorCount )

Definition at line 3735 of file drivesup.c. References ExAllocatePoolWithTag, Executive, ExFreePool(), FALSE, IoBuildDeviceIoControlRequest(), IoCallDriver, KeInitializeEvent, KernelMode, KeWaitForSingleObject(), NonPagedPool, NT_SUCCESS, NTSTATUS(), NULL, PAGED_CODE, and VOID(). Referenced by xHalIoReadPartitionTable(). : We need this routine to get the number of cylinders that the disk driver thinks is on the drive. We will need this to calculate CHS values when we fill in the partition table entries. Arguments: DeviceObject - The device object describing the entire drive. Geometry - The geometry of the drive RealSectorCount - the actual number of sectors reported by the drive ( this may be less than the size computed by the geometry) Return Value: None. --*/ { PIRP localIrp; IO_STATUS_BLOCK iosb; PKEVENT eventPtr; NTSTATUS status; PAGED_CODE(); eventPtr = ExAllocatePoolWithTag( NonPagedPool, sizeof(KEVENT), 'btsF' ); if (!eventPtr) { return STATUS_INSUFFICIENT_RESOURCES; } KeInitializeEvent( eventPtr, NotificationEvent, FALSE ); localIrp = IoBuildDeviceIoControlRequest( IOCTL_DISK_GET_DRIVE_GEOMETRY, DeviceObject, NULL, 0UL, Geometry, sizeof(DISK_GEOMETRY), FALSE, eventPtr, &iosb ); if (!localIrp) { ExFreePool(eventPtr); return STATUS_INSUFFICIENT_RESOURCES; } // // Call the lower level driver, wait for the opertion // to finish. // status = IoCallDriver( DeviceObject, localIrp ); if (status == STATUS_PENDING) { (VOID) KeWaitForSingleObject( eventPtr, Executive, KernelMode, FALSE, (PLARGE_INTEGER) NULL ); status = iosb.Status; } if(NT_SUCCESS(status)) { PARTITION_INFORMATION partitionInfo; localIrp = IoBuildDeviceIoControlRequest( IOCTL_DISK_GET_PARTITION_INFO, DeviceObject, NULL, 0UL, &partitionInfo, sizeof(PARTITION_INFORMATION), FALSE, eventPtr, &iosb ); if (!localIrp) { ExFreePool(eventPtr); return STATUS_INSUFFICIENT_RESOURCES; } // // Call the lower level driver, wait for the opertion // to finish. // status = IoCallDriver( DeviceObject, localIrp ); if (status == STATUS_PENDING) { (VOID) KeWaitForSingleObject( eventPtr, Executive, KernelMode, FALSE, (PLARGE_INTEGER) NULL ); status = iosb.Status; } if(NT_SUCCESS(status)) { *RealSectorCount = (partitionInfo.PartitionLength.QuadPart / Geometry->BytesPerSector); } } ExFreePool(eventPtr); return status; }

BOOLEAN HalpIsOldStyleFloppy (  IN PUNICODE_STRING  DeviceName  )

Definition at line 1171 of file drivesup.c. References _FILE_OBJECT::DeviceObject, Executive, FALSE, IoBuildDeviceIoControlRequest(), IoCallDriver, IoGetAttachedDeviceReference(), IoGetDeviceObjectPointer(), KeInitializeEvent, KernelMode, KeWaitForSingleObject(), NT_SUCCESS, NTSTATUS(), NULL, ObDereferenceObject, PAGED_CODE, and TRUE. Referenced by xHalIoAssignDriveLetters(). : This routine determines whether or not the given device is an old style floppy. That is, a floppy controlled by a traditional floppy controller. These floppies have precedent in the drive letter ordering. Arguments: DeviceName - Supplies the device name. Return Value: FALSE - The given device is not an old style floppy. TRUE - The given device is an old style floppy. --*/ { PFILE_OBJECT fileObject; PDEVICE_OBJECT deviceObject; KEVENT event; PIRP irp; MOUNTDEV_NAME name; IO_STATUS_BLOCK ioStatus; NTSTATUS status; PAGED_CODE(); status = IoGetDeviceObjectPointer(DeviceName, FILE_READ_ATTRIBUTES, &fileObject, &deviceObject); if (!NT_SUCCESS(status)) { return FALSE; } deviceObject = IoGetAttachedDeviceReference(fileObject->DeviceObject); ObDereferenceObject(fileObject); KeInitializeEvent(&event, NotificationEvent, FALSE); irp = IoBuildDeviceIoControlRequest(IOCTL_MOUNTDEV_QUERY_DEVICE_NAME, deviceObject, NULL, 0, &name, sizeof(name), FALSE, &event, &ioStatus); if (!irp) { ObDereferenceObject(deviceObject); return FALSE; } status = IoCallDriver(deviceObject, irp); if (status == STATUS_PENDING) { KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL); status = ioStatus.Status; } ObDereferenceObject(deviceObject); if (status == STATUS_BUFFER_OVERFLOW) { return FALSE; } return TRUE; }

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

Definition at line 3425 of file drivesup.c. References DebugPrint, FALSE, GET_PARTITION_LENGTH, GET_STARTING_SECTOR, PAGED_CODE, _PARTITION_DESCRIPTOR::PartitionType, and TRUE. Referenced by xHalIoReadPartitionTable(). { ULONGLONG endingSector; PAGED_CODE(); if(Entry->PartitionType == PARTITION_ENTRY_UNUSED) { // // Unused partition entries are always valid. // return TRUE; } // // Container partition entries and normal partition entries are valid iff // the partition they describe can possibly fit on the disk. We add // the base sector, the sector offset of the partition and the partition // length. If they exceed the sector count then this partition entry // is considered invalid. // endingSector = GET_STARTING_SECTOR(Entry) + GET_PARTITION_LENGTH(Entry); if(endingSector > MaxSector) { DebugPrint((1, "HalpIsValidPartitionEntry: entry is invalid\n")); DebugPrint((1, "\tHalpIsValidPartitionEntry: offset %#08lx\n", GET_STARTING_SECTOR(Entry))); DebugPrint((1, "\tHalpIsValidPartitionEntry: length %#08lx\n", GET_PARTITION_LENGTH(Entry))); DebugPrint((1, "\tHalpIsValidPartitionEntry: end %#I64x\n", endingSector)); DebugPrint((1, "\tHalpIsValidPartitionEntry: max %#I64x\n", MaxSector)); return FALSE; } else if(GET_STARTING_SECTOR(Entry) > MaxOffset) { DebugPrint((1, "HalpIsValidPartitionEntry: entry is invalid\n")); DebugPrint((1, "\tHalpIsValidPartitionEntry: offset %#08lx\n", GET_STARTING_SECTOR(Entry))); DebugPrint((1, "\tHalpIsValidPartitionEntry: length %#08lx\n", GET_PARTITION_LENGTH(Entry))); DebugPrint((1, "\tHalpIsValidPartitionEntry: end %#I64x\n", endingSector)); DebugPrint((1, "\tHalpIsValidPartitionEntry: maxOffset %#I64x\n", MaxOffset)); return FALSE; } return TRUE; }

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

Definition at line 934 of file drivesup.c. References HalpNextMountLetter(), HalpSetMountLetter(), IoCreateSymbolicLink(), L, NT_SUCCESS, NTSTATUS(), RtlAnsiStringToUnicodeString(), RtlEqualUnicodeString(), RtlFreeUnicodeString(), RtlInitUnicodeString(), RtlPrefixUnicodeString(), and TRUE. Referenced by xHalIoAssignDriveLetters(). : This routine gives the device the next available drive letter. Arguments: DeviceName - Supplies the device name. NtDeviceName - Supplies the NT device name. NtSystemPath - Supplies the NT system path. Return Value: The drive letter assigned or 0. --*/ { NTSTATUS status; UCHAR firstDriveLetter, driveLetter; WCHAR name[40]; UNICODE_STRING symName; UNICODE_STRING unicodeString, floppyPrefix, cdromPrefix; status = HalpNextMountLetter(DeviceName, &driveLetter); if (NT_SUCCESS(status)) { return driveLetter; } if (!NtDeviceName || !NtSystemPath) { return 0xFF; } RtlInitUnicodeString(&floppyPrefix, L"\\Device\\Floppy"); RtlInitUnicodeString(&cdromPrefix, L"\\Device\\CdRom"); if (RtlPrefixUnicodeString(&floppyPrefix, DeviceName, TRUE)) { firstDriveLetter = 'A'; } else if (RtlPrefixUnicodeString(&cdromPrefix, DeviceName, TRUE)) { firstDriveLetter = 'D'; } else { firstDriveLetter = 'C'; } for (driveLetter = firstDriveLetter; driveLetter <= 'Z'; driveLetter++) { status = HalpSetMountLetter(DeviceName, driveLetter); if (NT_SUCCESS(status)) { RtlAnsiStringToUnicodeString(&unicodeString, NtDeviceName, TRUE); if (RtlEqualUnicodeString(&unicodeString, DeviceName, TRUE)) { NtSystemPath[0] = driveLetter; } RtlFreeUnicodeString(&unicodeString); return driveLetter; } } if (!UseHardLinksIfNecessary) { return 0; } for (driveLetter = firstDriveLetter; driveLetter <= 'Z'; driveLetter++) { swprintf(name, L"\\DosDevices\\%c:", driveLetter); RtlInitUnicodeString(&symName, name); status = IoCreateSymbolicLink(&symName, DeviceName); if (NT_SUCCESS(status)) { RtlAnsiStringToUnicodeString(&unicodeString, NtDeviceName, TRUE); if (RtlEqualUnicodeString(&unicodeString, DeviceName, TRUE)) { NtSystemPath[0] = driveLetter; } RtlFreeUnicodeString(&unicodeString); return driveLetter; } } return 0; }

NTSTATUS HalpNextMountLetter (  IN PUNICODE_STRING  DeviceName, OUT PUCHAR  DriveLetter )

Definition at line 851 of file drivesup.c. References ExAllocatePoolWithTag, Executive, ExFreePool(), FALSE, IoBuildDeviceIoControlRequest(), IoCallDriver, IoGetDeviceObjectPointer(), KeInitializeEvent, KernelMode, KeWaitForSingleObject(), NT_SUCCESS, NTSTATUS(), NULL, ObDereferenceObject, PagedPool, and RtlInitUnicodeString(). Referenced by HalpNextDriveLetter(). 00858 : 00859 00860 This routine gives the device the next available drive letter. 00861 00862 Arguments: 00863 00864 DeviceName - Supplies the device name. 00865 00866 DriveLetter - Returns the drive letter assigned or 0. 00867 00868 Return Value: 00869 00870 NTSTATUS 00871 00872 --*/ 00873 00874 { 00875 UNICODE_STRING name; 00876 PFILE_OBJECT fileObject; 00877 PDEVICE_OBJECT deviceObject; 00878 PMOUNTMGR_DRIVE_LETTER_TARGET input; 00879 KEVENT event; 00880 PIRP irp; 00881 MOUNTMGR_DRIVE_LETTER_INFORMATION output; 00882 IO_STATUS_BLOCK ioStatus; 00883 NTSTATUS status; 00884 00885 RtlInitUnicodeString(&name, MOUNTMGR_DEVICE_NAME); 00886 status = IoGetDeviceObjectPointer(&name, FILE_READ_ATTRIBUTES, &fileObject, 00887 &deviceObject); 00888 if (!NT_SUCCESS(status)) { 00889 return status; 00890 } 00891 00892 input = ExAllocatePoolWithTag(PagedPool, 00893 (sizeof(MOUNTMGR_DRIVE_LETTER_TARGET) + 00894 DeviceName->Length), 00895 'btsF' 00896 ); 00897 00898 if (!input) { 00899 ObDereferenceObject(fileObject); 00900 return STATUS_INSUFFICIENT_RESOURCES; 00901 } 00902 00903 input->DeviceNameLength = DeviceName->Length; 00904 RtlCopyMemory(input->DeviceName, DeviceName->Buffer, DeviceName->Length); 00905 00906 KeInitializeEvent(&event, NotificationEvent, FALSE); 00907 irp = IoBuildDeviceIoControlRequest(IOCTL_MOUNTMGR_NEXT_DRIVE_LETTER, 00908 deviceObject, input, 00909 sizeof(MOUNTMGR_DRIVE_LETTER_TARGET) + 00910 DeviceName->Length, &output, 00911 sizeof(output), FALSE, &event, 00912 &ioStatus); 00913 if (!irp) { 00914 ExFreePool(input); 00915 ObDereferenceObject(fileObject); 00916 return STATUS_INSUFFICIENT_RESOURCES; 00917 } 00918 00919 status = IoCallDriver(deviceObject, irp); 00920 if (status == STATUS_PENDING) { 00921 KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL); 00922 status = ioStatus.Status; 00923 } 00924 00925 ExFreePool(input); 00926 ObDereferenceObject(fileObject); 00927 00928 *DriveLetter = output.CurrentDriveLetter; 00929 00930 return status; 00931 }

NTSTATUS HalpQueryDriveLayout (  IN PUNICODE_STRING  DeviceName, OUT PDRIVE_LAYOUT_INFORMATION *  DriveLayout )

Definition at line 792 of file drivesup.c. References _DEVICE_OBJECT::Characteristics, _FILE_OBJECT::DeviceObject, Executive, FALSE, IoBuildDeviceIoControlRequest(), IoCallDriver, IoGetAttachedDeviceReference(), IoGetDeviceObjectPointer(), IoReadPartitionTable(), KeInitializeEvent, KernelMode, KeWaitForSingleObject(), NT_SUCCESS, NTSTATUS(), NULL, and ObDereferenceObject. Referenced by xHalIoAssignDriveLetters(). { NTSTATUS status; PFILE_OBJECT fileObject; PDEVICE_OBJECT deviceObject; KEVENT event; PIRP irp; DISK_GEOMETRY geometry; IO_STATUS_BLOCK ioStatus; status = IoGetDeviceObjectPointer(DeviceName, FILE_READ_ATTRIBUTES, &fileObject, &deviceObject); if (!NT_SUCCESS(status)) { return status; } deviceObject = IoGetAttachedDeviceReference(fileObject->DeviceObject); ObDereferenceObject(fileObject); if (deviceObject->Characteristics&FILE_REMOVABLE_MEDIA) { ObDereferenceObject(deviceObject); return STATUS_NO_MEDIA; } KeInitializeEvent(&event, NotificationEvent, FALSE); irp = IoBuildDeviceIoControlRequest(IOCTL_DISK_GET_DRIVE_GEOMETRY, deviceObject, NULL, 0, &geometry, sizeof(geometry), FALSE, &event, &ioStatus); if (!irp) { ObDereferenceObject(deviceObject); return STATUS_INSUFFICIENT_RESOURCES; } status = IoCallDriver(deviceObject, irp); if (status == STATUS_PENDING) { KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL); status = ioStatus.Status; } if (!NT_SUCCESS(status)) { ObDereferenceObject(deviceObject); return status; } status = IoReadPartitionTable(deviceObject, geometry.BytesPerSector, FALSE, DriveLayout); ObDereferenceObject(deviceObject); return status; }

NTSTATUS HalpQueryPartitionType (  IN PUNICODE_STRING  DeviceName, IN PDRIVE_LAYOUT_INFORMATION  DriveLayout, OUT PULONG  PartitionType )

Definition at line 706 of file drivesup.c. References BOOTABLE_PARTITION, _DEVICE_OBJECT::Characteristics, _FILE_OBJECT::DeviceObject, Executive, FALSE, FT_PARTITION, IoBuildDeviceIoControlRequest(), IoCallDriver, IoGetAttachedDeviceReference(), IoGetDeviceObjectPointer(), KeInitializeEvent, KernelMode, KeWaitForSingleObject(), LOGICAL_PARTITION, NT_SUCCESS, NTSTATUS(), NULL, ObDereferenceObject, OTHER_PARTITION, and PRIMARY_PARTITION. Referenced by xHalIoAssignDriveLetters(). { NTSTATUS status; PFILE_OBJECT fileObject; PDEVICE_OBJECT deviceObject; KEVENT event; PIRP irp; PARTITION_INFORMATION partInfo; IO_STATUS_BLOCK ioStatus; ULONG i; status = IoGetDeviceObjectPointer(DeviceName, FILE_READ_ATTRIBUTES, &fileObject, &deviceObject); if (!NT_SUCCESS(status)) { return status; } deviceObject = IoGetAttachedDeviceReference(fileObject->DeviceObject); ObDereferenceObject(fileObject); if ((deviceObject->Characteristics&FILE_REMOVABLE_MEDIA) || !DriveLayout) { ObDereferenceObject(deviceObject); *PartitionType = LOGICAL_PARTITION; return STATUS_SUCCESS; } KeInitializeEvent(&event, NotificationEvent, FALSE); irp = IoBuildDeviceIoControlRequest(IOCTL_DISK_GET_PARTITION_INFO, deviceObject, NULL, 0, &partInfo, sizeof(partInfo), FALSE, &event, &ioStatus); if (!irp) { ObDereferenceObject(deviceObject); return STATUS_INSUFFICIENT_RESOURCES; } status = IoCallDriver(deviceObject, irp); if (status == STATUS_PENDING) { KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL); status = ioStatus.Status; } ObDereferenceObject(deviceObject); if (!NT_SUCCESS(status)) { return status; } if (!IsRecognizedPartition(partInfo.PartitionType)) { *PartitionType = OTHER_PARTITION; return STATUS_SUCCESS; } if (partInfo.PartitionType&0x80) { *PartitionType = FT_PARTITION; return STATUS_SUCCESS; } for (i = 0; i < 4; i++) { if (partInfo.StartingOffset.QuadPart == DriveLayout->PartitionEntry[i].StartingOffset.QuadPart) { if (partInfo.BootIndicator) { *PartitionType = BOOTABLE_PARTITION; } else { *PartitionType = PRIMARY_PARTITION; } return STATUS_SUCCESS; } } *PartitionType = LOGICAL_PARTITION; return STATUS_SUCCESS; }

NTSTATUS HalpSetMountLetter (  IN PUNICODE_STRING  DeviceName, IN UCHAR  DriveLetter )

Definition at line 1078 of file drivesup.c. References ExAllocatePoolWithTag, Executive, ExFreePool(), FALSE, IoBuildDeviceIoControlRequest(), IoCallDriver, IoGetDeviceObjectPointer(), KeInitializeEvent, KernelMode, KeWaitForSingleObject(), L, NT_SUCCESS, NTSTATUS(), NULL, ObDereferenceObject, PagedPool, and RtlInitUnicodeString(). Referenced by HalpNextDriveLetter(), and xHalIoAssignDriveLetters(). : This routine sets the drive letter for the given device. Arguments: DeviceName - Supplies the device name. DriveLetter - Supplies the drive letter. Return Value: NTSTATUS --*/ { WCHAR dosBuffer[30]; UNICODE_STRING dosName; ULONG createPointSize; PMOUNTMGR_CREATE_POINT_INPUT createPoint; UNICODE_STRING name; NTSTATUS status; PFILE_OBJECT fileObject; PDEVICE_OBJECT deviceObject; KEVENT event; PIRP irp; IO_STATUS_BLOCK ioStatus; swprintf(dosBuffer, L"\\DosDevices\\%c:", DriveLetter); RtlInitUnicodeString(&dosName, dosBuffer); createPointSize = sizeof(MOUNTMGR_CREATE_POINT_INPUT) + dosName.Length + DeviceName->Length; createPoint = (PMOUNTMGR_CREATE_POINT_INPUT) ExAllocatePoolWithTag(PagedPool, createPointSize, 'btsF'); if (!createPoint) { return STATUS_INSUFFICIENT_RESOURCES; } createPoint->SymbolicLinkNameOffset = sizeof(MOUNTMGR_CREATE_POINT_INPUT); createPoint->SymbolicLinkNameLength = dosName.Length; createPoint->DeviceNameOffset = createPoint->SymbolicLinkNameOffset + createPoint->SymbolicLinkNameLength; createPoint->DeviceNameLength = DeviceName->Length; RtlCopyMemory((PCHAR) createPoint + createPoint->SymbolicLinkNameOffset, dosName.Buffer, dosName.Length); RtlCopyMemory((PCHAR) createPoint + createPoint->DeviceNameOffset, DeviceName->Buffer, DeviceName->Length); RtlInitUnicodeString(&name, MOUNTMGR_DEVICE_NAME); status = IoGetDeviceObjectPointer(&name, FILE_READ_ATTRIBUTES, &fileObject, &deviceObject); if (!NT_SUCCESS(status)) { ExFreePool(createPoint); return status; } KeInitializeEvent(&event, NotificationEvent, FALSE); irp = IoBuildDeviceIoControlRequest(IOCTL_MOUNTMGR_CREATE_POINT, deviceObject, createPoint, createPointSize, NULL, 0, FALSE, &event, &ioStatus); if (!irp) { ObDereferenceObject(fileObject); ExFreePool(createPoint); return STATUS_INSUFFICIENT_RESOURCES; } status = IoCallDriver(deviceObject, irp); if (status == STATUS_PENDING) { KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL); status = ioStatus.Status; } ObDereferenceObject(fileObject); ExFreePool(createPoint); return status; }

VOID FASTCALL xHalExamineMBR (  IN PDEVICE_OBJECT  DeviceObject, IN ULONG  SectorSize, IN ULONG  MBRTypeIdentifier, OUT PVOID *  Buffer )

Definition at line 190 of file drivesup.c. References ASSERT, BOOT_RECORD_SIGNATURE, BOOT_SIGNATURE_OFFSET, Buffer, ExAllocatePoolWithTag, Executive, ExFreePool(), FALSE, _IO_STACK_LOCATION::Flags, IoBuildSynchronousFsdRequest(), IoCallDriver, IoGetNextIrpStackLocation, IRP_MJ_READ, KeInitializeEvent, KernelMode, KeWaitForSingleObject(), NonPagedPoolCacheAligned, NT_SUCCESS, NTSTATUS(), NULL, PAGE_SIZE, PARTITION_TABLE_OFFSET, _PARTITION_DESCRIPTOR::PartitionType, PUSHORT, SectorSize, SL_OVERRIDE_VERIFY_VOLUME, and VOID(). 00199 : 00200 00201 Given a master boot record type (MBR - the zero'th sector on the disk), 00202 read the master boot record of a disk. If the MBR is found to be of that 00203 type, allocate a structure whose layout is dependant upon that partition 00204 type, fill with the appropriate values, and return a pointer to that buffer 00205 in the output parameter. 00206 00207 The best example for a use of this routine is to support Ontrack 00208 systems DiskManager software. Ontrack software lays down a special 00209 partition describing the entire drive. The special partition type 00210 (0x54) will be recognized and a couple of longwords of data will 00211 be passed back in a buffer for a disk driver to act upon. 00212 00213 Arguments: 00214 00215 DeviceObject - The device object describing the entire drive. 00216 00217 SectorSize - The minimum number of bytes that an IO operation can 00218 fetch. 00219 00220 MBRIndentifier - A value that will be searched for in the 00221 in the MBR. This routine will understand 00222 the semantics implied by this value. 00223 00224 Buffer - Pointer to a buffer that returns data according to the 00225 type of MBR searched for. If the MBR is not of the 00226 type asked for, the buffer will not be allocated and this 00227 pointer will be NULL. It is the responsibility of the 00228 caller of HalExamineMBR to deallocate the buffer. The 00229 caller should deallocate the memory ASAP. 00230 00231 Return Value: 00232 00233 None. 00234 00235 --*/ 00236 00237 { 00238 00239 00240 LARGE_INTEGER partitionTableOffset; 00241 PUCHAR readBuffer = (PUCHAR) NULL; 00242 KEVENT event; 00243 IO_STATUS_BLOCK ioStatus; 00244 PIRP irp; 00245 PPARTITION_DESCRIPTOR partitionTableEntry; 00246 NTSTATUS status = STATUS_SUCCESS; 00247 ULONG readSize; 00248 00249 *Buffer = NULL; 00250 // 00251 // Determine the size of a read operation to ensure that at least 512 00252 // bytes are read. This will guarantee that enough data is read to 00253 // include an entire partition table. Note that this code assumes that 00254 // the actual sector size of the disk (if less than 512 bytes) is a 00255 // multiple of 2, a fairly reasonable assumption. 00256 // 00257 00258 if (SectorSize >= 512) { 00259 readSize = SectorSize; 00260 } else { 00261 readSize = 512; 00262 } 00263 00264 // 00265 // Start at sector 0 of the device. 00266 // 00267 00268 partitionTableOffset = RtlConvertUlongToLargeInteger( 0 ); 00269 00270 // 00271 // Allocate a buffer that will hold the reads. 00272 // 00273 00274 readBuffer = ExAllocatePoolWithTag( 00275 NonPagedPoolCacheAligned, 00276 PAGE_SIZE>readSize?PAGE_SIZE:readSize, 00277 'btsF' 00278 ); 00279 00280 if (readBuffer == NULL) { 00281 return; 00282 } 00283 00284 // 00285 // Read record containing partition table. 00286 // 00287 // Create a notification event object to be used while waiting for 00288 // the read request to complete. 00289 // 00290 00291 KeInitializeEvent( &event, NotificationEvent, FALSE ); 00292 00293 irp = IoBuildSynchronousFsdRequest( IRP_MJ_READ, 00294 DeviceObject, 00295 readBuffer, 00296 readSize, 00297 &partitionTableOffset, 00298 &event, 00299 &ioStatus ); 00300 00301 if (!irp) { 00302 ExFreePool(readBuffer); 00303 return; 00304 } else { 00305 PIO_STACK_LOCATION irpStack; 00306 irpStack = IoGetNextIrpStackLocation(irp); 00307 irpStack->Flags |= SL_OVERRIDE_VERIFY_VOLUME; 00308 } 00309 00310 status = IoCallDriver( DeviceObject, irp ); 00311 00312 if (status == STATUS_PENDING) { 00313 (VOID) KeWaitForSingleObject( &event, 00314 Executive, 00315 KernelMode, 00316 FALSE, 00317 (PLARGE_INTEGER) NULL); 00318 status = ioStatus.Status; 00319 } 00320 00321 if (!NT_SUCCESS( status )) { 00322 ExFreePool(readBuffer); 00323 return; 00324 } 00325 00326 // 00327 // Check for Boot Record signature. 00328 // 00329 00330 if (((PUSHORT) readBuffer)[BOOT_SIGNATURE_OFFSET] != BOOT_RECORD_SIGNATURE) { 00331 ExFreePool(readBuffer); 00332 return; 00333 } 00334 00335 // 00336 // Check for DM type partition. 00337 // 00338 00339 partitionTableEntry = (PPARTITION_DESCRIPTOR) &(((PUSHORT) readBuffer)[PARTITION_TABLE_OFFSET]); 00340 00341 if (partitionTableEntry->PartitionType != MBRTypeIdentifier) { 00342 00343 // 00344 // The partition type isn't what the caller cares about. 00345 // 00346 ExFreePool(readBuffer); 00347 00348 } else { 00349 00350 if (partitionTableEntry->PartitionType == 0x54) { 00351 00352 // 00353 // Rather than allocate a new piece of memory to return 00354 // the data - just use the memory allocated for the buffer. 00355 // We can assume the caller will delete this shortly. 00356 // 00357 00358 ((PULONG)readBuffer)[0] = 63; 00359 *Buffer = readBuffer; 00360 00361 } else if (partitionTableEntry->PartitionType == 0x55) { 00362 00363 // 00364 // EzDrive Parititon. Simply return the pointer to non-null 00365 // There is no skewing here. 00366 // 00367 00368 *Buffer = readBuffer; 00369 00370 } else { 00371 00372 ASSERT(partitionTableEntry->PartitionType == 0x55); 00373 00374 } 00375 00376 } 00377 00378 }

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

Definition at line 382 of file drivesup.c. References ExAllocatePoolWithTag, Executive, ExFreePool(), FALSE, IoBuildDeviceIoControlRequest(), IoCallDriver, KeInitializeEvent, KernelMode, KeWaitForSingleObject(), NonPagedPool, NT_SUCCESS, NTSTATUS(), NULL, and VOID(). Referenced by xHalIoClearPartitionTable(), and xHalIoWritePartitionTable(). : We need this routine to get the number of cylinders that the disk driver thinks is on the drive. We will need this to calculate CHS values when we fill in the partition table entries. Arguments: DeviceObject - The device object describing the entire drive. ConventionalCylinders - Number of cylinders on the drive. Return Value: None. --*/ { PIRP localIrp; PDISK_GEOMETRY diskGeometry; PIO_STATUS_BLOCK iosb; PKEVENT eventPtr; NTSTATUS status; *ConventionalCylinders = 0UL; *DiskSize = 0UL; diskGeometry = ExAllocatePoolWithTag( NonPagedPool, sizeof(DISK_GEOMETRY), 'btsF' ); if (!diskGeometry) { return; } iosb = ExAllocatePoolWithTag( NonPagedPool, sizeof(IO_STATUS_BLOCK), 'btsF' ); if (!iosb) { ExFreePool(diskGeometry); return; } eventPtr = ExAllocatePoolWithTag( NonPagedPool, sizeof(KEVENT), 'btsF' ); if (!eventPtr) { ExFreePool(iosb); ExFreePool(diskGeometry); return; } KeInitializeEvent( eventPtr, NotificationEvent, FALSE ); localIrp = IoBuildDeviceIoControlRequest( IOCTL_DISK_GET_DRIVE_GEOMETRY, DeviceObject, NULL, 0UL, diskGeometry, sizeof(DISK_GEOMETRY), FALSE, eventPtr, iosb ); if (!localIrp) { ExFreePool(eventPtr); ExFreePool(iosb); ExFreePool(diskGeometry); return; } // // Call the lower level driver, wait for the opertion // to finish. // status = IoCallDriver( DeviceObject, localIrp ); if (status == STATUS_PENDING) { (VOID) KeWaitForSingleObject( eventPtr, Executive, KernelMode, FALSE, (PLARGE_INTEGER) NULL ); status = iosb->Status; } if (NT_SUCCESS(status)) { // // The operation completed successfully. Get the cylinder // count of the drive. // *ConventionalCylinders = diskGeometry->Cylinders.LowPart; // // If the count is less than 1024 we can pass that back. Otherwise // send back the 1024 // if (diskGeometry->Cylinders.QuadPart >= (LONGLONG)1024) { *ConventionalCylinders = 1024; } // // Calculate disk size from gemotry information // *DiskSize = diskGeometry->Cylinders.QuadPart * diskGeometry->TracksPerCylinder * diskGeometry->SectorsPerTrack * diskGeometry->BytesPerSector; } ExFreePool(eventPtr); ExFreePool(iosb); ExFreePool(diskGeometry); return; }

VOID FASTCALL xHalIoAssignDriveLetters (  IN struct _LOADER_PARAMETER_BLOCK *  LoaderBlock, IN PSTRING  NtDeviceName, OUT PUCHAR  NtSystemPath, OUT PSTRING  NtSystemPathString )

Definition at line 1243 of file drivesup.c. References BOOTABLE_PARTITION, _CONFIGURATION_INFORMATION::CdRomCount, DbgPrint, _CONFIGURATION_INFORMATION::DiskCount, DiskPartitionName, ExAllocatePoolWithTag, ExFreePool(), FALSE, _CONFIGURATION_INFORMATION::FloppyCount, FT_PARTITION, HalpEnableAutomaticDriveLetterAssignment(), HalpIsOldStyleFloppy(), HalpNextDriveLetter(), HalpQueryDriveLayout(), HalpQueryPartitionType(), HalpSetMountLetter(), IoCreateSymbolicLink(), IoGetConfigurationInformation(), IoRemoteBootClient, KeBugCheck(), L, LOGICAL_PARTITION, NonPagedPool, NT_SUCCESS, NTSTATUS(), NULL, PAGED_CODE, PCONFIGURATION_INFORMATION, PRIMARY_PARTITION, RtlAnsiStringToUnicodeString(), RtlFreeUnicodeString(), RtlInitAnsiString(), RtlInitString(), RtlInitUnicodeString(), RtlPrefixUnicodeString(), SETUPBLK_FLAGS_REMOTE_INSTALL, SETUPBLK_FLAGS_SYSPREP_INSTALL, sprintf(), strlen(), TRUE, and ZwOpenFile(). : This routine assigns DOS drive letters to eligible disk partitions and CDROM drives. It also maps the partition containing the NT boot path to \SystemRoot. In NT, objects are built for all partition types except 0 (unused) and 5 (extended). But drive letters are assigned only to recognized partition types (1, 4, 6, 7, e). Drive letter assignment is done in several stages: 1) For each CdRom: Determine if sticky letters are assigned and reserve the letter. 2) For each disk: Determine how many primary partitions and which is bootable. Determine which partitions already have 'sticky letters' and create their symbolic links. Create a bit map for each disk that idicates which partitions require default drive letter assignments. 3) For each disk: Assign default drive letters for the bootable primary partition or the first nonbootable primary partition. 4) For each disk: Assign default drive letters for the partitions in extended volumes. 5) For each disk: Assign default drive letters for the remaining (ENHANCED) primary partitions. 6) Assign A: and B: to the first two floppies in the system if they exist. Then assign remaining floppies next available drive letters. 7) Assign drive letters to CdRoms (either sticky or default). Arguments: LoaderBlock - pointer to a loader parameter block. NtDeviceName - pointer to the boot device name string used to resolve NtSystemPath. Return Value: None. --*/ { PUCHAR ntName; STRING ansiString; UNICODE_STRING unicodeString; PUCHAR ntPhysicalName; STRING ansiPhysicalString; UNICODE_STRING unicodePhysicalString; NTSTATUS status; OBJECT_ATTRIBUTES objectAttributes; PCONFIGURATION_INFORMATION configurationInformation; ULONG diskCount; ULONG floppyCount; HANDLE deviceHandle; IO_STATUS_BLOCK ioStatusBlock; ULONG diskNumber; ULONG i, j; UCHAR driveLetter; WCHAR deviceNameBuffer[50]; UNICODE_STRING deviceName, floppyPrefix, cdromPrefix; PDRIVE_LAYOUT_INFORMATION layout; BOOLEAN bootable; ULONG partitionType; ULONG skip; ULONG diskCountIncrement; ULONG actualDiskCount = 0; PAGED_CODE(); // // Get the count of devices from the registry. // configurationInformation = IoGetConfigurationInformation(); diskCount = configurationInformation->DiskCount; floppyCount = configurationInformation->FloppyCount; // // Allocate general NT name buffer. // ntName = ExAllocatePoolWithTag( NonPagedPool, 128, 'btsF'); ntPhysicalName = ExAllocatePoolWithTag( NonPagedPool, 64, 'btsF'); if (ntName == NULL || ntPhysicalName == NULL) { KeBugCheck( ASSIGN_DRIVE_LETTERS_FAILED ); } // // If we're doing a remote boot, set NtSystemPath appropriately. // if (IoRemoteBootClient) { PUCHAR p; PUCHAR q; // // If this is a remote boot setup boot, NtBootPathName is of the // form <server><share>\setup<install-directory><platform>. // We want the root of the X: drive to be the root of the install // directory. // // If this is a normal remote boot, NtBootPathName is of the form // <server><share>\images<machine>\winnt. We want the root of // the X: drive to be the root of the machine directory. // // Thus in either case, we need to remove all but the last element // of the path. // // Find the beginning of the last element of the path (including // the leading backslash). // p = strrchr( LoaderBlock->NtBootPathName, '\\' ); // find last separator q = NULL; if ( (p != NULL) && (*(p+1) == 0) ) { // // NtBootPathName ends with a backslash, so we need to back up // to the previous backslash. // q = p; *q = 0; p = strrchr( LoaderBlock->NtBootPathName, '\\' ); // find last separator *q = '\\'; } if ( p == NULL ) { KeBugCheck( ASSIGN_DRIVE_LETTERS_FAILED ); } // // Set NtSystemPath to X:<last element of path>. Note that the symbolic // link for X: is created in io\ioinit.c\IopInitializeBootDrivers. // // Note that we use X: for the textmode setup phase of a remote // installation. But for a true remote boot, we use C:. // #if defined(REMOTE_BOOT) if ((LoaderBlock->SetupLoaderBlock->Flags & (SETUPBLK_FLAGS_REMOTE_INSTALL | SETUPBLK_FLAGS_SYSPREP_INSTALL)) == 0) { NtSystemPath[0] = 'C'; } else #endif { NtSystemPath[0] = 'X'; } NtSystemPath[1] = ':'; strcpy(&NtSystemPath[2], p ); if ( q != NULL ) { NtSystemPath[strlen(NtSystemPath)-1] = '\0'; // remove trailing backslash } RtlInitString(NtSystemPathString, NtSystemPath); } // // For each disk ... // diskCountIncrement = 0; for (diskNumber = 0; diskNumber < diskCount; diskNumber++) { // // Create ANSI name string for physical disk. // sprintf( ntName, DiskPartitionName, diskNumber, 0 ); // // Convert to unicode string. // RtlInitAnsiString( &ansiString, ntName ); RtlAnsiStringToUnicodeString( &unicodeString, &ansiString, TRUE ); InitializeObjectAttributes( &objectAttributes, &unicodeString, OBJ_CASE_INSENSITIVE, NULL, NULL ); // // Open device by name. // status = ZwOpenFile( &deviceHandle, FILE_READ_DATA | SYNCHRONIZE, &objectAttributes, &ioStatusBlock, FILE_SHARE_READ, FILE_SYNCHRONOUS_IO_NONALERT ); if (NT_SUCCESS( status )) { // // The device was successfully opened. Generate a DOS device name // for the drive itself. // sprintf( ntPhysicalName, "\\DosDevices\\PhysicalDrive%d", diskNumber ); RtlInitAnsiString( &ansiPhysicalString, ntPhysicalName ); RtlAnsiStringToUnicodeString( &unicodePhysicalString, &ansiPhysicalString, TRUE ); IoCreateSymbolicLink( &unicodePhysicalString, &unicodeString ); RtlFreeUnicodeString( &unicodePhysicalString ); ZwClose(deviceHandle); actualDiskCount = diskNumber + 1; } RtlFreeUnicodeString( &unicodeString ); if (!NT_SUCCESS( status )) { #if DBG DbgPrint( "IoAssignDriveLetters: Failed to open %s\n", ntName ); #endif // DBG // // This may be a sparse name space. Try going farther but // not forever. // if (diskCountIncrement < 50) { diskCountIncrement++; diskCount++; } } } // end for diskNumber ... ExFreePool( ntName ); ExFreePool( ntPhysicalName ); diskCount -= diskCountIncrement; if (actualDiskCount > diskCount) { diskCount = actualDiskCount; } for (i = 0; i < diskCount; i++) { swprintf(deviceNameBuffer, L"\\Device\\Harddisk%d\\Partition0", i); RtlInitUnicodeString(&deviceName, deviceNameBuffer); status = HalpQueryDriveLayout(&deviceName, &layout); if (!NT_SUCCESS(status)) { layout = NULL; } bootable = FALSE; for (j = 1; ; j++) { swprintf(deviceNameBuffer, L"\\Device\\Harddisk%d\\Partition%d", i, j); RtlInitUnicodeString(&deviceName, deviceNameBuffer); status = HalpQueryPartitionType(&deviceName, layout, &partitionType); if (!NT_SUCCESS(status)) { break; } if (partitionType != BOOTABLE_PARTITION) { continue; } bootable = TRUE; HalpNextDriveLetter(&deviceName, NtDeviceName, NtSystemPath, FALSE); break; } if (bootable) { if (layout) { ExFreePool(layout); } continue; } for (j = 1; ; j++) { swprintf(deviceNameBuffer, L"\\Device\\Harddisk%d\\Partition%d", i, j); RtlInitUnicodeString(&deviceName, deviceNameBuffer); status = HalpQueryPartitionType(&deviceName, layout, &partitionType); if (!NT_SUCCESS(status)) { break; } if (partitionType != PRIMARY_PARTITION) { continue; } HalpNextDriveLetter(&deviceName, NtDeviceName, NtSystemPath, FALSE); break; } if (layout) { ExFreePool(layout); } } for (i = 0; i < diskCount; i++) { swprintf(deviceNameBuffer, L"\\Device\\Harddisk%d\\Partition0", i); RtlInitUnicodeString(&deviceName, deviceNameBuffer); status = HalpQueryDriveLayout(&deviceName, &layout); if (!NT_SUCCESS(status)) { layout = NULL; } for (j = 1; ; j++) { swprintf(deviceNameBuffer, L"\\Device\\Harddisk%d\\Partition%d", i, j); RtlInitUnicodeString(&deviceName, deviceNameBuffer); status = HalpQueryPartitionType(&deviceName, layout, &partitionType); if (!NT_SUCCESS(status)) { break; } if (partitionType != LOGICAL_PARTITION) { continue; } HalpNextDriveLetter(&deviceName, NtDeviceName, NtSystemPath, FALSE); } if (layout) { ExFreePool(layout); } } for (i = 0; i < diskCount; i++) { swprintf(deviceNameBuffer, L"\\Device\\Harddisk%d\\Partition0", i); RtlInitUnicodeString(&deviceName, deviceNameBuffer); status = HalpQueryDriveLayout(&deviceName, &layout); if (!NT_SUCCESS(status)) { layout = NULL; } skip = 0; for (j = 1; ; j++) { swprintf(deviceNameBuffer, L"\\Device\\Harddisk%d\\Partition%d", i, j); RtlInitUnicodeString(&deviceName, deviceNameBuffer); status = HalpQueryPartitionType(&deviceName, layout, &partitionType); if (!NT_SUCCESS(status)) { break; } if (partitionType == BOOTABLE_PARTITION) { skip = j; } else if (partitionType == PRIMARY_PARTITION) { if (!skip) { skip = j; } } } for (j = 1; ; j++) { if (j == skip) { continue; } swprintf(deviceNameBuffer, L"\\Device\\Harddisk%d\\Partition%d", i, j); RtlInitUnicodeString(&deviceName, deviceNameBuffer); status = HalpQueryPartitionType(&deviceName, layout, &partitionType); if (!NT_SUCCESS(status)) { break; } if (partitionType != PRIMARY_PARTITION && partitionType != FT_PARTITION) { continue; } HalpNextDriveLetter(&deviceName, NtDeviceName, NtSystemPath, FALSE); } if (layout) { ExFreePool(layout); } } for (i = 0; i < floppyCount; i++) { swprintf(deviceNameBuffer, L"\\Device\\Floppy%d", i); RtlInitUnicodeString(&deviceName, deviceNameBuffer); if (!HalpIsOldStyleFloppy(&deviceName)) { continue; } HalpNextDriveLetter(&deviceName, NtDeviceName, NtSystemPath, TRUE); } for (i = 0; i < floppyCount; i++) { swprintf(deviceNameBuffer, L"\\Device\\Floppy%d", i); RtlInitUnicodeString(&deviceName, deviceNameBuffer); if (HalpIsOldStyleFloppy(&deviceName)) { continue; } HalpNextDriveLetter(&deviceName, NtDeviceName, NtSystemPath, TRUE); } for (i = 0; i < configurationInformation->CdRomCount; i++) { swprintf(deviceNameBuffer, L"\\Device\\CdRom%d", i); RtlInitUnicodeString(&deviceName, deviceNameBuffer); HalpNextDriveLetter(&deviceName, NtDeviceName, NtSystemPath, TRUE); } if (!IoRemoteBootClient) { RtlAnsiStringToUnicodeString(&unicodeString, NtDeviceName, TRUE); driveLetter = HalpNextDriveLetter(&unicodeString, NULL, NULL, TRUE); if (driveLetter) { if (driveLetter != 0xFF) { NtSystemPath[0] = driveLetter; } } else { RtlInitUnicodeString(&floppyPrefix, L"\\Device\\Floppy"); RtlInitUnicodeString(&cdromPrefix, L"\\Device\\CdRom"); if (RtlPrefixUnicodeString(&floppyPrefix, &unicodeString, TRUE)) { driveLetter = 'A'; } else if (RtlPrefixUnicodeString(&cdromPrefix, &unicodeString, TRUE)) { driveLetter = 'D'; } else { driveLetter = 'C'; } for (; driveLetter <= 'Z'; driveLetter++) { status = HalpSetMountLetter(&unicodeString, driveLetter); if (NT_SUCCESS(status)) { NtSystemPath[0] = driveLetter; } } } RtlFreeUnicodeString(&unicodeString); } HalpEnableAutomaticDriveLetterAssignment(); } // end IoAssignDriveLetters()

NTSTATUS FASTCALL xHalIoClearPartitionTable (  IN PDEVICE_OBJECT  DeviceObject, IN ULONG  SectorSize, IN ULONG  SectorsPerTrack, IN ULONG  NumberOfHeads )

Definition at line 3486 of file drivesup.c. References BOOT_RECORD_SIGNATURE, BOOT_SIGNATURE_OFFSET, ExAllocatePoolWithTag, Executive, ExFreePool(), FALSE, _IO_STACK_LOCATION::Flags, HalExamineMBR, IoBuildSynchronousFsdRequest(), IoCallDriver, IoGetNextIrpStackLocation, IRP_MJ_READ, IRP_MJ_WRITE, KeInitializeEvent, KernelMode, KeWaitForSingleObject(), NonPagedPoolCacheAligned, NT_SUCCESS, NTSTATUS(), NULL, PAGE_SIZE, PAGED_CODE, PUSHORT, SectorSize, SL_OVERRIDE_VERIFY_VOLUME, TRUE, USHORT, VOID(), WHICH_BIT, and xHalGetPartialGeometry(). : This routine walks the disk writing the partition tables from the entries in the partition list buffer for each partition. Applications that create and delete partitions should issue a IoReadPartitionTable call with the 'return recognized partitions' boolean set to false to get a full description of the system. Then the drive layout structure can be modified by the application to reflect the new configuration of the disk and then is written back to the disk using this routine. Arguments: DeviceObject - Pointer to device object for this disk. SectorSize - Sector size on the device. SectorsPerTrack - Track size on the device. NumberOfHeads - Same as tracks per cylinder. Return Value: The functional value is STATUS_SUCCESS if all writes are completed without error. --*/ { typedef struct _PARTITION_TABLE { PARTITION_INFORMATION PartitionEntry[4]; } PARTITION_TABLE, *PPARTITION_TABLE; typedef struct _DISK_LAYOUT { ULONG TableCount; ULONG Signature; PARTITION_TABLE PartitionTable[1]; } DISK_LAYOUT, *PDISK_LAYOUT; typedef struct _PTE { UCHAR ActiveFlag; // Bootable or not UCHAR StartingTrack; // Not used USHORT StartingCylinder; // Not used UCHAR PartitionType; // 12 bit FAT, 16 bit FAT etc. UCHAR EndingTrack; // Not used USHORT EndingCylinder; // Not used ULONG StartingSector; // Hidden sectors ULONG PartitionLength; // Sectors in this partition } PTE; typedef PTE UNALIGNED *PPTE; // // This macro has the effect of Bit = log2(Data) // #define WHICH_BIT(Data, Bit) { \ for (Bit = 0; Bit < 32; Bit++) { \ if ((Data >> Bit) == 1) { \ break; \ } \ } \ } ULONG writeSize; PUSHORT writeBuffer = NULL; PPARTITION_TABLE partitionTable; CCHAR shiftCount; LARGE_INTEGER partitionTableOffset; LARGE_INTEGER nextRecordOffset; ULONG partitionTableCount; KEVENT event; IO_STATUS_BLOCK ioStatus; PIRP irp; BOOLEAN rewritePartition = FALSE; NTSTATUS status = STATUS_SUCCESS; LARGE_INTEGER tempInt; BOOLEAN foundEZHooker = FALSE; ULONG conventionalCylinders; LONGLONG diskSize; BOOLEAN isSuperFloppy = FALSE; // // Ensure that no one is calling this function illegally. // PAGED_CODE(); // // Determine the size of a write operation to ensure that at least 512 // bytes are written. This will guarantee that enough data is written to // include an entire partition table. Note that this code assumes that // the actual sector size of the disk (if less than 512 bytes) is a // multiple of 2, a fairly reasonable assumption. // if (SectorSize >= 512) { writeSize = SectorSize; } else { writeSize = 512; } xHalGetPartialGeometry( DeviceObject, &conventionalCylinders, &diskSize ); // // Look to see if this is an EZDrive Disk. If it is then get the // real partititon table at 1. // { PVOID buff; HalExamineMBR( DeviceObject, writeSize, (ULONG)0x55, &buff ); if (buff) { foundEZHooker = TRUE; ExFreePool(buff); partitionTableOffset.QuadPart = 512; } else { partitionTableOffset.QuadPart = 0; } } // // Calculate shift count for converting between byte and sector. // WHICH_BIT( SectorSize, shiftCount ); // // Allocate a buffer for the sector writes. // writeBuffer = ExAllocatePoolWithTag( NonPagedPoolCacheAligned, PAGE_SIZE, 'btsF'); if (writeBuffer == NULL) { return STATUS_INSUFFICIENT_RESOURCES; } // // Read the boot record that's already there into the write buffer // and save its boot code area if the signature is valid. This way // we don't clobber any boot code that might be there already. // KeInitializeEvent( &event, SynchronizationEvent, FALSE ); irp = IoBuildSynchronousFsdRequest( IRP_MJ_READ, DeviceObject, writeBuffer, writeSize, &partitionTableOffset, &event, &ioStatus ); if (!irp) { ExFreePool(writeBuffer); return STATUS_INSUFFICIENT_RESOURCES; } status = IoCallDriver( DeviceObject, irp ); if (status == STATUS_PENDING) { (VOID) KeWaitForSingleObject( &event, Executive, KernelMode, FALSE, (PLARGE_INTEGER) NULL); status = ioStatus.Status; } if (!NT_SUCCESS( status )) { ExFreePool(writeBuffer); return status; } // // If there's an 0xaa55 in the MBR signature, clear it out. // if(writeBuffer[BOOT_SIGNATURE_OFFSET] == BOOT_RECORD_SIGNATURE) { writeBuffer[BOOT_SIGNATURE_OFFSET] += 0x1111; } irp = IoBuildSynchronousFsdRequest( IRP_MJ_WRITE, DeviceObject, writeBuffer, writeSize, &partitionTableOffset, &event, &ioStatus ); if (!irp) { ExFreePool(writeBuffer); return STATUS_INSUFFICIENT_RESOURCES; } else { PIO_STACK_LOCATION irpStack; irpStack = IoGetNextIrpStackLocation(irp); irpStack->Flags |= SL_OVERRIDE_VERIFY_VOLUME; } status = IoCallDriver( DeviceObject, irp ); if (status == STATUS_PENDING) { (VOID) KeWaitForSingleObject( &event, Executive, KernelMode, FALSE, (PLARGE_INTEGER) NULL); status = ioStatus.Status; } // // Deallocate write buffer if it was allocated it. // ExFreePool( writeBuffer ); return status; }

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

Definition at line 1739 of file drivesup.c. References _PARTITION_DESCRIPTOR::ActiveFlag, ASSERT, BOOT_RECORD_SIGNATURE, BOOT_SIGNATURE_OFFSET, DebugPrint, DrivesupBreakIn, ExAllocatePoolWithTag, Executive, ExFreePool(), FALSE, _IO_STACK_LOCATION::Flags, GET_PARTITION_LENGTH, GET_STARTING_SECTOR, HalExamineMBR, HalpGetFullGeometry(), HalpIsValidPartitionEntry(), IoBuildSynchronousFsdRequest(), IoCallDriver, IoGetNextIrpStackLocation, IRP_MJ_READ, _BOOT_SECTOR_INFO::JumpByte, KeInitializeEvent, KernelMode, KeWaitForSingleObject(), NonPagedPool, NonPagedPoolCacheAligned, NT_SUCCESS, NTSTATUS(), NULL, NUM_PARTITION_TABLE_ENTRIES, PAGE_SIZE, PAGED_CODE, PARTITION_ACTIVE_FLAG, PARTITION_BUFFER_SIZE, PARTITION_TABLE_OFFSET, _PARTITION_DESCRIPTOR::PartitionType, PBOOT_SECTOR_INFO, PUSHORT, SectorSize, SL_OVERRIDE_VERIFY_VOLUME, TRUE, and VOID(). 01748 : 01749 01750 This routine walks the disk reading the partition tables and creates 01751 an entry in the partition list buffer for each partition. 01752 01753 The algorithm used by this routine is two-fold: 01754 01755 1) Read each partition table and for each valid, recognized 01756 partition found, to build a descriptor in a partition list. 01757 Extended partitions are located in order to find other 01758 partition tables, but no descriptors are built for these. 01759 The partition list is built in nonpaged pool that is allocated 01760 by this routine. It is the caller's responsibility to free 01761 this pool after it has gathered the appropriate information 01762 from the list. 01763 01764 2) Read each partition table and for each and every entry, build 01765 a descriptor in the partition list. Extended partitions are 01766 located to find each partition table on the disk, and entries 01767 are built for these as well. The partition list is build in 01768 nonpaged pool that is allocated by this routine. It is the 01769 caller's responsibility to free this pool after it has copied 01770 the information back to its caller. 01771 01772 The first algorithm is used when the ReturnRecognizedPartitions flag 01773 is set. This is used to determine how many partition device objects 01774 the device driver is to create, and where each lives on the drive. 01775 01776 The second algorithm is used when the ReturnRecognizedPartitions flag 01777 is clear. This is used to find all of the partition tables and their 01778 entries for a utility such as fdisk, that would like to revamp where 01779 the partitions live. 01780 01781 Arguments: 01782 01783 DeviceObject - Pointer to device object for this disk. 01784 01785 SectorSize - Sector size on the device. 01786 01787 ReturnRecognizedPartitions - A flag indicated whether only recognized 01788 partition descriptors are to be returned, or whether all partition 01789 entries are to be returned. 01790 01791 PartitionBuffer - Pointer to the pointer of the buffer in which the list 01792 of partition will be stored. 01793 01794 Return Value: 01795 01796 The functional value is STATUS_SUCCESS if at least one sector table was 01797 read. 01798 01799 Notes: 01800 01801 It is the responsibility of the caller to deallocate the partition list 01802 buffer allocated by this routine. 01803 01804 --*/ 01805 01806 { 01807 ULONG partitionBufferSize = PARTITION_BUFFER_SIZE; 01808 PDRIVE_LAYOUT_INFORMATION newPartitionBuffer = NULL; 01809 01810 LONG partitionTableCounter = -1; 01811 01812 DISK_GEOMETRY diskGeometry; 01813 ULONGLONG endSector; 01814 ULONGLONG maxSector; 01815 ULONGLONG maxOffset; 01816 01817 LARGE_INTEGER partitionTableOffset; 01818 LARGE_INTEGER volumeStartOffset; 01819 LARGE_INTEGER tempInt; 01820 BOOLEAN primaryPartitionTable; 01821 LONG partitionNumber; 01822 PUCHAR readBuffer = (PUCHAR) NULL; 01823 KEVENT event; 01824 01825 IO_STATUS_BLOCK ioStatus; 01826 PIRP irp; 01827 PPARTITION_DESCRIPTOR partitionTableEntry; 01828 CCHAR partitionEntry; 01829 NTSTATUS status = STATUS_SUCCESS; 01830 ULONG readSize; 01831 PPARTITION_INFORMATION partitionInfo; 01832 BOOLEAN foundEZHooker = FALSE; 01833 01834 BOOLEAN mbrSignatureFound = FALSE; 01835 BOOLEAN emptyPartitionTable = TRUE; 01836 01837 PAGED_CODE(); 01838 01839 // 01840 // Create the buffer that will be passed back to the driver containing 01841 // the list of partitions on the disk. 01842 // 01843 01844 *PartitionBuffer = ExAllocatePoolWithTag( NonPagedPool, 01845 partitionBufferSize, 01846 'btsF' ); 01847 01848 if (*PartitionBuffer == NULL) { 01849 return STATUS_INSUFFICIENT_RESOURCES; 01850 } 01851 01852 // 01853 // Determine the size of a read operation to ensure that at least 512 01854 // bytes are read. This will guarantee that enough data is read to 01855 // include an entire partition table. Note that this code assumes that 01856 // the actual sector size of the disk (if less than 512 bytes) is a 01857 // multiple of 2, a fairly reasonable assumption. 01858 // 01859 01860 if (SectorSize >= 512) { 01861 readSize = SectorSize; 01862 } else { 01863 readSize = 512; 01864 } 01865 01866 // 01867 // Look to see if this is an EZDrive Disk. If it is then get the 01868 // real parititon table at 1. 01869 // 01870 01871 { 01872 01873 PVOID buff; 01874 01875 HalExamineMBR( 01876 DeviceObject, 01877 readSize, 01878 (ULONG)0x55, 01879 &buff 01880 ); 01881 01882 if (buff) { 01883 01884 foundEZHooker = TRUE; 01885 ExFreePool(buff); 01886 partitionTableOffset.QuadPart = 512; 01887 01888 } else { 01889 01890 partitionTableOffset.QuadPart = 0; 01891 01892 } 01893 01894 } 01895 01896 // 01897 // Get the drive size so we can verify that the partition table is 01898 // correct. 01899 // 01900 01901 status = HalpGetFullGeometry(DeviceObject, 01902 &diskGeometry, 01903 &maxOffset); 01904 01905 if(!NT_SUCCESS(status)) { 01906 ExFreePool(*PartitionBuffer); 01907 *PartitionBuffer = NULL; 01908 return status; 01909 } 01910 01911 // 01912 // Partition offsets need to fit on the disk or we're not going to 01913 // expose them. Partition ends are generally very very sloppy so we 01914 // need to allow some slop. Adding in a cylinders worth isn't enough 01915 // so now we'll assume that all partitions end within 2x of the real end 01916 // of the disk. 01917 // 01918 01919 endSector = maxOffset; 01920 01921 maxSector = maxOffset * 2; 01922 01923 DebugPrint((2, "MaxOffset = %#I64x, maxSector = %#I64x\n", 01924 maxOffset, maxSector)); 01925 01926 // 01927 // Indicate that the primary partition table is being read and 01928 // processed. 01929 // 01930 01931 primaryPartitionTable = TRUE; 01932 01933 // 01934 // The partitions in this volume have their start sector as 0. 01935 // 01936 01937 volumeStartOffset.QuadPart = 0; 01938 01939 // 01940 // Initialize the number of partitions in the list. 01941 // 01942 01943 partitionNumber = -1; 01944 01945 // 01946 // Allocate a buffer that will hold the reads. 01947 // 01948 01949 readBuffer = ExAllocatePoolWithTag( NonPagedPoolCacheAligned, 01950 PAGE_SIZE, 01951 'btsF' ); 01952 01953 if (readBuffer == NULL) { 01954 ExFreePool( *PartitionBuffer ); 01955 return STATUS_INSUFFICIENT_RESOURCES; 01956 } 01957 01958 // 01959 // Read each partition table, create an object for the partition(s) 01960 // it represents, and then if there is a link entry to another 01961 // partition table, repeat. 01962 // 01963 01964 do { 01965 01966 BOOLEAN tableIsValid; 01967 ULONG containerPartitionCount; 01968 01969 tableIsValid = TRUE; 01970 01971 // 01972 // Read record containing partition table. 01973 // 01974 // Create a notification event object to be used while waiting for 01975 // the read request to complete. 01976 // 01977 01978 KeInitializeEvent( &event, NotificationEvent, FALSE ); 01979 01980 // 01981 // Zero out the buffer we're reading into. In case we get back 01982 // STATUS_NO_DATA_DETECTED we'll be prepared. 01983 // 01984 01985 RtlZeroMemory(readBuffer, readSize); 01986 01987 irp = IoBuildSynchronousFsdRequest( IRP_MJ_READ, 01988 DeviceObject, 01989 readBuffer, 01990 readSize, 01991 &partitionTableOffset, 01992 &event, 01993 &ioStatus ); 01994 01995 if (!irp) { 01996 status = STATUS_INSUFFICIENT_RESOURCES; 01997 break; 01998 } else { 01999 PIO_STACK_LOCATION irpStack; 02000 irpStack = IoGetNextIrpStackLocation(irp); 02001 irpStack->Flags |= SL_OVERRIDE_VERIFY_VOLUME; 02002 } 02003 02004 status = IoCallDriver( DeviceObject, irp ); 02005 02006 if (status == STATUS_PENDING) { 02007 (VOID) KeWaitForSingleObject( &event, 02008 Executive, 02009 KernelMode, 02010 FALSE, 02011 (PLARGE_INTEGER) NULL); 02012 status = ioStatus.Status; 02013 } 02014 02015 // 02016 // Special case - if we got a blank-check reading the sector then 02017 // pretend it was just successful so we can deal with superfloppies 02018 // where noone bothered to write anything to the non-filesystem sectors 02019 // 02020 02021 if(status == STATUS_NO_DATA_DETECTED) { 02022 status = STATUS_SUCCESS; 02023 } 02024 02025 if (!NT_SUCCESS( status )) { 02026 break; 02027 } 02028 02029 // 02030 // If EZDrive is hooking the MBR then we found the first partition table 02031 // in sector 1 rather than 0. However that partition table is relative 02032 // to sector zero. So, Even though we got it from one, reset the partition 02033 // offset to 0. 02034 // 02035 02036 if (foundEZHooker && (partitionTableOffset.QuadPart == 512)) { 02037 02038 partitionTableOffset.QuadPart = 0; 02039 02040 } 02041 02042 // 02043 // Check for Boot Record signature. 02044 // 02045 02046 if (((PUSHORT) readBuffer)[BOOT_SIGNATURE_OFFSET] != BOOT_RECORD_SIGNATURE) { 02047 02048 DebugPrint((1, "xHalIoReadPT: No 0xaa55 found in partition table %d\n", 02049 partitionTableCounter + 1)); 02050 02051 break; 02052 02053 } else { 02054 mbrSignatureFound = TRUE; 02055 } 02056 02057 // 02058 // Copy NTFT disk signature to buffer 02059 // 02060 02061 if (partitionTableOffset.QuadPart == 0) { 02062 (*PartitionBuffer)->Signature = ((PULONG) readBuffer)[PARTITION_TABLE_OFFSET/2-1]; 02063 } 02064 02065 partitionTableEntry = (PPARTITION_DESCRIPTOR) &(((PUSHORT) readBuffer)[PARTITION_TABLE_OFFSET]); 02066 02067 // 02068 // Keep count of partition tables in case we have an extended partition; 02069 // 02070 02071 partitionTableCounter++; 02072 02073 // 02074 // First create the objects corresponding to the entries in this 02075 // table that are not link entries or are unused. 02076 // 02077 02078 DebugPrint((2, "Partition Table %d:\n", partitionTableCounter)); 02079 02080 for (partitionEntry = 1, containerPartitionCount = 0; 02081 partitionEntry <= NUM_PARTITION_TABLE_ENTRIES; 02082 partitionEntry++, partitionTableEntry++) { 02083 02084 DebugPrint((2, "Partition Entry %d,%d: type %#x %s\n", 02085 partitionTableCounter, 02086 partitionEntry, 02087 partitionTableEntry->PartitionType, 02088 (partitionTableEntry->ActiveFlag) ? "Active" : "")); 02089 02090 DebugPrint((2, "\tOffset %#08lx for %#08lx Sectors\n", 02091 GET_STARTING_SECTOR(partitionTableEntry), 02092 GET_PARTITION_LENGTH(partitionTableEntry))); 02093 // 02094 // Do a quick pass over the entry to see if this table is valid. 02095 // It's only fatal if the master partition table is invalid. 02096 // 02097 02098 if((HalpIsValidPartitionEntry(partitionTableEntry, 02099 maxOffset, 02100 maxSector) == FALSE) && 02101 (partitionTableCounter == 0)) { 02102 02103 ASSERT(DrivesupBreakIn == FALSE); 02104 DrivesupBreakIn = FALSE; 02105 tableIsValid = FALSE; 02106 break; 02107 02108 } 02109 // 02110 // Only one container partition is allowed per table - any more 02111 // and it's invalid. 02112 // 02113 02114 if(IsContainerPartition(partitionTableEntry->PartitionType)) { 02115 02116 containerPartitionCount++; 02117 02118 if(containerPartitionCount != 1) { 02119 02120 DebugPrint((1, "Multiple container partitions found in " 02121 "partition table %d\n - table is invalid\n", 02122 partitionTableCounter)); 02123 tableIsValid = FALSE; 02124 break; 02125 } 02126 02127 } 02128 02129 if(emptyPartitionTable) { 02130 02131 if((GET_STARTING_SECTOR(partitionTableEntry) != 0) || 02132 (GET_PARTITION_LENGTH(partitionTableEntry) != 0)) { 02133 02134 // 02135 // There's a valid, non-empty partition here. The table 02136 // is not empty. 02137 // 02138 02139 emptyPartitionTable = FALSE; 02140 } 02141 } 02142 02143 // 02144 // If the partition entry is not used or not recognized, skip 02145 // it. Note that this is only done if the caller wanted only 02146 // recognized partition descriptors returned. 02147 // 02148 02149 if (ReturnRecognizedPartitions) { 02150 02151 // 02152 // Check if partition type is 0 (unused) or 5/f (extended). 02153 // The definition of recognized partitions has broadened 02154 // to include any partition type other than 0 or 5/f. 02155 // 02156 02157 if ((partitionTableEntry->PartitionType == PARTITION_ENTRY_UNUSED) || 02158 IsContainerPartition(partitionTableEntry->PartitionType)) { 02159 02160 continue; 02161 } 02162 } 02163 02164 // 02165 // Bump up to the next partition entry. 02166 // 02167 02168 partitionNumber++; 02169 02170 if (((partitionNumber * sizeof( PARTITION_INFORMATION )) + 02171 sizeof( DRIVE_LAYOUT_INFORMATION )) > 02172 (ULONG) partitionBufferSize) { 02173 02174 // 02175 // The partition list is too small to contain all of the 02176 // entries, so create a buffer that is twice as large to 02177 // store the partition list and copy the old buffer into 02178 // the new one. 02179 // 02180 02181 newPartitionBuffer = ExAllocatePoolWithTag( NonPagedPool, 02182 partitionBufferSize << 1, 02183 'btsF' ); 02184 02185 if (newPartitionBuffer == NULL) { 02186 --partitionNumber; 02187 status = STATUS_INSUFFICIENT_RESOURCES; 02188 break; 02189 } 02190 02191 RtlMoveMemory( newPartitionBuffer, 02192 *PartitionBuffer, 02193 partitionBufferSize ); 02194 02195 ExFreePool( *PartitionBuffer ); 02196 02197 // 02198 // Reassign the new buffer to the return parameter and 02199 // reset the size of the buffer. 02200 // 02201 02202 *PartitionBuffer = newPartitionBuffer; 02203 partitionBufferSize <<= 1; 02204 } 02205 02206 // 02207 // Describe this partition table entry in the partition list 02208 // entry being built for the driver. This includes writing 02209 // the partition type, starting offset of the partition, and 02210 // the length of the partition. 02211 // 02212 02213 partitionInfo = &(*PartitionBuffer)->PartitionEntry[partitionNumber]; 02214 02215 partitionInfo->PartitionType = partitionTableEntry->PartitionType; 02216 02217 partitionInfo->RewritePartition = FALSE; 02218 02219 if (partitionTableEntry->PartitionType != PARTITION_ENTRY_UNUSED) { 02220 LONGLONG startOffset; 02221 02222 partitionInfo->BootIndicator = 02223 partitionTableEntry->ActiveFlag & PARTITION_ACTIVE_FLAG ? 02224 (BOOLEAN) TRUE : (BOOLEAN) FALSE; 02225 02226 if (IsContainerPartition(partitionTableEntry->PartitionType)) { 02227 partitionInfo->RecognizedPartition = FALSE; 02228 startOffset = volumeStartOffset.QuadPart; 02229 } else { 02230 partitionInfo->RecognizedPartition = TRUE; 02231 startOffset = partitionTableOffset.QuadPart; 02232 } 02233 02234 partitionInfo->StartingOffset.QuadPart = startOffset + 02235 UInt32x32To64(GET_STARTING_SECTOR(partitionTableEntry), 02236 SectorSize); 02237 tempInt.QuadPart = (partitionInfo->StartingOffset.QuadPart - 02238 startOffset) / SectorSize; 02239 partitionInfo->HiddenSectors = tempInt.LowPart; 02240 02241 partitionInfo->PartitionLength.QuadPart = 02242 UInt32x32To64(GET_PARTITION_LENGTH(partitionTableEntry), 02243 SectorSize); 02244 02245 } else { 02246 02247 // 02248 // Partitions that are not used do not describe any part 02249 // of the disk. These types are recorded in the partition 02250 // list buffer when the caller requested all of the entries 02251 // be returned. Simply zero out the remaining fields in 02252 // the entry. 02253 // 02254 02255 partitionInfo->BootIndicator = FALSE; 02256 partitionInfo->RecognizedPartition = FALSE; 02257 partitionInfo->StartingOffset.QuadPart = 0; 02258 partitionInfo->PartitionLength.QuadPart = 0; 02259 partitionInfo->HiddenSectors = 0; 02260 } 02261 02262 } 02263 02264 DebugPrint((2, "\n")); 02265 02266 // 02267 // If an error occurred, leave the routine now. 02268 // 02269 02270 if (!NT_SUCCESS( status )) { 02271 break; 02272 } 02273 02274 if(tableIsValid == FALSE) { 02275 02276 // 02277 // Invalidate this partition table and stop looking for new ones. 02278 // we'll build the partition list based on the ones we found 02279 // previously. 02280 // 02281 02282 partitionTableCounter--; 02283 break; 02284 } 02285 02286 // 02287 // Now check to see if there are any link entries in this table, 02288 // and if so, set up the sector address of the next partition table. 02289 // There can only be one link entry in each partition table, and it 02290 // will point to the next table. 02291 // 02292 02293 partitionTableEntry = (PPARTITION_DESCRIPTOR) &(((PUSHORT) readBuffer)[PARTITION_TABLE_OFFSET]); 02294 02295 // 02296 // Assume that the link entry is empty. 02297 // 02298 02299 partitionTableOffset.QuadPart = 0; 02300 02301 for (partitionEntry = 1; 02302 partitionEntry <= NUM_PARTITION_TABLE_ENTRIES; 02303 partitionEntry++, partitionTableEntry++) { 02304 02305 if (IsContainerPartition(partitionTableEntry->PartitionType)) { 02306 02307 // 02308 // Obtain the address of the next partition table on the 02309 // disk. This is the number of hidden sectors added to 02310 // the beginning of the extended partition (in the case of 02311 // logical drives), since all logical drives are relative 02312 // to the extended partition. The VolumeStartSector will 02313 // be zero if this is the primary parition table. 02314 // 02315 02316 partitionTableOffset.QuadPart = volumeStartOffset.QuadPart + 02317 UInt32x32To64(GET_STARTING_SECTOR(partitionTableEntry), 02318 SectorSize); 02319 02320 // 02321 // Set the VolumeStartSector to be the begining of the 02322 // second partition (extended partition) because all of 02323 // the offsets to the partition tables of the logical drives 02324 // are relative to this extended partition. 02325 // 02326 02327 if (primaryPartitionTable) { 02328 volumeStartOffset = partitionTableOffset; 02329 } 02330 02331 // 02332 // Update the maximum sector to be the end of the container 02333 // partition. 02334 // 02335 02336 maxSector = GET_PARTITION_LENGTH(partitionTableEntry); 02337 02338 DebugPrint((2, "MaxSector now = %#08lx\n", maxSector)); 02339 02340 // 02341 // There is only ever one link entry per partition table, 02342 // exit the loop once it has been found. 02343 // 02344 02345 break; 02346 } 02347 } 02348 02349 02350 // 02351 // All the other partitions will be logical drives. 02352 // 02353 02354 primaryPartitionTable = FALSE; 02355 02356 02357 } while (partitionTableOffset.HighPart | partitionTableOffset.LowPart); 02358 02359 // 02360 // Detect super-floppy media attempt #1. 02361 // If the media is removable and has an 0xaa55 signature on it and 02362 // is empty then check to see if we can recognize the BPB. If we recognize 02363 // a jump-byte at the beginning of the media then it's a super floppy. If 02364 // we don't then it's an unpartitioned disk. 02365 // 02366 02367 DebugPrint((4, "xHalIoReadPartitionTable: RM %d PTC %d MBR %d EPT %d\n", 02368 diskGeometry.MediaType, 02369 partitionTableCounter, 02370 mbrSignatureFound, 02371 emptyPartitionTable)); 02372 02373 if((diskGeometry.MediaType == RemovableMedia) && 02374 (partitionTableCounter == 0) && 02375 (mbrSignatureFound == TRUE) && 02376 (emptyPartitionTable == TRUE)) { 02377 02378 PBOOT_SECTOR_INFO bootSector = (PBOOT_SECTOR_INFO) readBuffer; 02379 02380 if((bootSector->JumpByte[0] == 0xeb) || 02381 (bootSector->JumpByte[0] == 0xe9)) { 02382 02383 // 02384 // We've got a superfloppy of some sort. 02385 // 02386 02387 DebugPrint((1, "xHalIoReadPartitionTable: Jump byte %#x found " 02388 "along with empty partition table - disk is a " 02389 "super floppy and has no valid MBR\n", 02390 bootSector->JumpByte)); 02391 02392 partitionTableCounter = -1; 02393 } 02394 } 02395 02396 // 02397 // If the partition table count is still -1 then we didn't find any 02398 // valid partition records. In this case we'll build a partition list 02399 // that contiains one partition spanning the entire disk. 02400 // 02401 02402 if(partitionTableCounter == -1) { 02403 02404 if((mbrSignatureFound == TRUE) || 02405 (diskGeometry.MediaType == RemovableMedia)) { 02406 02407 // 02408 // Either we found a signature but the partition layout was 02409 // invalid (for all disks) or we didn't find a signature but this 02410 // is a removable disk. Either of these two cases makes a 02411 // superfloppy. 02412 // 02413 02414 DebugPrint((1, "xHalIoReadPartitionTable: Drive %#p has no valid MBR. " 02415 "Make it into a super-floppy\n", DeviceObject)); 02416 02417 DebugPrint((1, "xHalIoReadPartitionTable: Drive has %#08lx sectors " 02418 "and is %#016I64x bytes large\n", 02419 endSector, endSector * diskGeometry.BytesPerSector)); 02420 02421 if (endSector > 0) { 02422 02423 partitionInfo = &(*PartitionBuffer)->PartitionEntry[0]; 02424 02425 partitionInfo->RewritePartition = FALSE; 02426 partitionInfo->RecognizedPartition = TRUE; 02427 partitionInfo->PartitionType = PARTITION_FAT_16; 02428 partitionInfo->BootIndicator = FALSE; 02429 02430 partitionInfo->HiddenSectors = 0; 02431 02432 partitionInfo->StartingOffset.QuadPart = 0; 02433 02434 partitionInfo->PartitionLength.QuadPart = 02435 (endSector * diskGeometry.BytesPerSector); 02436 02437 (*PartitionBuffer)->Signature = 1; 02438 02439 partitionNumber = 0; 02440 } 02441 } else { 02442 02443 // 02444 // We found no partitions. Make sure the partition count is -1 02445 // so that we setup a zeroed-out partition table below. 02446 // 02447 02448 partitionNumber = -1; 02449 } 02450 } 02451 02452 // 02453 // Fill in the first field in the PartitionBuffer. This field indicates how 02454 // many partition entries there are in the PartitionBuffer. 02455 // 02456 02457 (*PartitionBuffer)->PartitionCount = ++partitionNumber; 02458 02459 if (!partitionNumber) { 02460 02461 // 02462 // Zero out disk signature. 02463 // 02464 02465 (*PartitionBuffer)->Signature = 0; 02466 } 02467 02468 // 02469 // Deallocate read buffer if it was allocated it. 02470 // 02471 02472 if (readBuffer != NULL) { 02473 ExFreePool( readBuffer ); 02474 } 02475 02476 if (!NT_SUCCESS(status)) { 02477 ExFreePool(*PartitionBuffer); 02478 *PartitionBuffer = NULL; 02479 } 02480 return status; 02481 }

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

Definition at line 2485 of file drivesup.c. References BOOT_RECORD_SIGNATURE, BOOT_SIGNATURE_OFFSET, ExAllocatePoolWithTag, Executive, ExFreePool(), FALSE, _IO_STACK_LOCATION::Flags, GET_STARTING_SECTOR, HalExamineMBR, IoBuildSynchronousFsdRequest(), IoCallDriver, IoGetNextIrpStackLocation, IRP_MJ_READ, IRP_MJ_WRITE, KeInitializeEvent, KeResetEvent(), KernelMode, KeWaitForSingleObject(), NonPagedPoolCacheAligned, NT_SUCCESS, NTSTATUS(), NULL, NUM_PARTITION_TABLE_ENTRIES, PAGE_SIZE, PAGED_CODE, PARTITION_TABLE_OFFSET, _PARTITION_DESCRIPTOR::PartitionType, PUSHORT, SectorSize, SL_OVERRIDE_VERIFY_VOLUME, TRUE, and VOID(). 02494 : 02495 02496 This routine is invoked when a disk device driver is asked to set the 02497 partition type in a partition table entry via an I/O control code. This 02498 control code is generally issued by the format utility just after it 02499 has formatted the partition. The format utility performs the I/O control 02500 function on the partition and the driver passes the address of the base 02501 physical device object and the number of the partition associated with 02502 the device object that the format utility has open. If this routine 02503 returns success, then the disk driver should updates its notion of the 02504 partition type for this partition in its device extension. 02505 02506 Arguments: 02507 02508 DeviceObject - Pointer to the base physical device object for the device 02509 on which the partition type is to be set. 02510 02511 SectorSize - Supplies the size of a sector on the disk in bytes. 02512 02513 PartitionNumber - Specifies the partition number on the device whose 02514 partition type is to be changed. 02515 02516 PartitionType - Specifies the new type for the partition. 02517 02518 Return Value: 02519 02520 The function value is the final status of the operation. 02521 02522 Notes: 02523 02524 This routine is synchronous. Therefore, it MUST be invoked by the disk 02525 driver's dispatch routine, or by a disk driver's thread. Likewise, all 02526 users, FSP threads, etc., must be prepared to enter a wait state when 02527 issuing the I/O control code to set the partition type for the device. 02528 02529 Note also that this routine assumes that the partition number passed 02530 in by the disk driver actually exists since the driver itself supplies 02531 this parameter. 02532 02533 Finally, note that this routine may NOT be invoked at APC_LEVEL. It 02534 must be invoked at PASSIVE_LEVEL. This is due to the fact that this 02535 routine uses a kernel event object to synchronize I/O completion on the 02536 device. The event cannot be set to the signaled state without queueing 02537 the I/O system's special kernel APC routine for I/O completion and 02538 executing it. (This rules is a bit esoteric since it only holds true 02539 if the device driver returns something other than STATUS_PENDING, which 02540 it will probably never do.) 02541 02542 --*/ 02543 02544 { 02545 02546 #define GET_STARTING_SECTOR( p ) ( \ 02547 (ULONG) (p->StartingSectorLsb0) + \ 02548 (ULONG) (p->StartingSectorLsb1 << 8) + \ 02549 (ULONG) (p->StartingSectorMsb0 << 16) + \ 02550 (ULONG) (p->StartingSectorMsb1 << 24) ) 02551 02552 PIRP irp; 02553 KEVENT event; 02554 IO_STATUS_BLOCK ioStatus; 02555 NTSTATUS status; 02556 LARGE_INTEGER partitionTableOffset; 02557 LARGE_INTEGER volumeStartOffset; 02558 PUCHAR buffer = (PUCHAR) NULL; 02559 ULONG transferSize; 02560 ULONG partitionNumber; 02561 ULONG partitionEntry; 02562 PPARTITION_DESCRIPTOR partitionTableEntry; 02563 BOOLEAN primaryPartitionTable; 02564 BOOLEAN foundEZHooker = FALSE; 02565 02566 PAGED_CODE(); 02567 02568 // 02569 // Begin by determining the size of the buffer required to read and write 02570 // the partition information to/from the disk. This is done to ensure 02571 // that at least 512 bytes are read, thereby guaranteeing that enough data 02572 // is read to include an entire partition table. Note that this code 02573 // assumes that the actual sector size of the disk (if less than 512 02574 // bytes) is a multiple of 2, a 02575 // fairly reasonable assumption. 02576 // 02577 02578 if (SectorSize >= 512) { 02579 transferSize = SectorSize; 02580 } else { 02581 transferSize = 512; 02582 } 02583 02584 02585 // 02586 // Look to see if this is an EZDrive Disk. If it is then get the 02587 // real parititon table at 1. 02588 // 02589 02590 { 02591 02592 PVOID buff; 02593 02594 HalExamineMBR( 02595 DeviceObject, 02596 transferSize, 02597 (ULONG)0x55, 02598 &buff 02599 ); 02600 02601 if (buff) { 02602 02603 foundEZHooker = TRUE; 02604 ExFreePool(buff); 02605 partitionTableOffset.QuadPart = 512; 02606 02607 } else { 02608 02609 partitionTableOffset.QuadPart = 0; 02610 02611 } 02612 02613 } 02614 02615 02616 // 02617 // The partitions in this primary partition have their start sector 0. 02618 // 02619 02620 volumeStartOffset.QuadPart = 0; 02621 02622 // 02623 // Indicate that the table being read and processed is the primary partition 02624 // table. 02625 // 02626 02627 primaryPartitionTable = TRUE; 02628 02629 // 02630 // Initialize the number of partitions found thus far. 02631 // 02632 02633 partitionNumber = 0; 02634 02635 // 02636 // Allocate a buffer that will hold the read/write data. 02637 // 02638 02639 buffer = ExAllocatePoolWithTag( NonPagedPoolCacheAligned, PAGE_SIZE, 'btsF'); 02640 if (buffer == NULL) { 02641 return STATUS_INSUFFICIENT_RESOURCES; 02642 } 02643 02644 // 02645 // Initialize a kernel event to use in synchronizing device requests 02646 // with I/O completion. 02647 // 02648 02649 KeInitializeEvent( &event, NotificationEvent, FALSE ); 02650 02651 // 02652 // Read each partition table scanning for the partition table entry that 02653 // the caller wishes to modify. 02654 // 02655 02656 do { 02657 02658 // 02659 // Read the record containing the partition table. 02660 // 02661 02662 (VOID) KeResetEvent( &event ); 02663 02664 irp = IoBuildSynchronousFsdRequest( IRP_MJ_READ, 02665 DeviceObject, 02666 buffer, 02667 transferSize, 02668 &partitionTableOffset, 02669 &event, 02670 &ioStatus ); 02671 02672 if (!irp) { 02673 status = STATUS_INSUFFICIENT_RESOURCES; 02674 break; 02675 } else { 02676 PIO_STACK_LOCATION irpStack; 02677 irpStack = IoGetNextIrpStackLocation(irp); 02678 irpStack->Flags |= SL_OVERRIDE_VERIFY_VOLUME; 02679 } 02680 02681 status = IoCallDriver( DeviceObject, irp ); 02682 02683 if (status == STATUS_PENDING) { 02684 (VOID) KeWaitForSingleObject( &event, 02685 Executive, 02686 KernelMode, 02687 FALSE, 02688 (PLARGE_INTEGER) NULL ); 02689 status = ioStatus.Status; 02690 } 02691 02692 if (!NT_SUCCESS( status )) { 02693 break; 02694 } 02695 02696 // 02697 // If EZDrive is hooking the MBR then we found the first partition table 02698 // in sector 1 rather than 0. However that partition table is relative 02699 // to sector zero. So, Even though we got it from one, reset the partition 02700 // offset to 0. 02701 // 02702 02703 if (foundEZHooker && (partitionTableOffset.QuadPart == 512)) { 02704 02705 partitionTableOffset.QuadPart = 0; 02706 02707 } 02708 02709 // 02710 // Check for a valid Boot Record signature in the partition table 02711 // record. 02712 // 02713 02714 if (((PUSHORT) buffer)[BOOT_SIGNATURE_OFFSET] != BOOT_RECORD_SIGNATURE) { 02715 status = STATUS_BAD_MASTER_BOOT_RECORD; 02716 break; 02717 } 02718 02719 partitionTableEntry = (PPARTITION_DESCRIPTOR) &(((PUSHORT) buffer)[PARTITION_TABLE_OFFSET]); 02720 02721 // 02722 // Scan the partition entries in this partition table to determine if 02723 // any of the entries are the desired entry. Each entry in each 02724 // table must be scanned in the same order as in IoReadPartitionTable 02725 // so that the partition table entry cooresponding to the driver's 02726 // notion of the partition number can be located. 02727 // 02728 02729 for (partitionEntry = 1; 02730 partitionEntry <= NUM_PARTITION_TABLE_ENTRIES; 02731 partitionEntry++, partitionTableEntry++) { 02732 02733 02734 // 02735 // If the partition entry is empty or for an extended, skip it. 02736 // 02737 02738 if ((partitionTableEntry->PartitionType == PARTITION_ENTRY_UNUSED) || 02739 IsContainerPartition(partitionTableEntry->PartitionType)) { 02740 continue; 02741 } 02742 02743 // 02744 // A valid partition entry that is recognized has been located. 02745 // Bump the count and check to see if this entry is the desired 02746 // entry. 02747 // 02748 02749 partitionNumber++; 02750 02751 if (partitionNumber == PartitionNumber) { 02752 02753 // 02754 // This is the desired partition that is to be changed. Simply 02755 // overwrite the partition type and write the entire partition 02756 // buffer back out to the disk. 02757 // 02758 02759 partitionTableEntry->PartitionType = (UCHAR) PartitionType; 02760 02761 (VOID) KeResetEvent( &event ); 02762 02763 irp = IoBuildSynchronousFsdRequest( IRP_MJ_WRITE, 02764 DeviceObject, 02765 buffer, 02766 transferSize, 02767 &partitionTableOffset, 02768 &event, 02769 &ioStatus ); 02770 02771 if (!irp) { 02772 status = STATUS_INSUFFICIENT_RESOURCES; 02773 break; 02774 } else { 02775 PIO_STACK_LOCATION irpStack; 02776 irpStack = IoGetNextIrpStackLocation(irp); 02777 irpStack->Flags |= SL_OVERRIDE_VERIFY_VOLUME; 02778 } 02779 02780 status = IoCallDriver( DeviceObject, irp ); 02781 02782 if (status == STATUS_PENDING) { 02783 (VOID) KeWaitForSingleObject( &event, 02784 Executive, 02785 KernelMode, 02786 FALSE, 02787 (PLARGE_INTEGER) NULL ); 02788 status = ioStatus.Status; 02789 } 02790 02791 break; 02792 } 02793 } 02794 02795 // 02796 // If all of the entries in the current buffer were scanned and the 02797 // desired entry was not found, then continue. Otherwise, leave the 02798 // routine. 02799 // 02800 02801 if (partitionEntry <= NUM_PARTITION_TABLE_ENTRIES) { 02802 break; 02803 } 02804 02805 // 02806 // Now scan the current buffer to locate an extended partition entry 02807 // in the table so that its partition information can be read. There 02808 // can only be one extended partition entry in each partition table, 02809 // and it will point to the next table. 02810 // 02811 02812 partitionTableEntry = (PPARTITION_DESCRIPTOR) &(((PUSHORT) buffer)[PARTITION_TABLE_OFFSET]); 02813 02814 for (partitionEntry = 1; 02815 partitionEntry <= NUM_PARTITION_TABLE_ENTRIES; 02816 partitionEntry++, partitionTableEntry++) { 02817 02818 if (IsContainerPartition(partitionTableEntry->PartitionType)) { 02819 02820 // 02821 // Obtain the address of the next partition table on the disk. 02822 // This is the number of hidden sectors added to the beginning 02823 // of the extended partition (in the case of logical drives), 02824 // since all logical drives are relative to the extended 02825 // partition. The starting offset of the volume will be zero 02826 // if this is the primary partition table. 02827 // 02828 02829 partitionTableOffset.QuadPart = volumeStartOffset.QuadPart + 02830 UInt32x32To64(GET_STARTING_SECTOR(partitionTableEntry), 02831 SectorSize); 02832 02833 // 02834 // Set the starting offset of the volume to be the beginning of 02835 // the second partition (the extended partition) because all of 02836 // the offsets to the partition tables of the logical drives 02837 // are relative to this extended partition. 02838 // 02839 02840 if (primaryPartitionTable) { 02841 volumeStartOffset = partitionTableOffset; 02842 } 02843 02844 break; 02845 } 02846 } 02847 02848 // 02849 // Ensure that a partition entry was located that was an extended 02850 // partition, otherwise the desired partition will never be found. 02851 // 02852 02853 if (partitionEntry > NUM_PARTITION_TABLE_ENTRIES) { 02854 status = STATUS_BAD_MASTER_BOOT_RECORD; 02855 break; 02856 } 02857 02858 // 02859 // All the other partitions will be logical drives. 02860 // 02861 02862 primaryPartitionTable = FALSE; 02863 02864 } while (partitionNumber < PartitionNumber); 02865 02866 // 02867 // If a data buffer was successfully allocated, deallocate it now. 02868 // 02869 02870 if (buffer != NULL) { 02871 ExFreePool( buffer ); 02872 } 02873 02874 return status; 02875 }

NTSTATUS FASTCALL xHalIoWritePartitionTable (  IN PDEVICE_OBJECT  DeviceObject, IN ULONG  SectorSize, IN ULONG  SectorsPerTrack, IN ULONG  NumberOfHeads, IN struct _DRIVE_LAYOUT_INFORMATION *  PartitionBuffer )

Definition at line 2879 of file drivesup.c. References BOOT_RECORD_SIGNATURE, BOOT_SIGNATURE_OFFSET, ExAllocatePoolWithTag, Executive, ExFreePool(), FALSE, _IO_STACK_LOCATION::Flags, HalExamineMBR, HalpCalculateChsValues(), IoBuildSynchronousFsdRequest(), IoCallDriver, IoGetNextIrpStackLocation, IRP_MJ_READ, IRP_MJ_WRITE, KeInitializeEvent, KernelMode, KeWaitForSingleObject(), NonPagedPoolCacheAligned, NT_SUCCESS, NTSTATUS(), NULL, NUM_PARTITION_TABLE_ENTRIES, PAGE_SIZE, PAGED_CODE, PARTITION_ACTIVE_FLAG, PARTITION_TABLE_OFFSET, PUSHORT, SectorSize, SL_OVERRIDE_VERIFY_VOLUME, TRUE, USHORT, VOID(), WHICH_BIT, and xHalGetPartialGeometry(). : This routine walks the disk writing the partition tables from the entries in the partition list buffer for each partition. Applications that create and delete partitions should issue a IoReadPartitionTable call with the 'return recognized partitions' boolean set to false to get a full description of the system. Then the drive layout structure can be modified by the application to reflect the new configuration of the disk and then is written back to the disk using this routine. Arguments: DeviceObject - Pointer to device object for this disk. SectorSize - Sector size on the device. SectorsPerTrack - Track size on the device. NumberOfHeads - Same as tracks per cylinder. PartitionBuffer - Pointer drive layout buffer. Return Value: The functional value is STATUS_SUCCESS if all writes are completed without error. --*/ { typedef struct _PARTITION_TABLE { PARTITION_INFORMATION PartitionEntry[4]; } PARTITION_TABLE, *PPARTITION_TABLE; typedef struct _DISK_LAYOUT { ULONG TableCount; ULONG Signature; PARTITION_TABLE PartitionTable[1]; } DISK_LAYOUT, *PDISK_LAYOUT; typedef struct _PTE { UCHAR ActiveFlag; // Bootable or not UCHAR StartingTrack; // Not used USHORT StartingCylinder; // Not used UCHAR PartitionType; // 12 bit FAT, 16 bit FAT etc. UCHAR EndingTrack; // Not used USHORT EndingCylinder; // Not used ULONG StartingSector; // Hidden sectors ULONG PartitionLength; // Sectors in this partition } PTE; typedef PTE UNALIGNED *PPTE; // // This macro has the effect of Bit = log2(Data) // #define WHICH_BIT(Data, Bit) { \ for (Bit = 0; Bit < 32; Bit++) { \ if ((Data >> Bit) == 1) { \ break; \ } \ } \ } ULONG writeSize; PUSHORT writeBuffer = NULL; PPTE partitionEntry; PPARTITION_TABLE partitionTable; CCHAR shiftCount; LARGE_INTEGER partitionTableOffset; LARGE_INTEGER nextRecordOffset; ULONG partitionTableCount; ULONG partitionEntryCount; KEVENT event; IO_STATUS_BLOCK ioStatus; PIRP irp; BOOLEAN rewritePartition = FALSE; NTSTATUS status = STATUS_SUCCESS; LARGE_INTEGER tempInt; BOOLEAN foundEZHooker = FALSE; ULONG conventionalCylinders; LONGLONG diskSize; BOOLEAN isSuperFloppy = FALSE; // // Cast to a structure that is easier to use. // PDISK_LAYOUT diskLayout = (PDISK_LAYOUT) PartitionBuffer; // // Ensure that no one is calling this function illegally. // PAGED_CODE(); // // Determine the size of a write operation to ensure that at least 512 // bytes are written. This will guarantee that enough data is written to // include an entire partition table. Note that this code assumes that // the actual sector size of the disk (if less than 512 bytes) is a // multiple of 2, a fairly reasonable assumption. // if (SectorSize >= 512) { writeSize = SectorSize; } else { writeSize = 512; } xHalGetPartialGeometry( DeviceObject, &conventionalCylinders, &diskSize ); // // Look to see if this is an EZDrive Disk. If it is then get the // real partititon table at 1. // { PVOID buff; HalExamineMBR( DeviceObject, writeSize, (ULONG)0x55, &buff ); if (buff) { foundEZHooker = TRUE; ExFreePool(buff); partitionTableOffset.QuadPart = 512; } else { partitionTableOffset.QuadPart = 0; } } // // Initialize starting variables. // nextRecordOffset.QuadPart = 0; // // Calculate shift count for converting between byte and sector. // WHICH_BIT( SectorSize, shiftCount ); // // Check to see if this device is partitioned (or is being partitioned) // as a floppy. Floppys have a single partititon with hidden sector count // and partition offset equal to zero. If the disk is being partitioned // like this then we need to be sure not to write an MBR signature or // an NTFT signature to the media. // // NOTE: this is only to catch ourself when someone tries to write the // existing partition table back to disk. Any changes to the table will // result in a real MBR being written out. // if(PartitionBuffer->PartitionCount == 1) { PPARTITION_INFORMATION partitionEntry = PartitionBuffer->PartitionEntry; if((partitionEntry->StartingOffset.QuadPart == 0) && (partitionEntry->HiddenSectors == 0)) { isSuperFloppy = TRUE; // // This would indeed appear to be an attempt to format a floppy. // Make sure the other parameters match the defaut values we // provide in ReadParititonTable. If they don't then fail // the write operation. // if((partitionEntry->PartitionNumber != 0) || (partitionEntry->PartitionType != PARTITION_FAT_16) || (partitionEntry->BootIndicator == TRUE)) { return STATUS_INVALID_PARAMETER; } if(partitionEntry->RewritePartition == TRUE) { rewritePartition = TRUE; } foundEZHooker = FALSE; } } // // Convert partition count to partition table or boot sector count. // diskLayout->TableCount = (PartitionBuffer->PartitionCount + NUM_PARTITION_TABLE_ENTRIES - 1) / NUM_PARTITION_TABLE_ENTRIES; // // Allocate a buffer for the sector writes. // writeBuffer = ExAllocatePoolWithTag( NonPagedPoolCacheAligned, PAGE_SIZE, 'btsF'); if (writeBuffer == NULL) { return STATUS_INSUFFICIENT_RESOURCES; } // // Point to the partition table entries in write buffer. // partitionEntry = (PPTE) &writeBuffer[PARTITION_TABLE_OFFSET]; for (partitionTableCount = 0; partitionTableCount < diskLayout->TableCount; partitionTableCount++) { UCHAR partitionType; // // the first partition table is in the mbr (physical sector 0). // other partition tables are in ebr's within the extended partition. // BOOLEAN mbr = (BOOLEAN) (!partitionTableCount); LARGE_INTEGER extendedPartitionOffset; // // Read the boot record that's already there into the write buffer // and save its boot code area if the signature is valid. This way // we don't clobber any boot code that might be there already. // KeInitializeEvent( &event, NotificationEvent, FALSE ); irp = IoBuildSynchronousFsdRequest( IRP_MJ_READ, DeviceObject, writeBuffer, writeSize, &partitionTableOffset, &event, &ioStatus ); if (!irp) { status = STATUS_INSUFFICIENT_RESOURCES; break; } else { PIO_STACK_LOCATION irpStack; irpStack = IoGetNextIrpStackLocation(irp); irpStack->Flags |= SL_OVERRIDE_VERIFY_VOLUME; } status = IoCallDriver( DeviceObject, irp ); if (status == STATUS_PENDING) { (VOID) KeWaitForSingleObject( &event, Executive, KernelMode, FALSE, (PLARGE_INTEGER) NULL); status = ioStatus.Status; } if (!NT_SUCCESS( status )) { break; } // // If EZDrive is hooking the MBR then we found the first partition table // in sector 1 rather than 0. However that partition table is relative // to sector zero. So, Even though we got it from one, reset the partition // offset to 0. // if (foundEZHooker && (partitionTableOffset.QuadPart == 512)) { partitionTableOffset.QuadPart = 0; } if(isSuperFloppy == FALSE) { // // Write signature to last word of boot sector. // writeBuffer[BOOT_SIGNATURE_OFFSET] = BOOT_RECORD_SIGNATURE; // // Write NTFT disk signature if it changed and this is the MBR. // rewritePartition = FALSE; if (partitionTableOffset.QuadPart == 0) { if (((PULONG)writeBuffer)[PARTITION_TABLE_OFFSET/2-1] != PartitionBuffer->Signature) { ((PULONG) writeBuffer)[PARTITION_TABLE_OFFSET/2-1] = PartitionBuffer->Signature; rewritePartition = TRUE; } } // // Get pointer to first partition table. // partitionTable = &diskLayout->PartitionTable[partitionTableCount]; // // Walk table to determine whether this boot record has changed // and update partition table in write buffer in case it needs // to be written out to disk. // for (partitionEntryCount = 0; partitionEntryCount < NUM_PARTITION_TABLE_ENTRIES; partitionEntryCount++) { partitionType = partitionTable->PartitionEntry[partitionEntryCount].PartitionType; // // If the rewrite ISN'T true then copy then just leave the data // alone that is in the on-disk table. // if (partitionTable->PartitionEntry[partitionEntryCount].RewritePartition) { // // This boot record needs to be written back to disk. // rewritePartition = TRUE; // // Copy partition type from user buffer to write buffer. // partitionEntry[partitionEntryCount].PartitionType = partitionTable->PartitionEntry[partitionEntryCount].PartitionType; // // Copy the partition active flag. // partitionEntry[partitionEntryCount].ActiveFlag = partitionTable->PartitionEntry[partitionEntryCount].BootIndicator ? (UCHAR) PARTITION_ACTIVE_FLAG : (UCHAR) 0; if (partitionType != PARTITION_ENTRY_UNUSED) { LARGE_INTEGER sectorOffset; // // Calculate partition offset. // If in the mbr or the entry is not a link entry, partition offset // is sectors past last boot record. Otherwise (not in the mbr and // entry is a link entry), partition offset is sectors past start // of extended partition. // if (mbr || !IsContainerPartition(partitionType)) { tempInt.QuadPart = partitionTableOffset.QuadPart; } else { tempInt.QuadPart = extendedPartitionOffset.QuadPart; } sectorOffset.QuadPart = partitionTable->PartitionEntry[partitionEntryCount].StartingOffset.QuadPart - tempInt.QuadPart; tempInt.QuadPart = sectorOffset.QuadPart >> shiftCount; partitionEntry[partitionEntryCount].StartingSector = tempInt.LowPart; // // Calculate partition length. // tempInt.QuadPart = partitionTable->PartitionEntry[partitionEntryCount].PartitionLength.QuadPart >> shiftCount; partitionEntry[partitionEntryCount].PartitionLength = tempInt.LowPart; // // Fill in CHS values // HalpCalculateChsValues( &partitionTable->PartitionEntry[partitionEntryCount].StartingOffset, &partitionTable->PartitionEntry[partitionEntryCount].PartitionLength, shiftCount, SectorsPerTrack, NumberOfHeads, conventionalCylinders, (PPARTITION_DESCRIPTOR) &partitionEntry[partitionEntryCount]); } else { // // Zero out partition entry fields in case an entry // was deleted. // partitionEntry[partitionEntryCount].StartingSector = 0; partitionEntry[partitionEntryCount].PartitionLength = 0; partitionEntry[partitionEntryCount].StartingTrack = 0; partitionEntry[partitionEntryCount].EndingTrack = 0; partitionEntry[partitionEntryCount].StartingCylinder = 0; partitionEntry[partitionEntryCount].EndingCylinder = 0; } } if (IsContainerPartition(partitionType)) { // // Save next record offset. // nextRecordOffset = partitionTable->PartitionEntry[partitionEntryCount].StartingOffset; } } // end for partitionEntryCount ... } else { // // If there's an 0xaa55 in the MBR signature, clear it out. // // // BUGBUG - don't do this. // if(writeBuffer[BOOT_SIGNATURE_OFFSET] == BOOT_RECORD_SIGNATURE) { // writeBuffer[BOOT_SIGNATURE_OFFSET] += 0x1111; } } if (rewritePartition == TRUE) { rewritePartition = FALSE; // // Create a notification event object to be used while waiting for // the write request to complete. // KeInitializeEvent( &event, NotificationEvent, FALSE ); if (foundEZHooker && (partitionTableOffset.QuadPart == 0)) { partitionTableOffset.QuadPart = 512; } irp = IoBuildSynchronousFsdRequest( IRP_MJ_WRITE, DeviceObject, writeBuffer, writeSize, &partitionTableOffset, &event, &ioStatus ); if (!irp) { status = STATUS_INSUFFICIENT_RESOURCES; break; } else { PIO_STACK_LOCATION irpStack; irpStack = IoGetNextIrpStackLocation(irp); irpStack->Flags |= SL_OVERRIDE_VERIFY_VOLUME; } status = IoCallDriver( DeviceObject, irp ); if (status == STATUS_PENDING) { (VOID) KeWaitForSingleObject( &event, Executive, KernelMode, FALSE, (PLARGE_INTEGER) NULL); status = ioStatus.Status; } if (!NT_SUCCESS( status )) { break; } if (foundEZHooker && (partitionTableOffset.QuadPart == 512)) { partitionTableOffset.QuadPart = 0; } } // end if (reWrite ... // // Update partitionTableOffset to next boot record offset // partitionTableOffset = nextRecordOffset; if(mbr) { extendedPartitionOffset = nextRecordOffset; } } // end for partitionTableCount ... // // Deallocate write buffer if it was allocated it. // if (writeBuffer != NULL) { ExFreePool( writeBuffer ); } return status; }

---

Variable Documentation

PUCHAR DiskPartitionName = "\\Device\\Harddisk%d\\Partition%d" [static]

Definition at line 91 of file drivesup.c. Referenced by xHalIoAssignDriveLetters().

ULONG DrivesupBreakIn = FALSE

Definition at line 43 of file drivesup.c. Referenced by xHalIoReadPartitionTable().

ULONG DrivesupDebug = 0

Definition at line 42 of file drivesup.c. Referenced by DrivesupDebugPrint().

PUCHAR RegistryKeyName = DISK_REGISTRY_KEY [static]

Definition at line 92 of file drivesup.c.

---