uefidisk.c File Reference

#include <uefildr.h>
#include <debug.h>
#include <pshpack1.h>
#include <poppack.h>

Include dependency graph for uefidisk.c:

Go to the source code of this file.

Classes
struct	_GPT_TABLE_HEADER
struct	_GPT_PARTITION_ENTRY
struct	tagDISKCONTEXT
struct	_INTERNAL_UEFI_DISK

Macros
#define	TAG_HW_RESOURCE_LIST   'lRwH'
#define	TAG_HW_DISK_CONTEXT   'cDwH'
#define	FIRST_BIOS_DISK   0x80
#define	FIRST_PARTITION   1
#define	MAX_SUPPORTED_BLOCK_SIZE   8192
#define	EFI_PARTITION_HEADER_SIGNATURE   "EFI PART"
#define	EFI_HEADER_LOCATION   1ULL
#define	EFI_TABLE_REVISION   0x00010000
#define	EFI_PARTITION_ENTRIES_BLOCK   2ULL
#define	EFI_PARTITION_ENTRY_COUNT   128
#define	EFI_PARTITION_ENTRY_SIZE   128
#define	EFI_PARTITION_NAME_LENGTH   36
#define	EFI_PART_TYPE_UNUSED_GUID    {0x00000000, 0x0000, 0x0000, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}
#define	EFI_PART_TYPE_EFI_SYSTEM_PART_GUID    {0xc12a7328, 0xf81f, 0x11d2, {0xba, 0x4b, 0x00, 0xa0, 0xc9, 0x3e, 0xc9, 0x3b}}

Typedefs
typedef struct _GPT_TABLE_HEADER	GPT_TABLE_HEADER
typedef struct _GPT_TABLE_HEADER *	PGPT_TABLE_HEADER
typedef struct _GPT_PARTITION_ENTRY	GPT_PARTITION_ENTRY
typedef struct _GPT_PARTITION_ENTRY *	PGPT_PARTITION_ENTRY
typedef struct tagDISKCONTEXT	DISKCONTEXT
typedef struct _INTERNAL_UEFI_DISK	INTERNAL_UEFI_DISK
typedef struct _INTERNAL_UEFI_DISK *	PINTERNAL_UEFI_DISK

Functions
	DBG_DEFAULT_CHANNEL (WARNING)
static BOOLEAN	UefiIsAlignedPointer (IN PVOID Pointer, IN ULONG Alignment)
static BOOLEAN	UefiEnsureDiskReadBufferAligned (IN ULONG Alignment)
PCHAR	GetHarddiskIdentifier (UCHAR DriveNumber)
LONG	DiskReportError (BOOLEAN bShowError)
static BOOLEAN	UefiReadGptHeader (IN UCHAR DriveNumber, OUT PGPT_TABLE_HEADER GptHeader)
BOOLEAN	UefiGetGptPartitionEntry (IN UCHAR DriveNumber, IN ULONG PartitionNumber, OUT PPARTITION_TABLE_ENTRY PartitionTableEntry)
static BOOLEAN	UefiGetBootPartitionEntry (IN UCHAR DriveNumber, OUT PPARTITION_TABLE_ENTRY PartitionTableEntry, OUT PULONG BootPartition)
static ARC_STATUS	UefiDiskClose (ULONG FileId)
static ARC_STATUS	UefiDiskGetFileInformation (ULONG FileId, FILEINFORMATION *Information)
static ARC_STATUS	UefiDiskOpen (CHAR *Path, OPENMODE OpenMode, ULONG *FileId)
static ARC_STATUS	UefiDiskRead (ULONG FileId, VOID *Buffer, ULONG N, ULONG *Count)
static ARC_STATUS	UefiDiskSeek (ULONG FileId, LARGE_INTEGER *Position, SEEKMODE SeekMode)
static VOID	GetHarddiskInformation (UCHAR DriveNumber)
static VOID	UefiSetupBlockDevices (VOID)
static BOOLEAN	UefiSetBootpath (VOID)
BOOLEAN	UefiInitializeBootDevices (VOID)
UCHAR	UefiGetFloppyCount (VOID)
BOOLEAN	UefiDiskReadLogicalSectors (IN UCHAR DriveNumber, IN ULONGLONG SectorNumber, IN ULONG SectorCount, OUT PVOID Buffer)
BOOLEAN	UefiDiskGetDriveGeometry (UCHAR DriveNumber, PGEOMETRY Geometry)
ULONG	UefiDiskGetCacheableBlockCount (UCHAR DriveNumber)

Variables
EFI_SYSTEM_TABLE *	GlobalSystemTable
EFI_HANDLE	GlobalImageHandle
EFI_HANDLE	PublicBootHandle
PVOID	DiskReadBuffer
static PVOID	DiskReadBufferRaw
static ULONG	DiskReadBufferAlignment
static BOOLEAN	DiskReadBufferFromPool
UCHAR	PcBiosDiskCount
UCHAR	FrldrBootDrive
ULONG	FrldrBootPartition
SIZE_T	DiskReadBufferSize
PVOID	Buffer
static const CHAR	Hex [] = "0123456789abcdef"
static CHAR	PcDiskIdentifier [32][20]
static ULONG	UefiBootRootIndex = 0
static ULONG	PublicBootArcDisk = 0
static INTERNAL_UEFI_DISK *	InternalUefiDisk = NULL
static EFI_GUID	BlockIoGuid = BLOCK_IO_PROTOCOL
static EFI_HANDLE *	handles = NULL
static ULONG	HandleCount = 0
static LONG	lReportError = 0
static const DEVVTBL	UefiDiskVtbl

Macro Definition Documentation

EFI_HEADER_LOCATION

#define EFI_HEADER_LOCATION   1ULL

Definition at line 25 of file uefidisk.c.

EFI_PART_TYPE_EFI_SYSTEM_PART_GUID

#define EFI_PART_TYPE_EFI_SYSTEM_PART_GUID    {0xc12a7328, 0xf81f, 0x11d2, {0xba, 0x4b, 0x00, 0xa0, 0xc9, 0x3e, 0xc9, 0x3b}}

Definition at line 36 of file uefidisk.c.

EFI_PART_TYPE_UNUSED_GUID

#define EFI_PART_TYPE_UNUSED_GUID    {0x00000000, 0x0000, 0x0000, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}

Definition at line 33 of file uefidisk.c.

EFI_PARTITION_ENTRIES_BLOCK

#define EFI_PARTITION_ENTRIES_BLOCK   2ULL

Definition at line 27 of file uefidisk.c.

EFI_PARTITION_ENTRY_COUNT

#define EFI_PARTITION_ENTRY_COUNT   128

Definition at line 28 of file uefidisk.c.

EFI_PARTITION_ENTRY_SIZE

#define EFI_PARTITION_ENTRY_SIZE   128

Definition at line 29 of file uefidisk.c.

EFI_PARTITION_HEADER_SIGNATURE

#define EFI_PARTITION_HEADER_SIGNATURE   "EFI PART"

Definition at line 24 of file uefidisk.c.

EFI_PARTITION_NAME_LENGTH

#define EFI_PARTITION_NAME_LENGTH   36

Definition at line 30 of file uefidisk.c.

EFI_TABLE_REVISION

#define EFI_TABLE_REVISION   0x00010000

Definition at line 26 of file uefidisk.c.

FIRST_BIOS_DISK

#define FIRST_BIOS_DISK   0x80

Definition at line 17 of file uefidisk.c.

FIRST_PARTITION

#define FIRST_PARTITION   1

Definition at line 18 of file uefidisk.c.

MAX_SUPPORTED_BLOCK_SIZE

#define MAX_SUPPORTED_BLOCK_SIZE   8192

Definition at line 21 of file uefidisk.c.

TAG_HW_DISK_CONTEXT

#define TAG_HW_DISK_CONTEXT   'cDwH'

Definition at line 16 of file uefidisk.c.

TAG_HW_RESOURCE_LIST

#define TAG_HW_RESOURCE_LIST   'lRwH'

Definition at line 15 of file uefidisk.c.

Typedef Documentation

DISKCONTEXT

typedef struct tagDISKCONTEXT DISKCONTEXT

GPT_PARTITION_ENTRY

typedef struct _GPT_PARTITION_ENTRY GPT_PARTITION_ENTRY

GPT_TABLE_HEADER

typedef struct _GPT_TABLE_HEADER GPT_TABLE_HEADER

INTERNAL_UEFI_DISK

typedef struct _INTERNAL_UEFI_DISK INTERNAL_UEFI_DISK

PGPT_PARTITION_ENTRY

typedef struct _GPT_PARTITION_ENTRY * PGPT_PARTITION_ENTRY

PGPT_TABLE_HEADER

typedef struct _GPT_TABLE_HEADER * PGPT_TABLE_HEADER

PINTERNAL_UEFI_DISK

typedef struct _INTERNAL_UEFI_DISK * PINTERNAL_UEFI_DISK

Function Documentation

DBG_DEFAULT_CHANNEL()

DBG_DEFAULT_CHANNEL

(

WARNING

)

DiskReportError()

LONG DiskReportError

(

BOOLEAN

bShowError

)

Definition at line 194 of file uefidisk.c.

{
    /* Set the reference count */
    if (bShowError) ++lReportError;
    else            --lReportError;
    return lReportError;
}

Referenced by GetHarddiskInformation().

GetHarddiskIdentifier()

PCHAR GetHarddiskIdentifier

(

UCHAR

DriveNumber

)

Definition at line 183 of file uefidisk.c.

