ramdisk.c File Reference

#include <freeldr.h>
#include "../ntldr/ntldropts.h"
#include <debug.h>

Include dependency graph for ramdisk.c:

Go to the source code of this file.

Functions
	DBG_DEFAULT_CHANNEL (DISK)
static ARC_STATUS	RamDiskClose (ULONG FileId)
static ARC_STATUS	RamDiskGetFileInformation (ULONG FileId, FILEINFORMATION *Information)
static ARC_STATUS	RamDiskOpen (CHAR *Path, OPENMODE OpenMode, ULONG *FileId)
static ARC_STATUS	RamDiskRead (ULONG FileId, VOID *Buffer, ULONG N, ULONG *Count)
static ARC_STATUS	RamDiskSeek (ULONG FileId, LARGE_INTEGER *Position, SEEKMODE SeekMode)
static ARC_STATUS	RamDiskLoadVirtualFile (IN PCSTR FileName, IN PCSTR DefaultPath OPTIONAL)
ARC_STATUS	RamDiskInitialize (IN BOOLEAN InitRamDisk, IN PCSTR LoadOptions OPTIONAL, IN PCSTR DefaultPath OPTIONAL)

Variables
PVOID	gInitRamDiskBase = NULL
ULONG	gInitRamDiskSize = 0
static BOOLEAN	RamDiskDeviceRegistered = FALSE
static PVOID	RamDiskBase
static ULONGLONG	RamDiskFileSize
static ULONGLONG	RamDiskImageLength
static ULONG	RamDiskImageOffset
static ULONGLONG	RamDiskOffset
static const DEVVTBL	RamDiskVtbl

Function Documentation

DBG_DEFAULT_CHANNEL()

DBG_DEFAULT_CHANNEL

(

DISK

)

RamDiskClose()

static ARC_STATUS RamDiskClose ( ULONG  FileId )

static

Definition at line 32 of file ramdisk.c.

{
    /* Nothing to do */
    return ESUCCESS;
}

RamDiskGetFileInformation()

static ARC_STATUS RamDiskGetFileInformation ( ULONG  FileId, FILEINFORMATION *  Information  )

static

Definition at line 38 of file ramdisk.c.

{
    RtlZeroMemory(Information, sizeof(*Information));
    Information->EndingAddress.QuadPart = RamDiskImageLength;
    Information->CurrentAddress.QuadPart = RamDiskOffset;
    Information->Type = DiskPeripheral;
 
    return ESUCCESS;
}

RamDiskInitialize()

ARC_STATUS RamDiskInitialize	(	IN BOOLEAN	InitRamDisk,
		IN PCSTR LoadOptions	OPTIONAL,
		IN PCSTR DefaultPath	OPTIONAL
	)

Definition at line 229 of file ramdisk.c.

{
    TRACE("RamDiskInitialize(%s, '%s', '%s')\n",
          InitRamDisk ? "INIT" : "REGULAR",
          LoadOptions ? LoadOptions : "n/a",
          DefaultPath ? DefaultPath : "n/a");
 
    /* Reset the RAMDISK device */
    if ((RamDiskBase != gInitRamDiskBase) &&
        (RamDiskFileSize != gInitRamDiskSize) &&
        (gInitRamDiskSize != 0))
    {
        /* This is not the initial Ramdisk, so we can free the allocated memory */
        MmFreeMemory(RamDiskBase);
    }
    RamDiskBase = NULL;
    RamDiskFileSize = 0;
    RamDiskImageLength = 0;
    RamDiskImageOffset = 0;
    RamDiskOffset = 0;
 
    if (InitRamDisk)
    {
        /* We initialize the initial Ramdisk: it should be present in memory */
        if (!gInitRamDiskBase || gInitRamDiskSize == 0)
            return ENODEV;
 
        // TODO: Handle SDI image.
 
        RamDiskBase = gInitRamDiskBase;
        RamDiskFileSize = gInitRamDiskSize;
        ASSERT(RamDiskFileSize < 0x100000000); // See FIXME about 4GB support in RamDiskLoadVirtualFile().
    }
    else
    {
        /* We initialize the Ramdisk from the load options */
        ARC_STATUS Status;
        CHAR FileName[MAX_PATH] = "";
 
        /* If we don't have any load options, initialize an empty Ramdisk */
        if (LoadOptions)
        {
            PCSTR Option;
            ULONG FileNameLength;
 
            /* Ramdisk image file name */
            Option = NtLdrGetOptionEx(LoadOptions, "RDPATH=", &FileNameLength);
            if (Option && (FileNameLength > 7))
            {
                /* Copy the file name */
                Option += 7; FileNameLength -= 7;
                RtlStringCbCopyNA(FileName, sizeof(FileName),
                                  Option, FileNameLength * sizeof(CHAR));
            }
 
            /* Ramdisk image length */
            Option = NtLdrGetOption(LoadOptions, "RDIMAGELENGTH=");
            if (Option)
            {
                RamDiskImageLength = _atoi64(Option + 14);
            }
 
            /* Ramdisk image offset */
            Option = NtLdrGetOption(LoadOptions, "RDIMAGEOFFSET=");
            if (Option)
            {
                RamDiskImageOffset = atol(Option + 14);
            }
        }
 
        if (*FileName)
            Status = RamDiskLoadVirtualFile(FileName, DefaultPath);
        else
            Status = RamDiskLoadVirtualFile(DefaultPath, NULL);
        if (Status != ESUCCESS)
            return Status;
    }
 
    /* Adjust the Ramdisk image length if needed */
    if (!RamDiskImageLength || (RamDiskImageLength > RamDiskFileSize - RamDiskImageOffset))
        RamDiskImageLength = RamDiskFileSize - RamDiskImageOffset;
 
    /* Register the RAMDISK device */
    if (!RamDiskDeviceRegistered)
    {
        FsRegisterDevice("ramdisk(0)", &RamDiskVtbl);
        RamDiskDeviceRegistered = TRUE;
    }
 
    return ESUCCESS;
}

