haldisp.h File Reference

Go to the source code of this file.

Classes
struct	_ADAPTER_OBJECT
struct	_XHAL_WAIT_CONTEXT_BLOCK
Typedefs
typedef _ADAPTER_OBJECT	ADAPTER_OBJECT
typedef _XHAL_WAIT_CONTEXT_BLOCK	XHAL_WAIT_CONTEXT_BLOCK
typedef _XHAL_WAIT_CONTEXT_BLOCK *	PXHAL_WAIT_CONTEXT_BLOCK
Functions
NTSTATUS	xHalQuerySystemInformation (IN HAL_QUERY_INFORMATION_CLASS InformationClass, IN ULONG BufferSize, OUT PVOID Buffer, OUT PULONG ReturnedLength)
NTSTATUS	xHalSetSystemInformation (IN HAL_SET_INFORMATION_CLASS InformationClass, IN ULONG BufferSize, OUT PVOID Buffer)
NTSTATUS	xHalQueryBusSlots (IN PBUS_HANDLER BusHandler, IN ULONG BufferSize, OUT PULONG SlotNumbers, OUT PULONG ReturnedLength)
VOID	xHalSetWakeEnable (IN BOOLEAN Enable)
VOID	xHalSetWakeAlarm (IN ULONGLONG WakeTime, IN PTIME_FIELDS WakeTimeFields)
VOID	xHalLocateHiberRanges (IN PVOID MemoryMap)
NTSTATUS	xHalRegisterBusHandler (IN INTERFACE_TYPE InterfaceType, IN BUS_DATA_TYPE ConfigurationSpace, IN ULONG BusNumber, IN INTERFACE_TYPE ParentBusType, IN ULONG ParentBusNumber, IN ULONG SizeofBusExtensionData, IN PINSTALL_BUS_HANDLER InstallBusHandlers, OUT PBUS_HANDLER *BusHandler)
PBUS_HANDLER FASTCALL	xHalHandlerForBus (IN INTERFACE_TYPE InterfaceType, IN ULONG BusNumber)
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)
VOID FASTCALL	xHalReferenceHandler (IN PBUS_HANDLER Handler)
NTSTATUS	xHalInitPnpDriver (VOID)
NTSTATUS	xHalInitPowerManagement (IN PPM_DISPATCH_TABLE PmDriverDispatchTable, IN OUT PPM_DISPATCH_TABLE *PmHalDispatchTable)
PDMA_ADAPTER	xHalGetDmaAdapter (IN PVOID Context, IN struct _DEVICE_DESCRIPTION *DeviceDescriptor, OUT PULONG NumberOfMapRegisters)
VOID	xHalPutDmaAdapter (PDMA_ADAPTER DmaAdapter)
PVOID	xHalAllocateCommonBuffer (IN PDMA_ADAPTER DmaAdapter, IN ULONG Length, OUT PPHYSICAL_ADDRESS LogicalAddress, IN BOOLEAN CacheEnabled)
VOID	xHalFreeCommonBuffer (IN PDMA_ADAPTER DmaAdapter, IN ULONG Length, IN PHYSICAL_ADDRESS LogicalAddress, IN PVOID VirtualAddress, IN BOOLEAN CacheEnabled)
NTSTATUS	xHalAllocateAdapterChannel (IN PDMA_ADAPTER DmaAdapter, IN PDEVICE_OBJECT DeviceObject, IN ULONG NumberOfMapRegisters, IN PDRIVER_CONTROL ExecutionRoutine, IN PVOID Context)
BOOLEAN	xHalFlushAdapterBuffers (IN PDMA_ADAPTER DmaAdapter, IN PMDL Mdl, IN PVOID MapRegisterBase, IN PVOID CurrentVa, IN ULONG Length, IN BOOLEAN WriteToDevice)
VOID	xHalFreeAdapterChannel (IN PDMA_ADAPTER DmaAdapter)
VOID	xHalFreeMapRegisters (IN PDMA_ADAPTER DmaAdapter, PVOID MapRegisterBase, ULONG NumberOfMapRegisters)
PHYSICAL_ADDRESS	xHalMapTransfer (IN PDMA_ADAPTER DmaAdapter, IN PMDL Mdl, IN PVOID MapRegisterBase, IN PVOID CurrentVa, IN OUT PULONG Length, IN BOOLEAN WriteToDevice)
ULONG	xHalGetDmaAlignment (IN PDMA_ADAPTER DmaAdapter)
ULONG	xHalReadDmaCounter (IN PDMA_ADAPTER DmaAdapter)
NTSTATUS	xHalGetScatterGatherList (IN PDMA_ADAPTER DmaAdapter, IN PDEVICE_OBJECT DeviceObject, IN PMDL Mdl, IN PVOID CurrentVa, IN ULONG Length, IN PDRIVER_LIST_CONTROL ExecutionRoutine, IN PVOID Context, IN BOOLEAN WriteToDevice)
VOID	xHalPutScatterGatherList (IN PDMA_ADAPTER DmaAdapter, IN PSCATTER_GATHER_LIST ScatterGather, IN BOOLEAN WriteToDevice)
IO_ALLOCATION_ACTION	xHalpAllocateAdapterCallback (IN struct _DEVICE_OBJECT *DeviceObject, IN struct _IRP *Irp, IN PVOID MapRegisterBase, IN PVOID Context)
NTSTATUS	xHalGetInterruptTranslator (IN INTERFACE_TYPE ParentInterfaceType, IN ULONG ParentBusNumber, IN INTERFACE_TYPE BridgeInterfaceType, IN USHORT Size, IN USHORT Version, OUT PTRANSLATOR_INTERFACE Translator, OUT PULONG BridgeBusNumber)
BOOLEAN	xHalTranslateBusAddress (IN INTERFACE_TYPE InterfaceType, IN ULONG BusNumber, IN PHYSICAL_ADDRESS BusAddress, IN OUT PULONG AddressSpace, OUT PPHYSICAL_ADDRESS TranslatedAddress)
NTSTATUS	xHalAssignSlotResources (IN PUNICODE_STRING RegistryPath, IN PUNICODE_STRING DriverClassName OPTIONAL, IN PDRIVER_OBJECT DriverObject, IN PDEVICE_OBJECT DeviceObject OPTIONAL, IN INTERFACE_TYPE BusType, IN ULONG BusNumber, IN ULONG SlotNumber, IN OUT PCM_RESOURCE_LIST *AllocatedResources)
VOID	xHalHaltSystem (VOID)