{
    TRACE("GetHarddiskIdentifier: DriveNumber: %d\n", DriveNumber);
    if (DriveNumber < FIRST_BIOS_DISK)
        return NULL;
    return PcDiskIdentifier[DriveNumber - FIRST_BIOS_DISK];
}

Referenced by DetectBiosDisks().

GetHarddiskInformation()

static VOID GetHarddiskInformation ( UCHAR  DriveNumber )

static

Definition at line 835 of file uefidisk.c.

{
    PMASTER_BOOT_RECORD Mbr;
    PULONG Buffer;
    ULONG i;
    ULONG Checksum;
    ULONG Signature;
    BOOLEAN ValidPartitionTable;
    CHAR ArcName[MAX_PATH];
    PARTITION_TABLE_ENTRY PartitionTableEntry;
    ULONG ArcDriveIndex;
    PCHAR Identifier;
 
    ArcDriveIndex = DriveNumber - FIRST_BIOS_DISK;
    if (ArcDriveIndex >= 32)
        return;
 
    Identifier = PcDiskIdentifier[ArcDriveIndex];
 
    /* Detect disk partition type */
    DiskDetectPartitionType(DriveNumber);
 
    /* Read the MBR */
    if (!MachDiskReadLogicalSectors(DriveNumber, 0ULL, 1, DiskReadBuffer))
    {
        ERR("Reading MBR failed\n");
        /* We failed, use a default identifier */
        sprintf(Identifier, "BIOSDISK%d", ArcDriveIndex);
        return;
    }
 
    Buffer = (ULONG*)DiskReadBuffer;
    Mbr = (PMASTER_BOOT_RECORD)DiskReadBuffer;
 
    Signature = Mbr->Signature;
    TRACE("Signature: %x\n", Signature);
 
    /* Calculate the MBR checksum */
    Checksum = 0;
    for (i = 0; i < 512 / sizeof(ULONG); i++)
    {
        Checksum += Buffer[i];
    }
    Checksum = ~Checksum + 1;
    TRACE("Checksum: %x\n", Checksum);
 
    ValidPartitionTable = (Mbr->MasterBootRecordMagic == 0xAA55);
 
    /* Fill out the ARC disk block */
    sprintf(ArcName, "multi(0)disk(0)rdisk(%u)", ArcDriveIndex);
    AddReactOSArcDiskInfo(ArcName, Signature, Checksum, ValidPartitionTable);
 
    sprintf(ArcName, "multi(0)disk(0)rdisk(%u)partition(0)", ArcDriveIndex);
    FsRegisterDevice(ArcName, &UefiDiskVtbl);
 
    /* Add partitions */
    i = FIRST_PARTITION;
    DiskReportError(FALSE);
    while (DiskGetPartitionEntry(DriveNumber, i, &PartitionTableEntry))
    {
        if (PartitionTableEntry.SystemIndicator != PARTITION_ENTRY_UNUSED)
        {
            sprintf(ArcName, "multi(0)disk(0)rdisk(%u)partition(%lu)", ArcDriveIndex, i);
            FsRegisterDevice(ArcName, &UefiDiskVtbl);
        }
        i++;
    }
    DiskReportError(TRUE);
 
    if (ArcDriveIndex < PcBiosDiskCount && InternalUefiDisk != NULL)
    {
        InternalUefiDisk[ArcDriveIndex].NumOfPartitions = i;
    }
 
    /* Convert checksum and signature to identifier string */
    Identifier[0] = Hex[(Checksum >> 28) & 0x0F];
    Identifier[1] = Hex[(Checksum >> 24) & 0x0F];
    Identifier[2] = Hex[(Checksum >> 20) & 0x0F];
    Identifier[3] = Hex[(Checksum >> 16) & 0x0F];
    Identifier[4] = Hex[(Checksum >> 12) & 0x0F];
    Identifier[5] = Hex[(Checksum >> 8) & 0x0F];
    Identifier[6] = Hex[(Checksum >> 4) & 0x0F];
    Identifier[7] = Hex[Checksum & 0x0F];
    Identifier[8] = '-';
    Identifier[9] = Hex[(Signature >> 28) & 0x0F];
    Identifier[10] = Hex[(Signature >> 24) & 0x0F];
    Identifier[11] = Hex[(Signature >> 20) & 0x0F];
    Identifier[12] = Hex[(Signature >> 16) & 0x0F];
    Identifier[13] = Hex[(Signature >> 12) & 0x0F];
    Identifier[14] = Hex[(Signature >> 8) & 0x0F];
    Identifier[15] = Hex[(Signature >> 4) & 0x0F];
    Identifier[16] = Hex[Signature & 0x0F];
    Identifier[17] = '-';
    Identifier[18] = (ValidPartitionTable ? 'A' : 'X');
    Identifier[19] = 0;
    TRACE("Identifier: %s\n", Identifier);
}

Referenced by UefiSetupBlockDevices().

UefiDiskClose()

static ARC_STATUS UefiDiskClose ( ULONG  FileId )

static

Definition at line 573 of file uefidisk.c.

{
    DISKCONTEXT* Context = FsGetDeviceSpecific(FileId);
    FrLdrTempFree(Context, TAG_HW_DISK_CONTEXT);
    return ESUCCESS;
}

UefiDiskGetCacheableBlockCount()

ULONG UefiDiskGetCacheableBlockCount

(

UCHAR

DriveNumber

)

Definition at line 1563 of file uefidisk.c.

{
    ULONG ArcDriveIndex;
    EFI_BLOCK_IO* BlockIo;
    EFI_STATUS Status;
 
    if (DriveNumber < FIRST_BIOS_DISK)
        return 0;
 
    ArcDriveIndex = DriveNumber - FIRST_BIOS_DISK;
 
    if (InternalUefiDisk == NULL)
    {
        ERR("InternalUefiDisk not initialized\n");
        return 0;
    }
 
    if (ArcDriveIndex >= 32 || InternalUefiDisk[ArcDriveIndex].Handle == NULL)
    {
        ERR("Invalid drive number: %d\n", DriveNumber);
        return 0;
    }
 
    Status = GlobalSystemTable->BootServices->HandleProtocol(
        InternalUefiDisk[ArcDriveIndex].Handle,
        &BlockIoGuid,
        (VOID**)&BlockIo);
 
    if (EFI_ERROR(Status) || BlockIo == NULL)
    {
        ERR("Failed to get Block I/O protocol for drive %d\n", DriveNumber);
        return 0;
    }
 
    if (!BlockIo->Media->MediaPresent)
    {
        ERR("Media not present for drive %d\n", DriveNumber);
        return 0;
    }
 
    return (ULONG)(BlockIo->Media->LastBlock + 1);
}

Referenced by MachInit().

UefiDiskGetDriveGeometry()

BOOLEAN UefiDiskGetDriveGeometry	(	UCHAR	DriveNumber,
		PGEOMETRY	Geometry
	)

Definition at line 1513 of file uefidisk.c.

{
    ULONG ArcDriveIndex;
    EFI_BLOCK_IO* BlockIo;
    EFI_STATUS Status;
 
    if (DriveNumber < FIRST_BIOS_DISK)
        return FALSE;
 
    ArcDriveIndex = DriveNumber - FIRST_BIOS_DISK;
 
    if (InternalUefiDisk == NULL)
    {
        ERR("InternalUefiDisk not initialized\n");
        return FALSE;
    }
 
    if (ArcDriveIndex >= 32 || InternalUefiDisk[ArcDriveIndex].Handle == NULL)
    {
        ERR("Invalid drive number: %d\n", DriveNumber);
        return FALSE;
    }
 
    Status = GlobalSystemTable->BootServices->HandleProtocol(
        InternalUefiDisk[ArcDriveIndex].Handle,
        &BlockIoGuid,
        (VOID**)&BlockIo);
 
    if (EFI_ERROR(Status) || BlockIo == NULL)
    {
        ERR("Failed to get Block I/O protocol for drive %d\n", DriveNumber);
        return FALSE;
    }
 
    if (!BlockIo->Media->MediaPresent)
    {
        ERR("Media not present for drive %d\n", DriveNumber);
        return FALSE;
    }
 
    Geometry->Cylinders = 1; /* Not relevant for UEFI Block I/O protocol */
    Geometry->Heads = 1;     /* Not relevant for UEFI Block I/O protocol */
    Geometry->SectorsPerTrack = (ULONG)(BlockIo->Media->LastBlock + 1);
    Geometry->BytesPerSector = BlockIo->Media->BlockSize;
    Geometry->Sectors = BlockIo->Media->LastBlock + 1;
 
    return TRUE;
}

Referenced by MachInit().

UefiDiskGetFileInformation()

static ARC_STATUS UefiDiskGetFileInformation ( ULONG  FileId, FILEINFORMATION *  Information  )

static

Definition at line 582 of file uefidisk.c.

{
    DISKCONTEXT* Context = FsGetDeviceSpecific(FileId);
    RtlZeroMemory(Information, sizeof(*Information));
 
    /*
     * The ARC specification mentions that for partitions, StartingAddress and
     * EndingAddress are the start and end positions of the partition in terms
     * of byte offsets from the start of the disk.
     * CurrentAddress is the current offset into (i.e. relative to) the partition.
     */
    Information->StartingAddress.QuadPart = Context->SectorOffset * Context->SectorSize;
    Information->EndingAddress.QuadPart   = (Context->SectorOffset + Context->SectorCount) * Context->SectorSize;
    Information->CurrentAddress.QuadPart  = Context->SectorNumber * Context->SectorSize;
 
    Information->Type = DiskPeripheral; /* No floppy for you for now... */
 
    return ESUCCESS;
}

