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
#define	FIRST_PARTITION   1

Typedefs
typedef struct tagDISKCONTEXT	DISKCONTEXT

Functions
	DBG_DEFAULT_CHANNEL (HWDETECT)
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 (UCHAR DriveNumber)
static UCHAR	EnumerateHarddisks (OUT PBOOLEAN BootDriveReported)
static BOOLEAN	DiskGetBootPath (BOOLEAN IsPxe)
BOOLEAN	PcInitializeBootDevices (VOID)

Variables
static const CHAR	Hex [] = "0123456789abcdef"
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.

FIRST_PARTITION

#define FIRST_PARTITION   1

Definition at line 32 of file hwdisk.c.

Typedef Documentation

DISKCONTEXT

typedef struct tagDISKCONTEXT DISKCONTEXT

Function Documentation

DBG_DEFAULT_CHANNEL()

DBG_DEFAULT_CHANNEL

(

HWDETECT

)

DiskClose()

static ARC_STATUS DiskClose ( ULONG  FileId )

static

Definition at line 57 of file hwdisk.c.

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

DiskGetBootPath()

static BOOLEAN DiskGetBootPath ( BOOLEAN  IsPxe )

static

Definition at line 405 of file hwdisk.c.

{
    if (*FrLdrBootPath)
        return TRUE;
 
    // FIXME! FIXME! Do this in some drive recognition procedure!!!!
    if (IsPxe)
    {
        RtlStringCbCopyA(FrLdrBootPath, sizeof(FrLdrBootPath), "net(0)");
    }
    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)");
    }
    else if (FrldrBootDrive < FIRST_BIOS_DISK)
    {
        /* This is a floppy */
        RtlStringCbPrintfA(FrLdrBootPath, sizeof(FrLdrBootPath),
                           "multi(0)disk(0)fdisk(%u)", FrldrBootDrive);
    }
    else if (FrldrBootPartition == 0xFF)
    {
        /* Boot Partition 0xFF is the magic value that indicates booting from CD-ROM (see isoboot.S) */
        RtlStringCbPrintfA(FrLdrBootPath, sizeof(FrLdrBootPath),
                           "multi(0)disk(0)cdrom(%u)", FrldrBootDrive - FIRST_BIOS_DISK);
    }
    else
    {
        ULONG BootPartition;
        PARTITION_TABLE_ENTRY PartitionEntry;
 
        /* This is a hard disk */
        if (!DiskGetBootPartitionEntry(FrldrBootDrive, &PartitionEntry, &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);
    }
 
    return TRUE;
}

Referenced by PcInitializeBootDevices().

DiskGetFileInformation()

static ARC_STATUS DiskGetFileInformation ( ULONG  FileId, FILEINFORMATION *  Information  )

static

Definition at line 65 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 87 of file hwdisk.c.

{
    DISKCONTEXT* Context;
    CONFIGURATION_TYPE DriveType;
    UCHAR DriveNumber;
    ULONG DrivePartition, SectorSize;
    ULONGLONG SectorOffset = 0;
    ULONGLONG SectorCount = 0;
    PARTITION_TABLE_ENTRY PartitionTableEntry;
 
    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 (DriveType == CdromController)
    {
        /* This is a CD-ROM device */
        SectorSize = 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 */
        SectorSize = 512;
    }
 
    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->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 160 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) ? EIO : ESUCCESS;
}

DiskSeek()

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

static

