windows-server-2003/base/ntsetup/textmode/kernel/sppart3.c

/*++

Copyright (c) 2000 Microsoft Corporation

Module Name:

    sppart3.c

Abstract:

    Partitioning module for disks in textmode setup.

    Contains functions that initialize the in memory data structures,
    representing the extents on the disk.    

Author:

    Matt Holle (matth) 1-December-1999

Revision History:

    Vijay Jayaseelan (vijayj) 2-April-2000
        -   Clean up
        -   Added lookup and prompting for system partition on 
            ARC systems
        -   Added on disk ordinals for MBR disks            

--*/


#include "spprecmp.h"
#pragma hdrstop
#include <initguid.h>
#include <devguid.h>
#include <diskguid.h>
#include <oemtypes.h>
#include "sppart3.h"


#define         MAX_NTPATH_LENGTH   (2048)
#define         SUGGESTED_SYSTEMPARTIION_SIZE_MB (100)
#define         SUGGESTED_INSTALL_PARTITION_SIZE_MB (4*1024)

extern BOOLEAN ConsoleRunning;
extern BOOLEAN ForceConsole;
 
//
// Debugging Macros
//

//#define PERF_STATS  1
//#define TESTING_SYSTEM_PARTITION 1

NTSTATUS
SpPtnInitializeDiskDrive(
    IN ULONG DiskId
    )
/*++

Routine Description:

    Initializes the in memory disk region structures for
    the given disk number.

Arguments:

    DiskId  :   Disk ID

Return Value:

    STATUS_SUCCESS if successful otherwise appropriate
    error code

--*/    
{
    NTSTATUS    Status;


#ifdef PERF_STATS
    LARGE_INTEGER   StartTime, EndTime;
    ULONGLONG       Diff;

    KeQuerySystemTime(&StartTime);
#endif

    //
    // Send the event
    //
    SendSetupProgressEvent(PartitioningEvent, ScanDiskEvent, &DiskId);
    
    //
    // It would have been better to just have a pointer to a list
    // of PDISK_REGIONs off of HARD_DISK, but for some reason, someone
    // long ago decided to also maintain a list of PARTITIONED_DISK, which
    // *does* contain a list of PDISK_REGIONs.  I'm not sure of the use
    // of maintaining both HARD_DISKs and PARTITIONED_DISKs, but that's
    // the way the data structures are set, so we'll use those.
    //
    // But it doesn't end there.  Rather than assuming that HardDisk[i]
    // is describing the same disk as PartitionedDisks[i], we'll
    // keep a pointer out of PartitionedDisks[i] that points to the
    // corresponding HardDisk entry.  Oh well...
    //
    PartitionedDisks[DiskId].HardDisk = &HardDisks[DiskId];

    //
    // Initialize structures that are based on the partition tables.
    //
    Status = SpPtnInitializeDiskAreas(DiskId);

    //
    // Now we need to fill in additional Region structures
    // to represent empty space on the disk.  For example, assume
    // we have 2 partitions on the disk, but there's empty space
    // in between:
    // partition1: 0 - 200 sectors
    // <empty space>
    // partition2: 500 - 1000 sectors
    //
    // I need to create another Region structure to represent
    // this empty space (ensuring that it's marked as unpartitioned.
    // This will allow me to present a nice UI to the user when it's
    // time to ask for input.
    //

    //
    // Sort the Partitions based on their location on the disk.
    //
    if( NT_SUCCESS(Status) ) {
        Status = SpPtnSortDiskAreas(DiskId);
        
        //
        // Create place holders for all empty spaces on the disk.
        //
        if( NT_SUCCESS(Status) ) {    
            Status = SpPtnFillDiskFreeSpaceAreas(DiskId);

            if (NT_SUCCESS(Status)) {
                //
                // Mark logical drive's and its container, if any.
                //
                Status = SpPtnMarkLogicalDrives(DiskId);
            }
        }
    }

#ifdef PERF_STATS
    KeQuerySystemTime(&EndTime);
    
    Diff = EndTime.QuadPart - StartTime.QuadPart;
    Diff /= 1000000;

    KdPrint(("SETUP:SpPtInitializeDiskDrive(%d) took %I64d Secs\n",
            DiskId,
            Diff));    
#endif

    SpPtDumpDiskDriveInformation(TRUE);
    
    return Status;
}

NTSTATUS
SpPtnInitializeDiskDrives(
    VOID
    )
/*++

Routine Description:

    Initializes all the disk drive's in memory data structure
    representing the disk regions (extents)

Arguments:

    None

Return Value:

    STATUS_SUCCESS if successful other wise appropriate error
    code.

--*/    
{
    ULONG       disk;
    NTSTATUS    Status = STATUS_SUCCESS;
    NTSTATUS    ErrStatus = STATUS_SUCCESS;
    BOOLEAN     ValidHardDiskPresent = FALSE;

    //
    // If there are no hard disks, bail now.
    //
    if(!HardDiskCount) {

#if defined(REMOTE_BOOT)
        //
        // If this is a diskless remote boot setup, it's OK for there to be
        // no hard disks. Otherwise, this is a fatal error.
        //
        if (!RemoteBootSetup || RemoteInstallSetup)
#endif // defined(REMOTE_BOOT)
        {
            SpDisplayScreen(SP_SCRN_NO_HARD_DRIVES,3,HEADER_HEIGHT+1);
            SpDisplayStatusOptions(DEFAULT_STATUS_ATTRIBUTE,SP_STAT_F3_EQUALS_EXIT,0);
            SpInputDrain();

            while(SpInputGetKeypress() != KEY_F3);

            SpDone(0,FALSE,TRUE);
        }
        
        return STATUS_SUCCESS;
    }

    CLEAR_CLIENT_SCREEN();

    //
    // Initialize all the RAW disks to platform specific
    // default disk styles
    // 
    for(disk=0, Status = STATUS_SUCCESS; 
        (disk < HardDiskCount); 
        disk++) {        

        if (SPPT_IS_RAW_DISK(disk) && SPPT_IS_BLANK_DISK(disk)) {
            PHARD_DISK HardDisk = SPPT_GET_HARDDISK(disk);
            PARTITION_STYLE Style = SPPT_DEFAULT_PARTITION_STYLE;

            //
            // Removable Media are always MBR (so don't bother)
            //
            if (HardDisk->Characteristics & FILE_REMOVABLE_MEDIA) {
                continue;
            }                            
            
            Status = SpPtnInitializeDiskStyle(disk, 
                        Style,
                        NULL);

            if (!NT_SUCCESS(Status)) {
                KdPrintEx((DPFLTR_SETUP_ID, DPFLTR_ERROR_LEVEL,
                    "SETUP:SpPtnInitializeDiskStyle(%d) failed with"
                    " %lx \n",
                    disk,
                    Status));
            }
        }                        
    }        


    //
    // Allocate an array for the partitioned disk descriptors.
    //
    PartitionedDisks = SpMemAlloc(HardDiskCount * sizeof(PARTITIONED_DISK));

    if(!PartitionedDisks) {
        return(STATUS_NO_MEMORY);
    }

    RtlZeroMemory( PartitionedDisks, HardDiskCount * sizeof(PARTITIONED_DISK) );

    //
    // Unlock the floppy if we booted off the ls-120 media
    //
    SpPtnUnlockDevice(L"\\device\\floppy0");

    //
    // Collect information about each partition.
    //
    for(disk=0, Status = ErrStatus = STATUS_SUCCESS; 
        (disk < HardDiskCount); 
        disk++) {
        
        //
        // Initialize the region structure for the given
        // disk
        //
        Status = SpPtnInitializeDiskDrive(disk);           

        //
        // TBD - In remote boot case the disk needs to have
        // a valid signature. I am assuming that setupldr
        // would have stamped the signature when booting off
        // the harddisk
        // 

        //
        // Save of the last error
        //
        if (!NT_SUCCESS(Status)){
            ErrStatus = Status;
        } else {
            ValidHardDiskPresent = TRUE;
        }
    }

    //
    // If no valid hard disk is present and this is not a remote boot setup
    // then we stop the setup.
    // 
    if (!ValidHardDiskPresent &&
        (!RemoteBootSetup || RemoteInstallSetup)){
        SpDisplayScreen(SP_SCRN_NO_HARD_DRIVES,
                        3,
                        HEADER_HEIGHT+1);
        
        SpDisplayStatusOptions(DEFAULT_STATUS_ATTRIBUTE,
                               SP_STAT_F3_EQUALS_EXIT,
                               0);
        
        SpInputDrain();

        while(SpInputGetKeypress() != KEY_F3);

        SpDone(0,FALSE,TRUE);
        return ErrStatus;
    }
    
#if defined(_IA64_)
    //
    // Go and figure out the ESP partitions and
    // initialize the MSR partitions on valid GPT
    // disks
    //
    if (SpIsArc() && !SpDrEnabled()) {    
        if (!ValidArcSystemPartition) {
            //
            // Create a system partition
            //
            Status = SpPtnCreateESP(TRUE);                    
        }            

        //
        // Initialize the GPT disks, to have MSR
        // partition
        //
        Status = SpPtnInitializeGPTDisks();
    }
#endif    

    return  ErrStatus;
}

NTSTATUS
SpPtnInitializeDiskAreas(
    IN ULONG DiskNumber
    )