UefiDiskOpen()

static ARC_STATUS UefiDiskOpen ( CHAR *  Path, OPENMODE  OpenMode, ULONG *  FileId  )

static

Definition at line 604 of file uefidisk.c.

{
    DISKCONTEXT* Context;
    UCHAR DriveNumber;
    ULONG DrivePartition, SectorSize;
    ULONGLONG SectorOffset = 0;
    ULONGLONG SectorCount = 0;
    ULONG ArcDriveIndex;
    PARTITION_TABLE_ENTRY PartitionTableEntry;
    EFI_BLOCK_IO* BlockIo;
    EFI_STATUS Status;
 
    TRACE("UefiDiskOpen: File ID: %p, Path: %s\n", FileId, Path);
 
    if (DiskReadBufferSize == 0)
    {
        ERR("DiskOpen(): DiskReadBufferSize is 0, something is wrong.\n");
        ASSERT(FALSE);
        return ENOMEM;
    }
 
    if (!DissectArcPath(Path, NULL, &DriveNumber, &DrivePartition))
        return EINVAL;
 
    TRACE("Opening disk: DriveNumber: %d, DrivePartition: %d\n", DriveNumber, DrivePartition);
 
    if (DriveNumber < FIRST_BIOS_DISK)
        return EINVAL;
 
    ArcDriveIndex = DriveNumber - FIRST_BIOS_DISK;
    if (ArcDriveIndex >= PcBiosDiskCount || InternalUefiDisk == NULL)
        return EINVAL;
 
    /* Get Block I/O protocol for this drive */
    Status = GlobalSystemTable->BootServices->HandleProtocol(
        InternalUefiDisk[ArcDriveIndex].Handle,
        &BlockIoGuid,
        (VOID**)&BlockIo);
 
    if (EFI_ERROR(Status) || BlockIo == NULL)
    {
        ERR("Failed to get Block I/O protocol for drive %d\n", DriveNumber);
        return EINVAL;
    }
 
    /* Check media is present */
    if (!BlockIo->Media->MediaPresent)
    {
        ERR("Media not present for drive %d\n", DriveNumber);
        return EINVAL;
    }
 
    SectorSize = BlockIo->Media->BlockSize;
 
    if (DrivePartition != 0xff && DrivePartition != 0)
    {
        if (!DiskGetPartitionEntry(DriveNumber, DrivePartition, &PartitionTableEntry))
            return EINVAL;
 
        SectorOffset = PartitionTableEntry.SectorCountBeforePartition;
        SectorCount = PartitionTableEntry.PartitionSectorCount;
    }
    else
    {
        GEOMETRY Geometry;
        if (!MachDiskGetDriveGeometry(DriveNumber, &Geometry))
            return EINVAL;
 
        if (SectorSize != Geometry.BytesPerSector)
        {
            ERR("SectorSize (%lu) != Geometry.BytesPerSector (%lu), expect problems!\n",
                SectorSize, Geometry.BytesPerSector);
        }
 
        SectorOffset = 0;
        SectorCount = Geometry.Sectors;
    }
 
    Context = FrLdrTempAlloc(sizeof(DISKCONTEXT), TAG_HW_DISK_CONTEXT);
    if (!Context)
        return ENOMEM;
 
    Context->DriveNumber = DriveNumber;
    Context->SectorSize = SectorSize;
    Context->SectorOffset = SectorOffset;
    Context->SectorCount = SectorCount;
    Context->SectorNumber = 0;
    FsSetDeviceSpecific(*FileId, Context);
    return ESUCCESS;
}

UefiDiskRead()

static ARC_STATUS UefiDiskRead ( ULONG  FileId, VOID *  Buffer, ULONG  N, ULONG *  Count  )

static

Definition at line 697 of file uefidisk.c.

{
    DISKCONTEXT* Context = FsGetDeviceSpecific(FileId);
    UCHAR* Ptr = (UCHAR*)Buffer;
    ULONG Length, TotalSectors, MaxSectors, ReadSectors;
    ULONGLONG SectorOffset;
    BOOLEAN ret;
    EFI_BLOCK_IO* BlockIo;
    EFI_STATUS Status;
    ULONG ArcDriveIndex;
 
    ASSERT(DiskReadBufferSize > 0);
 
 
    TotalSectors = (N + Context->SectorSize - 1) / Context->SectorSize;
    MaxSectors   = DiskReadBufferSize / Context->SectorSize;
    SectorOffset = Context->SectorOffset + Context->SectorNumber;
 
    // If MaxSectors is 0, this will lead to infinite loop.
    // In release builds assertions are disabled, however we also have sanity checks in DiskOpen()
    ASSERT(MaxSectors > 0);
 
    if (MaxSectors == 0)
    {
        ERR("MaxSectors is 0, cannot read\n");
        *Count = 0;
        return EIO;
    }
 
    ArcDriveIndex = Context->DriveNumber - FIRST_BIOS_DISK;
    if (ArcDriveIndex >= PcBiosDiskCount || InternalUefiDisk == NULL)
    {
        ERR("Invalid drive number %d\n", Context->DriveNumber);
        *Count = 0;
        return EINVAL;
    }
 
    /* Get Block I/O protocol */
    Status = GlobalSystemTable->BootServices->HandleProtocol(
        InternalUefiDisk[ArcDriveIndex].Handle,
        &BlockIoGuid,
        (VOID**)&BlockIo);
 
    if (EFI_ERROR(Status) || BlockIo == NULL)
    {
        ERR("Failed to get Block I/O protocol\n");
        *Count = 0;
        return EIO;
    }
 
    if (!UefiEnsureDiskReadBufferAligned(BlockIo->Media->IoAlign))
    {
        ERR("Failed to align disk read buffer\n");
        *Count = 0;
        return EIO;
    }
 
    ret = TRUE;
 
    while (TotalSectors)
    {
        ReadSectors = min(TotalSectors, MaxSectors);
 
        Status = BlockIo->ReadBlocks(
            BlockIo,
            BlockIo->Media->MediaId,
            SectorOffset,
            ReadSectors * Context->SectorSize,
            DiskReadBuffer);
 
        if (EFI_ERROR(Status))
        {
            ERR("ReadBlocks failed: Status = 0x%lx\n", (ULONG)Status);
            ret = FALSE;
            break;
        }
 
        Length = ReadSectors * Context->SectorSize;
        Length = min(Length, N);
 
        RtlCopyMemory(Ptr, DiskReadBuffer, Length);
 
        Ptr += Length;
        N -= Length;
        SectorOffset += ReadSectors;
        TotalSectors -= ReadSectors;
    }
 
    *Count = (ULONG)((ULONG_PTR)Ptr - (ULONG_PTR)Buffer);
    Context->SectorNumber = SectorOffset - Context->SectorOffset;
 
    return (ret ? ESUCCESS : EIO);
}

UefiDiskReadLogicalSectors()

BOOLEAN UefiDiskReadLogicalSectors	(	IN UCHAR	DriveNumber,
		IN ULONGLONG	SectorNumber,
		IN ULONG	SectorCount,
		OUT PVOID	Buffer
	)

Definition at line 1378 of file uefidisk.c.