---

Typedef Documentation

typedef struct _ADAPTER_OBJECT ADAPTER_OBJECT

typedef struct _XHAL_WAIT_CONTEXT_BLOCK * PXHAL_WAIT_CONTEXT_BLOCK

typedef struct _XHAL_WAIT_CONTEXT_BLOCK XHAL_WAIT_CONTEXT_BLOCK

---

Function Documentation

NTSTATUS xHalAllocateAdapterChannel (  IN PDMA_ADAPTER  DmaAdapter, IN PDEVICE_OBJECT  DeviceObject, IN ULONG  NumberOfMapRegisters, IN PDRIVER_CONTROL  ExecutionRoutine, IN PVOID  Context )

PVOID xHalAllocateCommonBuffer (  IN PDMA_ADAPTER  DmaAdapter, IN ULONG  Length, OUT PPHYSICAL_ADDRESS  LogicalAddress, IN BOOLEAN  CacheEnabled )

NTSTATUS xHalAssignSlotResources (  IN PUNICODE_STRING  RegistryPath, IN PUNICODE_STRING DriverClassName  OPTIONAL, IN PDRIVER_OBJECT  DriverObject, IN PDEVICE_OBJECT DeviceObject  OPTIONAL, IN INTERFACE_TYPE  BusType, IN ULONG  BusNumber, IN ULONG  SlotNumber, IN OUT PCM_RESOURCE_LIST *  AllocatedResources )