Referenced by ArmHwDetect(), LoadAndBootWindows(), and LoadReactOSSetup().

RamDiskLoadVirtualFile()

static ARC_STATUS RamDiskLoadVirtualFile ( IN PCSTR  FileName, IN PCSTR DefaultPath  OPTIONAL  )

static

Definition at line 110 of file ramdisk.c.

{
    ARC_STATUS Status;
    ULONG RamFileId;
    ULONG ChunkSize, Count;
    ULONGLONG TotalRead;
    ULONG PercentPerChunk, Percent;
    FILEINFORMATION Information;
    LARGE_INTEGER Position;
 
    /* Display progress */
    UiDrawProgressBarCenter("Loading RamDisk...");
 
    /* Try opening the Ramdisk file */
    TRACE("RamDiskLoadVirtualFile: Opening '%s', '%s'\n",
          FileName, DefaultPath ? DefaultPath : "n/a");
    Status = FsOpenFile(FileName, DefaultPath, OpenReadOnly, &RamFileId);
    if (Status != ESUCCESS)
        return Status;
 
    /* Get the file or device size */
    Status = ArcGetFileInformation(RamFileId, &Information);
    if (Status != ESUCCESS)
    {
        ArcClose(RamFileId);
        return Status;
    }
    /* NOTE: For partitions, StartingAddress/EndingAddress are the start/end
     * positions of the partition as byte offsets from the start of the disk */
    Information.EndingAddress.QuadPart -= Information.StartingAddress.QuadPart;
    Information.StartingAddress.QuadPart = 0ULL;
 
    /* If we are actually opening a RAW device, retrieve instead its usable volume size */
    if (Information.FileNameLength == 0 && Information.FileName[0] == ANSI_NULL &&
        (Information.Type == DiskPeripheral || Information.Type == FloppyDiskPeripheral))
    {
        ULONGLONG VolumeSize;
        Status = FsGetVolumeSize(RamFileId, &VolumeSize);
        if (Status != ESUCCESS)
            ERR("Couldn't retrieve volume size on device '%s', falling back to RAW size\n", FileName);
        else
            Information.EndingAddress.QuadPart = VolumeSize;
    }
 
    TRACE("RAMDISK size: %I64u (High: %lu ; Low: %lu)\n",
          Information.EndingAddress.QuadPart,
          Information.EndingAddress.HighPart,
          Information.EndingAddress.LowPart);
 
    /* FIXME: For now, limit RAM disks to 4GB */
    if (Information.EndingAddress.HighPart != 0) // (RamDiskFileSize >= 0x100000000ULL)
    {
        ArcClose(RamFileId);
        UiMessageBox("RAM disk too big.");
        return ENOMEM;
    }
    RamDiskFileSize = Information.EndingAddress.QuadPart;
 
    /* Allocate memory for it */
    ChunkSize = 8 * 1024 * 1024;
    if (RamDiskFileSize < ChunkSize)
        PercentPerChunk = 0;
    else
        PercentPerChunk = 100 * ChunkSize / RamDiskFileSize;
    RamDiskBase = MmAllocateMemoryWithType(RamDiskFileSize, LoaderXIPRom);
    if (!RamDiskBase)
    {
        RamDiskFileSize = 0;
        ArcClose(RamFileId);
        UiMessageBox("Failed to allocate memory for RAM disk.");
        return ENOMEM;
    }
 
    /*
     * Read it in chunks, starting at the beginning
     */
    Position.QuadPart = 0;
    Status = ArcSeek(RamFileId, &Position, SeekAbsolute);
    if (Status != ESUCCESS)
        goto ReadFailure;
 
    for (TotalRead = 0, Percent = 0;
         TotalRead < RamDiskFileSize;
         TotalRead += ChunkSize, Percent += PercentPerChunk)
    {
        /* If we are at the last chunk, read only what's remaining */
        if ((RamDiskFileSize - TotalRead) < ChunkSize)
            ChunkSize = (ULONG)(RamDiskFileSize - TotalRead);
 
        /* Update progress */
        UiUpdateProgressBar(Percent, NULL);
 
        /* Copy the data */
        Status = ArcRead(RamFileId,
                         (PVOID)((ULONG_PTR)RamDiskBase + (ULONG_PTR)TotalRead),
                         ChunkSize,
                         &Count);
        if ((Status != ESUCCESS) || (Count != ChunkSize))
        {
            Status = ((Status != ESUCCESS) ? Status : EIO);
            goto ReadFailure;
        }
    }
    UiUpdateProgressBar(100, NULL);
    ArcClose(RamFileId);
    return ESUCCESS;
 
ReadFailure:
    MmFreeMemory(RamDiskBase);
    RamDiskBase = NULL;
    RamDiskFileSize = 0;
    ArcClose(RamFileId);
    UiMessageBox("Failed to read RAM disk.");
    return Status;
}