{
    ULONG ArcDriveIndex;
    EFI_BLOCK_IO* BlockIo;
    EFI_STATUS Status;
    ULONG BlockSize;
    ULONG IoAlign;
 
    if (DriveNumber < FIRST_BIOS_DISK)
        return FALSE;
 
    ArcDriveIndex = DriveNumber - FIRST_BIOS_DISK;
 
    if (InternalUefiDisk == NULL)
    {
        ERR("InternalUefiDisk not initialized\n");
        return FALSE;
    }
 
    if (ArcDriveIndex >= 32)
    {
        ERR("Drive index out of bounds: %d (ArcDriveIndex=%lu)\n", DriveNumber, ArcDriveIndex);
        return FALSE;
    }
 
    /* Allow access during initialization: check if handle is set up */
    /* During initialization, Handle is set before GetHarddiskInformation is called */
    if (InternalUefiDisk[ArcDriveIndex].Handle == NULL)
    {
        ERR("Invalid drive number: %d (ArcDriveIndex=%lu, PcBiosDiskCount=%lu, Handle=NULL)\n", 
            DriveNumber, ArcDriveIndex, PcBiosDiskCount);
        return FALSE;
    }
 
    Status = GlobalSystemTable->BootServices->HandleProtocol(
        InternalUefiDisk[ArcDriveIndex].Handle,
        &BlockIoGuid,
        (VOID**)&BlockIo);
 
    if (EFI_ERROR(Status) || BlockIo == NULL)
    {
        ERR("Failed to get Block I/O protocol for drive %d\n", DriveNumber);
        return FALSE;
    }
 
    if (!BlockIo->Media->MediaPresent)
    {
        ERR("Media not present for drive %d\n", DriveNumber);
        return FALSE;
    }
 
    BlockSize = BlockIo->Media->BlockSize;
    IoAlign = BlockIo->Media->IoAlign;
 
    if (!UefiEnsureDiskReadBufferAligned(IoAlign))
    {
        ERR("Failed to align disk read buffer for drive %d\n", DriveNumber);
        return FALSE;
    }
 
    if (!UefiIsAlignedPointer(Buffer, (IoAlign == 0) ? 1 : IoAlign))
    {
        ULONG TotalSectors = SectorCount;
        ULONG MaxSectors = DiskReadBufferSize / BlockSize;
        ULONGLONG CurrentSector = SectorNumber;
        PUCHAR OutPtr = (PUCHAR)Buffer;
 
        if (MaxSectors == 0)
        {
            ERR("DiskReadBufferSize too small for block size %lu\n", BlockSize);
            return FALSE;
        }
 
        while (TotalSectors)
        {
            ULONG ReadSectors = min(TotalSectors, MaxSectors);
            UINTN ReadSize = ReadSectors * BlockSize;
 
            Status = BlockIo->ReadBlocks(
                BlockIo,
                BlockIo->Media->MediaId,
                CurrentSector,
                ReadSize,
                DiskReadBuffer);
 
            if (EFI_ERROR(Status))
            {
                ERR("ReadBlocks failed: DriveNumber=%d, SectorNumber=%llu, SectorCount=%lu, Status=0x%lx\n",
                    DriveNumber, CurrentSector, ReadSectors, (ULONG)Status);
                ERR("ReadBlocks details: BlockSize=%lu, IoAlign=%lu, Buffer=%p, DiskReadBuffer=%p, MediaId=0x%lx\n",
                    BlockSize, IoAlign, Buffer, DiskReadBuffer, (ULONG)BlockIo->Media->MediaId);
                ERR("ReadBlocks media: LastBlock=%llu, LogicalPartition=%s, RemovableMedia=%s\n",
                    BlockIo->Media->LastBlock,
                    BlockIo->Media->LogicalPartition ? "TRUE" : "FALSE",
                    BlockIo->Media->RemovableMedia ? "TRUE" : "FALSE");
                return FALSE;
            }
 
            RtlCopyMemory(OutPtr, DiskReadBuffer, ReadSize);
            OutPtr += ReadSize;
            CurrentSector += ReadSectors;
            TotalSectors -= ReadSectors;
        }
 
        return TRUE;
    }
 
    Status = BlockIo->ReadBlocks(
        BlockIo,
        BlockIo->Media->MediaId,
        SectorNumber,
        SectorCount * BlockSize,
        Buffer);
 
    if (EFI_ERROR(Status))
    {
        ERR("ReadBlocks failed: DriveNumber=%d, SectorNumber=%llu, SectorCount=%lu, Status=0x%lx\n",
            DriveNumber, SectorNumber, SectorCount, (ULONG)Status);
        ERR("ReadBlocks details: BlockSize=%lu, IoAlign=%lu, Buffer=%p, DiskReadBuffer=%p, MediaId=0x%lx\n",
            BlockSize, IoAlign, Buffer, DiskReadBuffer, (ULONG)BlockIo->Media->MediaId);
        ERR("ReadBlocks media: LastBlock=%llu, LogicalPartition=%s, RemovableMedia=%s\n",
            BlockIo->Media->LastBlock,
            BlockIo->Media->LogicalPartition ? "TRUE" : "FALSE",
            BlockIo->Media->RemovableMedia ? "TRUE" : "FALSE");
        return FALSE;
    }
 
    return TRUE;
}

Referenced by MachInit().

UefiDiskSeek()

static ARC_STATUS UefiDiskSeek ( ULONG  FileId, LARGE_INTEGER *  Position, SEEKMODE  SeekMode  )

static

Definition at line 793 of file uefidisk.c.

{
    DISKCONTEXT* Context = FsGetDeviceSpecific(FileId);
    LARGE_INTEGER NewPosition = *Position;
 
    switch (SeekMode)
    {
        case SeekAbsolute:
            break;
        case SeekRelative:
            NewPosition.QuadPart += (Context->SectorNumber * Context->SectorSize);
            break;
        default:
            ASSERT(FALSE);
            return EINVAL;
    }
 
    if (NewPosition.QuadPart & (Context->SectorSize - 1))
        return EINVAL;
 
    /* Convert in number of sectors */
    NewPosition.QuadPart /= Context->SectorSize;
 
    /* HACK: CDROMs may have a SectorCount of 0 */
    if (Context->SectorCount != 0 && NewPosition.QuadPart >= Context->SectorCount)
        return EINVAL;
 
    Context->SectorNumber = NewPosition.QuadPart;
    return ESUCCESS;
}

UefiEnsureDiskReadBufferAligned()

static BOOLEAN UefiEnsureDiskReadBufferAligned ( IN ULONG  Alignment )

static

Definition at line 137 of file uefidisk.c.

{
    ULONG RequiredAlignment = (Alignment == 0) ? 1 : Alignment;
    EFI_STATUS Status;
 
    if (DiskReadBuffer != NULL && DiskReadBufferAlignment >= RequiredAlignment &&
        UefiIsAlignedPointer(DiskReadBuffer, RequiredAlignment))
    {
        return TRUE;
    }
 
    DiskReadBufferAlignment = RequiredAlignment;
 
    if (DiskReadBufferRaw != NULL && DiskReadBufferFromPool)
    {
        GlobalSystemTable->BootServices->FreePool(DiskReadBufferRaw);
        DiskReadBufferRaw = NULL;
        DiskReadBuffer = NULL;
        DiskReadBufferFromPool = FALSE;
    }
 
    Status = GlobalSystemTable->BootServices->AllocatePool(EfiLoaderData,
                                                           DiskReadBufferSize + RequiredAlignment,
                                                           (void**)&DiskReadBufferRaw);
    if (EFI_ERROR(Status) || DiskReadBufferRaw == NULL)
    {
        ERR("Failed to allocate aligned disk read buffer (align %lu)\n", RequiredAlignment);
        DiskReadBuffer = NULL;
        return FALSE;
    }
    DiskReadBufferFromPool = TRUE;
 
    DiskReadBuffer = (PVOID)ALIGN_UP_POINTER_BY(DiskReadBufferRaw, RequiredAlignment);
    if (!UefiIsAlignedPointer(DiskReadBuffer, RequiredAlignment))
    {
        ERR("Aligned disk read buffer is not properly aligned (align %lu)\n", RequiredAlignment);
        return FALSE;
    }
 
    return TRUE;
}

Referenced by UefiDiskRead(), UefiDiskReadLogicalSectors(), UefiInitializeBootDevices(), UefiReadGptHeader(), and UefiSetupBlockDevices().

UefiGetBootPartitionEntry()

static BOOLEAN UefiGetBootPartitionEntry ( IN UCHAR  DriveNumber, OUT PPARTITION_TABLE_ENTRY  PartitionTableEntry, OUT PULONG  BootPartition  )

static

Definition at line 360 of file uefidisk.c.

