hwdisk.c File Reference

#include <freeldr.h>
#include <debug.h>

Include dependency graph for hwdisk.c:

Go to the source code of this file.

Classes
struct	tagDISKCONTEXT

Macros
#define	FIRST_BIOS_DISK   0x80

Typedefs
typedef struct tagDISKCONTEXT	DISKCONTEXT

Functions
	DBG_DEFAULT_CHANNEL (DISK)
static ARC_STATUS	DiskClose (ULONG FileId)
static ARC_STATUS	DiskGetFileInformation (ULONG FileId, FILEINFORMATION *Information)
static ARC_STATUS	DiskOpen (CHAR *Path, OPENMODE OpenMode, ULONG *FileId)
static ARC_STATUS	DiskRead (ULONG FileId, VOID *Buffer, ULONG N, ULONG *Count)
static ARC_STATUS	DiskSeek (ULONG FileId, LARGE_INTEGER *Position, SEEKMODE SeekMode)
PCHAR	GetHarddiskIdentifier (UCHAR DriveNumber)
static VOID	GetHarddiskInformation (_In_ UCHAR DriveNumber)
static UCHAR	EnumerateHarddisks (OUT PBOOLEAN BootDriveReported)
static BOOLEAN	DiskGetBootPath (_In_ BOOLEAN IsPxe, _Out_ PCONFIGURATION_TYPE DeviceType)
BOOLEAN	PcInitializeBootDevices (VOID)

Variables
UCHAR	PcBiosDiskCount = 0
static CHAR	PcDiskIdentifier [32][20]
PVOID	DiskReadBuffer
SIZE_T	DiskReadBufferSize
static const DEVVTBL	DiskVtbl

Macro Definition Documentation

FIRST_BIOS_DISK

#define FIRST_BIOS_DISK   0x80

Definition at line 31 of file hwdisk.c.

Typedef Documentation

DISKCONTEXT

typedef struct tagDISKCONTEXT DISKCONTEXT

Function Documentation

DBG_DEFAULT_CHANNEL()

DBG_DEFAULT_CHANNEL

(

DISK

)

DiskClose()

static ARC_STATUS DiskClose ( ULONG  FileId )

static

Definition at line 54 of file hwdisk.c.

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

DiskGetBootPath()

static BOOLEAN DiskGetBootPath ( _In_ BOOLEAN  IsPxe, _Out_ PCONFIGURATION_TYPE  DeviceType  )

static

Definition at line 377 of file hwdisk.c.

{
    // *DeviceType = DiskGetConfigType(FrldrBootDrive);
    if (*FrLdrBootPath)
        return TRUE;
 
    *DeviceType = 0;
 
    // FIXME: Do this in some drive recognition procedure!
    if (IsPxe)
    {
        RtlStringCbCopyA(FrLdrBootPath, sizeof(FrLdrBootPath), "net(0)");
        *DeviceType = NetworkPeripheral;
    }
    else
    /* 0x49 is our magic ramdisk drive, so try to detect it first */
    if (FrldrBootDrive == 0x49)
    {
        /* This is the ramdisk. See ArmInitializeBootDevices() too... */
        // RtlStringCbPrintfA(FrLdrBootPath, sizeof(FrLdrBootPath), "ramdisk(%u)", 0);
        RtlStringCbCopyA(FrLdrBootPath, sizeof(FrLdrBootPath), "ramdisk(0)");
        *DeviceType = DiskPeripheral;
    }
    else if (FrldrBootDrive < FIRST_BIOS_DISK) // (DiskGetConfigType(FrldrBootDrive) == FloppyDiskPeripheral)
    {
        /* This is a floppy */
        RtlStringCbPrintfA(FrLdrBootPath, sizeof(FrLdrBootPath),
                           "multi(0)disk(0)fdisk(%u)", FrldrBootDrive);
        *DeviceType = FloppyDiskPeripheral;
    }
    else if (FrldrBootPartition == 0xFF)
    {
        /* Boot Partition 0xFF is the magic value that indicates booting from CD-ROM (see isoboot.S) */
        // TODO: Check if it's really a CD-ROM drive
        RtlStringCbPrintfA(FrLdrBootPath, sizeof(FrLdrBootPath),
                           "multi(0)disk(0)cdrom(%u)", FrldrBootDrive - FIRST_BIOS_DISK);
        *DeviceType = CdromController;
    }
    else
    {
        /* This is a hard disk, find the boot partition */
        ULONG BootPartition;
        if (!DiskGetBootPartitionEntry(FrldrBootDrive, NULL, &BootPartition))
        {
            ERR("Failed to get boot partition entry\n");
            return FALSE;
        }
        FrldrBootPartition = BootPartition;
 
        RtlStringCbPrintfA(FrLdrBootPath, sizeof(FrLdrBootPath),
                           "multi(0)disk(0)rdisk(%u)partition(%lu)",
                           FrldrBootDrive - FIRST_BIOS_DISK, FrldrBootPartition);
        *DeviceType = DiskPeripheral;
    }
 
    return TRUE;
}