/*++

Routine Description:

    Examine the disk for partitioning information and fill in our
    partition descriptors.

    We'll ask the volume manager for a list of partitions and fill
    in our descriptors from the information he provided us.


Arguments:

    DiskNumber - supplies the disk number of the disk whose partitions
                 we want to inspect for determining their types.

Return Value:

    NTSTATUS.  If all goes well, we should be returing STATUS_SUCCESS.

--*/
{
    NTSTATUS        Status = STATUS_SUCCESS;
    PDRIVE_LAYOUT_INFORMATION_EX   DriveLayoutEx;
    WCHAR           DevicePath[(sizeof(DISK_DEVICE_NAME_BASE)+sizeof(L"000"))/sizeof(WCHAR)];
    HANDLE          Handle;
    IO_STATUS_BLOCK IoStatusBlock;
    PDISK_REGION    pDiskRegion = NULL;
    PFILE_FS_ATTRIBUTE_INFORMATION  pFSInfo = NULL;
    PFILE_FS_SIZE_INFORMATION       pSizeInfo = NULL;
    PFILE_FS_VOLUME_INFORMATION     pLabelInfo = NULL;
    PWCHAR          MyTempBuffer = NULL;
    ULONG           DriveLayoutSize,
                    i,
                    r;
    PWSTR           LocalSourceFiles[1] = { LocalSourceDirectory };
    PHARD_DISK          Disk = NULL;
    PPARTITIONED_DISK   PartDisk = NULL;
    ULONGLONG           *NewPartitions = NULL;
    ULONG               NewPartitionCount;
    
    Disk = SPPT_GET_HARDDISK(DiskNumber);
    PartDisk = SPPT_GET_PARTITIONED_DISK(DiskNumber);
    
    //
    // Give the user some indication of what we're doing.
    //
    SpDisplayStatusText( SP_STAT_EXAMINING_DISK_N,
                         DEFAULT_STATUS_ATTRIBUTE,
                         Disk->Description);

    //
    // If we are updating the local source region disk then
    // make sure we invalidate LocalSourceRegion
    //
    if (LocalSourceRegion && (LocalSourceRegion->DiskNumber == DiskNumber)) {
        LocalSourceRegion = NULL;
    }

    //
    // Save off the new partitions created 
    //
    NewPartitionCount = SpPtnCountPartitionsByFSType(DiskNumber, 
                            FilesystemNewlyCreated);                            

    if (NewPartitionCount) {
        PDISK_REGION    NewRegion = SPPT_GET_PRIMARY_DISK_REGION(DiskNumber);
        ULONG           Index;
        
        NewPartitions = (PULONGLONG) SpMemAlloc(sizeof(ULONGLONG) * NewPartitionCount);

        if (!NewPartitions) {
            return STATUS_NO_MEMORY;
        }
        
        RtlZeroMemory(NewPartitions, sizeof(ULONGLONG) * NewPartitionCount);

        Index = 0;
        
        while (NewRegion && (Index < NewPartitionCount)) {
            if (SPPT_IS_REGION_PARTITIONED(NewRegion) && 
                !SPPT_IS_REGION_MARKED_DELETE(NewRegion) &&
                (NewRegion->Filesystem == FilesystemNewlyCreated)) {
                
                NewPartitions[Index] = NewRegion->StartSector;
                Index++;
            }
            
            NewRegion = NewRegion->Next;
        }
    }
    
    //
    // Free the old regions we allocated, if there are any
    //
    SpPtnFreeDiskRegions(DiskNumber);
    
    //
    // ============================
    //
    // Open a handle to this hard disk
    //
    // ============================
    //

    //
    // Create a device path (NT style!) that will describe this disk.  This
    // will be of the form: \Device\Harddisk0
    //
    swprintf( DevicePath,
              L"\\Device\\Harddisk%u",
              DiskNumber );

    //
    // Open partition 0 on this disk..
    //
    Status = SpOpenPartition0( DevicePath,
                               &Handle,
                               FALSE );

    if(!NT_SUCCESS(Status)) {

        KdPrintEx(( DPFLTR_SETUP_ID, DPFLTR_ERROR_LEVEL,  
                    "SETUP: SpPtInitializeDiskAreas: unable to open partition0 on device %ws (%lx)\n",
                    DevicePath,
                    Status ));

        if (NewPartitions) {
            SpMemFree(NewPartitions);
        }

        return( Status );
    }
    
    //
    // ============================
    //
    // Load the drive layout information.
    //
    // ============================
    //

    //
    // Get the disk's layout information.  We aren't
    // sure how big of a buffer we need, so brute-force it.
    //
    DriveLayoutSize = 0;
    DriveLayoutEx = NULL;
    Status = STATUS_BUFFER_TOO_SMALL;

    while ((Status == STATUS_BUFFER_TOO_SMALL) || 
           (Status == STATUS_BUFFER_OVERFLOW)) {

        if (DriveLayoutEx)
            SpMemFree(DriveLayoutEx);

        DriveLayoutSize += 1024;
        DriveLayoutEx = SpMemAlloc( DriveLayoutSize );
        
        if(!DriveLayoutEx) {
            KdPrintEx(( DPFLTR_SETUP_ID, DPFLTR_ERROR_LEVEL,  
                "SETUP: SpPtInitializeDiskAreas: SpMemAlloc failed!\n" ));

            if (NewPartitions) {
                SpMemFree(NewPartitions);
            }
            
            return  (STATUS_NO_MEMORY);
        }

        RtlZeroMemory( DriveLayoutEx, DriveLayoutSize );

        //
        // Attempt to get the disk's partition information.
        //
        Status = ZwDeviceIoControlFile( Handle,
                                        NULL,
                                        NULL,
                                        NULL,
                                        &IoStatusBlock,
                                        IOCTL_DISK_GET_DRIVE_LAYOUT_EX,
                                        NULL,
                                        0,
                                        DriveLayoutEx,
                                        DriveLayoutSize );
    }                                        

    if(!NT_SUCCESS(Status)) {
        KdPrintEx(( DPFLTR_SETUP_ID, DPFLTR_ERROR_LEVEL,  
              "SETUP: SpPtInitializeDiskAreas: unable to query IOCTL_DISK_GET_DRIVE_LAYOUT_EX on device %ws (%lx)\n",
              DevicePath,
              Status ));

        if (NewPartitions) {
            SpMemFree(NewPartitions);
        }

        if (DriveLayoutEx)
            SpMemFree(DriveLayoutEx);

        if (Handle != INVALID_HANDLE_VALUE)
            ZwClose(Handle);

        return ( Status );
    }

    //
    // What kind of disk is this?
    //
    switch (DriveLayoutEx->PartitionStyle) {
        case PARTITION_STYLE_GPT:
            Disk->FormatType = DISK_FORMAT_TYPE_GPT;

            break;
            
        case PARTITION_STYLE_MBR:
            Disk->FormatType = DISK_FORMAT_TYPE_PCAT;
            Disk->Signature = DriveLayoutEx->Mbr.Signature;

#if defined(_IA64_)            
            //
            // Make sure that this is not a raw disk
            // which is being faked as MBR disk
            //
            if (SpPtnIsRawDiskDriveLayout(DriveLayoutEx)) {
                Disk->FormatType = DISK_FORMAT_TYPE_RAW;
                SPPT_SET_DISK_BLANK(DiskNumber, TRUE);
            }
#endif

            break;
            
        case PARTITION_STYLE_RAW:
            Disk->FormatType = DISK_FORMAT_TYPE_RAW;
            SPPT_SET_DISK_BLANK(DiskNumber, TRUE);

            break;

        default:
            Disk->FormatType = DISK_FORMAT_TYPE_UNKNOWN;

            break;            
    }

    SpAppendDiskTag(Disk);

    SpPtDumpDriveLayoutInformation(DevicePath, DriveLayoutEx);
    
    //
    // Don't need this guy anymore.
    //
    ZwClose( Handle );
    
    //
    // might need this while committing
    //
    Disk->DriveLayout = *DriveLayoutEx;

    Status = STATUS_SUCCESS;
    
    //
    // ============================
    //
    // Initialize partiton descriptors.
    //
    // ============================
    //    
    if(DriveLayoutEx->PartitionCount) {
        BOOLEAN SysPartFound = FALSE;
        ULONG   PartitionedSpaceCount = 1;
        
        //
        // Initialize an area entry for each partition
        // on the disk.
        //
        for( i = 0, pDiskRegion = NULL; i < DriveLayoutEx->PartitionCount; i++ ) {
            ULONG Count = 0;
            ULONG TypeNameId = SP_TEXT_UNKNOWN;
            LARGE_INTEGER DelayTime;
            BOOLEAN AssignDriveLetter = TRUE;

            PPARTITION_INFORMATION_EX PartInfo = DriveLayoutEx->PartitionEntry + i;
            
            //
            // IOCTL_DISK_GET_DRIVE_LAYOUT_EX may return us a list of entries that
            // are not used, so ignore these partitions.
            //
            if (// if its partition 0, which indicates whole disk
                (SPPT_IS_GPT_DISK(DiskNumber) && (PartInfo->PartitionNumber == 0)) ||
                (PartInfo->PartitionLength.QuadPart == 0) ||
                // if MBR entry not used or length is zero
                ((DriveLayoutEx->PartitionStyle == PARTITION_STYLE_MBR) &&
                 (PartInfo->Mbr.PartitionType == PARTITION_ENTRY_UNUSED) &&
                 (PartInfo->PartitionLength.QuadPart == 0)) ||
                // if unknown/unused GPT partition
                ((DriveLayoutEx->PartitionStyle == PARTITION_STYLE_GPT) &&
                 (!memcmp(&PartInfo->Gpt.PartitionType, 
                            &PARTITION_ENTRY_UNUSED_GUID, sizeof(GUID))))){
                continue;                                  
            }

            //
            // Allocate space for the next region.
            //
            if(pDiskRegion) {
                pDiskRegion->Next = SpMemAlloc( sizeof(DISK_REGION) );                
                pDiskRegion = pDiskRegion->Next;
            } else {
                //
                // First region allocation for harddisk so initialize 
                // the region list head for the hardisk
                //                
                ASSERT(PartDisk->PrimaryDiskRegions == NULL);
                
                pDiskRegion = SpMemAlloc(sizeof(DISK_REGION));
                PartDisk->PrimaryDiskRegions = pDiskRegion;
                SPPT_SET_DISK_BLANK(DiskNumber, FALSE);
            }

            if(!pDiskRegion) {
                KdPrintEx(( DPFLTR_SETUP_ID, DPFLTR_ERROR_LEVEL,  
                    "SETUP: SpPtInitializeDiskAreas: SpMemAlloc failed!\n" ));
                                    
                Status = STATUS_NO_MEMORY;

                break;
            }
            
            RtlZeroMemory(pDiskRegion, sizeof(DISK_REGION));
            
            //
            // Start filling out our Region descriptor...
            //

            //
            // DiskNumber
            //
            pDiskRegion->DiskNumber = DiskNumber;

            //
            // Partition information
            //
            pDiskRegion->PartInfo = *PartInfo;

            //
            // StartSector
            //
            pDiskRegion->StartSector = PartInfo->StartingOffset.QuadPart /
                                        Disk->Geometry.BytesPerSector;

            //
            // SectorCount
            //
            pDiskRegion->SectorCount = PartInfo->PartitionLength.QuadPart /
                                        Disk->Geometry.BytesPerSector;


            //
            // PartitionNumber
            //
            pDiskRegion->PartitionNumber = PartInfo->PartitionNumber;
            
            if (SPPT_IS_MBR_DISK(DiskNumber) && (PartInfo->PartitionNumber == 0)) {
                if (IsContainerPartition(PartInfo->Mbr.PartitionType)) {
                    SPPT_SET_REGION_EPT(pDiskRegion, EPTContainerPartition);
                }

                //
                // nothing after this is really needed for container partition
                //
                continue;                  
            } else {
                //
                // PartitionedSpace
                //
                SPPT_SET_REGION_PARTITIONED(pDiskRegion, TRUE);
            }

            if (SPPT_IS_REGION_PARTITIONED(pDiskRegion)) {
                pDiskRegion->TablePosition = PartitionedSpaceCount++;
            }                

            //
            // Partition Number should be valid
            //
            ASSERT(pDiskRegion->PartitionNumber);
            
            //
            // IsSystemPartition (is it active)
            //
            if( DriveLayoutEx->PartitionStyle == PARTITION_STYLE_MBR ) {
                //
                // On IA64 systems don't use active MBR partitions as system 
                // partitions
                //
                if (!SpIsArc()) {
                    //
                    // He's an MBR disk, so we can rely on the BootIndicator field.
                    //
                    pDiskRegion->IsSystemPartition = PartInfo->Mbr.BootIndicator;
                } 

                //
                // Don't assign drive letters to OEM partitions
                //
                if (IsOEMPartition(SPPT_GET_PARTITION_TYPE(pDiskRegion))) {
                    AssignDriveLetter = FALSE;
                }
            } else {
                //
                // He's not MBR, look at his PartitionType (which is a GUID).
                //
                pDiskRegion->IsSystemPartition = FALSE;
                
                if(IsEqualGUID(&(PartInfo->Gpt.PartitionType), &(PARTITION_SYSTEM_GUID))) {
                    pDiskRegion->IsSystemPartition = TRUE;
                    AssignDriveLetter = FALSE;

#ifdef _IA64_
                    //
                    // We assign a Drive letter for ESP in the Recovery Console 
                    // for IA64
                    //
                    if (ForceConsole) {
                    	AssignDriveLetter = TRUE;                    	
                    }
#endif
                }
                              
            }

            if (SPPT_IS_REGION_SYSTEMPARTITION(pDiskRegion)) {
                SysPartFound = TRUE;
            }
                    
            
            //
            // FtPartition
            //
            if( DriveLayoutEx->PartitionStyle == PARTITION_STYLE_MBR ) {
                //
                // He's an MBR disk, so we can rely on the PartitionType field.
                //
                pDiskRegion->FtPartition = IsFTPartition(PartInfo->Mbr.PartitionType);
            } else {
                //
                // He's not MBR.  Assume he's GPT and look at his PartitionType (which is a GUID).
                //
                pDiskRegion->FtPartition = FALSE;
            }

            //
            // DynamicVolume
            // DynamicVolumeSuitableForOS
            //
            if( DriveLayoutEx->PartitionStyle == PARTITION_STYLE_MBR ) {
                //
                // He's an MBR disk, so we can rely on the PartitionType field.
                //
                pDiskRegion->DynamicVolume = (PartInfo->Mbr.PartitionType == PARTITION_LDM);
            } else {
                //
                // He's not MBR.  Assume he's GPT and look at his PartitionType (which is a GUID).
                //
                pDiskRegion->DynamicVolume = FALSE;
                
                if( !memcmp(&PartInfo->Gpt.PartitionType, 
                            &PARTITION_LDM_DATA_GUID, sizeof(GUID)) ) {
                    //
                    // The GUIDs match.
                    pDiskRegion->DynamicVolume = TRUE;
                }
            }

            if (pDiskRegion->DynamicVolume) {
                TypeNameId = SP_TEXT_PARTITION_NAME_DYNVOL;
            }

            //
            // if MSFT reserved partition (we need to keep track of it but
            // not process it)
            //
            if((DriveLayoutEx->PartitionStyle == PARTITION_STYLE_GPT) &&                
                (IsEqualGUID(&(PartInfo->Gpt.PartitionType), &PARTITION_MSFT_RESERVED_GUID) ||
                 IsEqualGUID(&(PartInfo->Gpt.PartitionType), &PARTITION_LDM_METADATA_GUID)  ||
                 IS_OEM_PARTITION_GPT(PartInfo->Gpt.Attributes))) {

                pDiskRegion->IsReserved = TRUE; 
                AssignDriveLetter = FALSE;

                //
                // Get the type name from the resources.
                //
                SpFormatMessage(pDiskRegion->TypeName,
                            sizeof(pDiskRegion->TypeName),
                            SP_TEXT_PARTNAME_RESERVED);
                
                continue;
            }               

            //
            // Assume we can't install on this dynamic volume.
            //
            pDiskRegion->DynamicVolumeSuitableForOS = FALSE;
            
            //
            // For the following entries, we need an Open handle to this partition.
            //            

            //
            // If the partition just got created, we may have to wait for
            // a few seconds before its actually available 
            //
            // Note : We wait for 20 secs at the max for each partition
            //
            for (Count = 0; (Count < 10); Count++) {
                //
                // Open the handle to the required partition
                //
                Status = SpOpenPartition( DevicePath,                
                                          PartInfo->PartitionNumber,
                                          &Handle,
                                          FALSE );

                if((Status == STATUS_NO_SUCH_DEVICE) ||
                   (Status == STATUS_OBJECT_NAME_NOT_FOUND)) {                    
                    KdPrintEx(( DPFLTR_SETUP_ID, DPFLTR_ERROR_LEVEL,  
                                "SETUP: SpPtInitializeDiskAreas: unable to open partition%d on device %ws (%lx)\n",
                                PartInfo->PartitionNumber,
                                DevicePath,
                                Status ));


                    DelayTime.HighPart = -1;                // relative time
                    DelayTime.LowPart = (ULONG)(-20000000);  // 2 secs in 100ns interval                     
                    
                    KeDelayExecutionThread(KernelMode, FALSE, &DelayTime);
                } else {
                    break;
                }
            }                

            //
            // Need the partition handle to continue
            //
            if (!NT_SUCCESS(Status)) {
                //
                // ignore the error while trying to open dynamic disks
                //
                if (SPPT_IS_REGION_DYNAMIC_VOLUME(pDiskRegion)) {
                    Status = STATUS_SUCCESS;
                }

                //
                // Get the type name from the resources.
                //
                SpFormatMessage(pDiskRegion->TypeName,
                            sizeof(pDiskRegion->TypeName),
                            TypeNameId);
                            
                continue;
            }                

            //
            // Check, if installtion can be done on the dynamic volume
            //
            if( pDiskRegion->DynamicVolume ) {
                //
                // Call disk manager to tell me if it's okay to
                // install on this dynamic volume.  If I get back
                // anything but STATUS_SUCCESS, then assume we
                // can't install here.
                //
                Status = ZwDeviceIoControlFile( 
                            Handle,
                            NULL,
                            NULL,
                            NULL,
                            &IoStatusBlock,
                            IOCTL_VOLUME_IS_PARTITION,
                            NULL,
                            0,
                            NULL,
                            0 );

                if( NT_SUCCESS(Status) ){
                    pDiskRegion->DynamicVolumeSuitableForOS = TRUE;
                }
            }
            
            //
            // Filesystem
            //
            pFSInfo = SpMemAlloc( sizeof(FILE_FS_ATTRIBUTE_INFORMATION) + (MAX_PATH*2) );

            if( !pFSInfo ) {
                KdPrintEx(( DPFLTR_SETUP_ID, DPFLTR_ERROR_LEVEL,  
                    "SETUP: SpPtInitializeDiskAreas: SpMemAlloc failed!\n" ));
                    
                ZwClose( Handle );

                Status = STATUS_NO_MEMORY;
                break;
            }

            RtlZeroMemory( pFSInfo, sizeof(FILE_FS_ATTRIBUTE_INFORMATION) + (MAX_PATH*2) );

            Status = ZwQueryVolumeInformationFile( 
                        Handle, 
                        &IoStatusBlock,
                        pFSInfo,
                        sizeof(FILE_FS_ATTRIBUTE_INFORMATION) + (MAX_PATH*2),
                        FileFsAttributeInformation );
                                                                                                   
            if (!NT_SUCCESS(Status)) {
                KdPrintEx(( DPFLTR_SETUP_ID, DPFLTR_ERROR_LEVEL,  
                    "SETUP: SpPtInitializeDiskAreas: Failed to retrieve partition attribute information (%lx)\n", 
                    Status ));
            } else {                
                if (!wcscmp(pFSInfo->FileSystemName, L"NTFS")) {
                    pDiskRegion->Filesystem = FilesystemNtfs;
                    TypeNameId = SP_TEXT_FS_NAME_3;
                } else if (!wcscmp(pFSInfo->FileSystemName, L"FAT")) {
                    pDiskRegion->Filesystem = FilesystemFat;
                    TypeNameId = SP_TEXT_FS_NAME_2;
                } else if (!wcscmp(pFSInfo->FileSystemName, L"FAT32")) {
                    pDiskRegion->Filesystem = FilesystemFat32;
                    TypeNameId = SP_TEXT_FS_NAME_4;
                } else if (TypeNameId == SP_TEXT_UNKNOWN){
                    ULONG   Index;

                    pDiskRegion->Filesystem = FilesystemUnknown;

                    //
                    // Make sure it was not already created new partition
                    //
                    for (Index = 0; Index < NewPartitionCount; Index++) {
                        if (pDiskRegion->StartSector == NewPartitions[Index]) {
                            pDiskRegion->Filesystem = FilesystemNewlyCreated;
                            TypeNameId = SP_TEXT_FS_NAME_1;

                            break;
                        }                       
                    }                                                    
                }
            }

            //
            // if we cannot determine the partition type, then try
            // to use the known name from partition id.
            //
            if ((TypeNameId == SP_TEXT_UNKNOWN) && SPPT_IS_MBR_DISK(DiskNumber)) {                
                ULONG PartitionType = SPPT_GET_PARTITION_TYPE(pDiskRegion);

                if (PartitionType < 256) {   
                    UCHAR NameId = PartitionNameIds[SPPT_GET_PARTITION_TYPE(pDiskRegion)];

                    if (NameId != 0xFF) {
                        TypeNameId = SP_TEXT_PARTITION_NAME_BASE + NameId;
                    }                                                
                }                        
            }                
                                                            

            //
            // Get the type name from the resources.
            //
            SpFormatMessage(pDiskRegion->TypeName,
                        sizeof(pDiskRegion->TypeName),
                        TypeNameId);

            SpMemFree( pFSInfo );

            //
            // FreeSpaceKB and BytesPerCluster (only if we know what FS it is)
            //
            if ((pDiskRegion->Filesystem != FilesystemUnknown) &&
                 (pDiskRegion->Filesystem != FilesystemNewlyCreated)) {
                //
                // Delete \pagefile.sys if it's there.  This makes disk free space
                // calculations a little easier.
                //
                MyTempBuffer = (PWCHAR)SpMemAlloc( MAX_NTPATH_LENGTH );

                if( !MyTempBuffer ) {
                    //
                    // No memory...
                    //
                    KdPrintEx(( DPFLTR_SETUP_ID, DPFLTR_ERROR_LEVEL,  
                        "SETUP: SpPtInitializeDiskAreas: SpMemAlloc failed!\n" ));

                    Status = STATUS_NO_MEMORY;
                    break;
                }

                SpNtNameFromRegion( pDiskRegion,
                                    MyTempBuffer,
                                    MAX_NTPATH_LENGTH,
                                    PrimaryArcPath );
                                    
                SpConcatenatePaths( MyTempBuffer, L"" );
                SpDeleteFile( MyTempBuffer, L"pagefile.sys", NULL );

                SpMemFree( MyTempBuffer );
                MyTempBuffer = NULL;

                pSizeInfo = SpMemAlloc( sizeof(FILE_FS_SIZE_INFORMATION) + (MAX_PATH*2) );

                if( !pSizeInfo ) {
                    KdPrintEx(( DPFLTR_SETUP_ID, DPFLTR_ERROR_LEVEL,  
                        "SETUP: SpPtInitializeDiskAreas: SpMemAlloc failed!\n" ));
                    
                    ZwClose( Handle );

                    Status = STATUS_NO_MEMORY;
                    break;
                }

                RtlZeroMemory( pSizeInfo, sizeof(FILE_FS_SIZE_INFORMATION) + (MAX_PATH*2) );

                Status = ZwQueryVolumeInformationFile( 
                            Handle, 
                            &IoStatusBlock,
                            pSizeInfo,
                            sizeof(FILE_FS_SIZE_INFORMATION) + (MAX_PATH*2),
                            FileFsSizeInformation );

                //
                // Waiting for another 2 secs for the volume to appear 
                //
                if (Status == STATUS_NO_SUCH_DEVICE) {
                    //
                    // Wait for 2 seconds
                    //
                    DelayTime.HighPart = -1;                // relative time
                    DelayTime.LowPart = (ULONG)(-20000000);  // 2 secs in 100ns interval                                     
                    KeDelayExecutionThread(KernelMode, FALSE, &DelayTime);
                    
                    RtlZeroMemory( pSizeInfo, sizeof(FILE_FS_SIZE_INFORMATION) + (MAX_PATH*2) );

                    Status = ZwQueryVolumeInformationFile( 
                                Handle, 
                                &IoStatusBlock,
                                pSizeInfo,
                                sizeof(FILE_FS_SIZE_INFORMATION) + (MAX_PATH*2),
                                FileFsSizeInformation );
                }
                            
                if (!NT_SUCCESS(Status)) {
                    KdPrintEx(( DPFLTR_SETUP_ID, DPFLTR_ERROR_LEVEL,  
                        "SETUP: SpPtInitializeDiskAreas: Failed to retrieve disk(%d)partition(%d) sizing information (%lx)\n", 
                        DiskNumber,
                        pDiskRegion->PartitionNumber,                        
                        Status ));
                } else {
                    LARGE_INTEGER FreeBytes;

                    FreeBytes = RtlExtendedIntegerMultiply( 
                                    pSizeInfo->AvailableAllocationUnits,
                                    pSizeInfo->SectorsPerAllocationUnit * pSizeInfo->BytesPerSector );

                    pDiskRegion->FreeSpaceKB = RtlExtendedLargeIntegerDivide( FreeBytes,
                                                                              1024, &r ).LowPart;
                    if(r >= 512) {
                        pDiskRegion->FreeSpaceKB++;
                    }

                    //
                    // Sigh...  Legacy stuff.  SpPtDeterminePartitionGood() will want this
                    // field so that he knows what the free-space+space_from_local_source is.
                    //
                    pDiskRegion->AdjustedFreeSpaceKB = pDiskRegion->FreeSpaceKB;

                    pDiskRegion->BytesPerCluster = 
                        pSizeInfo->SectorsPerAllocationUnit * pSizeInfo->BytesPerSector;
                }

                SpMemFree( pSizeInfo );

                //
                // VolumeLabel
                //
                pLabelInfo = SpMemAlloc( sizeof(FILE_FS_VOLUME_INFORMATION) + (MAX_PATH*2) );

                if( !pFSInfo ) {
                    KdPrintEx(( DPFLTR_SETUP_ID, DPFLTR_ERROR_LEVEL,  
                        "SETUP: SpPtInitializeDiskAreas: SpMemAlloc failed!\n" ));
                        
                    ZwClose( Handle );

                    Status = STATUS_NO_MEMORY;
                    break;
                }

                RtlZeroMemory( pLabelInfo, sizeof(FILE_FS_VOLUME_INFORMATION) + (MAX_PATH*2) );

                Status = ZwQueryVolumeInformationFile(
                            Handle, 
                            &IoStatusBlock,
                            pLabelInfo,
                            sizeof(FILE_FS_VOLUME_INFORMATION) + (MAX_PATH*2),
                            FileFsVolumeInformation );

                if (!NT_SUCCESS(Status)) {
                    KdPrintEx(( DPFLTR_SETUP_ID, DPFLTR_ERROR_LEVEL,  
                        "SETUP: SpPtInitializeDiskAreas: Failed to retrieve volume information (%lx)\n", Status));
                } else {
                    ULONG SaveCharCount;
                    
                    //
                    // We'll only save away the first <n> characters of
                    // the volume label.
                    //
                    SaveCharCount = min( pLabelInfo->VolumeLabelLength + sizeof(WCHAR),
                                         sizeof(pDiskRegion->VolumeLabel) ) / sizeof(WCHAR);

                    if(SaveCharCount) {
                        SaveCharCount--;  // allow for terminating NUL.
                    }

                    wcsncpy( pDiskRegion->VolumeLabel,
                             pLabelInfo->VolumeLabel,
                             SaveCharCount );
                             
                    pDiskRegion->VolumeLabel[SaveCharCount] = 0;

                }

                SpMemFree( pLabelInfo );
            } else {
                //
                // Free space is what ever the partition size is
                //
                pDiskRegion->FreeSpaceKB = (pDiskRegion->SectorCount * 
                                            Disk->Geometry.BytesPerSector) / 1024;

                pDiskRegion->AdjustedFreeSpaceKB = pDiskRegion->FreeSpaceKB;                                            
            }

            //
            // Assign the drive letter if required
            //
            if (AssignDriveLetter) {
                //
                // Retrieve nt pathname for this region.
                //
                MyTempBuffer = (PWCHAR)SpMemAlloc( MAX_NTPATH_LENGTH );

                if( !MyTempBuffer ) {
                    //
                    // No memory...
                    //
                    KdPrintEx(( DPFLTR_SETUP_ID, DPFLTR_ERROR_LEVEL,  
                        "SETUP: SpPtInitializeDiskAreas: SpMemAlloc failed!\n" ));

                    Status = STATUS_NO_MEMORY;
                    break;
                }
        
                SpNtNameFromRegion( pDiskRegion,
                                    MyTempBuffer,
                                    MAX_NTPATH_LENGTH,
                                    PrimaryArcPath );

                //
                // Assign the drive letter 
                //
                pDiskRegion->DriveLetter = SpGetDriveLetter( MyTempBuffer, NULL );

                KdPrintEx(( DPFLTR_SETUP_ID, DPFLTR_INFO_LEVEL, 
                    "SETUP: SpPtInitializeDiskAreas: Partition = %ls, DriveLetter = %wc: \n", 
                    MyTempBuffer, pDiskRegion->DriveLetter));

                SpMemFree( MyTempBuffer );
                MyTempBuffer = NULL;
            }                
            
            //
            // See if this guy has the local source.
            //
            //
            MyTempBuffer = (PWCHAR)SpMemAlloc( MAX_NTPATH_LENGTH );

            if( !MyTempBuffer ) {
                //
                // No memory...
                //
                KdPrintEx(( DPFLTR_SETUP_ID, DPFLTR_ERROR_LEVEL,  
                    "SETUP: SpPtInitializeDiskAreas: SpMemAlloc failed!\n" ));
                    
                Status = STATUS_NO_MEMORY;
                break;
            }

            SpNtNameFromRegion( pDiskRegion,
                                MyTempBuffer,
                                MAX_NTPATH_LENGTH,
                                PrimaryArcPath );
                                
            SpConcatenatePaths( MyTempBuffer, L"" );

            //
            // Don't need this guy anymore.
            //
            ZwClose( Handle );


            if( WinntSetup && !WinntFromCd && !LocalSourceRegion &&
                    SpNFilesExist(MyTempBuffer, LocalSourceFiles, ELEMENT_COUNT(LocalSourceFiles), TRUE) ) {

                LocalSourceRegion = pDiskRegion;
                pDiskRegion->IsLocalSource = TRUE;

                KdPrintEx((DPFLTR_SETUP_ID, DPFLTR_INFO_LEVEL, 
                    "SETUP: %ws is the local source partition.\n", MyTempBuffer));
            } else {
                KdPrintEx((DPFLTR_SETUP_ID, DPFLTR_INFO_LEVEL, 
                    "SETUP: %ws is not the local source partition.\n", MyTempBuffer));
            }

            SpMemFree( MyTempBuffer );
            MyTempBuffer = NULL;
            Status = STATUS_SUCCESS;
        }

        //
        // Go ahead and locate the system partitions on this disk
        //
        if (SpIsArc()) {
            if (!SysPartFound) {
                SpPtnLocateDiskSystemPartitions(DiskNumber);
            } else {
                ValidArcSystemPartition = TRUE;
            }
        }
    }

    //
    // Update the boot entries to reflect the 
    // new region pointers
    //
    SpUpdateRegionForBootEntries();

    if (NewPartitions) {
        SpMemFree(NewPartitions);
    }    

    SpMemFree( DriveLayoutEx );

    return Status;
}