{
    ULONG PartitionNum;
    ULONG ArcDriveIndex;
    EFI_BLOCK_IO* BootBlockIo;
    EFI_STATUS Status;
    ULONGLONG BootPartitionSize;
    PARTITION_TABLE_ENTRY TempPartitionEntry;
 
    TRACE("UefiGetBootPartitionEntry: DriveNumber: %d\n", DriveNumber - FIRST_BIOS_DISK);
 
    if (DriveNumber < FIRST_BIOS_DISK)
        return FALSE;
 
    ArcDriveIndex = DriveNumber - FIRST_BIOS_DISK;
    if (ArcDriveIndex >= PcBiosDiskCount || handles == NULL || UefiBootRootIndex >= HandleCount)
        return FALSE;
 
    /* Get the boot handle's Block I/O protocol to determine partition offset/size */
    Status = GlobalSystemTable->BootServices->HandleProtocol(
        handles[UefiBootRootIndex],
        &BlockIoGuid,
        (VOID**)&BootBlockIo);
 
    if (EFI_ERROR(Status) || BootBlockIo == NULL)
    {
        ERR("Failed to get Block I/O protocol for boot handle\n");
        return FALSE;
    }
 
    /* For logical partitions, UEFI Block I/O protocol starts at block 0 */
    /* We need to find which partition it corresponds to by comparing sizes */
    BootPartitionSize = BootBlockIo->Media->LastBlock + 1;
 
    TRACE("Boot partition: Size=%llu blocks, BlockSize=%lu\n",
        BootPartitionSize, BootBlockIo->Media->BlockSize);
 
    /* If boot handle is the root device itself (not a logical partition) */
    if (!BootBlockIo->Media->LogicalPartition)
    {
        TRACE("Boot handle is root device, using partition 0\n");
        *BootPartition = 0;
        if (PartitionTableEntry != NULL)
        {
            RtlZeroMemory(PartitionTableEntry, sizeof(*PartitionTableEntry));
        }
        return TRUE;
    }
 
    /* Boot handle is a logical partition - find matching partition entry */
    /* Try to detect GPT first by reading GPT header */
    GPT_TABLE_HEADER GptHeader;
    BOOLEAN IsGpt = UefiReadGptHeader(DriveNumber, &GptHeader);
 
    if (IsGpt)
    {
        /* For GPT, iterate through GPT partition entries */
        GPT_TABLE_HEADER GptHeader;
        GPT_PARTITION_ENTRY GptEntry;
        ULONG ArcDriveIndex = DriveNumber - FIRST_BIOS_DISK;
        EFI_BLOCK_IO* RootBlockIo;
        ULONG BlockSize;
        ULONGLONG EntryLba;
        ULONG EntryOffset;
        ULONG EntriesPerBlock;
        EFI_STATUS Status;
        EFI_GUID UnusedGuid = EFI_PART_TYPE_UNUSED_GUID;
 
        if (!UefiReadGptHeader(DriveNumber, &GptHeader))
        {
            ERR("Failed to read GPT header\n");
            return FALSE;
        }
 
        Status = GlobalSystemTable->BootServices->HandleProtocol(
            InternalUefiDisk[ArcDriveIndex].Handle,
            &BlockIoGuid,
            (VOID**)&RootBlockIo);
 
        if (EFI_ERROR(Status) || RootBlockIo == NULL)
            return FALSE;
 
        BlockSize = RootBlockIo->Media->BlockSize;
        EntriesPerBlock = BlockSize / GptHeader.SizeOfPartitionEntry;
 
        /* Iterate through GPT partition entries */
        for (ULONG i = 0; i < GptHeader.NumberOfPartitionEntries; i++)
        {
            EntryLba = GptHeader.PartitionEntryLba + (i / EntriesPerBlock);
            EntryOffset = (i % EntriesPerBlock) * GptHeader.SizeOfPartitionEntry;
 
            /* Read the block containing the partition entry */
            Status = RootBlockIo->ReadBlocks(
                RootBlockIo,
                RootBlockIo->Media->MediaId,
                EntryLba,
                BlockSize,
                DiskReadBuffer);
 
            if (EFI_ERROR(Status))
                continue;
 
            /* Extract partition entry */
            RtlCopyMemory(&GptEntry, (PUCHAR)DiskReadBuffer + EntryOffset, sizeof(GPT_PARTITION_ENTRY));
 
            /* Skip unused partitions */
            if (memcmp(&GptEntry.PartitionTypeGuid, &UnusedGuid, sizeof(EFI_GUID)) == 0)
                continue;
 
            /* Calculate partition size in blocks */
            ULONGLONG PartitionSizeBlocks = GptEntry.EndingLba - GptEntry.StartingLba + 1;
 
            TRACE("GPT Partition %lu: StartLba=%llu, EndLba=%llu, SizeBlocks=%llu\n",
                i + 1, GptEntry.StartingLba, GptEntry.EndingLba, PartitionSizeBlocks);
 
            /* Match partition by size (within 1 block tolerance for rounding) */
            if (PartitionSizeBlocks == BootPartitionSize ||
                (PartitionSizeBlocks > 0 && 
                 (PartitionSizeBlocks - 1 <= BootPartitionSize && 
                  BootPartitionSize <= PartitionSizeBlocks + 1)))
            {
                TRACE("Found matching GPT partition %lu: Size matches (%llu blocks)\n",
                    i + 1, BootPartitionSize);
 
                *BootPartition = i + 1; /* GPT partitions are 1-indexed */
 
                /* Convert GPT entry to MBR-style entry for compatibility */
                if (PartitionTableEntry != NULL)
                {
                    RtlZeroMemory(PartitionTableEntry, sizeof(*PartitionTableEntry));
                    ULONGLONG StartSector = (GptEntry.StartingLba * BlockSize) / 512;
                    ULONGLONG SectorCount = (PartitionSizeBlocks * BlockSize) / 512;
                    PartitionTableEntry->SectorCountBeforePartition = (ULONG)StartSector;
                    PartitionTableEntry->PartitionSectorCount = (ULONG)SectorCount;
                    PartitionTableEntry->SystemIndicator = PARTITION_GPT;
                }
                return TRUE;
            }
        }
    }
    else
    {
        /* MBR partition matching */
        PartitionNum = FIRST_PARTITION;
        while (DiskGetPartitionEntry(DriveNumber, PartitionNum, &TempPartitionEntry))
        {
            ULONGLONG PartitionSizeSectors = TempPartitionEntry.PartitionSectorCount;
            ULONGLONG PartitionSizeBlocks;
 
            /* Convert partition size from MBR sectors (always 512 bytes) to UEFI blocks */
            /* MBR partition table always uses 512-byte sectors per specification */
            /* UEFI Block I/O protocol reports sizes in device's BlockSize bytes */
            /* Compare in bytes to avoid rounding issues, then convert to boot partition's block size */
            ULONGLONG PartitionSizeBytes = PartitionSizeSectors * 512ULL;
            PartitionSizeBlocks = PartitionSizeBytes / BootBlockIo->Media->BlockSize;
 
            TRACE("Partition %lu: SizeSectors=%llu, SizeBlocks=%llu\n",
                PartitionNum, PartitionSizeSectors, PartitionSizeBlocks);
 
            /* Match partition by size (within 1 block tolerance for rounding) */
            if (PartitionSizeBlocks == BootPartitionSize ||
                (PartitionSizeBlocks > 0 && 
                 (PartitionSizeBlocks - 1 <= BootPartitionSize && 
                  BootPartitionSize <= PartitionSizeBlocks + 1)))
            {
                TRACE("Found matching partition %lu: Size matches (%llu blocks)\n",
                    PartitionNum, BootPartitionSize);
 
                *BootPartition = PartitionNum;
                if (PartitionTableEntry != NULL)
                {
                    RtlCopyMemory(PartitionTableEntry, &TempPartitionEntry, sizeof(*PartitionTableEntry));
                }
                return TRUE;
            }
 
            PartitionNum++;
        }
    }
 
    /* If we couldn't find a match, check if it's a CD-ROM (special case) */
    if (BootBlockIo->Media->RemovableMedia && BootBlockIo->Media->BlockSize == 2048)
    {
        TRACE("Boot device is CD-ROM, using partition 0xFF\n");
        *BootPartition = 0xFF;
        if (PartitionTableEntry != NULL)
        {
            RtlZeroMemory(PartitionTableEntry, sizeof(*PartitionTableEntry));
        }
        return TRUE;
    }
 
    /* Fallback: if we can't determine, use partition 1 */
    ERR("Could not determine boot partition, using partition 1 as fallback\n");
    PartitionNum = FIRST_PARTITION;
    if (DiskGetPartitionEntry(DriveNumber, PartitionNum, &TempPartitionEntry))
    {
        *BootPartition = PartitionNum;
        if (PartitionTableEntry != NULL)
        {
            RtlCopyMemory(PartitionTableEntry, &TempPartitionEntry, sizeof(*PartitionTableEntry));
        }
        return TRUE;
    }
 
    return FALSE;
}

Referenced by UefiSetBootpath().

UefiGetFloppyCount()

UCHAR UefiGetFloppyCount

(

VOID

)

Definition at line 1371 of file uefidisk.c.

{
    /* No floppy support in UEFI */
    return 0;
}

Referenced by MachInit().

UefiGetGptPartitionEntry()

BOOLEAN UefiGetGptPartitionEntry	(	IN UCHAR	DriveNumber,
		IN ULONG	PartitionNumber,
		OUT PPARTITION_TABLE_ENTRY	PartitionTableEntry
	)

Definition at line 273 of file uefidisk.c.

{
    GPT_TABLE_HEADER GptHeader;
    GPT_PARTITION_ENTRY GptEntry;
    ULONG ArcDriveIndex;
    EFI_BLOCK_IO* BlockIo;
    EFI_STATUS Status;
    ULONG BlockSize;
    ULONGLONG EntryLba;
    ULONG EntryOffset;
    ULONG EntriesPerBlock;
    EFI_GUID UnusedGuid = EFI_PART_TYPE_UNUSED_GUID;
 
    if (DriveNumber < FIRST_BIOS_DISK)
        return FALSE;
 
    ArcDriveIndex = DriveNumber - FIRST_BIOS_DISK;
    if (ArcDriveIndex >= PcBiosDiskCount || InternalUefiDisk == NULL)
        return FALSE;
 
    /* Read GPT header */
    if (!UefiReadGptHeader(DriveNumber, &GptHeader))
        return FALSE;
 
    /* Validate partition number */
    if (PartitionNumber == 0 || PartitionNumber > GptHeader.NumberOfPartitionEntries)
        return FALSE;
 
    /* Convert to 0-based index */
    ULONG EntryIndex = PartitionNumber - 1;
 
    Status = GlobalSystemTable->BootServices->HandleProtocol(
        InternalUefiDisk[ArcDriveIndex].Handle,
        &BlockIoGuid,
        (VOID**)&BlockIo);
 
    if (EFI_ERROR(Status) || BlockIo == NULL)
        return FALSE;
 
    BlockSize = BlockIo->Media->BlockSize;
    EntriesPerBlock = BlockSize / GptHeader.SizeOfPartitionEntry;
    EntryLba = GptHeader.PartitionEntryLba + (EntryIndex / EntriesPerBlock);
    EntryOffset = (EntryIndex % EntriesPerBlock) * GptHeader.SizeOfPartitionEntry;
 
    /* Read the block containing the partition entry */
    Status = BlockIo->ReadBlocks(
        BlockIo,
        BlockIo->Media->MediaId,
        EntryLba,
        BlockSize,
        DiskReadBuffer);
 
    if (EFI_ERROR(Status))
        return FALSE;
 
    /* Extract partition entry */
    RtlCopyMemory(&GptEntry, (PUCHAR)DiskReadBuffer + EntryOffset, sizeof(GPT_PARTITION_ENTRY));
 
    /* Check if partition is unused */
    if (memcmp(&GptEntry.PartitionTypeGuid, &UnusedGuid, sizeof(EFI_GUID)) == 0)
        return FALSE;
 
    /* Convert GPT entry to MBR-style PARTITION_TABLE_ENTRY */
    RtlZeroMemory(PartitionTableEntry, sizeof(*PartitionTableEntry));
 
    /* Calculate sector offset and count */
    /* GPT uses LBA, convert to 512-byte sectors */
    ULONGLONG StartLba = GptEntry.StartingLba;
    ULONGLONG EndLba = GptEntry.EndingLba;
    ULONGLONG SectorCount = (EndLba - StartLba + 1);
 
    /* For GPT, we need to convert from device block size to 512-byte sectors */
    ULONGLONG StartSector = (StartLba * BlockSize) / 512;
    ULONGLONG SectorCount512 = (SectorCount * BlockSize) / 512;
 
    PartitionTableEntry->SectorCountBeforePartition = (ULONG)StartSector;
    PartitionTableEntry->PartitionSectorCount = (ULONG)SectorCount512;
    PartitionTableEntry->SystemIndicator = PARTITION_GPT; /* Mark as GPT partition */
 
    return TRUE;
}