Referenced by RamDiskInitialize().

RamDiskOpen()

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

static

Definition at line 48 of file ramdisk.c.

{
    /* Always return success, as contents are already in memory */
    return ESUCCESS;
}

RamDiskRead()

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

static

Definition at line 54 of file ramdisk.c.

{
    PVOID StartAddress;
 
    /* Don't allow reads past our image */
    if (RamDiskOffset >= RamDiskImageLength || RamDiskOffset + N > RamDiskImageLength)
    {
        *Count = 0;
        return EIO;
    }
    // N = min(N, RamdiskImageLength - RamDiskOffset);
 
    /* Get actual pointer */
    StartAddress = (PVOID)((ULONG_PTR)RamDiskBase + RamDiskImageOffset + (ULONG_PTR)RamDiskOffset);
 
    /* Do the read */
    RtlCopyMemory(Buffer, StartAddress, N);
    RamDiskOffset += N;
    *Count = N;
 
    return ESUCCESS;
}

RamDiskSeek()

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

static

Definition at line 77 of file ramdisk.c.

{
    LARGE_INTEGER NewPosition = *Position;
 
    switch (SeekMode)
    {
        case SeekAbsolute:
            break;
        case SeekRelative:
            NewPosition.QuadPart += RamDiskOffset;
            break;
        default:
            ASSERT(FALSE);
            return EINVAL;
    }
 
    if (NewPosition.QuadPart >= RamDiskImageLength)
        return EINVAL;
 
    RamDiskOffset = NewPosition.QuadPart;
    return ESUCCESS;
}

Variable Documentation

gInitRamDiskBase

PVOID gInitRamDiskBase = NULL

Definition at line 20 of file ramdisk.c.

Referenced by CmdLineParse(), and RamDiskInitialize().

gInitRamDiskSize

ULONG gInitRamDiskSize = 0

Definition at line 21 of file ramdisk.c.

Referenced by CmdLineParse(), and RamDiskInitialize().

RamDiskBase

PVOID RamDiskBase

static

Definition at line 24 of file ramdisk.c.

Referenced by RamDiskInitialize(), RamDiskLoadVirtualFile(), and RamDiskRead().

RamDiskDeviceRegistered

BOOLEAN RamDiskDeviceRegistered = FALSE

static

Definition at line 23 of file ramdisk.c.

Referenced by RamDiskInitialize().

RamDiskFileSize

ULONGLONG RamDiskFileSize

static

Definition at line 25 of file ramdisk.c.

Referenced by RamDiskInitialize(), and RamDiskLoadVirtualFile().

RamDiskImageLength

ULONGLONG RamDiskImageLength

static

Definition at line 26 of file ramdisk.c.

Referenced by RamDiskGetFileInformation(), RamDiskInitialize(), RamDiskRead(), and RamDiskSeek().

RamDiskImageOffset

ULONG RamDiskImageOffset

static

Definition at line 27 of file ramdisk.c.

Referenced by RamDiskInitialize(), and RamDiskRead().

RamDiskOffset

ULONGLONG RamDiskOffset

static

Definition at line 28 of file ramdisk.c.

Referenced by RamDiskGetFileInformation(), RamDiskInitialize(), RamDiskRead(), and RamDiskSeek().

RamDiskVtbl

const DEVVTBL RamDiskVtbl

static

Initial value:

=
{
    RamDiskClose,
    RamDiskGetFileInformation,
    RamDiskOpen,
    RamDiskRead,
    RamDiskSeek,
}

Definition at line 100 of file ramdisk.c.

Referenced by RamDiskInitialize().