NTSTATUS
SpPtnSortDiskAreas(
    IN ULONG DiskNumber
    )
/*++

Routine Description:

    Examine the partitions defined on this disk and sort them
    according to their location on the disk.

Arguments:

    DiskNumber - supplies the disk number of the disk whose partitions
                 we want to inspect.

Return Value:

    NTSTATUS.  If all goes well, we should be returing STATUS_SUCCESS.

--*/
{
    NTSTATUS        Status = STATUS_SUCCESS;
    PDISK_REGION    pTempDiskRegion = NULL;
    PDISK_REGION    pCurrentDiskRegion = NULL;
    PDISK_REGION    pPreviousDiskRegion = NULL;

    //
    // Get a pointer to the list of regions.
    //
    pCurrentDiskRegion = PartitionedDisks[DiskNumber].PrimaryDiskRegions;

    if( !pCurrentDiskRegion ) {
        //
        // Odd.  Either something is very wrong, or
        // this disk simply has no partitions, which is
        // certainly possible.  Assume the best.
        //
        return  STATUS_SUCCESS;
    }

    //
    // We got something.  Go sort the list.  There
    // can't be very many partitions, so just bubble-sort.
    //
    while( pCurrentDiskRegion->Next ) {
        //
        // There's another partition ahead of
        // us.  See if we need to switch places.
        //
        if( pCurrentDiskRegion->StartSector > pCurrentDiskRegion->Next->StartSector ) {
            //
            // Yes, we need to swap these 2 entries.
            // Fixup the pointers.
            //
            if( pPreviousDiskRegion ) {
                //
                // 1. Set the previous disk region to point to
                //    the region after us.
                //
                pPreviousDiskRegion->Next = pCurrentDiskRegion->Next;
            } else {
                //
                // We're at the very beginning of the linked
                // list.
                //

                //
                // 1. Set the disk's region pointer to point to
                //    the region after us.
                //
                PartitionedDisks[DiskNumber].PrimaryDiskRegions = pCurrentDiskRegion->Next;
            }

            //
            // 2. Set our our next region's Next pointer to
            //    come back to us.
            //
            pTempDiskRegion = pCurrentDiskRegion->Next->Next;
            pCurrentDiskRegion->Next->Next = pCurrentDiskRegion;

            //
            // 3. Set our own pointer to a couple of regions ahead.
            //
            pCurrentDiskRegion->Next = pTempDiskRegion;

            //
            // Now reset so we start the sort over again.
            //
            pCurrentDiskRegion = PartitionedDisks[DiskNumber].PrimaryDiskRegions;
            pPreviousDiskRegion = NULL;
        } else {
            //
            // No need to swap these two regions in our list.  Increment
            // our pointers and continue.
            //
            pPreviousDiskRegion = pCurrentDiskRegion;
            pCurrentDiskRegion = pCurrentDiskRegion->Next;
        }
    }

    return  Status;
}


NTSTATUS
SpPtnInitRegionFromDisk(
    IN ULONG DiskNumber,
    OUT PDISK_REGION Region
    )
/*++

Routine Description:

    Given the disk id, creates a disk region representing
    the whole disk

Arguments:

    DiskNumber  :   Disk Id

    Region      :   Region which gets initialized on return

Return Value:

    STATUS_SUCCESS if successful, otherwise STATUS_INVALID_PARAMETER

--*/    
{   
    NTSTATUS Status = STATUS_INVALID_PARAMETER;
    
    if (Region) {
        PHARD_DISK Disk = SPPT_GET_HARDDISK(DiskNumber);

        RtlZeroMemory(Region, sizeof(DISK_REGION));

        //
        // Note : Most of the fields below don't need to be initialized
        // because of the memset above, but its done for sake of
        // clarity
        //
        Region->DiskNumber = DiskNumber;
        Region->StartSector = Disk->Geometry.SectorsPerTrack;
        Region->SectorCount = Disk->DiskSizeSectors - Region->StartSector;
        SPPT_SET_REGION_PARTITIONED(Region, FALSE);
        Region->PartitionNumber = 0;
        Region->MbrInfo = NULL;
        Region->TablePosition = 0;
        Region->IsSystemPartition = FALSE;
        Region->IsLocalSource = FALSE;
        Region->Filesystem = FilesystemUnknown;
        Region->FreeSpaceKB = Disk->DiskSizeMB * 1024;
        Region->BytesPerCluster = -1;
        Region->AdjustedFreeSpaceKB = Region->FreeSpaceKB;
        Region->DriveLetter = 0;
        Region->FtPartition = FALSE;
        Region->DynamicVolume = FALSE;
        Region->DynamicVolumeSuitableForOS = FALSE;

        Status = STATUS_SUCCESS;
    }        

    return Status;
}    


NTSTATUS
SpPtnFillDiskFreeSpaceAreas(
    IN ULONG DiskNumber
    )