Referenced by DiskGetPartitionEntry().

UefiInitializeBootDevices()

BOOLEAN UefiInitializeBootDevices

(

VOID

)

Definition at line 1282 of file uefidisk.c.

{
    EFI_BLOCK_IO* BlockIo;
    EFI_STATUS Status;
    ULONG ArcDriveIndex;
    PMASTER_BOOT_RECORD Mbr;
    PULONG Buffer;
    ULONG Checksum = 0;
    ULONG Signature;
    ULONG i;
 
    DiskReadBufferSize = EFI_PAGE_SIZE;
    DiskReadBuffer = NULL;
    DiskReadBufferRaw = NULL;
    DiskReadBufferAlignment = 1;
    DiskReadBufferFromPool = FALSE;
    if (!UefiEnsureDiskReadBufferAligned(1))
    {
        ERR("Failed to allocate disk read buffer\n");
        return FALSE;
    }
 
    UefiSetupBlockDevices();
 
    if (PcBiosDiskCount == 0)
    {
        ERR("No block devices found\n");
        return FALSE;
    }
 
    if (!UefiSetBootpath())
    {
        ERR("Failed to set boot path\n");
        return FALSE;
    }
 
    /* Handle CD-ROM boot device registration */
    ArcDriveIndex = PublicBootArcDisk;
    if (ArcDriveIndex >= PcBiosDiskCount || InternalUefiDisk == NULL)
    {
        ERR("Invalid boot arc disk index\n");
        return FALSE;
    }
 
    Status = GlobalSystemTable->BootServices->HandleProtocol(
        InternalUefiDisk[ArcDriveIndex].Handle,
        &BlockIoGuid,
        (VOID**)&BlockIo);
 
    if (EFI_ERROR(Status) || BlockIo == NULL)
    {
        ERR("Failed to get Block I/O protocol\n");
        return FALSE;
    }
 
    if (BlockIo->Media->RemovableMedia == TRUE && BlockIo->Media->BlockSize == 2048)
    {
        /* Read the MBR from CD-ROM (sector 16) */
        if (!MachDiskReadLogicalSectors(FrldrBootDrive, 16ULL, 1, DiskReadBuffer))
        {
            ERR("Reading MBR from CD-ROM failed\n");
            return FALSE;
        }
 
        Buffer = (ULONG*)DiskReadBuffer;
        Mbr = (PMASTER_BOOT_RECORD)DiskReadBuffer;
 
        Signature = Mbr->Signature;
        TRACE("CD-ROM Signature: %x\n", Signature);
 
        /* Calculate the MBR checksum */
        for (i = 0; i < 2048 / sizeof(ULONG); i++)
        {
            Checksum += Buffer[i];
        }
        Checksum = ~Checksum + 1;
        TRACE("CD-ROM Checksum: %x\n", Checksum);
 
        /* Fill out the ARC disk block */
        AddReactOSArcDiskInfo(FrLdrBootPath, Signature, Checksum, TRUE);
 
        FsRegisterDevice(FrLdrBootPath, &UefiDiskVtbl);
        TRACE("Registered CD-ROM boot device: 0x%02X\n", (int)FrldrBootDrive);
    }
 
    return TRUE;
}

Referenced by MachInit().

UefiIsAlignedPointer()

static BOOLEAN UefiIsAlignedPointer ( IN PVOID  Pointer, IN ULONG  Alignment  )

static

Definition at line 122 of file uefidisk.c.

{
    ULONG_PTR Value;
 
    if (Alignment <= 1)
        return TRUE;
 
    Value = (ULONG_PTR)Pointer;
    return ((Value & (Alignment - 1)) == 0);
}

Referenced by UefiDiskReadLogicalSectors(), and UefiEnsureDiskReadBufferAligned().

UefiReadGptHeader()

static BOOLEAN UefiReadGptHeader ( IN UCHAR  DriveNumber, OUT PGPT_TABLE_HEADER  GptHeader  )

static

Definition at line 207 of file uefidisk.c.

{
    ULONG ArcDriveIndex;
    EFI_BLOCK_IO* BlockIo;
    EFI_STATUS Status;
    ULONG BlockSize;
    ULONG IoAlign;
    ULONGLONG HeaderLba = EFI_HEADER_LOCATION;
 
    if (DriveNumber < FIRST_BIOS_DISK)
        return FALSE;
 
    ArcDriveIndex = DriveNumber - FIRST_BIOS_DISK;
    if (ArcDriveIndex >= PcBiosDiskCount || InternalUefiDisk == NULL)
        return FALSE;
 
    Status = GlobalSystemTable->BootServices->HandleProtocol(
        InternalUefiDisk[ArcDriveIndex].Handle,
        &BlockIoGuid,
        (VOID**)&BlockIo);
 
    if (EFI_ERROR(Status) || BlockIo == NULL)
        return FALSE;
 
    if (!BlockIo->Media->MediaPresent)
        return FALSE;
 
    BlockSize = BlockIo->Media->BlockSize;
    IoAlign = BlockIo->Media->IoAlign;
 
    if (!UefiEnsureDiskReadBufferAligned(IoAlign))
    {
        ERR("Failed to align disk read buffer for drive %d\n", DriveNumber);
        return FALSE;
    }
 
    /* Read GPT header from LBA 1 */
    Status = BlockIo->ReadBlocks(
        BlockIo,
        BlockIo->Media->MediaId,
        HeaderLba,
        BlockSize,
        DiskReadBuffer);
 
    if (EFI_ERROR(Status))
        return FALSE;
 
    RtlCopyMemory(GptHeader, DiskReadBuffer, sizeof(GPT_TABLE_HEADER));
 
    /* Verify GPT signature */
    if (memcmp(GptHeader->Signature, EFI_PARTITION_HEADER_SIGNATURE, 8) != 0)
        return FALSE;
 
    /* Verify revision */
    if (GptHeader->Revision != EFI_TABLE_REVISION)
    {
        TRACE("GPT header has unsupported revision: 0x%x\n", GptHeader->Revision);
        return FALSE;
    }
 
    return TRUE;
}

Referenced by UefiGetBootPartitionEntry(), and UefiGetGptPartitionEntry().

UefiSetBootpath()

static BOOLEAN UefiSetBootpath ( VOID  )

static

Definition at line 1191 of file uefidisk.c.

{
    EFI_BLOCK_IO* BootBlockIo = NULL;
    EFI_BLOCK_IO* RootBlockIo = NULL;
    EFI_STATUS Status;
    ULONG ArcDriveIndex;
 
    TRACE("UefiSetBootpath: Setting up boot path\n");
 
    if (UefiBootRootIndex >= HandleCount || handles == NULL)
    {
        ERR("Invalid boot root index\n");
        return FALSE;
    }
 
    ArcDriveIndex = PublicBootArcDisk;
    if (ArcDriveIndex >= PcBiosDiskCount || InternalUefiDisk == NULL)
    {
        ERR("Invalid boot arc disk index\n");
        return FALSE;
    }
 
    Status = GlobalSystemTable->BootServices->HandleProtocol(
        handles[UefiBootRootIndex],
        &BlockIoGuid,
        (VOID**)&BootBlockIo);
 
    if (EFI_ERROR(Status) || BootBlockIo == NULL)
    {
        ERR("Failed to get Block I/O protocol for boot handle\n");
        return FALSE;
    }
 
    Status = GlobalSystemTable->BootServices->HandleProtocol(
        InternalUefiDisk[ArcDriveIndex].Handle,
        &BlockIoGuid,
        (VOID**)&RootBlockIo);
 
    if (EFI_ERROR(Status) || RootBlockIo == NULL)
    {
        ERR("Failed to get Block I/O protocol for boot root device\n");
        return FALSE;
    }
 
    FrldrBootDrive = (FIRST_BIOS_DISK + ArcDriveIndex);
 
    /* Check if booting from CD-ROM by checking the boot handle properties */
    /* CD-ROMs have BlockSize=2048 and RemovableMedia=TRUE */
    if (BootBlockIo->Media->RemovableMedia == TRUE && BootBlockIo->Media->BlockSize == 2048)
    {
        /* Boot Partition 0xFF is the magic value that indicates booting from CD-ROM */
        FrldrBootPartition = 0xFF;
        RtlStringCbPrintfA(FrLdrBootPath, sizeof(FrLdrBootPath),
                           "multi(0)disk(0)cdrom(%u)", ArcDriveIndex);
        TRACE("Boot path set to CD-ROM: %s\n", FrLdrBootPath);
    }
    else
    {
        ULONG BootPartition;
        PARTITION_TABLE_ENTRY PartitionEntry;
 
        /* This is a hard disk */
        /* If boot handle is a logical partition, we need to determine which partition number */
        if (BootBlockIo->Media->LogicalPartition)
        {
            /* For logical partitions, we need to find the partition number */
            /* This is tricky - we'll use partition 1 as default for now */
            /* TODO: Properly determine partition number from boot handle */
            BootPartition = FIRST_PARTITION;
            TRACE("Boot handle is logical partition, using partition %lu\n", BootPartition);
        }
        else
        {
            /* Boot handle is the root device itself */
            if (!UefiGetBootPartitionEntry(FrldrBootDrive, &PartitionEntry, &BootPartition))
            {
                ERR("Failed to get boot partition entry\n");
                return FALSE;
            }
        }
 
        RtlStringCbPrintfA(FrLdrBootPath, sizeof(FrLdrBootPath),
                           "multi(0)disk(0)rdisk(%u)partition(%lu)",
                           ArcDriveIndex, BootPartition);
        TRACE("Boot path set to hard disk: %s\n", FrLdrBootPath);
    }
 
    return TRUE;
}