Referenced by PcInitializeBootDevices().

DiskGetFileInformation()

static ARC_STATUS DiskGetFileInformation ( ULONG  FileId, FILEINFORMATION *  Information  )

static

Definition at line 62 of file hwdisk.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 = (Context->IsFloppy ? FloppyDiskPeripheral : DiskPeripheral);
 
    return ESUCCESS;
}

DiskOpen()

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

static

Definition at line 84 of file hwdisk.c.

{
    DISKCONTEXT* Context;
    CONFIGURATION_TYPE DriveType;
    UCHAR DriveNumber;
    ULONG DrivePartition, SectorSize;
    GEOMETRY Geometry;
    ULONGLONG SectorOffset;
    ULONGLONG SectorCount;
    static BOOLEAN PrintForce = FALSE;
 
    if (DiskReadBufferSize == 0)
    {
        ERR("DiskOpen(): DiskReadBufferSize is 0, something is wrong.\n");
        ASSERT(FALSE);
        return ENOMEM;
    }
 
    if (!DissectArcPath(Path, NULL, &DriveNumber, &DrivePartition))
        return EINVAL;
 
    DriveType = DiskGetConfigType(DriveNumber);
 
    if (!MachDiskGetDriveGeometry(DriveNumber, &Geometry))
        return EIO;
    if (Geometry.BytesPerSector == 0)
    {
        WARN("MachDiskGetDriveGeometry(0x%x) failed, fall back to hardcoded values\n", DriveNumber);
        if (DriveType == CdromController)
        {
            /* This is a CD-ROM device */
            Geometry.BytesPerSector = 2048;
        }
        else
        {
            /* This is either a floppy disk or a hard disk device, but it doesn't
             * matter which one because they both have 512 bytes per sector */
            Geometry.BytesPerSector = 512;
        }
    }
    SectorSize = Geometry.BytesPerSector;
 
    if (DrivePartition != 0xff && DrivePartition != 0)
    {
        PARTITION_INFORMATION PartitionEntry;
        if (!DiskGetPartitionEntry(DriveNumber, SectorSize, DrivePartition, &PartitionEntry))
            return EIO;
 
        SectorOffset = PartitionEntry.StartingOffset.QuadPart / SectorSize;
        SectorCount = PartitionEntry.PartitionLength.QuadPart / SectorSize;
    }
    else
    {
        SectorOffset = 0;
        SectorCount = Geometry.Sectors;
    }
 
    Context = FrLdrTempAlloc(sizeof(DISKCONTEXT), TAG_HW_DISK_CONTEXT);
    if (!Context)
        return ENOMEM;
 
    if (DriveType == CdromController && SectorSize != 2048)
    {
        /* Workaround for CORE-20640 */
        if (!PrintForce)
        {
            ERR("BIOS reports BytesPerSector = %d for CD-ROM, forcing 2048\n", SectorSize);
            PrintForce = TRUE;
        }
        SectorSize = 2048;
    }
    Context->DriveNumber = DriveNumber;
    Context->IsFloppy = (DriveType == FloppyDiskPeripheral);
    Context->SectorSize = SectorSize;
    Context->SectorOffset = SectorOffset;
    Context->SectorCount = SectorCount;
    Context->SectorNumber = 0;
    FsSetDeviceSpecific(*FileId, Context);
 
    return ESUCCESS;
}