/*++

Routine Description:

    This function will go peruse all partitions on the disk.  If there are
    any free regions on the disk, we'll create a region entry and
    mark it as unformatted.

Arguments:

    DiskNumber - supplies the disk number of the disk whose partitions
                 we want to inspect.

Return Value:

    NTSTATUS.  If all goes well, we should be returing STATUS_SUCCESS.

--*/
{
    NTSTATUS        Status = STATUS_SUCCESS;
    PDISK_REGION    pTempDiskRegion;
    PDISK_REGION    pCurrentDiskRegion = NULL;
    ULONGLONG       NextStart;
    ULONGLONG       NextSize;
    PDISK_REGION    FirstContainer = NULL;

    //
    // Get a pointer to the list of regions.
    //
    pCurrentDiskRegion = PartitionedDisks[DiskNumber].PrimaryDiskRegions;

    if( !pCurrentDiskRegion ) {
        //
        // Odd.  Either something is very wrong, or
        // this disk simply has no partitions, which is
        // certainly possible.  Assume the best and
        // create one region entry that encompasses all
        // space on the disk, but is unpartitioned.
        //        
        pCurrentDiskRegion = SpMemAlloc(sizeof(DISK_REGION));

        if (pCurrentDiskRegion) {
            Status = SpPtnInitRegionFromDisk(DiskNumber, pCurrentDiskRegion);
        } else {
            Status = STATUS_NO_MEMORY;
        }            

        if (NT_SUCCESS(Status)) {
            ASSERT(!PartitionedDisks[DiskNumber].PrimaryDiskRegions);
            
            PartitionedDisks[DiskNumber].PrimaryDiskRegions =
                    pCurrentDiskRegion;

            SPPT_SET_DISK_BLANK(DiskNumber, TRUE);
        }                    
        
        return Status;
    }

    //
    // The regions are already sorted according to their relative
    // position on the disk, so before we go through them, let's
    // see if there's any empty space on the disk occurring *before*
    // the first partition.
    //
    if( pCurrentDiskRegion->StartSector > SPPT_DISK_TRACK_SIZE(DiskNumber) ) {
        //
        // Yep.  Make a region descriptor for this guy (if he is more than
        // one cylinder in size)
        //
        NextStart = SPPT_DISK_TRACK_SIZE(DiskNumber);
        NextSize = pCurrentDiskRegion->StartSector - NextStart;

        //
        // The first partition can start at first track offset. So this need not always
        // be of minimum cylinder size
        //
        if (NextSize >= (SPPT_DISK_CYLINDER_SIZE(DiskNumber) - SPPT_DISK_TRACK_SIZE(DiskNumber))) {        
            pTempDiskRegion = SpMemAlloc( sizeof(DISK_REGION) );

            if(!pTempDiskRegion) {
                KdPrintEx(( DPFLTR_SETUP_ID, DPFLTR_ERROR_LEVEL,  
                        "SETUP: SpPtFillFreeSpaceAreas: SpMemAlloc failed!\n" ));
                        
                return  STATUS_NO_MEMORY;
            }

            RtlZeroMemory( pTempDiskRegion, sizeof(DISK_REGION) );

            pTempDiskRegion->DiskNumber = DiskNumber;
            pTempDiskRegion->StartSector = NextStart;
            pTempDiskRegion->SectorCount = NextSize;

            //
            // Put this region before the current region
            //
            pTempDiskRegion->Next = pCurrentDiskRegion;
            PartitionedDisks[DiskNumber].PrimaryDiskRegions = pTempDiskRegion;
        }            
    }

    //
    // Now go through the regions, inserting regions to account for any
    // empty space between the partitions.
    //
    while( pCurrentDiskRegion ) {
        if( !pCurrentDiskRegion->Next ) {            

            NextStart = 0;
            
            //
            // if this is container partition then all the space in this
            // container is free space
            //
            if (SPPT_IS_MBR_DISK(DiskNumber) && 
                IsContainerPartition(SPPT_GET_PARTITION_TYPE(pCurrentDiskRegion))) {
                PDISK_REGION ExtFree = NULL;

                ASSERT(FirstContainer == NULL);

                //
                // We add one here because we should be able to differentiate the starting
                // free region inside the extended partition from the extended partition
                // itself.
                //
                NextStart = pCurrentDiskRegion->StartSector + 1;
                NextSize = pCurrentDiskRegion->SectorCount;

                if (NextSize >= SPPT_DISK_CYLINDER_SIZE(DiskNumber)) {                
                    PDISK_REGION ExtFree = SpMemAlloc(sizeof(DISK_REGION));

                    if (!ExtFree) {
                        KdPrintEx(( DPFLTR_SETUP_ID, DPFLTR_ERROR_LEVEL,  
                            "SETUP: SpPtFillFreeSpaceAreas: SpMemAlloc failed!\n" ));
                            
                        return  STATUS_NO_MEMORY;
                    }

                    RtlZeroMemory(ExtFree, sizeof(DISK_REGION));

                    ExtFree->DiskNumber = DiskNumber;
                    ExtFree->StartSector = NextStart;
                    ExtFree->SectorCount = NextSize;

                    pCurrentDiskRegion->Next = ExtFree;

                    //
                    // make the new region current region !!!
                    //
                    pCurrentDiskRegion = ExtFree;   

                    NextStart = NextStart + NextSize - 1;
                } else {
                    //
                    // Make sure that the free space after the extended 
                    // partition is accounted for
                    //
                    NextStart = 0;  
                }                    
            } 
            
            //                
            // There's nothing behind of us.  See if there's any
            // empty space back there that's unaccounted for.
            // 
            if (!NextStart) {
                NextStart = pCurrentDiskRegion->StartSector + 
                            pCurrentDiskRegion->SectorCount;
            }                            

            if (PartitionedDisks[DiskNumber].HardDisk->DiskSizeSectors > NextStart) {
                NextSize = PartitionedDisks[DiskNumber].HardDisk->DiskSizeSectors -
                                NextStart;
            } else {
                NextSize = 0;
            }

            //
            // For ASR, allow partition size on GPT disks to be >= 1 sector.  
            // In all other cases, partition size must be >= 1 cylinder.
            //
            if ((NextSize >= SPPT_DISK_CYLINDER_SIZE(DiskNumber))  || 
                (SpDrEnabled() && SPPT_IS_GPT_DISK(DiskNumber) && (NextSize >= 1))
                ) {
                //
                // Yes there is.  We need to make a region behind us that's
                // marked as unpartitioned.
                //                
                if (FirstContainer) {
                    //
                    // there could be free space at the end of the 
                    // extended partition. Mark is separately from
                    // the free space after the extended partition
                    //
                    ULONGLONG ExtEnd = FirstContainer->StartSector + 
                                        FirstContainer->SectorCount;
                    ULONGLONG ExtFreeStart = NextStart;
                    ULONGLONG ExtFreeSize = (ExtEnd > ExtFreeStart) ?
                                            ExtEnd - ExtFreeStart : 0;

                    KdPrintEx((DPFLTR_SETUP_ID, DPFLTR_INFO_LEVEL,
                            "SETUP:SpPtnFillDiskFreeSpaces():EFS:%I64d,EFSize:%I64d,EE:%I64d\n",
                            ExtFreeStart,
                            ExtFreeSize,
                            ExtEnd));

                    if (ExtFreeSize >= SPPT_DISK_CYLINDER_SIZE(DiskNumber)) {
                        PDISK_REGION ExtFree = SpMemAlloc(sizeof(DISK_REGION));

                        if (!ExtFree) {
                            KdPrintEx(( DPFLTR_SETUP_ID, DPFLTR_ERROR_LEVEL,  
                                "SETUP: SpPtnFillFreeSpaceAreas: SpMemAlloc failed!\n" ));
                                
                            return  STATUS_NO_MEMORY;
                        }

                        RtlZeroMemory(ExtFree, sizeof(DISK_REGION));

                        ExtFree->DiskNumber = DiskNumber;
                        ExtFree->StartSector = ExtFreeStart;
                        ExtFree->SectorCount = ExtFreeSize;

                        pCurrentDiskRegion->Next = ExtFree;
                        pCurrentDiskRegion = ExtFree;

                        NextStart = ExtEnd;
                        NextSize = 0;

                        if (PartitionedDisks[DiskNumber].HardDisk->DiskSizeSectors > NextStart) {
                            NextSize = PartitionedDisks[DiskNumber].HardDisk->DiskSizeSectors -
                                        NextStart;
                        }                                                                                                            
                    } else {
                        //
                        // Get rid of any free space at the end which is lesser than a 
                        // cylinder partition inside the exteneded partition before
                        // we try to see if there is adequate space at the end of extended
                        // partition
                        //
                        NextStart += ExtFreeSize;
                        NextSize -= ExtFreeSize;
                    }
                }

                //
                // For ASR, allow partition size on GPT disks to be >= 1 sector.  
                // In all other cases, partition size must be >= 1 cylinder.
                //
                if ((NextSize >= SPPT_DISK_CYLINDER_SIZE(DiskNumber))  || 
                    (SpDrEnabled() && SPPT_IS_GPT_DISK(DiskNumber) && (NextSize >= 1))
                    ) {
                    pTempDiskRegion = SpMemAlloc( sizeof(DISK_REGION) );

                    if(!pTempDiskRegion) {
                        KdPrintEx(( DPFLTR_SETUP_ID, DPFLTR_ERROR_LEVEL,  
                            "SETUP: SpPtnFillFreeSpaceAreas: SpMemAlloc failed!\n" ));
                            
                        return(STATUS_NO_MEMORY);
                    }

                    RtlZeroMemory( pTempDiskRegion, sizeof(DISK_REGION) );


                    pTempDiskRegion->DiskNumber = DiskNumber;
                    pTempDiskRegion->StartSector = NextStart;
                    pTempDiskRegion->SectorCount = NextSize;
                    pCurrentDiskRegion->Next = pTempDiskRegion;
                }                    
            }

            //
            // We just processed the last region.  If there was any free space
            // behind that partition, we just accounted for it, in which case
            // we're done with this disk.  If there wasn't any free space behind
            // that partition, then we're also done.
            //
            return( Status );
        } else {
            //
            // There's another partition ahead of us.
            // See if there's free space between them.
            //
            NextStart = pCurrentDiskRegion->StartSector + 
                        pCurrentDiskRegion->SectorCount;

            if (pCurrentDiskRegion->Next->StartSector > NextStart) {
                NextSize = pCurrentDiskRegion->Next->StartSector - NextStart;                        

                //
                // Check to see if its a container partition
                //
                if (!FirstContainer && SPPT_IS_MBR_DISK(DiskNumber) && 
                    IsContainerPartition(SPPT_GET_PARTITION_TYPE(pCurrentDiskRegion))) {
                    
                    FirstContainer = pCurrentDiskRegion; 
                    NextStart = pCurrentDiskRegion->StartSector + 1;
                    NextSize = pCurrentDiskRegion->Next->StartSector - NextStart;
                }

                if (FirstContainer) {
                    ULONGLONG   ExtEnd = FirstContainer->StartSector +  
                                         FirstContainer->SectorCount;
                    ULONGLONG   FreeEnd = pCurrentDiskRegion->Next->StartSector;
                    
                    //
                    // Split the free region into extended free and normal free region
                    // if needed
                    //
                    if (!SPPT_IS_REGION_CONTAINED(FirstContainer, pCurrentDiskRegion->Next) && 
                        (ExtEnd < FreeEnd)) {
                        
                        PDISK_REGION ExtFree = NULL;

                        //
                        // If the free space doesnt overlap the extended partition
                        // then do not subtract from extended end
                        //
                        if (NextStart < ExtEnd){
                            NextSize = ExtEnd - NextStart;
                        }
                        
                        if (NextSize >= SPPT_DISK_CYLINDER_SIZE(DiskNumber)) {
                            ExtFree = SpMemAlloc(sizeof(DISK_REGION));

                            if (!ExtFree) {
                                KdPrintEx(( DPFLTR_SETUP_ID, DPFLTR_ERROR_LEVEL,  
                                    "SETUP: SpPtnFillFreeSpaceAreas: SpMemAlloc failed!\n" ));
                                    
                                return  STATUS_NO_MEMORY;
                            }

                            RtlZeroMemory(ExtFree, sizeof(DISK_REGION));

                            ExtFree->DiskNumber = DiskNumber;
                            ExtFree->StartSector = NextStart;
                            ExtFree->SectorCount = NextSize;

                            //
                            // insert the region after the current one
                            //
                            ExtFree->Next = pCurrentDiskRegion->Next;
                            pCurrentDiskRegion->Next = ExtFree;

                            //
                            // make the new region current
                            //
                            pCurrentDiskRegion = ExtFree;
                        }

                        //
                        // Fix the next free region start
                        //
                        NextStart += NextSize;

                        if (FreeEnd > NextStart) {
                            NextSize = FreeEnd - NextStart;
                        } else {
                            NextSize = 0;
                        }
                    }                    
                }                
            } else {
                //
                // skip container partitions (expect for starting free space
                // inside the container partition)
                //  
                NextSize = 0;
                
                if (SPPT_IS_MBR_DISK(DiskNumber) && 
                    IsContainerPartition(SPPT_GET_PARTITION_TYPE(pCurrentDiskRegion)) && 
                    (pCurrentDiskRegion->Next->StartSector > pCurrentDiskRegion->StartSector)) {

                    if (!FirstContainer) {
                        FirstContainer = pCurrentDiskRegion;
                        KdPrintEx((DPFLTR_SETUP_ID, DPFLTR_INFO_LEVEL,
                            "SETUP:SpPtnFillDiskFreeSpaces():%p is the first container\n", 
                            FirstContainer));
                    }                        
                    
                    //
                    // We add one here because we should be able to differentiate the starting
                    // free region inside the extended partition from the extended partition
                    // itself.
                    //
                    NextStart = pCurrentDiskRegion->StartSector + 1;            
                    NextSize = pCurrentDiskRegion->Next->StartSector - NextStart + 1;
                }
            }                

            //
            // For ASR, allow partition size on GPT disks to be >= 1 sector.  
            // In all other cases, partition size must be >= 1 cylinder.
            //
            if ((NextSize >= SPPT_DISK_CYLINDER_SIZE(DiskNumber))  || 
                (SpDrEnabled() && SPPT_IS_GPT_DISK(DiskNumber) && (NextSize >= 1))
                ) {
                //
                // Yes, there's free space and we need to insert
                // a region here to represent it.  Allocate a region
                // and initialize it as unpartitioned space.
                //
                pTempDiskRegion = SpMemAlloc( sizeof(DISK_REGION) );

                if(!pTempDiskRegion) {
                    KdPrintEx(( DPFLTR_SETUP_ID, DPFLTR_ERROR_LEVEL,  
                    "SETUP: SpPtnFillFreeSpaceAreas: SpMemAlloc failed!\n" ));
                    
                    return(STATUS_NO_MEMORY);
                }

                RtlZeroMemory( pTempDiskRegion, sizeof(DISK_REGION) );


                pTempDiskRegion->DiskNumber = DiskNumber;
                pTempDiskRegion->StartSector = NextStart;
                pTempDiskRegion->SectorCount = NextSize;
                
                pTempDiskRegion->Next = pCurrentDiskRegion->Next;
                pCurrentDiskRegion->Next = pTempDiskRegion;
                pCurrentDiskRegion = pTempDiskRegion;
            }
        }
        pCurrentDiskRegion = pCurrentDiskRegion->Next;
    }

    return  Status;
}


#ifdef NOT_USED_CURRENTLY

VOID
SpDeleteDiskDriveLetters(
    VOID
    )
/*++

Routine Description:

    This routine will delete all drive letters assigned to disks and CD-ROM drives. The deletion will
    occur only if setup was started booting from the CD or boot floppies (in which case drive letter
    migration does not take place), and only if the non-removable dissks have no partitioned spaces.
    This ensures that on a clean install from the CD or boot floppies, the drive letters assigned to
    partitions on removable disks and CD-ROM drives will always be greater than the drive letters assigned
    to partitions on non-removable disks (unless the partitions on the removable disks were created before
    the ones in the removable disks, during textmode setup).


Arguments:

    None.

Return Value:

    None.

--*/
{
    ULONG           DiskNumber;
    PDISK_REGION    pDiskRegion;
    PWCHAR          MyTempBuffer = NULL;
    unsigned        pass;
    BOOLEAN         PartitionedSpaceFound = FALSE;

    if( WinntSetup ) {
        //
        // If setup started from winnt32.exe then do not delete the drive letters since we want to preserve them
        //
        return;
    }

    //
    //  Setup started booting from a CD.
    //
    //  Find out if the disks contain at least one partition that is not a container.
    //  Note that we do not take into consideration partitions that are on removable media.
    //  This is to avoid the situation in which a newly created partition on a non-removable disk ends up with
    //  a drive letter that is greater than the one assigned to an existing partition on a removable disk.
    //
    for(DiskNumber = 0; !PartitionedSpaceFound && (DiskNumber<HardDiskCount); DiskNumber++) {

        if( PartitionedDisks[DiskNumber].HardDisk->Geometry.MediaType != RemovableMedia) {
            //
            // This disk isn't removable.  Let's look at all the areas and see
            // if there's anything that's partitioned.
            //
            pDiskRegion = PartitionedDisks[DiskNumber].PrimaryDiskRegions;

            while( pDiskRegion ) {
                if(SPPT_IS_REGION_PARTITIONED(pDiskRegion)) {
                    PartitionedSpaceFound = TRUE;
                }

                //
                // Now get the next region on this disk.
                //
                pDiskRegion = pDiskRegion->Next;
            }
        }
    }

    if( !PartitionedSpaceFound ) {
        //
        // There are no partitions on this machine.  Delete all drive letters
        // so that the drive letters for each CD-ROM drive also get deleted.
        //
        // We'll do this by sending an IOCTL to the MountManager and ask him
        // to whack all his knowledge of drive letters.
        //
        NTSTATUS                Status;
        OBJECT_ATTRIBUTES       Obja;
        IO_STATUS_BLOCK         IoStatusBlock;
        UNICODE_STRING          UnicodeString;
        HANDLE                  Handle;

        INIT_OBJA(&Obja,&UnicodeString,MOUNTMGR_DEVICE_NAME);

        Status = ZwOpenFile( &Handle,
                             (ACCESS_MASK)(FILE_GENERIC_READ | FILE_GENERIC_WRITE),
                             &Obja,
                             &IoStatusBlock,
                             FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE,
                             FILE_NON_DIRECTORY_FILE );

        if( NT_SUCCESS( Status ) ) {

            MOUNTMGR_MOUNT_POINT    MountMgrMountPoint;

            MountMgrMountPoint.SymbolicLinkNameOffset = 0;
            MountMgrMountPoint.SymbolicLinkNameLength = 0;
            MountMgrMountPoint.UniqueIdOffset = 0;
            MountMgrMountPoint.UniqueIdLength = 0;
            MountMgrMountPoint.DeviceNameOffset = 0;
            MountMgrMountPoint.DeviceNameLength = 0;

            Status = ZwDeviceIoControlFile( Handle,
                                            NULL,
                                            NULL,
                                            NULL,
                                            &IoStatusBlock,
                                            IOCTL_MOUNTMGR_DELETE_POINTS,
                                            &MountMgrMountPoint,
                                            sizeof( MOUNTMGR_MOUNT_POINT ),
                                            TemporaryBuffer,
                                            sizeof( TemporaryBuffer ) );
            if( !NT_SUCCESS( Status ) ) {
                KdPrintEx(( DPFLTR_SETUP_ID, DPFLTR_ERROR_LEVEL, 
                    "SETUP: Unable to delete drive letters. "
                    "ZwDeviceIoControl( IOCTL_MOUNTMGR_DELETE_POINTS ) failed."
                    "Status = %lx \n", Status));
            } else {
                //
                // If the drive letters got deleted then reset the drive letters assigned to all partitions.
                // Note that we only really care about resetting the drive letters on the partitions on the
                // removable disks, since, if we got that far, there won't be any partition on the non-removable
                // disks
                //
                for(DiskNumber = 0; DiskNumber<HardDiskCount; DiskNumber++) {

                    //
                    // This disk isn't removable.  Let's look at all the areas and see
                    // if there's anything that's partitioned.
                    //
                    pDiskRegion = PartitionedDisks[DiskNumber].PrimaryDiskRegions;

                    while( pDiskRegion ) {

                        pDiskRegion->DriveLetter = 0;

                        //
                        // Now get the next region on this disk.
                        //
                        pDiskRegion = pDiskRegion->Next;
                    }
                }
            }

            ZwClose( Handle );
        } else {
            KdPrintEx(( DPFLTR_SETUP_ID, DPFLTR_ERROR_LEVEL, 
                "SETUP: Unable to delete drive letters. "
                "ZwOpenFile( %ls ) failed. Status = %lx \n", 
                MOUNTMGR_DEVICE_NAME, 
                Status));
        }
    }
}


NTSTATUS
SpAssignDiskDriveLetters(
    VOID
    )
/*++

Routine Description:



Arguments:


Return Value:


--*/    
{
    NTSTATUS        Status = STATUS_SUCCESS;
    ULONG           DiskNumber;
    PDISK_REGION      pDiskRegion;
    PWCHAR          MyTempBuffer = NULL;
    unsigned        pass;

    //
    // Before initializing the drive letters, delete them if necessary.
    // This is to get rid of the letters assigned to CD-ROM drives and removables, when the disks have no
    // partitioned space.
    //
    SpDeleteDiskDriveLetters();

    //
    // Initialize all drive letters to nothing.
    // If it the region is a partitioned space, then assign a drive letter also.
    //
    for( DiskNumber=0; DiskNumber<HardDiskCount; DiskNumber++ ) {
    
        pDiskRegion = PartitionedDisks[DiskNumber].PrimaryDiskRegions;

        while( pDiskRegion ) {
        
            pDiskRegion->DriveLetter = 0;
            
            if(SPPT_IS_REGION_PARTITIONED(pDiskRegion)) {
                //
                // Retrieve nt pathname for this region.
                //
                MyTempBuffer = (PWCHAR)SpMemAlloc( MAX_NTPATH_LENGTH );

                if( !MyTempBuffer ) {
                    //
                    // No memory...
                    //
                    KdPrintEx(( DPFLTR_SETUP_ID, DPFLTR_ERROR_LEVEL,  
                        "SETUP: SpPtAssignDriveLetters: SpMemAlloc failed!\n" ));
                        
                    return(STATUS_NO_MEMORY);
                }
                    
                SpNtNameFromRegion( pDiskRegion,
                                    MyTempBuffer,
                                    MAX_NTPATH_LENGTH,
                                    PrimaryArcPath );

                //
                // Assign the drive letter.
                //
                pDiskRegion->DriveLetter = SpGetDriveLetter( MyTempBuffer, NULL );

                KdPrintEx(( DPFLTR_SETUP_ID, DPFLTR_INFO_LEVEL, 
                    "SETUP: SpPtAssignDriveLetters: Partition = %ls, DriveLetter = %wc: \n", 
                    MyTempBuffer, pDiskRegion->DriveLetter));


                SpMemFree( MyTempBuffer );
                MyTempBuffer = NULL;
            }

            //
            // Now get the next region on this disk.
            //
            pDiskRegion = pDiskRegion->Next;
        }
    }

    return( Status );
}

#endif  // NOT_USED_CURRENTLY



//
// ============================================================================
// ============================================================================
//
// The following code provides support for disk/partition selection.
//
// ============================================================================
// ============================================================================
//
#define MENU_LEFT_X     3
#define MENU_WIDTH      (VideoVars.ScreenWidth-(2*MENU_LEFT_X))
#define MENU_INDENT     4

extern ULONG PartitionMnemonics[];


VOID
SpPtnAutoCreatePartitions(
    IN  PVOID         SifHandle,
    IN  PWSTR         SetupSourceDevicePath,
    IN  PWSTR         DirectoryOnSetupSource
    )