Referenced by UefiInitializeBootDevices().

UefiSetupBlockDevices()

static VOID UefiSetupBlockDevices ( VOID  )

static

Definition at line 935 of file uefidisk.c.

{
    ULONG BlockDeviceIndex;
    ULONG SystemHandleCount;
    EFI_STATUS Status;
    ULONG i;
    UINTN HandleSize = 0;
    EFI_BLOCK_IO* BlockIo;
 
    PcBiosDiskCount = 0;
    UefiBootRootIndex = 0;
 
    /* Step 1: Get the size needed for handles buffer - no matter how it fails we're good */
    Status = GlobalSystemTable->BootServices->LocateHandle(
        ByProtocol,
        &BlockIoGuid,
        NULL,
        &HandleSize,
        NULL);
 
    if (HandleSize == 0)
    {
        ERR("Failed to get handle buffer size: Status = 0x%lx\n", (ULONG)Status);
        return;
    }
 
    SystemHandleCount = HandleSize / sizeof(EFI_HANDLE);
    if (SystemHandleCount == 0)
    {
        ERR("No block devices found\n");
        return;
    }
 
    /* Step 2: Allocate buffer for handles */
    handles = MmAllocateMemoryWithType(HandleSize, LoaderFirmwareTemporary);
    if (handles == NULL)
    {
        ERR("Failed to allocate memory for handles\n");
        return;
    }
 
    /* Step 3: Get actual handles */
    Status = GlobalSystemTable->BootServices->LocateHandle(
        ByProtocol,
        &BlockIoGuid,
        NULL,
        &HandleSize,
        handles);
 
    if (EFI_ERROR(Status))
    {
        ERR("Failed to locate block device handles: Status = 0x%lx\n", (ULONG)Status);
        return;
    }
 
    HandleCount = SystemHandleCount;
 
    /* Step 4: Allocate internal disk structure */
    InternalUefiDisk = MmAllocateMemoryWithType(
        sizeof(INTERNAL_UEFI_DISK) * SystemHandleCount,
        LoaderFirmwareTemporary);
 
    if (InternalUefiDisk == NULL)
    {
        ERR("Failed to allocate memory for internal disk structure\n");
        return;
    }
 
    RtlZeroMemory(InternalUefiDisk, sizeof(INTERNAL_UEFI_DISK) * SystemHandleCount);
 
    /* Step 5: Find boot handle and determine if it's a root device or partition */
    UefiBootRootIndex = 0;
    for (i = 0; i < SystemHandleCount; i++)
    {
        if (handles[i] == PublicBootHandle)
        {
            UefiBootRootIndex = i;
            TRACE("Found boot handle at index %lu\n", i);
 
            /* Check if boot handle is a root device or partition */
            Status = GlobalSystemTable->BootServices->HandleProtocol(
                handles[i],
                &BlockIoGuid,
                (VOID**)&BlockIo);
 
            if (!EFI_ERROR(Status) && BlockIo != NULL)
            {
                TRACE("Boot handle: LogicalPartition=%s, RemovableMedia=%s, BlockSize=%lu\n",
                    BlockIo->Media->LogicalPartition ? "TRUE" : "FALSE",
                    BlockIo->Media->RemovableMedia ? "TRUE" : "FALSE",
                    BlockIo->Media->BlockSize);
            }
            break;
        }
    }
 
    /* Step 6: Enumerate root block devices (skip logical partitions) */
    BlockDeviceIndex = 0;
    for (i = 0; i < SystemHandleCount; i++)
    {
        Status = GlobalSystemTable->BootServices->HandleProtocol(
            handles[i],
            &BlockIoGuid,
            (VOID**)&BlockIo);
 
        if (EFI_ERROR(Status))
        {
            TRACE("HandleProtocol failed for handle %lu: Status = 0x%lx\n", i, (ULONG)Status);
            continue;
        }
 
        if (BlockIo == NULL)
        {
            TRACE("BlockIo is NULL for handle %lu\n", i);
            continue;
        }
 
        if (!BlockIo->Media->MediaPresent)
        {
            TRACE("Media not present for handle %lu\n", i);
            continue;
        }
 
        if (BlockIo->Media->BlockSize == 0)
        {
            TRACE("Invalid block size (0) for handle %lu\n", i);
            continue;
        }
 
        /* Filter out devices with unusually large block sizes (flash devices) */
        if (BlockIo->Media->BlockSize > MAX_SUPPORTED_BLOCK_SIZE)
        {
            TRACE("Block size too large (%lu) for handle %lu, skipping\n",
                BlockIo->Media->BlockSize, i);
            continue;
        }
 
        /* Logical partitions are handled separately by partition scanning */
        if (BlockIo->Media->LogicalPartition)
        {
            /* If boot handle is a logical partition, we need to find its parent root device */
            /* For now, we'll handle this after enumeration by matching handles */
            TRACE("Skipping logical partition handle %lu\n", i);
            continue;
        }
 
        /* This is a root block device */
        TRACE("Found root block device at index %lu: BlockSize=%lu, LastBlock=%llu\n",
            i, BlockIo->Media->BlockSize, BlockIo->Media->LastBlock);
 
        InternalUefiDisk[BlockDeviceIndex].ArcDriveNumber = BlockDeviceIndex;
        InternalUefiDisk[BlockDeviceIndex].UefiHandleIndex = i;
        InternalUefiDisk[BlockDeviceIndex].Handle = handles[i];
        InternalUefiDisk[BlockDeviceIndex].IsThisTheBootDrive = FALSE;
 
        /* Check if this root device contains the boot partition */
        /* If boot handle is a logical partition, we need to find which root device it belongs to */
        /* For now, if boot handle index matches, mark it as boot device */
        if (i == UefiBootRootIndex)
        {
            InternalUefiDisk[BlockDeviceIndex].IsThisTheBootDrive = TRUE;
            PublicBootArcDisk = BlockDeviceIndex;
            TRACE("Boot device is at ARC drive index %lu (root device)\n", BlockDeviceIndex);
        }
 
        /* Increment PcBiosDiskCount BEFORE calling GetHarddiskInformation
         * so that UefiDiskReadLogicalSectors can validate the drive number */
        PcBiosDiskCount = BlockDeviceIndex + 1;
 
        TRACE("Calling GetHarddiskInformation for drive %d (BlockDeviceIndex=%lu)\n",
            BlockDeviceIndex + FIRST_BIOS_DISK, BlockDeviceIndex);
        if (!UefiEnsureDiskReadBufferAligned(BlockIo->Media->IoAlign))
        {
            ERR("Failed to align disk read buffer for drive %d\n", BlockDeviceIndex + FIRST_BIOS_DISK);
            return;
        }
 
        GetHarddiskInformation(BlockDeviceIndex + FIRST_BIOS_DISK);
        BlockDeviceIndex++;
    }
 
    /* Step 7: If boot handle was a logical partition, find its parent root device */
    if (UefiBootRootIndex < HandleCount)
    {
        Status = GlobalSystemTable->BootServices->HandleProtocol(
            handles[UefiBootRootIndex],
            &BlockIoGuid,
            (VOID**)&BlockIo);
 
        if (!EFI_ERROR(Status) && BlockIo != NULL && BlockIo->Media->LogicalPartition)
        {
            TRACE("Boot handle is a logical partition, searching for parent root device\n");
            TRACE("Boot partition: BlockSize=%lu, RemovableMedia=%s\n",
                BlockIo->Media->BlockSize,
                BlockIo->Media->RemovableMedia ? "TRUE" : "FALSE");
 
            /* Find the root device that matches the boot partition's characteristics */
            /* For CD-ROMs: match BlockSize=2048 and RemovableMedia=TRUE */
            /* For hard disks: match BlockSize and find the root device before this partition */
            BOOLEAN FoundBootDevice = FALSE;
            for (i = 0; i < BlockDeviceIndex; i++)
            {
                EFI_BLOCK_IO* RootBlockIo;
                Status = GlobalSystemTable->BootServices->HandleProtocol(
                    InternalUefiDisk[i].Handle,
                    &BlockIoGuid,
                    (VOID**)&RootBlockIo);
 
                if (EFI_ERROR(Status) || RootBlockIo == NULL)
                    continue;
 
                /* For CD-ROM: match BlockSize=2048 and RemovableMedia */
                if (BlockIo->Media->BlockSize == 2048 && BlockIo->Media->RemovableMedia)
                {
                    if (RootBlockIo->Media->BlockSize == 2048 && 
                        RootBlockIo->Media->RemovableMedia &&
                        !RootBlockIo->Media->LogicalPartition)
                    {
                        PublicBootArcDisk = i;
                        InternalUefiDisk[i].IsThisTheBootDrive = TRUE;
                        FoundBootDevice = TRUE;
                        TRACE("Found CD-ROM boot device at ARC drive index %lu\n", i);
                        break;
                    }
                }
                /* For hard disk partitions: the root device should be before the partition handle */
                else if (InternalUefiDisk[i].UefiHandleIndex < UefiBootRootIndex)
                {
                    /* Check if this root device is likely the parent */
                    if (RootBlockIo->Media->BlockSize == BlockIo->Media->BlockSize &&
                        !RootBlockIo->Media->LogicalPartition)
                    {
                        /* This might be the parent, but we need to be more certain */
                        /* For now, use the last root device before the boot handle */
                        PublicBootArcDisk = i;
                        InternalUefiDisk[i].IsThisTheBootDrive = TRUE;
                        FoundBootDevice = TRUE;
                        TRACE("Found potential hard disk boot device at ARC drive index %lu\n", i);
                    }
                }
            }
 
            if (!FoundBootDevice && PcBiosDiskCount > 0)
            {
                PublicBootArcDisk = 0;
                InternalUefiDisk[0].IsThisTheBootDrive = TRUE;
                TRACE("Could not determine boot device, assuming first drive\n");
            }
        }
    }
 
    TRACE("Found %lu root block devices\n", PcBiosDiskCount);
}