Definition at line 884 of file halfnc.c. References KeBugCheckEx(). { // // If the HAL fails to override this function, then // the HAL has clearly failed to initialize. // KeBugCheckEx(HAL_INITIALIZATION_FAILED, 0, 0, 0, 7); return STATUS_NOT_IMPLEMENTED; }

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

Definition at line 190 of file drivesup.c. 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 }

BOOLEAN xHalFlushAdapterBuffers (  IN PDMA_ADAPTER  DmaAdapter, IN PMDL  Mdl, IN PVOID  MapRegisterBase, IN PVOID  CurrentVa, IN ULONG  Length, IN BOOLEAN  WriteToDevice )

VOID xHalFreeAdapterChannel (  IN PDMA_ADAPTER  DmaAdapter  )

VOID xHalFreeCommonBuffer (  IN PDMA_ADAPTER  DmaAdapter, IN ULONG  Length, IN PHYSICAL_ADDRESS  LogicalAddress, IN PVOID  VirtualAddress, IN BOOLEAN  CacheEnabled )

VOID xHalFreeMapRegisters (  IN PDMA_ADAPTER  DmaAdapter, PVOID  MapRegisterBase, ULONG  NumberOfMapRegisters )

PDMA_ADAPTER xHalGetDmaAdapter (  IN PVOID  Context, IN struct _DEVICE_DESCRIPTION *  DeviceDescriptor, OUT PULONG  NumberOfMapRegisters )

ULONG xHalGetDmaAlignment (  IN PDMA_ADAPTER  DmaAdapter  )

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