/*++

Routine Description:

    If there are no partitions on any disks, create some.


Arguments:

    SifHandle               :  Handle to txtsetup.sif

    SetupSourceDevicePath   :  Device from which setup was launced

    DirectoryOnSetupSource  :  Directory from where the kernel was loaded on
                               Setup device

Return Value:

    None.

--*/
{
    PDISK_REGION    p = NULL;
    PDISK_REGION    Region = NULL;
    ULONG           Index;
    BOOLEAN         Found = FALSE;
    WCHAR           RegionStr[128] = {0};
    NTSTATUS        FormatStatus;
    ULONG           MyPartitionSizeMB = 0;
    NTSTATUS        Status;



    KdPrintEx(( DPFLTR_SETUP_ID,
                DPFLTR_INFO_LEVEL,  
                "SETUP: SpPtnAutoCreatePartitions - Checking for any existing partitions.\n" ));


    Found = FALSE;

    for(Index = 0; (Index < HardDiskCount) && (!Found); Index++) {

        Region = SPPT_GET_PRIMARY_DISK_REGION( Index );

        while( (Region) && (!Found) ) {

            if( Region->PartitionedSpace && 
                !SPPT_IS_REGION_RESERVED_PARTITION(Region)) {

                //
                // He's got something on the disk.
                //
                Found = TRUE;
            }

            Region = Region->Next;
        }
    }

    if( !Found ) {

        //
        // The disks are all empty.  We need to go
        // create some partitions for the installation.
        //

        KdPrintEx(( DPFLTR_SETUP_ID,
                    DPFLTR_INFO_LEVEL,  
                    "SETUP: SpPtnAutoCreatePartitions - No existing partitions were found.\n" ));



        if (SpIsArc()) {
            //
            // If we're on an ARC machine, go create a system
            // partition first.
            //
            
            KdPrintEx(( DPFLTR_SETUP_ID, DPFLTR_INFO_LEVEL,  
                "SETUP: SpPtnAutoCreatePartitions - About to "
                "auto-generate a system partition.\n" ));

#if defined(_IA64_)

            Status = SpPtnCreateESP(FALSE);

            if (!NT_SUCCESS(Status)) {
                KdPrintEx(( DPFLTR_SETUP_ID, DPFLTR_INFO_LEVEL,  
                    "SETUP: SpPtnAutoCreatePartitions - Could not "
                    "autocreate ESP : %lx\n",
                    Status));

                return;
            }
            
#endif            
        }

        //
        // Now create a partition to install the operating system.
        //
        // To do this, we're going to take the following steps:
        // 1. go find some free space on a disk that's big enough.
        // 2. create a partitions that's half of this guy's free space, (make the
        //    partition at least 4Gig).
        //

        KdPrintEx(( DPFLTR_SETUP_ID, DPFLTR_INFO_LEVEL,  
            "SETUP: SpPtnAutoCreatePartitions - About to "
            "auto-generate an installation partition.\n" ));

        Found = FALSE;
        for(Index = 0; (Index < HardDiskCount) && (!Found); Index++) {

            Region = SPPT_GET_PRIMARY_DISK_REGION( Index );

            while( (Region) && (!Found) ) {

                if( (!Region->PartitionedSpace) &&
                    (SPPT_REGION_FREESPACE_KB(Region)/1024 >= (SUGGESTED_INSTALL_PARTITION_SIZE_MB)) ) {

                    KdPrintEx(( DPFLTR_SETUP_ID,
                                DPFLTR_INFO_LEVEL,  
                                "SETUP: SpPtnAutoCreatePartitions - I found an area big enough for an installation.\n" ));

                    MyPartitionSizeMB = max( (ULONG)(SPPT_REGION_FREESPACE_KB(Region)/(2*1024)), SUGGESTED_INSTALL_PARTITION_SIZE_MB );

                    if( SpPtnDoCreate( Region,
                                       &p,
                                       TRUE,
                                       MyPartitionSizeMB,
                                       NULL,
                                       FALSE ) ) {

                        KdPrintEx(( DPFLTR_SETUP_ID,
                                    DPFLTR_INFO_LEVEL,  
                                    "SETUP: SpPtnAutoCreatePartitions - I just created an installation partition.\n" ));

                        //
                        // Got it.
                        //
                        Found = TRUE;
                        Region = p;

                        //
                        // Now format it.
                        //
                        swprintf( RegionStr,
                                  L"\\Harddisk%u\\Partition%u",
                                  Region->DiskNumber,
                                  Region->PartitionNumber );

                        //
                        // Format the system region with NTFS file system
                        //
                        KdPrintEx(( DPFLTR_SETUP_ID,
                                    DPFLTR_INFO_LEVEL,  
                                    "SETUP: SpPtnAutoCreatePartitions - I'm about to go format the installation partition.\n" ));

                        FormatStatus = SpDoFormat( RegionStr,
                                                   Region,
                                                   FilesystemNtfs,
                                                   TRUE,
                                                   TRUE,
                                                   FALSE,
                                                   SifHandle,
                                                   0,          // default cluster size
                                                   SetupSourceDevicePath,
                                                   DirectoryOnSetupSource );



                        KdPrintEx(( DPFLTR_SETUP_ID,
                                    DPFLTR_INFO_LEVEL,  
                                    "SETUP: SpPtnAutoCreatePartitions - Format of an installation partition is complete.\n" ));


                    } else {
                        KdPrintEx(( DPFLTR_SETUP_ID,
                                    DPFLTR_INFO_LEVEL,  
                                    "SETUP: SpPtnAutoCreatePartitions - I failed to create an installation partition.\n" ));
                    }
                }

                Region = Region->Next;
            }
        }

    } else {

        // let 'em know
        KdPrintEx(( DPFLTR_SETUP_ID,
                    DPFLTR_INFO_LEVEL,  
                    "SETUP: SpPtnAutoCreatePartitions - Existing partitions were found.\n" ));
    }

}



NTSTATUS
SpPtnPrepareDisks(
    IN  PVOID         SifHandle,
    OUT PDISK_REGION  *InstallArea,
    OUT PDISK_REGION  *SystemPartitionArea,
    IN  PWSTR         SetupSourceDevicePath,
    IN  PWSTR         DirectoryOnSetupSource,
    IN  BOOLEAN       RemoteBootRepartition
    )
/*++

Routine Description:

    Shows the use the disk menu (with partitions) and locates
    the system and boot partition

Arguments:

    SifHandle               :  Handle to txtsetup.sif

    InstallArea             :  Place holder for boot partition

    SystemPartitionArea     :  Place holder for system partition

    SetupSourceDevicePath   :  Device from which setup was launced

    DirectoryOnSetupSource  :  Directory from where the kernel was loaded on
                               Setup device

    RemoteBootRePartition   :  Whether to repartition the disk for remote boot

Return Value:

    Appropriate status code

--*/
{
    NTSTATUS        Status = STATUS_SUCCESS;
    WCHAR           Buffer[256] = {0};
    ULONG           DiskNumber;
    PVOID           Menu;
    ULONG           MenuTopY;
    ULONG           ValidKeys[3] = { ASCI_CR, KEY_F3, 0 };
    ULONG           ValidKeysCmdCons[2] = { ASCI_ESC, 0 };
    ULONG           Keypress;
    PDISK_REGION    pDiskRegion;
    PDISK_REGION    FirstDiskRegion,DefaultDiskRegion;
    BOOLEAN         unattended = UnattendedOperation;
    BOOLEAN         OldUnattendedOperation;
    BOOLEAN         createdMenu;
    ULONG           LastUsedDisk = -1;
    BOOLEAN         Win9xPartition = FALSE;

    //
    // Do some special partitioning if there's nothing
    // on the disk and the user has asked us to do an express
    // installation.
    //
    if( (!CustomSetup) && (UnattendedOperation) && (HardDiskCount != 0)
#if defined(REMOTE_BOOT)
        && (!RemoteBootSetup) && (!RemoteInstallSetup)
#endif

     ) {

        //
        // See if we need to auto-generate some partitions for the
        // installation.
        //
        SpPtnAutoCreatePartitions( SifHandle,
                                   SetupSourceDevicePath,
                                   DirectoryOnSetupSource );

    }

    if (SpIsArc()) {
        //
        // Select a system partition from among those defined in NV-RAM.
        //
        *SystemPartitionArea = SpPtnValidSystemPartitionArc(SifHandle,
                                    SetupSourceDevicePath,
                                    DirectoryOnSetupSource, 
                                    FALSE);

        if (*SystemPartitionArea) {                                    
            (*SystemPartitionArea)->IsSystemPartition = TRUE;
        }            
    }

    //
    // If the user selected any accessibility option and wanted to choose partition, show the partition screen
    //
    if(AccessibleSetup && !AutoPartitionPicker) {
        unattended = FALSE;
    }

    //
    // Save the current unattended mode and put the temp one
    //
    OldUnattendedOperation = UnattendedOperation;
    UnattendedOperation = unattended;

    while(1) {

        createdMenu = FALSE;
        Keypress = 0;

#if defined(REMOTE_BOOT)
        if (RemoteBootSetup && !RemoteInstallSetup && HardDiskCount == 0) {

            //
            // If there are no hard disks, allow diskless install
            //

            pDiskRegion = NULL;

            //
            // Run through the rest of the code as if the user had just
            // hit enter to select this partition.
            //

            Keypress = ASCI_CR;

        } else
#endif // defined(REMOTE_BOOT)

        if (unattended && RemoteBootRepartition) {
            ULONG   DiskNumber;
            ULONG   DiskSpaceRequiredKB = 2 * 1024 * 1024;  // 2 GB

            //
            // What's the space we required for installation
            //
            SpFetchDiskSpaceRequirements(SifHandle,
                        4 * 1024,
                        &DiskSpaceRequiredKB,
                        NULL);

            //
            // Prepare the disk for remote boot installation. This involves
            // converting disk 0 into as big a partition as possible.
            //

            if (*SystemPartitionArea != NULL) {
                DiskNumber = (*SystemPartitionArea)->DiskNumber;
            } else {
                DiskNumber = SpDetermineDisk0();
            }

#ifdef _IA64_

            Status = SpPtnRepartitionGPTDisk(DiskNumber,
                            DiskSpaceRequiredKB,
                            &pDiskRegion);

#else                            

            Status = SpPtPartitionDiskForRemoteBoot(DiskNumber, 
                            &pDiskRegion);

#endif                            


            if (NT_SUCCESS(Status)) {

                SpPtRegionDescription(
                    &PartitionedDisks[pDiskRegion->DiskNumber],
                    pDiskRegion,
                    Buffer,
                    sizeof(Buffer)
                    );

                //
                // Run through the rest of the code as if the user had just
                // hit enter to select this partition.
                //
                Keypress = ASCI_CR;
            }
        }

        if (Keypress == 0) {

            //
            // Display the text that goes above the menu on the partitioning screen.
            //
            SpDisplayScreen(ConsoleRunning ? SP_SCRN_PARTITION_CMDCONS:SP_SCRN_PARTITION,
                    3,CLIENT_TOP+1);

            //
            // Calculate menu placement.  Leave one blank line
            // and one line for a frame.
            //
            MenuTopY = NextMessageTopLine + 2;

            //
            // Create a menu.
            //
            Menu = SpMnCreate(
                        MENU_LEFT_X,
                        MenuTopY,
                        MENU_WIDTH,
                        (VideoVars.ScreenHeight - MenuTopY -
                            (SplangQueryMinimizeExtraSpacing() ? 1 : 2) - STATUS_HEIGHT)
                        );

            if(!Menu) {
                UnattendedOperation = OldUnattendedOperation;
                return(STATUS_NO_MEMORY);
            }

            createdMenu = TRUE;

            //
            // Build up a menu of partitions and free spaces.
            //
            FirstDiskRegion = NULL;
            
            for(DiskNumber=0; DiskNumber<HardDiskCount; DiskNumber++) {
                if( !SpPtnGenerateDiskMenu(Menu, DiskNumber, &FirstDiskRegion) ) {
                    SpMnDestroy(Menu);

                    UnattendedOperation = OldUnattendedOperation;
                    return(STATUS_NO_MEMORY);
                }
            }

            ASSERT(FirstDiskRegion);

            //
            // If this is unattended operation, try to use the local source
            // region if there is one. If this fails, the user will have to
            // intervene manually.
            //
            if(!AutoPartitionPicker && unattended && LocalSourceRegion && CustomSetup &&
               (!LocalSourceRegion->DynamicVolume || LocalSourceRegion->DynamicVolumeSuitableForOS)) {
               
                pDiskRegion = LocalSourceRegion;

                Keypress = ASCI_CR;
                
            } else {            
                pDiskRegion = NULL;

                //
                // Unless we've been told not to, go look at each partition on each
                // disk and see if we can find anything suitable for an OS installation.
                //
                if( AutoPartitionPicker && !ConsoleRunning 
#if defined(REMOTE_BOOT)
                    && (!RemoteBootSetup || RemoteInstallSetup)
#endif // defined(REMOTE_BOOT)
                    ) {
                    
                    PDISK_REGION      pCurrentDiskRegion = NULL;
                    ULONG           RequiredKB = 0;
                    ULONG           SectorNo;

                    KdPrintEx((DPFLTR_SETUP_ID, DPFLTR_INFO_LEVEL,  
                        "SETUP: -------------------------------------------------------------\n" ));
                        
                    KdPrintEx((DPFLTR_SETUP_ID, DPFLTR_INFO_LEVEL,  
                        "SETUP: Looking for an install partition\n\n" ));

                    for( DiskNumber=0; 
                        ((DiskNumber < HardDiskCount) && (!pCurrentDiskRegion)); 
                        DiskNumber++ ) {
                    
                        pCurrentDiskRegion = PartitionedDisks[DiskNumber].PrimaryDiskRegions;

                        while( pCurrentDiskRegion ) {
                            //
                            // Fetch the amount of free space required on the windows nt drive.
                            //
                            SpFetchDiskSpaceRequirements( SifHandle,
                                                          pCurrentDiskRegion->BytesPerCluster,
                                                          &RequiredKB,
                                                          NULL );

                            if( SpPtDeterminePartitionGood(pCurrentDiskRegion, RequiredKB, TRUE) ) {
                                //
                                // Got it.  Remember the partition and pretend the user
                                // hit the <enter> key.
                                //
                                KdPrintEx((DPFLTR_SETUP_ID, DPFLTR_INFO_LEVEL, 
                                    "SETUP: Selected install partition = "
                                    "(DiskNumber:%d),(DriveLetter:%wc:),(%ws)\n",
                                    DiskNumber,pCurrentDiskRegion->DriveLetter,
                                    pCurrentDiskRegion->VolumeLabel));
                                    
                                pDiskRegion = pCurrentDiskRegion;
                                Keypress = ASCI_CR;
                                
                                break;
                            }

                            pCurrentDiskRegion = pCurrentDiskRegion->Next;
                        }
                    }
                    
                    KdPrintEx((DPFLTR_SETUP_ID, DPFLTR_INFO_LEVEL,  
                        "SETUP: -------------------------------------------------------------\n" ));
                }


                if( !pDiskRegion ) {
                    //
                    // We didn't find any suitable partitions, which means we'll be putting up a
                    // menu very quickly.  Initialize the partition to highlight in the
                    // menu.
                    //
                    if (LastUsedDisk == -1) {
                        DefaultDiskRegion = FirstDiskRegion;
                    } else {
                        //
                        // Select the first region on the disk which the user last
                        // operated on
                        //
                        PDISK_REGION ValidRegion = SPPT_GET_PRIMARY_DISK_REGION(LastUsedDisk);

                        while (ValidRegion && SPPT_IS_REGION_CONTAINER_PARTITION(ValidRegion)) {
                            ValidRegion = ValidRegion->Next;
                        }                 

                        if (!ValidRegion)
                            ValidRegion = FirstDiskRegion;

                        DefaultDiskRegion = ValidRegion;
                    }                                                                                    

                    //
                    // Call the menu callback to initialize the status line.
                    //
                    SpPtMenuCallback( (ULONG_PTR)DefaultDiskRegion );                    

                    SpMnDisplay( Menu,
                                 (ULONG_PTR)DefaultDiskRegion,
                                 TRUE,
                                 ConsoleRunning ? ValidKeysCmdCons : ValidKeys,
                                 PartitionMnemonics,
                                 SpPtMenuCallback,
                                 SpPtIsNotReservedPartition,
                                 &Keypress,
                                 (PULONG_PTR)(&pDiskRegion) );
                }
            }
        }            

        LastUsedDisk = pDiskRegion ? pDiskRegion->DiskNumber : -1;

        //
        // Now act on the user's selection.
        //
        if(Keypress & KEY_MNEMONIC) {
            Keypress &= ~KEY_MNEMONIC;
        }



        //
        // Disallow certain operations on partitions that contain local source
        // or are the system partition (in the amd64/x86 floppiless case).
        //
        switch(Keypress) {
            case MnemonicCreatePartition:
            case MnemonicMakeSystemPartition:
            case MnemonicDeletePartition:
            case MnemonicChangeDiskStyle:
            if( (pDiskRegion->IsLocalSource) ||
                ((Keypress == MnemonicDeletePartition) && 
                 (SpPtnIsDeleteAllowedForRegion(pDiskRegion) == FALSE))
#if defined(_AMD64_) || defined(_X86_)
                || (IsFloppylessBoot &&
                    pDiskRegion == (SpRegionFromArcName(ArcBootDevicePath, PartitionOrdinalOriginal, NULL)))
#endif // defined(_AMD64_) || defined(_X86_)
              ) {

                //
                // Inform the user that we can't do this operation on this
                // partition.
                //
                ULONG MyValidKeys[] = { ASCI_CR };
                SpDisplayScreen(SP_SCRN_CONFIRM_INABILITY,3,HEADER_HEIGHT+1);

                SpDisplayStatusOptions(
                    DEFAULT_STATUS_ATTRIBUTE,
                    SP_STAT_ENTER_EQUALS_CONTINUE,
                    0
                    );

                SpInputDrain();
                SpWaitValidKey(MyValidKeys,NULL,NULL);

                //
                // Now change the keypress so we'll fall through the next switch.
                //
                Keypress = MnemonicUnused;
            }
        }



        switch(Keypress) {

        case MnemonicCreatePartition:            
            SpPtnDoCreate(pDiskRegion, NULL, FALSE, 0, 0, TRUE);
            
            break;

        case MnemonicMakeSystemPartition: {
            //
            // Make sure we don't have any other system partition
            //
            if (SPPT_IS_REGION_SYSTEMPARTITION(pDiskRegion)) {
                ValidArcSystemPartition = TRUE;
            }
            
            if (!ValidArcSystemPartition && pDiskRegion->PartitionedSpace && SpIsArc() && 
                (pDiskRegion->Filesystem != FilesystemNtfs)) {            

                if (NT_SUCCESS(SpPtnMakeRegionArcSysPart(pDiskRegion))) {
                     PDISK_REGION SysPartRegion = NULL;
                        
                    //
                    // Ok format the partition if required
                    //
                    SysPartRegion = SpPtnValidSystemPartitionArc(SifHandle,
                                                                 SetupSourceDevicePath,
                                                                 DirectoryOnSetupSource,
                                                                 FALSE);                

                    if (SysPartRegion) {
                        ULONG SysPartDiskNumber = SysPartRegion->DiskNumber;                            
                        BOOLEAN Changes = FALSE;

                        if ((NT_SUCCESS(SpPtnCommitChanges(SysPartDiskNumber,
                                                &Changes))) &&
                           (NT_SUCCESS(SpPtnInitializeDiskDrive(SysPartDiskNumber)))) {
                            //
                            // create MSR partition if needed
                            //
                            SpPtnInitializeGPTDisk(SysPartDiskNumber);
                        }                                                
                    }

                } else {
                    ValidArcSystemPartition = FALSE;
                }                    
            }

            break;
        }            

        case MnemonicDeletePartition:   {
            BOOLEAN SysPartDeleted = FALSE;
            BOOLEAN DeletionResult;
        
            SysPartDeleted = SPPT_IS_REGION_SYSTEMPARTITION(pDiskRegion);            
        
            DeletionResult = SpPtnDoDelete(pDiskRegion, 
                                SpMnGetText(Menu,(ULONG_PTR)pDiskRegion),
                                TRUE);

            if (DeletionResult && SysPartDeleted && SpIsArc()) {
                //
                // Find out if there are any other
                // valid system partitions
                //
                SpPtnValidSystemPartitionArc(SifHandle,
                                SetupSourceDevicePath,
                                DirectoryOnSetupSource,
                                FALSE);
            }
                                     
            break;
        }            

        case MnemonicChangeDiskStyle: {
            //
            // Before changing style make sure, its allowed
            // on this platform for the selected disk
            //
            if (SpPtnIsDiskStyleChangeAllowed(pDiskRegion->DiskNumber)) {
                PARTITION_STYLE Style = SPPT_DEFAULT_PARTITION_STYLE;
            
                SpDisplayStatusOptions(DEFAULT_STATUS_ATTRIBUTE, 
                        SP_STAT_PLEASE_WAIT,
                        0);
                                    
                //
                // flip the style
                //
                if (!SPPT_IS_RAW_DISK(pDiskRegion->DiskNumber)) {
                    Style = SPPT_IS_GPT_DISK(pDiskRegion->DiskNumber) ?
                                PARTITION_STYLE_MBR : PARTITION_STYLE_GPT;
                }                            
                                
                Status = SpPtnInitializeDiskStyle(pDiskRegion->DiskNumber,
                                    Style, NULL);


                if (NT_SUCCESS(Status)) {
                    Status = SpPtnInitializeDiskDrive(pDiskRegion->DiskNumber);

#if defined(_IA64_)
                    //
                    // Go and figure out the ESP partitions and
                    // initialize the MSR partitions on valid GPT
                    // disks, if none present
                    //
                    if (Style == PARTITION_STYLE_GPT) {    
                        ULONG DiskNumber = pDiskRegion->DiskNumber;
                        
                        if (SpIsArc() && !ValidArcSystemPartition && !SpDrEnabled()) {                            
                            
                            //
                            // Create a system partition
                            //
                            Status = SpPtnCreateESP(TRUE);                    
                        }

                        //
                        // Initialize the GPT disks, to have MSR
                        // partition
                        //
                        Status = SpPtnInitializeGPTDisk(DiskNumber);                        
                    }                        
#endif                                        
                }
            }
            
            break;
        }            

        case KEY_F3:
            SpConfirmExit();
            break;

        case ASCI_ESC:
            if( ConsoleRunning ) {
                SpDisplayStatusOptions(DEFAULT_STATUS_ATTRIBUTE, 
                        SP_STAT_PLEASE_WAIT,
                        0);
            
                SpPtDoCommitChanges();
            }
            if (createdMenu) {
                SpMnDestroy(Menu);
            }
            UnattendedOperation = OldUnattendedOperation;
            return(STATUS_SUCCESS);

        case ASCI_CR:

            Win9xPartition = FALSE;

            if( SpPtDoPartitionSelection( &pDiskRegion,
                                          ((Buffer[0]) ? Buffer : SpMnGetText(Menu,(ULONG_PTR)pDiskRegion)),
                                          SifHandle,
                                          unattended,
                                          SetupSourceDevicePath,
                                          DirectoryOnSetupSource,
                                          RemoteBootRepartition,
                                          &Win9xPartition) ) {

                *InstallArea = pDiskRegion;
#if defined(REMOTE_BOOT)
                //
                // Set the install region differently if this is a remote
                // boot -- in that case, the install region is always remote.
                //
                if (RemoteBootSetup && !RemoteInstallSetup) {
                    *InstallArea = RemoteBootTargetRegion;
                }
#endif // defined(REMOTE_BOOT)

                //
                // We need to figure out where the system partition is.
                //
                if (!SpIsArc()) {
                    *SystemPartitionArea = SpPtnValidSystemPartition();
                } else {

                    PWSTR p;
                    NTSTATUS TempStatus;
                    
                    //
                    // Select a system partition from among those defined in NV-RAM.
                    // We have to do this again because the user may have deleted the
                    // system partition previously detected.
                    //
                    *SystemPartitionArea = SpPtnValidSystemPartitionArc(SifHandle,
                                                            SetupSourceDevicePath,
                                                            DirectoryOnSetupSource,
                                                            FALSE);

                    if (!(*SystemPartitionArea)) {                    
                        SpPtnPromptForSysPart(SifHandle);

                        break;  // user pressed escape to mark the system partition                            
                    }

                    //
                    // Make sure we can see the disk from the firmware/BIOS.
                    // If not then we need to put up a message asking to enable the
                    // ROM BIOS for the disabled disk containing the system partition
                    //					 
                    p = SpNtToArc( HardDisks[(*SystemPartitionArea)->DiskNumber].DevicePath,
                          PrimaryArcPath );            
                    if (p == NULL) {

                    	ULONG ValidKeys[] = { KEY_F3, ASCI_ESC,  0 };

                    	KdPrintEx((DPFLTR_SETUP_ID, DPFLTR_INFO_LEVEL,  
                               "SETUP: Enable the ROM BIOS for the Disk containing system partition\n" ));
                    	SpDisplayScreen(SP_ENABLE_ESP_DISK_IN_FIRMWARE, 3, HEADER_HEIGHT+1);
                    	SpDisplayStatusOptions(
                           DEFAULT_STATUS_ATTRIBUTE,
                           SP_STAT_F3_EQUALS_EXIT,
                           0);

                        //
                        // Wait for user input
                        //
                         SpInputDrain();
                    
                         switch (SpWaitValidKey(ValidKeys, NULL, NULL)){
				
                        	case KEY_F3 :
                         			
                         		// User has chosen to reboot
                         		SpDone(0,FALSE,FALSE);

	                       	case ASCI_ESC:
	                       		
                         		// User wants to go to the partitioning screen
                         		break;
                         }
                         break;
    			        
        			}

                    //
                    // Disallow installation onto ESP / MSR
                    //
                    if (SPPT_IS_REGION_EFI_SYSTEM_PARTITION(*InstallArea) ||
                        SPPT_IS_REGION_MSFT_RESERVED(*InstallArea)) {
                        ULONG ValidKeys[] = { ASCI_CR, 0 };

                        SpDisplayScreen(SP_ESP_INSTALL_PARTITION_SAME, 3, HEADER_HEIGHT+1);

                        SpDisplayStatusOptions(
                            DEFAULT_STATUS_ATTRIBUTE,
                            SP_STAT_ENTER_EQUALS_CONTINUE,
                            0);

                        //
                        // Wait for user input
                        //
                        SpInputDrain();
                        
                        SpWaitValidKey(ValidKeys, NULL, NULL);

                        break;
                    }

                    //
                    // Disallow non GPT ESPs
                    //
                    if (SpIsArc() && !SPPT_IS_GPT_DISK((*SystemPartitionArea)->DiskNumber)) {
                        ULONG ValidKeys[] = { ASCI_CR, 0 };

                        SpDisplayScreen(SP_NON_GPT_SYSTEM_PARTITION, 3, HEADER_HEIGHT+1);

                        SpDisplayStatusOptions(
                            DEFAULT_STATUS_ATTRIBUTE,
                            SP_STAT_ENTER_EQUALS_CONTINUE,
                            0);

                        //
                        // Wait for user input
                        //
                        SpInputDrain();
                        
                        SpWaitValidKey(ValidKeys, NULL, NULL);

                        break;
                    } 
                    
                    //
                    // Disallow installation if MSR does not exist on the disk containing the ESP.
                    //
                    TempStatus = SpPtnInitializeGPTDisk((*SystemPartitionArea)->DiskNumber);
                    if (NT_SUCCESS(TempStatus) && 
                        (!SpIsMSRPresentOnDisk((*SystemPartitionArea)->DiskNumber))){
                        ULONG ValidKeys[] = { ASCI_CR, 0 };

                        SpDisplayScreen(SP_MSR_NOT_PRESENT, 3, HEADER_HEIGHT+1);

                        SpDisplayStatusOptions(
                            DEFAULT_STATUS_ATTRIBUTE,
                            SP_STAT_ENTER_EQUALS_CONTINUE,
                            0);

                        //
                        // Wait for user input
                        //
                        SpInputDrain();
                        
                        SpWaitValidKey(ValidKeys, NULL, NULL);

                        break;
                    }
                    
                }

                //
                // We're done here.
                //
                if (createdMenu) {
                    SpMnDestroy(Menu);
                }                

#if defined(REMOTE_BOOT)
                ASSERT(*SystemPartitionArea ||
                       (RemoteBootSetup && !RemoteInstallSetup && (HardDiskCount == 0)));
#else
                ASSERT(*SystemPartitionArea);
                ASSERT((*SystemPartitionArea)->Filesystem >= FilesystemFat);
#endif // defined(REMOTE_BOOT)


#ifdef _X86_
                //
                // If we are installing on to the same partition as Win9x then
                // remove the boot entry for the old operating system
                //
                if (Win9xPartition) {
                    DiscardOldSystemLine = TRUE;
                }
#endif                

                UnattendedOperation = OldUnattendedOperation;
                return(STATUS_SUCCESS);

            } else {
                //
                // Something happened when we tried to select the
                // partition.  Make sure that autopartition-picker
                // doesn't invoke next time through our while loop.
                //
                AutoPartitionPicker = FALSE;
            }
            break;
        }

        if (createdMenu) {
            SpMnDestroy(Menu);
        }
        unattended = FALSE;
    }
}