DiskRead()

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

static

Definition at line 167 of file hwdisk.c.

{
    DISKCONTEXT* Context = FsGetDeviceSpecific(FileId);
    UCHAR* Ptr = (UCHAR*)Buffer;
    ULONG Length, TotalSectors, MaxSectors, ReadSectors;
    ULONGLONG SectorOffset;
    BOOLEAN ret;
 
    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);
 
    ret = TRUE;
 
    while (TotalSectors)
    {
        ReadSectors = TotalSectors;
        if (ReadSectors > MaxSectors)
            ReadSectors = MaxSectors;
 
        ret = MachDiskReadLogicalSectors(Context->DriveNumber,
                                         SectorOffset,
                                         ReadSectors,
                                         DiskReadBuffer);
        if (!ret)
            break;
 
        Length = ReadSectors * Context->SectorSize;
        if (Length > N)
            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);
}

DiskSeek()

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

static

Definition at line 219 of file hwdisk.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;
}

EnumerateHarddisks()

static UCHAR EnumerateHarddisks ( OUT PBOOLEAN  BootDriveReported )

static

Definition at line 319 of file hwdisk.c.

{
    UCHAR DiskCount, DriveNumber;
    ULONG i;
    BOOLEAN Changed;
 
    *BootDriveReported = FALSE;
 
    /* Count the number of visible harddisk drives */
    DiskReportError(FALSE);
    DiskCount = 0;
    DriveNumber = FIRST_BIOS_DISK;
 
    ASSERT(DiskReadBufferSize > 0);
 
    /*
     * There are some really broken BIOSes out there. There are even BIOSes
     * that happily report success when you ask them to read from non-existent
     * harddisks. So, we set the buffer to known contents first, then try to
     * read. If the BIOS reports success but the buffer contents haven't
     * changed then we fail anyway.
     */
    memset(DiskReadBuffer, 0xcd, DiskReadBufferSize);
    while (MachDiskReadLogicalSectors(DriveNumber, 0ULL, 1, DiskReadBuffer))
    {
        Changed = FALSE;
        for (i = 0; !Changed && i < DiskReadBufferSize; i++)
        {
            Changed = ((PUCHAR)DiskReadBuffer)[i] != 0xcd;
        }
        if (!Changed)
        {
            TRACE("BIOS reports success for disk %d (0x%02X) but data didn't change\n",
                  (int)DiskCount, DriveNumber);
            break;
        }
 
        /* Register and cache the BIOS hard disk information for later use */
        GetHarddiskInformation(DriveNumber);
 
        /* Check if we have seen the boot drive */
        if (FrldrBootDrive == DriveNumber)
            *BootDriveReported = TRUE;
 
        DiskCount++;
        DriveNumber++;
        memset(DiskReadBuffer, 0xcd, DiskReadBufferSize);
    }
    DiskReportError(TRUE);
 
    PcBiosDiskCount = DiskCount;
    TRACE("BIOS reports %d harddisk%s\n",
          (int)DiskCount, (DiskCount == 1) ? "" : "s");
 
    return DiskCount;
}

Referenced by PcInitializeBootDevices().

GetHarddiskIdentifier()

PCHAR GetHarddiskIdentifier

(

UCHAR

DriveNumber

)

Definition at line 261 of file hwdisk.c.

{
    return PcDiskIdentifier[DriveNumber - FIRST_BIOS_DISK];
}

Referenced by DetectBiosDisks().

GetHarddiskInformation()

static VOID GetHarddiskInformation ( _In_ UCHAR  DriveNumber )