Referenced by UefiInitializeBootDevices().

Variable Documentation

BlockIoGuid

EFI_GUID BlockIoGuid = BLOCK_IO_PROTOCOL

static

Definition at line 116 of file uefidisk.c.

Referenced by UefiDiskGetCacheableBlockCount(), UefiDiskGetDriveGeometry(), UefiDiskOpen(), UefiDiskRead(), UefiDiskReadLogicalSectors(), UefiGetBootPartitionEntry(), UefiGetGptPartitionEntry(), UefiInitializeBootDevices(), UefiReadGptHeader(), UefiSetBootpath(), and UefiSetupBlockDevices().

Buffer

PVOID Buffer

Definition at line 107 of file uefidisk.c.

Referenced by GetHarddiskInformation(), and UefiInitializeBootDevices().

DiskReadBuffer

PVOID DiskReadBuffer

Definition at line 98 of file uefidisk.c.

Referenced by GetHarddiskInformation(), UefiDiskRead(), UefiDiskReadLogicalSectors(), UefiEnsureDiskReadBufferAligned(), UefiGetBootPartitionEntry(), UefiGetGptPartitionEntry(), UefiInitializeBootDevices(), and UefiReadGptHeader().

DiskReadBufferAlignment

ULONG DiskReadBufferAlignment

static

Definition at line 100 of file uefidisk.c.

Referenced by UefiEnsureDiskReadBufferAligned(), and UefiInitializeBootDevices().

DiskReadBufferFromPool

BOOLEAN DiskReadBufferFromPool

static

Definition at line 101 of file uefidisk.c.

Referenced by UefiEnsureDiskReadBufferAligned(), and UefiInitializeBootDevices().

DiskReadBufferRaw

PVOID DiskReadBufferRaw

static

Definition at line 99 of file uefidisk.c.

Referenced by UefiEnsureDiskReadBufferAligned(), and UefiInitializeBootDevices().

DiskReadBufferSize

SIZE_T DiskReadBufferSize

Definition at line 106 of file uefidisk.c.

Referenced by UefiDiskOpen(), UefiDiskRead(), UefiDiskReadLogicalSectors(), UefiEnsureDiskReadBufferAligned(), and UefiInitializeBootDevices().

FrldrBootDrive

UCHAR FrldrBootDrive

Definition at line 104 of file uefidisk.c.

Referenced by ChainLoadBiosBootSectorCode(), DiskGetBootPath(), DiskGetConfigType(), EnumerateHarddisks(), FrldrGetBootDrive(), Pc98InitializeBootDevices(), PcInitializeBootDevices(), UefiInitializeBootDevices(), and UefiSetBootpath().

FrldrBootPartition

ULONG FrldrBootPartition

Definition at line 105 of file uefidisk.c.

Referenced by ChainLoadBiosBootSectorCode(), DiskGetBootPath(), DiskGetConfigType(), FrldrGetBootPartition(), Pc98InitializeBootDevices(), and UefiSetBootpath().

GlobalImageHandle

EFI_HANDLE GlobalImageHandle

extern

Definition at line 15 of file uefildr.c.

GlobalSystemTable

EFI_SYSTEM_TABLE* GlobalSystemTable

extern

Definition at line 16 of file uefildr.c.

Referenced by UefiDiskGetCacheableBlockCount(), UefiDiskGetDriveGeometry(), UefiDiskOpen(), UefiDiskRead(), UefiDiskReadLogicalSectors(), UefiEnsureDiskReadBufferAligned(), UefiGetBootPartitionEntry(), UefiGetGptPartitionEntry(), UefiInitializeBootDevices(), UefiReadGptHeader(), UefiSetBootpath(), and UefiSetupBlockDevices().

HandleCount

ULONG HandleCount = 0

static

Definition at line 118 of file uefidisk.c.

Referenced by $include(), ConsoleEfiGraphicalOpenProtocol(), CopyBackStatus(), EfiLocateHandleBuffer(), ExpDesktopOpen(), GetPerformanceInfo(), IopCloseFile(), LockHandles(), NtQueryInformationProcess(), NtQueryOpenSubKeys(), ObGetProcessHandleCount(), OpenProc(), PerfDataGetHandleCount(), PerfDataGetSystemHandleCount(), test_query_process(), UefiGetBootPartitionEntry(), UefiSetBootpath(), UefiSetupBlockDevices(), UnlockHandles(), UserCreateHandleTable(), VfatLockOrUnlockVolume(), WahInsertHandleContext(), WSPSelect(), and ZeroEvents().

handles

EFI_HANDLE* handles = NULL

static

Definition at line 117 of file uefidisk.c.

Referenced by _enumerateConnectedW(), apartment_hostobject_in_hostapt(), create_io_inherit_block(), d3dx9_fragment_linker_LinkPixelShader(), d3dx9_fragment_linker_LinkShader(), d3dx9_fragment_linker_LinkVertexShader(), decode_file_layout_handles(), EMF_PlayEnhMetaFileCallback(), get_constant_by_name(), local_server_thread(), MCI_SendCommandAsync(), PlayEnhMetaFileRecord(), PlayMetaFileRecord(), start_debugger(), task_proc(), test_CoWaitForMultipleHandles(), test_CoWaitForMultipleHandles_thread(), test_ffcnMultipleThreads(), test_file_inherit(), test_ProcThreadAttributeList(), test_register_local_server(), UefiGetBootPartitionEntry(), UefiSetBootpath(), UefiSetupBlockDevices(), wait_async_request(), wait_for_completion(), Wait_thread_proc(), WaitForMultipleObjects(), WaitForMultipleObjectsEx(), waitqueue_thread_proc(), and WNetCloseEnum().

Hex

const CHAR Hex[] = "0123456789abcdef"

static

Definition at line 109 of file uefidisk.c.

Referenced by GetHarddiskInformation().

InternalUefiDisk

INTERNAL_UEFI_DISK* InternalUefiDisk = NULL

static

Definition at line 115 of file uefidisk.c.

Referenced by GetHarddiskInformation(), UefiDiskGetCacheableBlockCount(), UefiDiskGetDriveGeometry(), UefiDiskOpen(), UefiDiskRead(), UefiDiskReadLogicalSectors(), UefiGetBootPartitionEntry(), UefiGetGptPartitionEntry(), UefiInitializeBootDevices(), UefiReadGptHeader(), UefiSetBootpath(), and UefiSetupBlockDevices().

lReportError

LONG lReportError = 0

static

Definition at line 191 of file uefidisk.c.

Referenced by DiskReportError().

PcBiosDiskCount

UCHAR PcBiosDiskCount

Definition at line 102 of file uefidisk.c.

Referenced by DetectBiosDisks(), GetHarddiskInformation(), UefiDiskOpen(), UefiDiskRead(), UefiDiskReadLogicalSectors(), UefiGetBootPartitionEntry(), UefiGetGptPartitionEntry(), UefiInitializeBootDevices(), UefiReadGptHeader(), UefiSetBootpath(), and UefiSetupBlockDevices().

PcDiskIdentifier

CHAR PcDiskIdentifier[32][20]

static

Definition at line 110 of file uefidisk.c.

Referenced by GetHarddiskIdentifier(), and GetHarddiskInformation().

PublicBootArcDisk

ULONG PublicBootArcDisk = 0

static

Definition at line 114 of file uefidisk.c.

Referenced by UefiInitializeBootDevices(), UefiSetBootpath(), and UefiSetupBlockDevices().

PublicBootHandle

EFI_HANDLE PublicBootHandle

extern

Definition at line 38 of file uefimem.c.

Referenced by UefiMemGetMemoryMap(), and UefiSetupBlockDevices().

UefiBootRootIndex

ULONG UefiBootRootIndex = 0

static

Definition at line 113 of file uefidisk.c.

Referenced by UefiGetBootPartitionEntry(), UefiSetBootpath(), and UefiSetupBlockDevices().

UefiDiskVtbl

const DEVVTBL UefiDiskVtbl

static

Initial value:

=
{
    UefiDiskClose,
    UefiDiskGetFileInformation,
    UefiDiskOpen,
    UefiDiskRead,
    UefiDiskSeek,
}

Definition at line 824 of file uefidisk.c.

Referenced by GetHarddiskInformation(), and UefiInitializeBootDevices().