BOOLEAN
SpPtnGenerateDiskMenu(
    IN  PVOID           Menu,
    IN  ULONG           DiskNumber,
    OUT PDISK_REGION    *FirstDiskRegion
    )
/*++

Routine Description:

    Examine the disk for partitioning information and fill in our
    menu.


Arguments:

    DiskNumber - supplies the disk number of the disk whose partitions
                 we want to inspect for determining their types.

Return Value:

    TRUE    Everything went okay.
    FALSE   Something horrible happened.

--*/
{
    WCHAR           Buffer[128];
    ULONG           MessageId;
    PDISK_REGION    Region = NULL;
    WCHAR           DriveLetter[3];
    WCHAR           PartitionName[128];
    ULONGLONG       FreeSpaceMB;
    ULONGLONG       AreaSizeMB;
    ULONGLONG       AreaSizeBytes;
    ULONGLONG       OneMB = 1024 * 1024;
    PHARD_DISK      Disk = SPPT_GET_HARDDISK(DiskNumber);
    PPARTITIONED_DISK   PartDisk = SPPT_GET_PARTITIONED_DISK(DiskNumber);

    //
    // Get a pointer to the list of regions.
    //
    Region = PartDisk->PrimaryDiskRegions;

    //
    // Add the disk name/description.
    //
    if(!SpMnAddItem(Menu, Disk->Description, MENU_LEFT_X, MENU_WIDTH, FALSE, 0)) {
        return(FALSE);
    }

    //
    // Only add a line between the disk name and partitions if we have space on
    // the screen. Not fatal if the space can't be added.
    //
    if(!SplangQueryMinimizeExtraSpacing()) {
        SpMnAddItem(Menu,L"",MENU_LEFT_X,MENU_WIDTH,FALSE,0);
    }

    //
    // If the disk is off-line, add a message indicating such.
    //    
    if((Disk->Status == DiskOffLine) || !Region) {
        MessageId = SP_TEXT_DISK_OFF_LINE;

        if( Disk->Characteristics & FILE_REMOVABLE_MEDIA ) {
            //
            // This is removable media, then just tell the user there's
            // no media in the drive.
            //
            MessageId = SP_TEXT_HARD_DISK_NO_MEDIA;
        }

        SpFormatMessage( Buffer,
                         sizeof(Buffer),
                         MessageId );

        return SpMnAddItem(Menu,
                            Buffer,
                            MENU_LEFT_X + MENU_INDENT,
                            MENU_WIDTH - (2 * MENU_INDENT),
                            FALSE,
                            0);
    }

    //
    // Now iterate through the areas on the disk and insert that info into the
    // menu.
    //
    while( Region ) {
        if (!SPPT_IS_REGION_CONTAINER_PARTITION(Region)) {            
            //
            // remember the very first area that we examine.
            //
            if(*FirstDiskRegion == NULL) {
                *FirstDiskRegion = Region;
            }

            //
            // Figure out how big this disk area is and how much
            // free space we've got.
            //
            if (Region->AdjustedFreeSpaceKB != -1) {
                FreeSpaceMB = Region->AdjustedFreeSpaceKB / 1024;
            } else {
                FreeSpaceMB = 0;
            }
            
            AreaSizeBytes = Region->SectorCount * Disk->Geometry.BytesPerSector;
            AreaSizeMB    = AreaSizeBytes / OneMB;

            if ((AreaSizeBytes % OneMB) > (OneMB / 2))
                AreaSizeMB++;

            /*
            SpPtDumpDiskRegion(Region);
            
            KdPrintEx((DPFLTR_SETUP_ID, DPFLTR_ERROR_LEVEL,  
                "SETUP: Menu Item Details Free:%I64d,%I64d,%I64d\n",
                FreeSpaceMB, AreaSizeBytes, AreaSizeMB));
            */                
            
            //
            // See if this guy's partitioned.
            //
            if(SPPT_IS_REGION_PARTITIONED(Region)){                
                //
                // Pickup the driveletter
                //
                if( Region->DriveLetter ) {
                    DriveLetter[0] = Region->DriveLetter;
                } else {
                    DriveLetter[0] = L'-';
                }

                DriveLetter[1] = L':';
                DriveLetter[2] = 0;

                //
                // Format the partition name
                //
                PartitionName[0] = 0;
                
                SpPtnGetPartitionName(Region,
                    PartitionName,
                    sizeof(PartitionName)/sizeof(PartitionName[0]));

                SpFormatMessage( Buffer,
                                 sizeof( Buffer ),
                                 SP_TEXT_REGION_DESCR_1,
                                 DriveLetter,
                                 SplangPadString(-35, PartitionName),
                                 (ULONG)AreaSizeMB,
                                 (ULONG)FreeSpaceMB );                             
            } else {
                //
                // It's an unformatted area.  Use a different message.
                //
                SpFormatMessage( Buffer,
                                 sizeof( Buffer ),
                                 SP_TEXT_REGION_DESCR_3,
                                 (ULONG)AreaSizeMB );
            }

            //
            // Add the formatted information into the menu.
            //
            if(!SpMnAddItem(Menu, Buffer, MENU_LEFT_X + MENU_INDENT,
                    MENU_WIDTH - (2 * MENU_INDENT), TRUE, (ULONG_PTR)Region)) {
                return(FALSE);
            }
        }            

        Region = Region->Next;
    }


    return (SplangQueryMinimizeExtraSpacing() ? 
                TRUE : SpMnAddItem(Menu,L"",MENU_LEFT_X,MENU_WIDTH,FALSE,0));
}


PDISK_REGION
SpPtnValidSystemPartition(
    VOID
    )

/*++

Routine Description:

    Determine whether there is a valid disk partition suitable for use
    as the system partition on an amd64/x86 machine (ie, C:).

    A primary, recognized (1/4/6/7 type) partition on disk 0 is suitable.
    If there is a partition that meets these criteria that is marked active,
    then it is the system partition, regardless of whether there are other
    partitions that also meet the criteria.

Arguments:

    None.

Return Value:

    Pointer to a disk region descriptor for a suitable system partition (C:)
    for an amd64/x86 machine.
    NULL if no such partition currently exists.

--*/