static

Definition at line 267 of file hwdisk.c.

{
    static const CHAR Hex[] = "0123456789abcdef";
 
    PCHAR Identifier = PcDiskIdentifier[DriveNumber - FIRST_BIOS_DISK];
    ARC_STATUS Status;
    ULONG Checksum, Signature;
    BOOLEAN ValidPartitionTable;
    CHAR DiskName[64];
 
    RtlStringCbPrintfA(DiskName, sizeof(DiskName),
                       "multi(0)disk(0)rdisk(%u)",
                       DriveNumber - FIRST_BIOS_DISK);
 
    DiskReportError(FALSE);
    Status = DiskInitialize(DriveNumber, DiskName, DiskPeripheral, &DiskVtbl,
                            &Checksum, &Signature, &ValidPartitionTable);
    DiskReportError(TRUE);
 
    if (Status != ESUCCESS)
    {
        /* The disk failed to be initialized, use a default identifier */
        RtlStringCbPrintfA(Identifier, 20, "BIOSDISK%u", DriveNumber - FIRST_BIOS_DISK + 1);
        return;
    }
 
    /* 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] = ANSI_NULL;
    TRACE("Identifier: %s\n", Identifier);
}

Referenced by EnumerateHarddisks().

PcInitializeBootDevices()

BOOLEAN PcInitializeBootDevices

(

VOID

)

Definition at line 438 of file hwdisk.c.

{
    UCHAR DiskCount;
    BOOLEAN BootDriveReported = FALSE;
    CONFIGURATION_TYPE DriveType;
 
    DiskCount = EnumerateHarddisks(&BootDriveReported);
 
    /* Initialize FrLdrBootPath, the path FreeLoader starts from */
    DiskGetBootPath(PxeInit(), &DriveType);
 
    /* Add it, if it's a floppy or CD-ROM */
    if ((FrldrBootDrive >= FIRST_BIOS_DISK && !BootDriveReported) ||
        (DriveType == FloppyDiskPeripheral || DriveType == CdromController))
    {
        ARC_STATUS Status;
 
        DiskReportError(FALSE);
        Status = DiskInitialize(FrldrBootDrive, FrLdrBootPath, DriveType,
                                &DiskVtbl, NULL, NULL, NULL);
        DiskReportError(TRUE);
 
        if (Status == ESUCCESS)
        {
            DiskCount++; // This is not accounted for in the number of pre-enumerated BIOS drives!
            TRACE("Additional boot drive detected: 0x%02X\n", FrldrBootDrive);
        }
        else
        {
            ERR("Additional boot drive 0x%02X failed\n", FrldrBootDrive);
        }
    }
 
    return (DiskCount != 0);
}

Referenced by MachInit(), and Pc98InitializeBootDevices().

Variable Documentation

DiskReadBuffer

PVOID DiskReadBuffer

Definition at line 47 of file hwdisk.c.

Referenced by DiskRead(), and EnumerateHarddisks().

DiskReadBufferSize

SIZE_T DiskReadBufferSize

Definition at line 48 of file hwdisk.c.

Referenced by DiskOpen(), DiskRead(), EnumerateHarddisks(), and PcMemFinalizeMemoryMap().

DiskVtbl

const DEVVTBL DiskVtbl

static

Initial value:

=
{
    DiskClose,
    DiskGetFileInformation,
    DiskOpen,
    DiskRead,
    DiskSeek,
}

Definition at line 250 of file hwdisk.c.

Referenced by GetHarddiskInformation(), and PcInitializeBootDevices().

PcBiosDiskCount

UCHAR PcBiosDiskCount = 0

Definition at line 44 of file hwdisk.c.

Referenced by DetectBiosDisks(), and EnumerateHarddisks().

PcDiskIdentifier

CHAR PcDiskIdentifier[32][20]

static

Definition at line 45 of file hwdisk.c.

Referenced by GetHarddiskIdentifier(), and GetHarddiskInformation().