Definition at line 107 of file translate.c. References PAGED_CODE. 00118 : 00119 00120 00121 Arguments: 00122 00123 ParentInterfaceType - The type of the bus the bridge lives on (normally PCI). 00124 00125 ParentBusNumber - The number of the bus the bridge lives on. 00126 00127 ParentSlotNumber - The slot number the bridge lives in (where valid). 00128 00129 BridgeInterfaceType - The bus type the bridge provides (ie ISA for a PCI-ISA bridge). 00130 00131 ResourceType - The resource type we want to translate. 00132 00133 Size - The size of the translator buffer. 00134 00135 Version - The version of the translator interface requested. 00136 00137 Translator - Pointer to the buffer where the translator should be returned 00138 00139 BridgeBusNumber - Pointer to where the bus number of the bridge bus should be returned 00140 00141 Return Value: 00142 00143 Returns the status of this operation. 00144 00145 --*/ 00146 { 00147 PAGED_CODE(); 00148 00149 #if defined(NO_LEGACY_DRIVERS) 00150 return STATUS_SUCCESS; 00151 } 00152 #else 00153 00154 UNREFERENCED_PARAMETER(ParentInterfaceType); 00155 UNREFERENCED_PARAMETER(ParentBusNumber); 00156 00157 ASSERT(Version == HAL_IRQ_TRANSLATOR_VERSION); 00158 ASSERT(Size >= sizeof (TRANSLATOR_INTERFACE)); 00159 00160 switch (BridgeInterfaceType) { 00161 case Eisa: 00162 case Isa: 00163 case MicroChannel: 00164 case InterfaceTypeUndefined: // special "IDE" cookie 00165 00166 // 00167 // Pass back an interface for an IRQ translator. 00168 // 00169 RtlZeroMemory(Translator, sizeof (TRANSLATOR_INTERFACE)); 00170 00171 Translator->Size = sizeof (TRANSLATOR_INTERFACE); 00172 Translator->Version = HAL_IRQ_TRANSLATOR_VERSION; 00173 Translator->InterfaceReference = &FstubTranslatorNull; 00174 Translator->InterfaceDereference = &FstubTranslatorNull; 00175 Translator->TranslateResources = &FstubTranslateResource; 00176 Translator->TranslateResourceRequirements = &FstubTranslateRequirement; 00177 00178 if (BridgeInterfaceType == InterfaceTypeUndefined) { 00179 Translator->Context = (PVOID)Isa; 00180 } else { 00181 Translator->Context = (PVOID)BridgeInterfaceType; 00182 } 00183 00184 return STATUS_SUCCESS; 00185 00186 default: 00187 return STATUS_NOT_IMPLEMENTED; 00188 } 00189 }

NTSTATUS xHalGetScatterGatherList (  IN PDMA_ADAPTER  DmaAdapter, IN PDEVICE_OBJECT  DeviceObject, IN PMDL  Mdl, IN PVOID  CurrentVa, IN ULONG  Length, IN PDRIVER_LIST_CONTROL  ExecutionRoutine, IN PVOID  Context, IN BOOLEAN  WriteToDevice )

VOID xHalHaltSystem (  VOID   )

Definition at line 905 of file halfnc.c. { for (;;) ; }

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

Definition at line 177 of file halfnc.c. References NULL. { return NULL; }

NTSTATUS xHalInitPnpDriver (  VOID   )

Definition at line 193 of file halfnc.c. { return STATUS_NOT_SUPPORTED; }

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

Definition at line 201 of file halfnc.c. { return STATUS_NOT_SUPPORTED; }

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

VOID xHalLocateHiberRanges (  IN PVOID  MemoryMap  )

Definition at line 169 of file halfnc.c. { }

PHYSICAL_ADDRESS xHalMapTransfer (  IN PDMA_ADAPTER  DmaAdapter, IN PMDL  Mdl, IN PVOID  MapRegisterBase, IN PVOID  CurrentVa, IN OUT PULONG  Length, IN BOOLEAN  WriteToDevice )

IO_ALLOCATION_ACTION xHalpAllocateAdapterCallback (  IN struct _DEVICE_OBJECT *  DeviceObject, IN struct _IRP *  Irp, IN PVOID  MapRegisterBase, IN PVOID  Context )

VOID xHalPutDmaAdapter (  PDMA_ADAPTER  DmaAdapter  )

VOID xHalPutScatterGatherList (  IN PDMA_ADAPTER  DmaAdapter, IN PSCATTER_GATHER_LIST  ScatterGather, IN BOOLEAN  WriteToDevice )

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

Definition at line 123 of file halfnc.c. References PAGED_CODE. { PAGED_CODE (); return STATUS_NOT_SUPPORTED; }

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

Definition at line 100 of file halfnc.c. References PAGED_CODE. { PAGED_CODE (); return STATUS_INVALID_LEVEL; }

ULONG xHalReadDmaCounter (  IN PDMA_ADAPTER  DmaAdapter  )

VOID FASTCALL xHalReferenceHandler (  IN PBUS_HANDLER  Handler  )

Definition at line 187 of file halfnc.c. { }

NTSTATUS xHalRegisterBusHandler (  IN INTERFACE_TYPE  InterfaceType, IN BUS_DATA_TYPE  ConfigurationSpace, IN ULONG  BusNumber, IN INTERFACE_TYPE  ParentBusType, IN ULONG  ParentBusNumber, IN ULONG  SizeofBusExtensionData, IN PINSTALL_BUS_HANDLER  InstallBusHandlers, OUT PBUS_HANDLER *  BusHandler )

Definition at line 136 of file halfnc.c. References PAGED_CODE. { PAGED_CODE (); return STATUS_NOT_SUPPORTED; }

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

Definition at line 112 of file halfnc.c. References PAGED_CODE. { PAGED_CODE (); return STATUS_INVALID_LEVEL; }

VOID xHalSetWakeAlarm (  IN ULONGLONG  WakeTime, IN PTIME_FIELDS  WakeTimeFields )

Definition at line 161 of file halfnc.c. { }

VOID xHalSetWakeEnable (  IN BOOLEAN  Enable  )

Definition at line 153 of file halfnc.c. { }

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

Definition at line 866 of file halfnc.c. References FALSE, and KeBugCheckEx(). { // // If the HAL fails to override this function, then // the HAL has clearly failed to initialize. // KeBugCheckEx(HAL_INITIALIZATION_FAILED, 0, 0, 0, 7); return FALSE; }

---