{
    PDISK_REGION ActiveRegion , FirstRegion, CurrRegion;
    PHARD_DISK  Disk = NULL;
    ULONG DiskNumber;

    DiskNumber = SpDetermineDisk0();

#if defined(REMOTE_BOOT)
    //
    // If this is a diskless remote boot setup, there is no drive 0.
    //
    if ( DiskNumber == (ULONG)-1 ) {
        return NULL;
    }
#endif // defined(REMOTE_BOOT)

    if (!PartitionedDisks) {
        return NULL;
    }        

    //
    // Look for the active partition on drive 0
    // and for the first recognized primary partition on drive 0.
    //       
    CurrRegion = SPPT_GET_PRIMARY_DISK_REGION(DiskNumber);
    FirstRegion = NULL;
    ActiveRegion = NULL;

    while (CurrRegion) {
        if (SPPT_IS_REGION_PRIMARY_PARTITION(CurrRegion)) {
            UCHAR PartitionType = SPPT_GET_PARTITION_TYPE(CurrRegion);
            
            if(!IsContainerPartition(PartitionType) && 
                ((IsRecognizedPartition(PartitionType)) ||
                (CurrRegion->DynamicVolume && CurrRegion->DynamicVolumeSuitableForOS) ||
                ((RepairWinnt || WinntSetup || SpDrEnabled() ) && CurrRegion->FtPartition))) {

                if (!FirstRegion)
                    FirstRegion = CurrRegion;
                    
                if (!ActiveRegion && SPPT_IS_REGION_ACTIVE_PARTITION(CurrRegion)) {
                    ActiveRegion = CurrRegion;

                    break;
                }                    
            }
        }            
        
        CurrRegion = CurrRegion->Next;
    }

#ifdef TESTING_SYSTEM_PARTITION
    KdPrintEx((DPFLTR_SETUP_ID, DPFLTR_INFO_LEVEL,
        "%p Active, %p First\n", 
        ActiveRegion, 
        FirstRegion));
    
    if (ActiveRegion)
        FirstRegion = ActiveRegion;
        
    ActiveRegion = NULL;
#endif

    /*
    //
    // Don't do commit here as the multiple caller's are trying
    // to reuse the old region from the existing linked list
    // of regions for the disk after this
    //
    if (!ActiveRegion && FirstRegion) {
        BOOLEAN     Changes = FALSE;
        ULONGLONG   StartSector = FirstRegion->StartSector;

        SpPtnMakeRegionActive(FirstRegion);
        SPPT_MARK_REGION_AS_SYSTEMPARTITION(FirstRegion, TRUE);

        if (NT_SUCCESS(SpPtnCommitChanges(DiskNumber, &Changes)) && Changes) {
            SPPT_MARK_REGION_AS_ACTIVE(FirstRegion, TRUE);
            
            KdPrintEx((DPFLTR_SETUP_ID, DPFLTR_INFO_LEVEL,
                "SETUP:SpPtnValidSystempartition():succeeded in marking\n"));
        } else {
            KdPrintEx((DPFLTR_SETUP_ID, DPFLTR_ERROR_LEVEL,
                "SETUP:SpPtnValidSystempartition():Could not mark the first "
                "partition on primary disk as active\n"));
        }
    }
    */

    //
    // If there is an active, recognized region, use it as the
    // system partition.  Otherwise, use the first primary
    // we encountered as the system partition.  If there is
    // no recognized primary, then there is no valid system partition.
    //
    return  (ActiveRegion ? ActiveRegion : FirstRegion);
}

#if 0

ULONG
SpDetermineDisk0(
    VOID
    )

/*++

Routine Description:

    Determine the real disk 0, which may not be the same as \device\harddisk0.
    Consider the case where we have 2 scsi adapters and
    the NT drivers load in an order such that the one with the BIOS
    gets loaded *second* -- meaning that the system partition is actually
    on disk 1, not disk 0.

Arguments:

    None.

Return Value:

    NT disk ordinal suitable for use in generating nt device paths
    of the form \device\harddiskx.

--*/


{
    ULONG DiskNumber = SpArcDevicePathToDiskNumber(L"multi(0)disk(0)rdisk(0)");

#if defined(REMOTE_BOOT)
    //
    // If this is a diskless remote boot setup, there is no drive 0.
    //
    if ( RemoteBootSetup && (DiskNumber == (ULONG)-1) && (HardDiskCount == 0) ) {
        return DiskNumber;
    }
#endif // defined(REMOTE_BOOT)

    return((DiskNumber == (ULONG)(-1)) ? 0 : DiskNumber);
}

#endif

BOOL
SpPtnIsSystemPartitionRecognizable(
    VOID
    )
/*++

Routine Description:

    Determine whether the active partition is suitable for use
    as the system partition on an amd64/x86 machine (ie, C:).

    A primary, recognized (1/4/6/7 type) partition on disk 0 is suitable.

Arguments:

    None.

Return Value:

    TRUE - We found a suitable partition

    FALSE - We didn't find a suitable partition

--*/
{
    ULONG           DiskNumber;
    PDISK_REGION    Region = NULL;

    //
    // Any partitions on NEC98 are primary and active. So don't need to check on NEC98.
    //
    if( IsNEC_98 ) {
    	return TRUE;
    }

    DiskNumber = SpDetermineDisk0();

    //
    // Look for the active partition on drive 0
    // and for the first recognized primary partition on drive 0.
    //
    Region = SPPT_GET_PRIMARY_DISK_REGION(DiskNumber);

    if (SPPT_IS_GPT_DISK(DiskNumber)) {        
        //
        // On GPT we just need a valid formatted partition
        //
        while (Region) {    
            if (SPPT_IS_REGION_PARTITIONED(Region) &&
                SPPT_IS_RECOGNIZED_FILESYSTEM(Region->Filesystem)) {

                break;
            }                

            Region = Region->Next;
        }
    } else {
        //
        // On MBR we need a valid active formatted partition
        //
        while (Region) {    
            if (SPPT_IS_REGION_ACTIVE_PARTITION(Region) &&
                SPPT_IS_RECOGNIZED_FILESYSTEM(Region->Filesystem)) {

                break;
            }                

            Region = Region->Next;
        }
    }                
    
    return (Region) ? TRUE : FALSE;
}


BOOLEAN
SpPtnValidSystemPartitionArcRegion(
    IN PVOID SifHandle,
    IN PDISK_REGION Region
    )
{
    BOOLEAN Valid = FALSE;
    
    if (SPPT_IS_REGION_SYSTEMPARTITION(Region) &&
        (Region->FreeSpaceKB != -1) &&
        (Region->Filesystem == FilesystemFat)) {

        ULONG TotalSizeOfFilesOnOsWinnt = 0;
        ULONG RequiredSpaceKB = 0;  

        //
        //  On non-x86 platformrs, specially alpha machines that in general
        //  have small system partitions (~3 MB), we should compute the size
        //  of the files on \os\winnt (currently, osloader.exe and hall.dll),
        //  and consider this size as available disk space. We can do this
        //  since these files will be overwritten by the new ones.
        //  This fixes the problem that we see on Alpha, when the system
        //  partition is too full.
        //

        SpFindSizeOfFilesInOsWinnt( SifHandle,
                                    Region,
                                    &TotalSizeOfFilesOnOsWinnt );
        //
        // Transform the size into KB
        //
        TotalSizeOfFilesOnOsWinnt /= 1024;

        //
        // Determine the amount of free space required on a system partition.
        //
        SpFetchDiskSpaceRequirements( SifHandle,
                                      Region->BytesPerCluster,
                                      NULL,
                                      &RequiredSpaceKB );

        if ((Region->FreeSpaceKB + TotalSizeOfFilesOnOsWinnt) >= RequiredSpaceKB) {
            Valid = TRUE;
        }
    }

    return Valid;
}

PDISK_REGION
SpPtnValidSystemPartitionArc(
    IN PVOID SifHandle,
    IN PWSTR SetupSourceDevicePath,
    IN PWSTR DirectoryOnSetupSource,
    IN BOOLEAN SysPartNeeded
    )

/*++

Routine Description:

    Determine whether there is a valid disk partition suitable for use
    as the system partition on an ARC machine.

    A partition is suitable if it is marked as a system partition in nvram,
    has the required free space and is formatted with the FAT filesystem.

Arguments:

    SifHandle - supplies handle to loaded setup information file.

Return Value:

    Pointer to a disk region descriptor for a suitable system partition.
    Does not return if no such partition exists.

--*/

{
    ULONG               RequiredSpaceKB = 0;
    PDISK_REGION        Region = NULL;
    PPARTITIONED_DISK   PartDisk;
    ULONG               Index;

    //
    // Go through all the regions.  The one that's maked system partition
    // or is valid system partition is used for further validation.
    //
    for(Index = 0; (Index < HardDiskCount) && (!Region); Index++) {
        PartDisk = SPPT_GET_PARTITIONED_DISK(Index);
        Region = SPPT_GET_PRIMARY_DISK_REGION(Index);

        while (Region) {
            if (SPPT_IS_REGION_PARTITIONED(Region) && 
                SPPT_IS_REGION_SYSTEMPARTITION(Region)) {
                break;  // found the required region                 
            }
            
            Region = Region->Next;
        }
    }

    //
    // If the region is there and not formatted format it as FAT
    // file system
    //
    if (Region && (Region->Filesystem < FilesystemFat)) {
        WCHAR       DriveLetterString[4] = {0};

        DriveLetterString[0] = Region->DriveLetter;
        
        if (!UnattendedOperation) {
            ULONG   ValidKeys[] = { KEY_F3, 0 };
            ULONG   Mnemonics[] = { MnemonicFormat, 0 };
            ULONG   KeyPressed;
            ULONG   EscKey = SysPartNeeded ? KEY_F3 : ASCI_ESC;

            ValidKeys[0] = SysPartNeeded ? KEY_F3 : ASCI_ESC;

            SpStartScreen(SysPartNeeded ? 
                            SP_SCRN_C_UNKNOWN_1 : SP_SCRN_C_UNKNOWN,
                          3,
                          HEADER_HEIGHT+1,
                          FALSE,
                          FALSE,
                          DEFAULT_ATTRIBUTE,
                          DriveLetterString
                          );       

            SpDisplayStatusOptions(DEFAULT_STATUS_ATTRIBUTE, 
                    SP_STAT_F_EQUALS_FORMAT,
                    SysPartNeeded ? 
                        SP_STAT_F3_EQUALS_EXIT : SP_STAT_ESC_EQUALS_CANCEL,
                    0);

            SpInputDrain();
                          
            KeyPressed = SpWaitValidKey(ValidKeys, NULL, Mnemonics);

            if (KeyPressed == EscKey) {
                Region = NULL;
            }                
        }

        if (Region) {
            WCHAR       RegionStr[128];
            NTSTATUS    FormatStatus;

            swprintf( RegionStr,
                      L"\\Harddisk%u\\Partition%u",
                      Region->DiskNumber,
                      Region->PartitionNumber );

            //
            // Format the system region with Fat file system
            //
            FormatStatus = SpDoFormat(RegionStr,
                                Region,
                                FilesystemFat,
                                TRUE,
                                TRUE,
                                FALSE,
                                SifHandle,
                                0,          // default cluster size
                                SetupSourceDevicePath,
                                DirectoryOnSetupSource);

            if (!NT_SUCCESS(FormatStatus)) {
                SpStartScreen(SP_SCRN_SYSPART_FORMAT_ERROR,
                              3,
                              HEADER_HEIGHT+1,
                              FALSE,
                              FALSE,
                              DEFAULT_ATTRIBUTE,
                              DriveLetterString
                              );
                              
                SpDisplayStatusOptions(DEFAULT_STATUS_ATTRIBUTE,
                        SP_STAT_F3_EQUALS_EXIT,
                        0);
                        
                SpInputDrain();
                
                while(SpInputGetKeypress() != KEY_F3) ;
                
                SpDone(0, FALSE, TRUE);
            }

            //
            // Since we have formatted system partition, make sure
            // it has adequate space to hold the startup files
            //
            if(!SpPtnValidSystemPartitionArcRegion(SifHandle, Region))
                Region = NULL;  
        }                
    }              
    
    if (!Region && SysPartNeeded) {
        //
        // Make sure we don't look bad.
        //
        if( RequiredSpaceKB == 0 ) {
            SpFetchDiskSpaceRequirements( SifHandle,
                                          (32 * 1024),
                                          NULL,
                                          &RequiredSpaceKB );
        }

        //
        // No valid system partition.
        //
        SpStartScreen(
            SP_SCRN_NO_SYSPARTS,
            3,
            HEADER_HEIGHT+1,
            FALSE,
            FALSE,
            DEFAULT_ATTRIBUTE,
            RequiredSpaceKB
            );

        SpDisplayStatusOptions(DEFAULT_STATUS_ATTRIBUTE,
                            SP_STAT_F3_EQUALS_EXIT,
                            0);

        SpInputDrain();

        //
        // wait for F3
        //
        while (SpInputGetKeypress() != KEY_F3) ;

        SpDone(0, FALSE, TRUE);
    }        

    ValidArcSystemPartition = (Region != NULL);

    return Region;
}    


NTSTATUS
SpPtnMarkLogicalDrives(
    IN ULONG DiskId
    )
/*++

Routine Description:

    Walks through the region linked list and marks the container
    partition and the logical drives. Also marks the free
    space inside container partition as contained space

Arguments:

    DiskId  : Disk to process

Return Value:

    STATUS_SUCCESS if successful, otherwise approprite error code

--*/    
{
    NTSTATUS Status = STATUS_SUCCESS;
    
    if (SPPT_IS_MBR_DISK(DiskId)) {
        PDISK_REGION    Region = SPPT_GET_PRIMARY_DISK_REGION(DiskId);
        PDISK_REGION    FirstContainer = NULL;
        PDISK_REGION    PrevContainer = NULL;

        while (Region) {
            if (SPPT_IS_REGION_CONTAINER_PARTITION(Region)) {
                if (!FirstContainer) {
                    FirstContainer = Region;
                    Region->Container = NULL;
                } else {
                    Region->Container = FirstContainer;
                }

                PrevContainer = Region;
            } else {
                if (PrevContainer) {
                    if (SPPT_IS_REGION_CONTAINED(PrevContainer, Region)) {
                        Region->Container = PrevContainer;

                        if (SPPT_IS_REGION_PARTITIONED(Region))
                            SPPT_SET_REGION_EPT(Region, EPTLogicalDrive);
                    } else {
                        if (SPPT_IS_REGION_CONTAINED(FirstContainer, Region))
                            Region->Container = FirstContainer;
                    }
                }
            }

            Region = Region->Next;
        }
    }    

    return Status;
}

ULONG
SpPtnGetOrdinal(
    IN PDISK_REGION         Region,
    IN PartitionOrdinalType OrdinalType
    )
/*++

Routine Description:

    Gets the Ordinal for the specified region of the specified
    type.
    
Arguments:

    Region      -   Region whose ordinal has to be found
    OrdinalType -   Type of ordinal for the region

Return Value:

    -1 if invalid request, otherwise appropriate ordinal number
    for the region.

--*/        
{
    ULONG   Ordinal = -1;
    
    if (Region && Region->PartitionNumber && SPPT_IS_REGION_PARTITIONED(Region)) {
        switch (OrdinalType) {
            case PartitionOrdinalOnDisk:
                if (SPPT_IS_MBR_DISK(Region->DiskNumber) && 
                    !SPPT_IS_REGION_CONTAINER_PARTITION(Region)) {
                    Ordinal = Region->TablePosition;
                } else if (SPPT_IS_GPT_DISK(Region->DiskNumber)) {
                    Ordinal = Region->TablePosition;
                }


                //
                // Ordinal zero is not valid
                //
                if (Ordinal == 0) {
                    Ordinal = -1;
                }

                break;

            default:
                Ordinal = Region->PartitionNumber;
                
                break;
        }                
    }        


    if( Ordinal == -1 ) {
        //
        // This is really bad.  We're about to
        // fall over.  Atleast try...
        //
        ASSERT(FALSE);
        Ordinal = 1;        

        KdPrintEx(( DPFLTR_SETUP_ID,
                    DPFLTR_INFO_LEVEL, 
                    "SETUP: SpPtnGetOrdinal: We didn't get an ordinal!  Force it.\n" ));
    }

    return Ordinal;        
}

VOID
SpPtnGetSectorLayoutInformation(
    IN  PDISK_REGION Region,
    OUT PULONGLONG   HiddenSectors,
    OUT PULONGLONG   VolumeSectorCount
    )
/*++

Routine Description:

    Gets the hidden sector and sector count for the formatted
    partitions (volumes)
    
Arguments:

    Region      -   The region for which the sector layout information
                    is needed
    HiddenSectors   -   Place holder to return the # of hidden sectors
                        for the region
    VolumeSectorCount-  Place holder to return the # of valid sectors                        
                        for the volume

Return Value:

    None

--*/        
{
    ULONGLONG   Hidden = 0;
    
    if (Region) {
        if (ARGUMENT_PRESENT(HiddenSectors)) {
            if (Region->PartInfo.PartitionStyle == PARTITION_STYLE_MBR)
                Hidden = Region->PartInfo.Mbr.HiddenSectors;
            else
                Hidden = 0;

            *HiddenSectors = Hidden;                
        }

        if (ARGUMENT_PRESENT(VolumeSectorCount)) {
            *VolumeSectorCount = Region->SectorCount - Hidden;
        }                        
    }
}

NTSTATUS
SpPtnUnlockDevice(
    IN PWSTR    DeviceName
    )
/*++

Routine Description:

    Attempts to unlock the media for the given device
    name (NT device pathname)
    
Arguments:

    DeviceName  :   The device for which the media needs to be
                    unlocked                    

Return Value:

    STATUS_SUCCESS if successful, otherwise appropriate error
    code

--*/        
{
    NTSTATUS    Status = STATUS_INVALID_PARAMETER;

    if (DeviceName) {
        IO_STATUS_BLOCK     IoStatusBlock;
        OBJECT_ATTRIBUTES   ObjectAttributes;
        UNICODE_STRING      UnicodeString;
        HANDLE              Handle;
        PREVENT_MEDIA_REMOVAL   PMRemoval;

        INIT_OBJA(&ObjectAttributes, 
                    &UnicodeString, 
                    DeviceName);

        //
        // Open the device
        //
        Status = ZwCreateFile(
                    &Handle,
                    FILE_GENERIC_WRITE,
                    &ObjectAttributes,
                    &IoStatusBlock,
                    NULL,                           // allocation size
                    FILE_ATTRIBUTE_NORMAL,
                    FILE_SHARE_VALID_FLAGS,         // full sharing
                    FILE_OPEN,
                    FILE_SYNCHRONOUS_IO_NONALERT,
                    NULL,                           // no EAs
                    0
                    );

        if( NT_SUCCESS(Status) ) {
            //
            // Allow media removal
            //
            PMRemoval.PreventMediaRemoval = FALSE;
            
            Status = ZwDeviceIoControlFile(
                        Handle,
                        NULL,
                        NULL,
                        NULL,
                        &IoStatusBlock,
                        IOCTL_STORAGE_MEDIA_REMOVAL,
                        &PMRemoval,
                        sizeof(PMRemoval),
                        NULL,
                        0
                        );

            ZwClose(Handle);

            if( !NT_SUCCESS(Status) ) {
                KdPrintEx((DPFLTR_SETUP_ID, DPFLTR_INFO_LEVEL, 
                    "Setup: SpPtnUnlockDevice(%ws) - "
                    "Failed to tell the floppy to release its media.\n",
                    DeviceName));
            }
        } else {
            KdPrintEx((DPFLTR_SETUP_ID, DPFLTR_ERROR_LEVEL, 
                "Setup: SpPtnUnlockDevice(%ws) - Failed to open the device.\n",
                DeviceName));
        }        
    }

    return Status;
}

