/*++
Copyright (c) 1993-1999 Microsoft Corporation
Module Name:
syspart.c
Abstract:
Routines to determine the system partition on x86 machines.
Author:
Ted Miller (tedm) 30-June-1994
Revision History:
Copied from winnt32 to risetup by ChuckL 12-May-1999
--*/
#include "pch.h"
#pragma hdrstop
#include <winioctl.h>
DEFINE_MODULE("SysPart");
#define MALLOC(_size) TraceAlloc(LPTR,(_size))
#define FREE(_p) TraceFree(_p)
UINT
MyGetDriveType(
IN TCHAR Drive
);
BOOL
IsNEC98(
VOID
);
#define WINNT_DONT_MATCH_PARTITION 0
#define WINNT_MATCH_PARTITION_NUMBER 1
#define WINNT_MATCH_PARTITION_STARTING_OFFSET 2
DWORD
FindSystemPartitionSignature(
IN LPCTSTR AdapterKeyName,
OUT LPTSTR Signature
);
DWORD
GetSystemVolumeGUID(
IN LPTSTR Signature,
OUT LPTSTR SysVolGuid
);
BOOL
DoDiskSignaturesCompare(
IN LPCTSTR Signature,
IN LPCTSTR DriveName,
IN OUT PVOID Compare,
IN DWORD Action
);
BOOL
x86DetermineSystemPartition(
IN HWND ParentWindow,
OUT PTCHAR SysPartDrive
)
/*++
Routine Description:
Determine the system partition on x86 machines.
On Win95, we always return C:. For NT, read on.
The system partition is the primary partition on the boot disk.
Usually this is the active partition on disk 0 and usually it's C:.
However the user could have remapped drive letters and generally
determining the system partition with 100% accuracy is not possible.
With there being differences in the IO system mapping and introduction of Volumes for NT 50
this has now become complicated. Listed below are the algorithms
NT 5.0 Beta 2 and above :
1. Get the signature from the registry. Located at
HKLM\Hardware\Description\System\<MultifunctionAdapter or EisaAdapter>\<some Bus No.>\DiskController\0\DiskPeripheral\0\Identifier
2. Go Through all of the volumes in the system with FindFirstVolume/FindNextVolume/FindVolumeClose.
3. Take off the trailing backslash to the name returne to get \\?\Volume{guid}.
4. IOCTL_STORAGE_GET_DEVICE_NUMBER with \\?\Volume{guid} => Check for FILE_DEVICE_DISK. Remember the partition number. Goto 6
5. If IOCTL_STORAGE_GET_DEVICE_NUMBER fails then use IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS which returns a list of harddisks.
For each harddisk remember the starting offset and goto 6.
6. Check Harddisk # by using \\.\PhysicalDrive# with IOCTL_DISK_GET_DRIVE_LAYOUT. If the signature matches then this is the disk we boot from.
7. To find the partition that we boot from we look for boot indicator. If we used 2 we try to match the partition number stored in 6
else if 3 we try to match the starting offset.Then you have a \\?\Volume{guid}\ name for the SYSTEM volume.
8. Call GetVolumeNameForVolumeMountPoint with A:\, B:\, C:\, ... and check the result of the form \\?\Volume{guid}\ against your match
to see what the drive letter is.
Important: Since the *Volume* APIs are post Beta2 we do dynamic loading of kernel32.dll based on the build number returned.
Versions below NT 5.0 Beta 2
1. Get the signature from the registry. Located at
HKLM\Hardware\Description\System\<MultifunctionAdapter or EisaAdapter>\<some Bus No.>\DiskController\0\DiskPeripheral\0\Identifier
2. Enumerate the \?? directory and look for all entries that begin with PhysicalDrive#.
3. For each of the Disks look for a match with the signature above and if they match then find out the partition number used to boot
using IOCTL_DISK_GET_DRIVE_LAYOUT and the BootIndicator bit.
4. On finding the Boot partition create a name of the form \Device\Harddisk#\Partition#
5. Then go through c:,d:...,z: calling QueryDosDeviceName and look for a match. That would be your system partition drive letter
Arguments:
ParentWindow - supplies window handle for window to be the parent for
any dialogs, etc.
SysPartDrive - if successful, receives drive letter of system partition.
Return Value:
Boolean value indicating whether SysPartDrive has been filled in.
If FALSE, the user will have been infomred about why.
--*/
{
TCHAR DriveName[4];
BOOL GotIt=FALSE;
TCHAR Buffer[512];
TCHAR Drive;
BOOL b;
TCHAR SysPartSig[20], PartitionNum[MAX_PATH], SysVolGuid[MAX_PATH];
TCHAR DriveVolGuid[MAX_PATH];
if(IsNEC98()) {
if (!GetWindowsDirectory(Buffer,sizeof(Buffer)/sizeof(TCHAR))) {
return(FALSE);
}
*SysPartDrive = Buffer[0];
return(TRUE);
}
//Get signature from registry - Step 1 listed above
if( (FindSystemPartitionSignature(TEXT("Hardware\\Description\\System\\EisaAdapter"),SysPartSig) != ERROR_SUCCESS )
&& (FindSystemPartitionSignature(TEXT("Hardware\\Description\\System\\MultiFunctionAdapter"),SysPartSig) != ERROR_SUCCESS ) ){
GotIt = FALSE;
goto c0;
}
//Get the SystemVolumeGUID - steps 2 through 7 listed above ( Beta 2 and after )
if( GetSystemVolumeGUID( SysPartSig, SysVolGuid ) != ERROR_SUCCESS ){
GotIt = FALSE;
goto c0;
}
DriveName[1] = TEXT(':');
//
// Enumerate all drive letters and compare their device names
//
for(Drive=TEXT('A'); Drive<=TEXT('Z'); Drive++) {
if(MyGetDriveType(Drive) == DRIVE_FIXED) {
DriveName[0] = Drive;
DriveName[2] = '\\';
DriveName[3] = 0;
if((*GetVolumeNameForVolumeMountPoint)((LPWSTR)DriveName, (LPWSTR)DriveVolGuid, MAX_PATH*sizeof(TCHAR))){
if(!lstrcmp(DriveVolGuid, SysVolGuid) ){
GotIt = TRUE; // Found it
break;
}
}
}
}
// This helps for some builds ~1500 < buildnum < 1877 that are in a tough spot
if(!GotIt) {
//
// Strange case, just assume C:
//
GotIt = TRUE;
Drive = TEXT('C');
}
c0:
if(GotIt) {
*SysPartDrive = Drive;
}
return(GotIt);
}
DWORD
GetSystemVolumeGUID(
IN LPTSTR Signature,
OUT LPTSTR SysVolGuid
)
/*++
Routine Description:
This routine enumerates all the volumes and if successful returns the \\?\Volume{guid} name for the system partition.
Arguments:
Signature - supplies a disk signature of the Boot disk so that it can be compared against. The details
to getting this value are detailed in the comments for x86DetermineSystemPartition.
SysVolGuid - If successful, will contain a name of form \\?\Volume{guid} for the System Partition (the one we use to boot)
Return Value:
Returns NO_ERROR if successful, otherwise it contains the error code.
--*/
{
HANDLE hVolume, h;
TCHAR VolumeName[MAX_PATH];
TCHAR driveName[30];
BOOL b,ret, DoExtent, MatchFound;
STORAGE_DEVICE_NUMBER number;
DWORD Err = NO_ERROR;
DWORD cnt;
PVOLUME_DISK_EXTENTS Extent = NULL;
PDISK_EXTENT Start, i;
DWORD ExtentSize, bytes;
PVOID p;
ULONG PartitionNumToCompare;
LARGE_INTEGER StartingOffToCompare;
//Enuberate all volumes
hVolume = (*FindFirstVolume)( (LPWSTR)VolumeName, MAX_PATH );
if( hVolume == INVALID_HANDLE_VALUE ){
return GetLastError();
}
MatchFound = FALSE;
do{
//Remove trailing backslash
DoExtent = FALSE;
if( wcsrchr( VolumeName,TEXT('\\') ) ){
*wcsrchr( VolumeName,TEXT('\\') ) = 0;
}else{
continue;
}
//Open the volume
h = CreateFile(VolumeName, GENERIC_READ, FILE_SHARE_READ |
FILE_SHARE_WRITE, NULL, OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL, INVALID_HANDLE_VALUE);
if (h == INVALID_HANDLE_VALUE) {
continue; // Move on to next volume
}
//Get the disk number
ret = DeviceIoControl(h, IOCTL_STORAGE_GET_DEVICE_NUMBER, NULL, 0,
&number, sizeof(number), &bytes, NULL);
if( !ret ){
// Try using IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS if the above failed
Extent = (PVOLUME_DISK_EXTENTS)MALLOC(1024);
ExtentSize = 1024;
if(!Extent) {
CloseHandle( h );
Err = ERROR_NOT_ENOUGH_MEMORY;
goto cleanup;
}
retry:
ret = DeviceIoControl( h, IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS,
NULL,0,(PVOID)Extent,ExtentSize,&bytes,NULL);
if(!ret) {
if((Err=GetLastError()) == ERROR_INSUFFICIENT_BUFFER) {
ExtentSize += 1024;
FREE(Extent);
if(Extent = (PVOLUME_DISK_EXTENTS)MALLOC(ExtentSize)) {
;
} else {
CloseHandle( h );
Err = ERROR_NOT_ENOUGH_MEMORY;
goto cleanup;
}
goto retry;
} else {
CloseHandle( h );
continue;
}
}else{
DoExtent = TRUE;
}
}
// Done with the handle this time around
CloseHandle( h );
if( !DoExtent ){
//
// Check to see if this is a disk and not CDROM etc.
//
if( number.DeviceType == FILE_DEVICE_DISK ){
// Remember the partition number
PartitionNumToCompare = number.PartitionNumber;
wsprintf( driveName, TEXT("\\\\.\\PhysicalDrive%lu"), number.DeviceNumber );
if(DoDiskSignaturesCompare( Signature, driveName, (PVOID)&PartitionNumToCompare, WINNT_MATCH_PARTITION_NUMBER ) ){
MatchFound = TRUE;
Err = NO_ERROR;
lstrcpy( SysVolGuid, VolumeName );
SysVolGuid[lstrlen(VolumeName)]=TEXT('\\');
SysVolGuid[lstrlen(VolumeName)+1]=0;
break;
}
}
// Move on ..
continue;
}else{
// Go through all disks and try for match
Start = Extent->Extents;
cnt = 0;
for( i = Start; cnt < Extent->NumberOfDiskExtents; i++ ){
cnt++;
// Remember the starting offset
StartingOffToCompare = i->StartingOffset;
wsprintf( driveName, TEXT("\\\\.\\PhysicalDrive%lu"), i->DiskNumber );
if(DoDiskSignaturesCompare( Signature, driveName, (PVOID)&StartingOffToCompare, WINNT_MATCH_PARTITION_STARTING_OFFSET ) ){
MatchFound = TRUE;
Err = NO_ERROR;
lstrcpy( SysVolGuid, VolumeName );
SysVolGuid[lstrlen(VolumeName)]=TEXT('\\');
SysVolGuid[lstrlen(VolumeName)+1]=0;
break;
}
}
}
if( MatchFound )
break;
}while( (*FindNextVolume)( hVolume, (LPWSTR)VolumeName, MAX_PATH ));
cleanup:
if( hVolume != INVALID_HANDLE_VALUE )
(*FindVolumeClose)( hVolume );
if( Extent != NULL ) {
FREE(Extent);
}
return Err;
}
BOOL
DoDiskSignaturesCompare(
IN LPCTSTR Signature,
IN LPCTSTR DriveName,
IN OUT PVOID Compare,
IN DWORD Action
)
/*++
Routine Description:
This routine compares the given disk signature with the one for the specified physical disk.
Arguments:
Signature - supplies a disk signature of the Boot disk so that it can be compared against. The details
to getting this value are detailed in the comments for x86DetermineSystemPartition.
DriveName - Physical Drive name of the form \\.\PhysicalDrive#
Compare - A pointer to a storage variable. The type depends on the value of Action
Action - Should be one of the following
WINNT_DONT_MATCH_PARTITION - Once disk signatures match it returns the boot partition number in Compare. Compare should be a PULONG.
WINNT_MATCH_PARTITION_NUMBER - Once disk signatures match it tries to match the boot partition number with the number passed in
through Compare. Compare should be PULONG.
WINNT_MATCH_PARTITION_STARTING_OFFSET - Once disk signatures match it tries to match the boot partition starting offset with the
starting offset number passed in through Compare. Compare should be PLARGE_INTEGER.
Return Value:
Returns TRUE if successful in getting a match.
--*/
{
TCHAR temp[30];
BOOL b,Found = FALSE;
PLARGE_INTEGER Starting_Off;
PPARTITION_INFORMATION Start, i;
HANDLE hDisk;
PDRIVE_LAYOUT_INFORMATION DriveLayout = NULL;
DWORD DriveLayoutSize;
DWORD cnt;
DWORD DataSize;
PULONG Disk_Num;
ULONG Sig;
if(!Compare )
return FALSE;
if( (Action==WINNT_MATCH_PARTITION_STARTING_OFFSET) && Compare )
Starting_Off = (PLARGE_INTEGER) Compare;
else
Disk_Num = (PULONG) Compare;
// On any failure return FALSE
//
// Get drive layout info for this physical disk.
// If we can't do this something is very wrong.
//
hDisk = CreateFile(
DriveName,
FILE_READ_ATTRIBUTES | FILE_READ_DATA,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL,
OPEN_EXISTING,
0,
NULL
);
if(hDisk == INVALID_HANDLE_VALUE) {
return FALSE;
}
//
// Get partition information.
//
DriveLayout = (PDRIVE_LAYOUT_INFORMATION)MALLOC(1024);
DriveLayoutSize = 1024;
if(!DriveLayout) {
goto cleanexit;
}
retry:
b = DeviceIoControl(
hDisk,
IOCTL_DISK_GET_DRIVE_LAYOUT,
NULL,
0,
(PVOID)DriveLayout,
DriveLayoutSize,
&DataSize,
NULL
);
if(!b) {
if(GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
DriveLayoutSize += 1024;
FREE(DriveLayout);
if(DriveLayout = (PDRIVE_LAYOUT_INFORMATION)MALLOC(DriveLayoutSize)) {
;
} else {
goto cleanexit;
}
goto retry;
} else {
goto cleanexit;
}
}else{
// Now walk the Drive_Layout to find the boot partition
Start = DriveLayout->PartitionEntry;
cnt = 0;
/*
_ultot( DriveLayout->Signature, temp, 16 );
if( lstrcmpi( temp, Signature ) )
goto cleanexit;
*/
Sig = wcstoul( Signature, NULL, 16 );
if( Sig != DriveLayout->Signature )
goto cleanexit;
for( i = Start; cnt < DriveLayout->PartitionCount; i++ ){
cnt++;
if( i->BootIndicator == TRUE ){
if( Action == WINNT_DONT_MATCH_PARTITION ){
*Disk_Num = i->PartitionNumber;
Found = TRUE;
goto cleanexit;
}
if( Action == WINNT_MATCH_PARTITION_NUMBER ){
if( *Disk_Num == i->PartitionNumber ){
Found = TRUE;
goto cleanexit;
}
}else{
if( Starting_Off->QuadPart == i->StartingOffset.QuadPart ){
Found = TRUE;
goto cleanexit;
}
}
break;
}
}
}
cleanexit:
if( hDisk != INVALID_HANDLE_VALUE )
CloseHandle( hDisk );
if( DriveLayout != NULL ) {
FREE(DriveLayout);
}
return Found;
}
DWORD
FindSystemPartitionSignature(
IN LPCTSTR AdapterKeyName,
OUT LPTSTR Signature
)
/*++
Routine Description:
This routine fetches the disk signature for the first disk that the BIOS sees. This has to be the disk that we boot from on x86s.
It is at location <AdapterKeyName>\<some Bus No.>\DiskController\0\DiskPeripheral\0\Identifier
Arguments:
Signature - If successful will contain the signature of the disk we boot off from in Hex.
Return Value:
Returns ERROR_SUCCESS if successful, otherwise it contains the error code.
--*/
{
DWORD Err, dwSize;
HKEY hkey, BusKey, Controller, SystemDiskKey;
int busnumber;
TCHAR BusString[20], Identifier[100];
Err = RegOpenKeyEx( HKEY_LOCAL_MACHINE,
AdapterKeyName,
0,
KEY_READ,
&hkey );
if( Err != ERROR_SUCCESS )
return Err;
// Start enumerating the buses
for( busnumber=0; ;busnumber++){
wsprintf( BusString, TEXT("%d"), busnumber );
Err = RegOpenKeyEx( hkey,
BusString,
0,
KEY_READ,
&BusKey );
if( Err != ERROR_SUCCESS ){
RegCloseKey( hkey );
return Err;
}
Err = RegOpenKeyEx( BusKey,
TEXT("DiskController"),
0,
KEY_READ,
&Controller );
RegCloseKey(BusKey); // Not needed anymore
if( Err != ERROR_SUCCESS ) // Move on to next bus
continue;
RegCloseKey( hkey ); // Not needed anymore
Err = RegOpenKeyEx( Controller,
TEXT("0\\DiskPeripheral\\0"),
0,
KEY_READ,
&SystemDiskKey );
if( Err != ERROR_SUCCESS ){
RegCloseKey( Controller );
return Err;
}
RegCloseKey( Controller ); // Not needed anymore
dwSize = sizeof(Identifier);
Err = RegQueryValueEx( SystemDiskKey,
TEXT("Identifier"),
NULL,
NULL,
(PBYTE) Identifier,
&dwSize);
if( Err != ERROR_SUCCESS ){
RegCloseKey( SystemDiskKey );
return Err;
}
if( Identifier && (lstrlen(Identifier) > 9 ) ){
PWCHAR p;
lstrcpy( Signature,Identifier+9);
p = wcsrchr( Signature,TEXT('-') );
if( p ) {
*p = 0;
}
RegCloseKey( SystemDiskKey );
return ERROR_SUCCESS;
}
else{
RegCloseKey( SystemDiskKey );
return Err;
}
}
// Should never get here
RegCloseKey( hkey );
return ERROR_PATH_NOT_FOUND;
}
UINT
MyGetDriveType(
IN TCHAR Drive
)
/*++
Routine Description:
Same as GetDriveType() Win32 API except on NT returns
DRIVE_FIXED for removeable hard drives.
Arguments:
Drive - supplies drive letter whose type is desired.
Return Value:
Same as GetDriveType().
--*/
{
TCHAR DriveNameNt[] = TEXT("\\\\.\\?:");
TCHAR DriveName[] = TEXT("?:\\");
HANDLE hDisk;
BOOL b;
UINT rc;
DWORD DataSize;
DISK_GEOMETRY MediaInfo;
//
// First, get the win32 drive type. If it tells us DRIVE_REMOVABLE,
// then we need to see whether it's a floppy or hard disk. Otherwise
// just believe the api.
//
//
DriveName[0] = Drive;
rc = GetDriveType(DriveName);
if((rc != DRIVE_REMOVABLE) || (Drive < L'C')) {
return(rc);
}
//
// DRIVE_REMOVABLE on NT.
//
//
// Disallow use of removable media (e.g. Jazz, Zip, ...).
//
DriveNameNt[4] = Drive;
hDisk = CreateFile(
DriveNameNt,
FILE_READ_ATTRIBUTES | SYNCHRONIZE,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL,
OPEN_EXISTING,
0,
NULL
);
if(hDisk != INVALID_HANDLE_VALUE) {
b = DeviceIoControl(
hDisk,
IOCTL_DISK_GET_DRIVE_GEOMETRY,
NULL,
0,
&MediaInfo,
sizeof(MediaInfo),
&DataSize,
NULL
);
//
// It's really a hard disk if the media type is removable.
//
if(b && (MediaInfo.MediaType == RemovableMedia)) {
rc = DRIVE_FIXED;
}
CloseHandle(hDisk);
}
return(rc);
}
BOOL
IsNEC98(
VOID
)
{
static BOOL Checked = FALSE;
static BOOL Is98;
if(!Checked) {
Is98 = ((GetKeyboardType(0) == 7) && ((GetKeyboardType(1) & 0xff00) == 0x0d00));
Checked = TRUE;
}
return(Is98);
}