Definition at line 212 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 347 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;
        }
 
        /* 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 254 of file hwdisk.c.

{
    return PcDiskIdentifier[DriveNumber - FIRST_BIOS_DISK];
}

GetHarddiskInformation()

static VOID GetHarddiskInformation ( UCHAR  DriveNumber )

static

Definition at line 260 of file hwdisk.c.

{
    PMASTER_BOOT_RECORD Mbr;
    PULONG Buffer;
    ULONG i;
    ULONG Checksum;
    ULONG Signature;
    BOOLEAN ValidPartitionTable;
    CHAR ArcName[MAX_PATH];
    PARTITION_TABLE_ENTRY PartitionTableEntry;
    PCHAR Identifier = PcDiskIdentifier[DriveNumber - FIRST_BIOS_DISK];
 
    /* 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", DriveNumber - FIRST_BIOS_DISK + 1);
        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)", DriveNumber - FIRST_BIOS_DISK);
    AddReactOSArcDiskInfo(ArcName, Signature, Checksum, ValidPartitionTable);
 
    sprintf(ArcName, "multi(0)disk(0)rdisk(%u)partition(0)", DriveNumber - FIRST_BIOS_DISK);
    FsRegisterDevice(ArcName, &DiskVtbl);
 
    /* 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)", DriveNumber - FIRST_BIOS_DISK, i);
            FsRegisterDevice(ArcName, &DiskVtbl);
        }
        i++;
    }
    DiskReportError(TRUE);
 
    /* 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 EnumerateHarddisks().

PcInitializeBootDevices()

BOOLEAN PcInitializeBootDevices

(

VOID

)

Definition at line 458 of file hwdisk.c.

{
    UCHAR DiskCount;
    BOOLEAN BootDriveReported = FALSE;
    CONFIGURATION_TYPE DriveType;
 
    DiskCount = EnumerateHarddisks(&BootDriveReported);
 
    /* Initialize FrLdrBootPath, the boot path we're booting from (the "SystemPartition") */
    DiskGetBootPath(PxeInit());
 
    /* Add it, if it's a floppy or CD-ROM */
    DriveType = DiskGetConfigType(FrldrBootDrive);
    if ((FrldrBootDrive >= FIRST_BIOS_DISK && !BootDriveReported) ||
        (DriveType == FloppyDiskPeripheral || DriveType == CdromController))
    {
        /* TODO: Check if it's really a CD-ROM drive */
 
        PMASTER_BOOT_RECORD Mbr;
        PULONG Buffer;
        ULONG Checksum = 0;
        ULONG Signature;
        ULONG i;
 
        /* Read the MBR */
        if (!MachDiskReadLogicalSectors(FrldrBootDrive, 16ULL, 1, DiskReadBuffer))
        {
            ERR("Reading MBR failed\n");
            return FALSE;
        }
 
        Buffer = (ULONG*)DiskReadBuffer;
        Mbr = (PMASTER_BOOT_RECORD)DiskReadBuffer;
 
        Signature = Mbr->Signature;
        TRACE("Signature: %x\n", Signature);
 
        /* Calculate the MBR checksum */
        for (i = 0; i < 2048 / sizeof(ULONG); i++)
        {
            Checksum += Buffer[i];
        }
        Checksum = ~Checksum + 1;
        TRACE("Checksum: %x\n", Checksum);
 
        /* Fill out the ARC disk block */
        AddReactOSArcDiskInfo(FrLdrBootPath, Signature, Checksum, TRUE);
 
        FsRegisterDevice(FrLdrBootPath, &DiskVtbl);
        DiskCount++; // This is not accounted for in the number of pre-enumerated BIOS drives!
        TRACE("Additional boot drive detected: 0x%02X\n", (int)FrldrBootDrive);
    }
 
    return (DiskCount != 0);
}

Referenced by MachInit(), and Pc98InitializeBootDevices().

Variable Documentation

DiskReadBuffer

PVOID DiskReadBuffer

Definition at line 50 of file hwdisk.c.

Referenced by DiskRead(), EnumerateHarddisks(), GetHarddiskInformation(), and PcInitializeBootDevices().

DiskReadBufferSize

SIZE_T DiskReadBufferSize

Definition at line 51 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 243 of file hwdisk.c.

Referenced by GetHarddiskInformation(), and PcInitializeBootDevices().

Hex

const CHAR Hex[] = "0123456789abcdef"

static

Definition at line 44 of file hwdisk.c.

Referenced by GetHarddiskInformation().

PcBiosDiskCount

UCHAR PcBiosDiskCount = 0

Definition at line 47 of file hwdisk.c.

Referenced by EnumerateHarddisks().

PcDiskIdentifier

CHAR PcDiskIdentifier[32][20]

static

Definition at line 48 of file hwdisk.c.

Referenced by GetHarddiskIdentifier(), and GetHarddiskInformation().