VOID
SpPtnAssignOrdinals(
    IN  ULONG   DiskNumber
    )
/*++

Routine Description:

    Assigns the on disk ordinal for the partitions for
    the requested disk. This on disk ordinal is used in
    the boot.ini (or NVRAM) ARC names to identify the
    boot and system partition devices.    
    
Arguments:

    DiskNumber  :   Disk Index for the disk which needs to
                    be assigned on disk ordinal for its
                    partitions

Return Value:

    None.

--*/        
{
    if ((DiskNumber < HardDiskCount)) {
        PDISK_REGION    Region = SPPT_GET_PRIMARY_DISK_REGION(DiskNumber);
        ULONG           OnDiskOrdinal = 1;

        if (SPPT_IS_MBR_DISK(DiskNumber)) {
            //
            // assign the ordinals to the primary partitions first
            //
            while (Region) {
                if (SPPT_IS_REGION_PRIMARY_PARTITION(Region)) {
                    Region->TablePosition = OnDiskOrdinal++;              
                }

                Region = Region->Next;
            }    

            Region = SPPT_GET_PRIMARY_DISK_REGION(DiskNumber);

            //
            // assign the ordinals to the logical drives next
            //
            while (Region) {
                if (SPPT_IS_REGION_LOGICAL_DRIVE(Region)) {
                    Region->TablePosition = OnDiskOrdinal++;
                }

                Region = Region->Next;
            }        
        } else {
            //
            // assign ordinals to the valid partition entries
            //
            while (Region) {
                if (SPPT_IS_REGION_PARTITIONED(Region)) {
                    Region->TablePosition = OnDiskOrdinal++;
                }

                Region = Region->Next;
            }
        }
    }
}

VOID
SpPtnLocateSystemPartitions(
    VOID
    )
/*++

Routine Description:

    Locates and marks the system partition, by looking into all the
    partitioned space on all the disks.

    For non ARC machines, locates and marks the system partition
    only on the primary disk 
    
Arguments:

    None

Return Value:

    None

--*/        
{
    ULONG DiskNumber;

    if (SpIsArc()) {
        for (DiskNumber = 0; DiskNumber < HardDiskCount; DiskNumber++) {
            SpPtnLocateDiskSystemPartitions(DiskNumber);
        }
    } else {
        DiskNumber = SpDetermineDisk0();

        if (DiskNumber != -1)
            SpPtnLocateDiskSystemPartitions(DiskNumber);
    }
}   


VOID
SpPtnLocateDiskSystemPartitions(
    IN ULONG DiskNumber
    )
/*++

Routine Description:

    Locates and marks the system partition for the requested
    disk (if none exists)

    For non ARC machine, only operates on primary disk
    
Arguments:

    DiskNumber  :   Disk index, for which system partition
                    needs to be located and marked.

Return Value:

    None.    

--*/        
{
    PDISK_REGION Region = NULL;
    
    if(!SpIsArc()) {
        //
        // Note: On amd64/X86 we currently don't allow system partitions to reside
        // on GPT disks
        //            
        if (SPPT_IS_MBR_DISK(DiskNumber) && (DiskNumber == SpDetermineDisk0())) {
            //
            // On x86 machines, we will mark any primary partitions on drive 0
            // as system partition, since such a partition is potentially bootable.
            //
            Region = SPPT_GET_PRIMARY_DISK_REGION(DiskNumber); 

            while (Region && !SPPT_IS_REGION_SYSTEMPARTITION(Region)) {
                Region = Region->Next;
            }                

            if (!Region) {
                Region = SPPT_GET_PRIMARY_DISK_REGION(DiskNumber); 

                while (Region) {
                    if (SPPT_IS_REGION_PRIMARY_PARTITION(Region)) {
                        SPPT_MARK_REGION_AS_SYSTEMPARTITION(Region, TRUE);
                        SPPT_SET_REGION_DIRTY(Region, TRUE);

                        break;
                    }
                    
                    Region = Region->Next;
                }
            }                
        }
    } else {
        PSP_BOOT_ENTRY BootEntry;

        //
        // Don't look for system partitions on MBR disks
        // on IA64
        //
        if (!SPPT_IS_GPT_DISK(DiskNumber)) {
            return;
        }

        //
        // On ARC machines, system partitions are specifically enumerated
        // in the NVRAM boot environment.
        //

        Region = SPPT_GET_PRIMARY_DISK_REGION(DiskNumber);

        while (Region) {
            //
            // Skip if not a partition or extended partition.
            //
            if(SPPT_IS_REGION_PARTITIONED(Region)) {
                //
                // Get the nt pathname for this region.
                //
                SpNtNameFromRegion(
                    Region,
                    TemporaryBuffer,
                    sizeof(TemporaryBuffer),
                    PartitionOrdinalOriginal
                    );

                //
                // Determine if it is a system partition.
                //
                for(BootEntry = SpBootEntries; BootEntry != NULL; BootEntry = BootEntry->Next) {
                    if(!IS_BOOT_ENTRY_DELETED(BootEntry) &&
                       IS_BOOT_ENTRY_WINDOWS(BootEntry) &&                    
                       (BootEntry->LoaderPartitionNtName != 0) &&
                       !_wcsicmp(BootEntry->LoaderPartitionNtName,TemporaryBuffer)) {
                        if (!SPPT_IS_REGION_SYSTEMPARTITION(Region)) {
                            SPPT_MARK_REGION_AS_SYSTEMPARTITION(Region, TRUE);
                            SPPT_SET_REGION_DIRTY(Region, TRUE);
                            ValidArcSystemPartition = TRUE;
                        }
                        
                        break;
                    }
                }
            }

            Region = Region->Next;
        }            
    }


    KdPrintEx((DPFLTR_SETUP_ID, DPFLTR_INFO_LEVEL,
        "SETUP:SpPtnLocateDiskSystemPartitions(%d):%p\n",
        DiskNumber,
        Region));

    if (Region) 
        SpPtDumpDiskRegion(Region);
}    

BOOLEAN
SpPtnIsDiskStyleChangeAllowed(
    IN ULONG DiskNumber
    )
/*++

Routine Description:

    Finds out whether disk style change is allowed for the
    given disk.

    On AXP machines disk style change is not allowed. On
    X-86 machines currently disk style change is disabled for
    primary disks. 
    
Arguments:

    DiskNumber  :   Disk, whose style needs to be changed.

Return Value:

    TRUE if disk style change is allowed, otherwise FALSE

--*/            
{
    BOOLEAN Result = FALSE;

    if (DiskNumber < HardDiskCount) {
#if defined(_AMD64_) || defined(_X86_)

        //
        // On non ARC x86 machines, the disk should be a clean
        // non-removable secondary disk
        //
        // Don't allow MBR to GPT disk conversion on X86
        //
        Result = (!SPPT_IS_REMOVABLE_DISK(DiskNumber) && 
                    SPPT_IS_BLANK_DISK(DiskNumber) && 
                    !SpIsArc() && SPPT_IS_GPT_DISK(DiskNumber));
                    
#elif defined (_IA64_)

        //
        // Don't allow conversion from GPT to MBR on IA-64
        //

        Result = !SPPT_IS_REMOVABLE_DISK(DiskNumber) &&
                    SPPT_IS_BLANK_DISK(DiskNumber) && 
                    SPPT_IS_MBR_DISK(DiskNumber);
        
#endif // defined(_AMD64_) || defined(_X86_)
    }


    return Result;
}


VOID
SpPtnPromptForSysPart(
    IN PVOID SifHandle
    )
/*++

Routine Description:

    Prompts the user about the absence of system partition
    while installating to another valid non-system partition.
    Allows the user to quit setup or continue (generally go
    back to the partitioning engine)
    
Arguments:

    SifHandle   :   Handle to txtsetup.sif (to do space calculation)

Return Value:

    None

--*/        
{    
    ULONG RequiredSpaceKB = 0;
    ULONG KeyPressed = 0;
    
    SpFetchDiskSpaceRequirements( SifHandle,
                                  (32 * 1024),
                                  NULL,
                                  &RequiredSpaceKB );

    //
    // No valid system partition.
    //
    SpStartScreen(
        SP_SCRN_MARK_SYSPART,
        3,
        HEADER_HEIGHT+1,
        FALSE,
        FALSE,
        DEFAULT_ATTRIBUTE,
        RequiredSpaceKB
        );

    SpDisplayStatusOptions(DEFAULT_STATUS_ATTRIBUTE,
                        SP_STAT_ESC_EQUALS_CANCEL,
                        SP_STAT_F3_EQUALS_EXIT,
                        0);

    SpInputDrain();

    //
    // wait for F3 or ESC key
    //
    while ((KeyPressed != KEY_F3) && (KeyPressed != ASCI_ESC)) {
        KeyPressed = SpInputGetKeypress();
    }        

    if (KeyPressed == KEY_F3) {
        SpDone(0, FALSE, TRUE);
    }         
}

BOOLEAN
SpPtnIsDeleteAllowedForRegion(
    IN PDISK_REGION Region
    )
/*++

Routine Description:

    Given a region this function tries to find out if the region
    can be deleted.
    
Arguments:

    Region :   Pointer to region which is to be checked for 
               deletion

Return Value:

    TRUE if the given region can be deleted otherwise FALSE

--*/
{
    BOOLEAN Result = FALSE;

    if (Region && SPPT_IS_REGION_PARTITIONED(Region)) {
        PDISK_REGION BootRegion = SpRegionFromNtName(NtBootDevicePath, 
                                    PartitionOrdinalCurrent);
        ULONG   DiskNumber = Region->DiskNumber;                                    

        if (SPPT_IS_REGION_DYNAMIC_VOLUME(Region)) {
            //
            // Don't delete the dynamic volume if its on
            // the same disk as local source or system partition
            //
            if (!(LocalSourceRegion && 
                 (LocalSourceRegion->DiskNumber == DiskNumber)) && 
                !(BootRegion && 
                 (BootRegion->DiskNumber == DiskNumber))) {                
                Result = TRUE;                 
            }                             
        } else {
            Result = ((BootRegion != Region) && (LocalSourceRegion != Region));
        }
    }

    return Result;
}


BOOLEAN
SpPtnIsRawDiskDriveLayout(
    IN PDRIVE_LAYOUT_INFORMATION_EX DriveLayout
    )
/*++

Routine Description:

    Given a drive layout tests whether the given drive layout
    could be for a raw disk

    NOTE : If all the partition entries are empty entries or
    if there are no partition entries then we assume the disk 
    to be RAW disk.
    
Arguments:

    DriveLayout : Drive layout information that needs to
    be tested

Return Value:

    TRUE if the given disk is RAW otherwise FALSE

--*/
{
    BOOLEAN Result = TRUE;

    if (DriveLayout && DriveLayout->PartitionCount && 
        (DriveLayout->PartitionStyle != PARTITION_STYLE_RAW)) {
        ULONG   Index;

        for (Index=0; Index < DriveLayout->PartitionCount; Index++) {
            PPARTITION_INFORMATION_EX   PartInfo = DriveLayout->PartitionEntry + Index;

            //
            // Partition is invalid partition if 
            //  - starting offset is 0 and
            //  - length is 0 and
            //  - partition number is 0
            //
            if ((PartInfo->StartingOffset.QuadPart) ||
                (PartInfo->PartitionLength.QuadPart) ||
                (PartInfo->PartitionNumber)) {
                Result = FALSE;

                break;  // found an valid partition entry
            }                        
        }
    }                

    return Result;
}

BOOLEAN
SpPtnIsDynamicDisk(
    IN  ULONG   DiskIndex
    )
/*++

Routine Description:

    Determines whether the given disk is dynamic i.e. it has
    atleast a single dynamic volume
        
Arguments:

    DiskIndex   -   Zero based index of the disk to test

Return Value:

    TRUE, if the disk has a dynamic volume otherwise FALSE

--*/
{
    BOOLEAN Result = FALSE;

    if ((DiskIndex < HardDiskCount) &&
        !SPPT_IS_REMOVABLE_DISK(DiskIndex)) {
        PDISK_REGION    Region = SPPT_GET_PRIMARY_DISK_REGION(DiskIndex);

        while (Region && !SPPT_IS_REGION_DYNAMIC_VOLUME(Region)) {
            Region = Region->Next;
        }

        if (Region) {
            Result = TRUE;
        }
    }

    return Result;
}


//
// Callback context structure for finding the Guid volume name
// for the specified NT partition name
//
typedef struct _NT_TO_GUID_VOLUME_NAME {
    WCHAR   NtName[MAX_PATH];
    WCHAR   GuidVolumeName[MAX_PATH];
} NT_TO_GUID_VOLUME_NAME, *PNT_TO_GUID_VOLUME_NAME;


static
BOOLEAN
SppPtnCompareGuidNameForPartition(
    IN PVOID Context,
    IN PMOUNTMGR_MOUNT_POINTS MountPoints,        
    IN PMOUNTMGR_MOUNT_POINT MountPoint
    )
/*++

Routine Description:

    Callback routine for searching the appropriate GUID
    volume name for the specified NT partition.
        
Arguments:

    Context  : PNT_TO_GUID_VOLUME_NAME pointer disguised as PVOID

    MountPoints : The MountPoints which were received from mountmgr.
                  NOTE : The only reason this is here is because
                  somebody created MOUNT_POINT structure abstraction
                  contained inside MOUNT_POINTS which has some fields
                  (like SymbolicNameOffset) which are relative to
                  the MOUNT_POINTS.

    MountPoint : The current mountpoint (as part of MountPoints)                          

Return Value:

    TRUE if we found a match and want to terminate the iteration else
    FALSE.

--*/
{
    BOOLEAN Result = FALSE;

    if (Context && MountPoint && MountPoint->SymbolicLinkNameLength) {
        WCHAR   CanonicalName[MAX_PATH];
        PWSTR   GuidName = NULL;
        UNICODE_STRING  String;
        PNT_TO_GUID_VOLUME_NAME Map = (PNT_TO_GUID_VOLUME_NAME)Context;

        GuidName = SpMemAlloc(MountPoint->SymbolicLinkNameLength + 2);

        if (GuidName) {
            //
            // Copy over the symbolic name and null terminate it
            // 
            RtlCopyMemory(GuidName, 
                ((PCHAR)MountPoints) + MountPoint->SymbolicLinkNameOffset,
                MountPoint->SymbolicLinkNameLength);

            GuidName[MountPoint->SymbolicLinkNameLength/sizeof(WCHAR)] = UNICODE_NULL;
            
            RtlInitUnicodeString(&String, GuidName); 

            //
            // We are only bothered about volume names & 
            // resolve the actual object name
            //
            if (MOUNTMGR_IS_VOLUME_NAME(&String) &&
                NT_SUCCESS(SpQueryCanonicalName(GuidName, 
                                -1, 
                                CanonicalName, 
                                sizeof(CanonicalName)))) {

                //
                // Do the names compare correctly
                //
                Result = (_wcsicmp(CanonicalName, Map->NtName) == 0);

                if (Result) {
                    //
                    // Copy the name to the result
                    //
                    RtlZeroMemory(Map->GuidVolumeName, 
                        sizeof(Map->GuidVolumeName));
                        
                    wcsncpy(Map->GuidVolumeName, 
                        GuidName, 
                        sizeof(Map->GuidVolumeName)/sizeof(WCHAR) - 1);
                        
                    Map->GuidVolumeName[sizeof(Map->GuidVolumeName)/sizeof(WCHAR) - 1] = UNICODE_NULL;
                }
            }                            

            SpMemFree(GuidName);
        }            
    }

    return Result;
}


NTSTATUS
SpPtnGetGuidNameForPartition(
    IN PWSTR NtPartitionName,
    IN OUT PWSTR VolumeName
    )
/*++

Routine Description:

    Gets the GUID volume name (in \\??\Volume{a-b-c-d} format) for
    the given NT partition name (in \Device\harddiskX\PartitionY format).
        
Arguments:

    NtPartitionName : NT partition name

    VolumeName  : Place holder buffer for receiving the GUID volume name.
                  Should be atlease MAX_PATH in length.

Return Value:

    Approriate NTSTATUS code.

--*/
{
    NTSTATUS Status = STATUS_INVALID_PARAMETER;

    if (NtPartitionName && VolumeName) {
        NT_TO_GUID_VOLUME_NAME  Context = {0};

        //
        // Resolve the NT name to actual object name
        //
        Status = SpQueryCanonicalName(NtPartitionName, 
                            -1,
                            Context.NtName,
                            sizeof(Context.NtName));
                            
        if (NT_SUCCESS(Status)) {                            
            //
            // Iterate through mountpoints and try to
            // get the GUID volume name for the NT name
            //
            Status = SpIterateMountMgrMountPoints(&Context,
                        SppPtnCompareGuidNameForPartition);

            if (NT_SUCCESS(Status)) {
                if (Context.GuidVolumeName[0]) {
                    //
                    // Copy over the result
                    //
                    wcscpy(VolumeName, Context.GuidVolumeName);
                } else {
                    Status = STATUS_OBJECT_NAME_NOT_FOUND;
                }                
            }
        }            
    }

    return Status;
}