14 Nov
2009
14 Nov
'09
5:49 p.m.
Author: pschweitzer
Date: Sat Nov 14 18:49:19 2009
New Revision: 44160
URL: http://svn.reactos.org/svn/reactos?rev=44160&view=rev
Log:
Various other build fixes
Modified:
branches/pierre-fsd/base/setup/reactos/reactos.c
branches/pierre-fsd/base/setup/reactos/reactos.rbuild
branches/pierre-fsd/base/setup/reactos/rsrc.rc
branches/pierre-fsd/dll/win32/opengl32/gl.c
branches/pierre-fsd/drivers/storage/class/ramdisk/ramdisk.c
branches/pierre-fsd/drivers/storage/class/ramdisk/ramdisk.rbuild
branches/pierre-fsd/include/reactos/drivers/ntddrdsk.h
branches/pierre-fsd/ntoskrnl/io/iomgr/ramdisk.c
Modified: branches/pierre-fsd/base/setup/reactos/reactos.c
URL:
http://svn.reactos.org/svn/reactos/branches/pierre-fsd/base/setup/reactos/r…
==============================================================================
--- branches/pierre-fsd/base/setup/reactos/reactos.c [iso-8859-1] (original)
+++ branches/pierre-fsd/base/setup/reactos/reactos.c [iso-8859-1] Sat Nov 14 18:49:19
2009
@@ -21,7 +21,8 @@
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS GUI first stage setup application
* FILE: subsys/system/reactos/reactos.c
- * PROGRAMMERS: Eric Kohl, Matthias Kupfer
+ * PROGRAMMERS: Eric Kohl
+ * Matthias Kupfer
* Dmitry Chapyshev (dmitry(a)reactos.org)
*/
@@ -152,6 +153,29 @@
return hFont;
}
+static VOID
+InitImageInfo(PIMGINFO ImgInfo)
+{
+ BITMAP bitmap;
+
+ ZeroMemory(ImgInfo, sizeof(*ImgInfo));
+
+ ImgInfo->hBitmap = LoadImage(hInstance,
+ MAKEINTRESOURCE(IDB_ROSLOGO),
+ IMAGE_BITMAP,
+ 0,
+ 0,
+ LR_DEFAULTCOLOR);
+
+ if (ImgInfo->hBitmap != NULL)
+ {
+ GetObject(ImgInfo->hBitmap, sizeof(BITMAP), &bitmap);
+
+ ImgInfo->cxSource = bitmap.bmWidth;
+ ImgInfo->cySource = bitmap.bmHeight;
+ }
+}
+
static INT_PTR CALLBACK
StartDlgProc(HWND hwndDlg,
UINT uMsg,
Modified: branches/pierre-fsd/base/setup/reactos/reactos.rbuild
URL:
http://svn.reactos.org/svn/reactos/branches/pierre-fsd/base/setup/reactos/r…
==============================================================================
--- branches/pierre-fsd/base/setup/reactos/reactos.rbuild [iso-8859-1] (original)
+++ branches/pierre-fsd/base/setup/reactos/reactos.rbuild [iso-8859-1] Sat Nov 14 18:49:19
2009
@@ -7,6 +7,7 @@
<library>gdi32</library>
<library>user32</library>
<library>comctl32</library>
+ <library>setupapi</library>
<library>uuid</library>
<file>reactos.c</file>
<file>reactos.rc</file>
Modified: branches/pierre-fsd/base/setup/reactos/rsrc.rc
URL:
http://svn.reactos.org/svn/reactos/branches/pierre-fsd/base/setup/reactos/r…
==============================================================================
--- branches/pierre-fsd/base/setup/reactos/rsrc.rc [iso-8859-1] (original)
+++ branches/pierre-fsd/base/setup/reactos/rsrc.rc [iso-8859-1] Sat Nov 14 18:49:19 2009
@@ -21,7 +21,7 @@
#include "lang/pt-BR.rc"
#include "lang/ru-RU.rc"
#include "lang/sk-SK.rc"
-#include "lang/sv-SE.rc"
+/*#include "lang/sv-SE.rc"
#include "lang/th-TH.rc"*/
#include "lang/uk-UA.rc"
//#include "lang/zh-CN.rc"
Modified: branches/pierre-fsd/dll/win32/opengl32/gl.c
URL:
http://svn.reactos.org/svn/reactos/branches/pierre-fsd/dll/win32/opengl32/g…
==============================================================================
--- branches/pierre-fsd/dll/win32/opengl32/gl.c [iso-8859-1] (original)
+++ branches/pierre-fsd/dll/win32/opengl32/gl.c [iso-8859-1] Sat Nov 14 18:49:19 2009
@@ -19,11 +19,8 @@
*
* On other machines we use C to forward the calls (slow...)
*/
-
-#define WIN32_LEANER_AND_MEANER
-#define WIN32_NO_STATUS
-#include <windows.h>
-#include "teb.h"
+
+#include "opengl32.h"
C_ASSERT(FIELD_OFFSET(TEB, glTable) == 0xbe8);
Modified: branches/pierre-fsd/drivers/storage/class/ramdisk/ramdisk.c
URL:
http://svn.reactos.org/svn/reactos/branches/pierre-fsd/drivers/storage/clas…
==============================================================================
--- branches/pierre-fsd/drivers/storage/class/ramdisk/ramdisk.c [iso-8859-1] (original)
+++ branches/pierre-fsd/drivers/storage/class/ramdisk/ramdisk.c [iso-8859-1] Sat Nov 14
18:49:19 2009
@@ -11,8 +11,10 @@
#include <initguid.h>
#include <ntddk.h>
#include <ntdddisk.h>
+#include <ntddcdrm.h>
#include <scsi.h>
#include <ntddscsi.h>
+#include <ntddvol.h>
#include <mountdev.h>
#include <mountmgr.h>
#include <ketypes.h>
@@ -20,15 +22,25 @@
#include <rtlfuncs.h>
#include <arc/arc.h>
#include <reactos/drivers/ntddrdsk.h>
+#include "../../../filesystems/fs_rec/fs_rec.h"
+#include <stdio.h>
#define NDEBUG
#include <debug.h>
/* GLOBALS ********************************************************************/
+#define RAMDISK_SESSION_SIZE \
+ FIELD_OFFSET(CDROM_TOC, TrackData) + sizeof(TRACK_DATA)
+
+#define RAMDISK_TOC_SIZE \
+ FIELD_OFFSET(CDROM_TOC, TrackData) + 2 * sizeof(TRACK_DATA)
+
+#define TOC_DATA_TRACK (0x04)
+
typedef enum _RAMDISK_DEVICE_TYPE
{
- RamdiskFdo,
- RamdiskPdo
+ RamdiskBus,
+ RamdiskDrive
} RAMDISK_DEVICE_TYPE;
typedef enum _RAMDISK_DEVICE_STATE
@@ -39,6 +51,7 @@
RamdiskStateStopped,
RamdiskStateRemoved,
RamdiskStateBusRemoved,
+ RamdiskStateEnumerated,
} RAMDISK_DEVICE_STATE;
DEFINE_GUID(RamdiskBusInterface,
@@ -55,10 +68,46 @@
PDEVICE_OBJECT PhysicalDeviceObject;
PDEVICE_OBJECT AttachedDevice;
IO_REMOVE_LOCK RemoveLock;
+ UNICODE_STRING DriveDeviceName;
+ UNICODE_STRING BusDeviceName;
+ FAST_MUTEX DiskListLock;
+ LIST_ENTRY DiskList;
+} RAMDISK_EXTENSION, *PRAMDISK_EXTENSION;
+
+typedef struct _RAMDISK_BUS_EXTENSION
+{
+ RAMDISK_EXTENSION;
+} RAMDISK_BUS_EXTENSION, *PRAMDISK_BUS_EXTENSION;
+
+typedef struct _RAMDISK_DRIVE_EXTENSION
+{
+ //
+ // Inherited base class
+ //
+ RAMDISK_EXTENSION;
+
+ //
+ // Data we get from the creator
+ //
+ GUID DiskGuid;
+ UNICODE_STRING GuidString;
UNICODE_STRING SymbolicLinkName;
- FAST_MUTEX DiskListLock;
- LIST_ENTRY DiskListHead;
-} RAMDISK_EXTENSION, *PRAMDISK_EXTENSION;
+ ULONG DiskType;
+ RAMDISK_CREATE_OPTIONS DiskOptions;
+ LARGE_INTEGER DiskLength;
+ LONG DiskOffset;
+ WCHAR DriveLetter;
+ ULONG BasePage;
+
+ //
+ // Data we get from the disk
+ //
+ ULONG BytesPerSector;
+ ULONG SectorsPerTrack;
+ ULONG NumberOfHeads;
+ ULONG Cylinders;
+ ULONG HiddenSectors;
+} RAMDISK_DRIVE_EXTENSION, *PRAMDISK_DRIVE_EXTENSION;
ULONG MaximumViewLength;
ULONG MaximumPerDiskViewLength;
@@ -230,37 +279,495 @@
}
}
+PVOID
+NTAPI
+RamdiskMapPages(IN PRAMDISK_DRIVE_EXTENSION DeviceExtension,
+ IN LARGE_INTEGER Offset,
+ IN ULONG Length,
+ OUT PULONG OutputLength)
+{
+ PHYSICAL_ADDRESS PhysicalAddress;
+ PVOID MappedBase;
+ ULONG PageOffset;
+ SIZE_T ActualLength;
+ LARGE_INTEGER ActualOffset;
+ LARGE_INTEGER ActualPages;
+
+ //
+ // We only support boot disks for now
+ //
+ ASSERT(DeviceExtension->DiskType == RAMDISK_BOOT_DISK);
+
+ //
+ // Calculate the actual offset in the drive
+ //
+ ActualOffset.QuadPart = DeviceExtension->DiskOffset + Offset.QuadPart;
+
+ //
+ // Convert to pages
+ //
+ ActualPages.QuadPart = ActualOffset.QuadPart >> PAGE_SHIFT;
+
+ //
+ // Now add the base page
+ //
+ ActualPages.QuadPart = DeviceExtension->BasePage + ActualPages.QuadPart;
+
+ //
+ // Calculate final amount of bytes
+ //
+ PhysicalAddress.QuadPart = ActualPages.QuadPart << PAGE_SHIFT;
+
+ //
+ // Calculate pages spanned for the mapping
+ //
+ ActualLength = ADDRESS_AND_SIZE_TO_SPAN_PAGES(ActualOffset.QuadPart, Length);
+
+ //
+ // And convert this back to bytes
+ //
+ ActualLength <<= PAGE_SHIFT;
+
+ //
+ // Get the offset within the page
+ //
+ PageOffset = BYTE_OFFSET(ActualOffset.QuadPart);
+
+ //
+ // Map the I/O Space from the loader
+ //
+ MappedBase = MmMapIoSpace(PhysicalAddress, ActualLength, MmCached);
+
+ //
+ // Return actual offset within the page as well as the length
+ //
+ if (MappedBase) MappedBase = (PVOID)((ULONG_PTR)MappedBase + PageOffset);
+ *OutputLength = Length;
+ return MappedBase;
+}
+
+VOID
+NTAPI
+RamdiskUnmapPages(IN PRAMDISK_DRIVE_EXTENSION DeviceExtension,
+ IN PVOID BaseAddress,
+ IN LARGE_INTEGER Offset,
+ IN ULONG Length)
+{
+ LARGE_INTEGER ActualOffset;
+ SIZE_T ActualLength;
+ ULONG PageOffset;
+
+ //
+ // We only support boot disks for now
+ //
+ ASSERT(DeviceExtension->DiskType == RAMDISK_BOOT_DISK);
+
+ //
+ // Calculate the actual offset in the drive
+ //
+ ActualOffset.QuadPart = DeviceExtension->DiskOffset + Offset.QuadPart;
+
+ //
+ // Calculate pages spanned for the mapping
+ //
+ ActualLength = ADDRESS_AND_SIZE_TO_SPAN_PAGES(ActualOffset.QuadPart, Length);
+
+ //
+ // And convert this back to bytes
+ //
+ ActualLength <<= PAGE_SHIFT;
+
+ //
+ // Get the offset within the page
+ //
+ PageOffset = BYTE_OFFSET(ActualOffset.QuadPart);
+
+ //
+ // Calculate actual base address where we mapped this
+ //
+ BaseAddress = (PVOID)((ULONG_PTR)BaseAddress - PageOffset);
+
+ //
+ // Unmap the I/O space we got from the loader
+ //
+ MmUnmapIoSpace(BaseAddress, ActualLength);
+}
+
NTSTATUS
NTAPI
-RamdiskOpenClose(IN PDEVICE_OBJECT DeviceObject,
- IN PIRP Irp)
-{
- //
- // Complete the IRP
- //
- Irp->IoStatus.Information = 1;
- Irp->IoStatus.Status = STATUS_SUCCESS;
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
- return STATUS_SUCCESS;
-}
-
-NTSTATUS
-NTAPI
-RamdiskReadWrite(IN PDEVICE_OBJECT DeviceObject,
- IN PIRP Irp)
-{
- UNIMPLEMENTED;
- while (TRUE);
- return STATUS_SUCCESS;
-}
-
-NTSTATUS
-NTAPI
-RamdiskCreateDiskDevice(IN PRAMDISK_EXTENSION DeviceExtension,
+RamdiskCreateDiskDevice(IN PRAMDISK_BUS_EXTENSION DeviceExtension,
IN PRAMDISK_CREATE_INPUT Input,
IN BOOLEAN ValidateOnly,
- OUT PDEVICE_OBJECT *DeviceObject)
-{
+ OUT PRAMDISK_DRIVE_EXTENSION *NewDriveExtension)
+{
+ ULONG BasePage, ViewCount, DiskType, Length;
+ NTSTATUS Status;
+ PDEVICE_OBJECT DeviceObject;
+ PRAMDISK_DRIVE_EXTENSION DriveExtension;
+ PVOID Buffer;
+ WCHAR LocalBuffer[16];
+ UNICODE_STRING SymbolicLinkName, DriveString, GuidString, DeviceName;
+ PPACKED_BOOT_SECTOR BootSector;
+ BIOS_PARAMETER_BLOCK BiosBlock;
+ ULONG BytesPerSector, SectorsPerTrack, Heads, BytesRead;
+ PVOID BaseAddress;
+ LARGE_INTEGER CurrentOffset, CylinderSize, DiskLength;
+ ULONG CylinderCount, SizeByCylinders;
+
+ //
+ // Check if we're a boot RAM disk
+ //
+ DiskType = Input->DiskType;
+ if (DiskType >= RAMDISK_BOOT_DISK)
+ {
+ //
+ // Check if we're an ISO
+ //
+ if (DiskType == RAMDISK_BOOT_DISK)
+ {
+ //
+ // NTLDR mounted us somewhere
+ //
+ BasePage = Input->BasePage;
+ if (!BasePage) return STATUS_INVALID_PARAMETER;
+
+ //
+ // Sanitize disk options
+ //
+ Input->Options.Fixed = TRUE;
+ Input->Options.Readonly = Input->Options.ExportAsCd |
+ Input->Options.Readonly;
+ Input->Options.Hidden = FALSE;
+ Input->Options.NoDosDevice = FALSE;
+ Input->Options.NoDriveLetter = IsWinPEBoot ? TRUE : FALSE;
+ }
+ else
+ {
+ //
+ // The only other possibility is a WIM disk
+ //
+ if (DiskType != RAMDISK_WIM_DISK)
+ {
+ //
+ // Fail
+ //
+ return STATUS_INVALID_PARAMETER;
+ }
+
+ //
+ // Read the view count instead
+ //
+ ViewCount = Input->ViewCount;
+
+ //
+ // Sanitize disk options
+ //
+ Input->Options.Hidden = FALSE;
+ Input->Options.NoDosDevice = FALSE;
+ Input->Options.Readonly = FALSE;
+ Input->Options.NoDriveLetter = TRUE;
+ Input->Options.Fixed = TRUE;
+ }
+
+ //
+ // Are we just validating and returning to the user?
+ //
+ if (ValidateOnly) return STATUS_SUCCESS;
+
+ //
+ // Build the GUID string
+ //
+ Status = RtlStringFromGUID(&Input->DiskGuid, &GuidString);
+ if (!(NT_SUCCESS(Status)) || !(GuidString.Buffer))
+ {
+ //
+ // Fail
+ //
+ Status = STATUS_INSUFFICIENT_RESOURCES;
+ goto FailCreate;
+ }
+
+ //
+ // Allocate our device name
+ //
+ Length = GuidString.Length + 32;
+ Buffer = ExAllocatePoolWithTag(NonPagedPool,
+ Length,
+ TAG('R', 'a', 'm',
'd'));
+ if (!Buffer)
+ {
+ //
+ // Fail
+ //
+ Status = STATUS_INSUFFICIENT_RESOURCES;
+ goto FailCreate;
+ }
+
+ //
+ // Build the device name string
+ //
+ DeviceName.Buffer = Buffer;
+ DeviceName.Length = Length - 2;
+ DeviceName.MaximumLength = Length;
+ wcsncpy(Buffer, L"\\Device\\Ramdisk", Length / sizeof(WCHAR));
+ wcsncat(Buffer, GuidString.Buffer, Length / sizeof(WCHAR));
+
+ //
+ // Create the drive device
+ //
+ Status = IoCreateDevice(DeviceExtension->DeviceObject->DriverObject,
+ sizeof(RAMDISK_DRIVE_EXTENSION),
+ &DeviceName,
+ (Input->Options.ExportAsCd) ?
+ FILE_DEVICE_CD_ROM : FILE_DEVICE_DISK,
+ 0,
+ 0,
+ &DeviceObject);
+ if (!NT_SUCCESS(Status)) goto FailCreate;
+
+ //
+ // Grab the drive extension
+ //
+ DriveExtension = DeviceObject->DeviceExtension;
+
+ //
+ // Check if we need a DOS device
+ //
+ if (!Input->Options.NoDosDevice)
+ {
+ //
+ // Build the symbolic link name
+ //
+ SymbolicLinkName.MaximumLength = GuidString.Length + 36;
+ SymbolicLinkName.Length = GuidString.Length + 34;
+ Buffer = ExAllocatePoolWithTag(NonPagedPool,
+ SymbolicLinkName.MaximumLength,
+ TAG('R', 'a', 'm',
'd'));
+ SymbolicLinkName.Buffer = Buffer;
+ if (Buffer)
+ {
+ //
+ // Create it
+ //
+ wcsncpy(Buffer,
+ L"\\GLOBAL??\\Ramdisk",
+ SymbolicLinkName.MaximumLength / sizeof(WCHAR));
+ wcsncat(Buffer,
+ GuidString.Buffer,
+ SymbolicLinkName.MaximumLength / sizeof(WCHAR));
+ Status = IoCreateSymbolicLink(&SymbolicLinkName, &DeviceName);
+ if (!NT_SUCCESS(Status))
+ {
+ //
+ // Nevermind...
+ //
+ Input->Options.NoDosDevice = TRUE;
+ ExFreePool(Buffer);
+ SymbolicLinkName.Buffer = NULL;
+ }
+ }
+ else
+ {
+ //
+ // No DOS device
+ //
+ Input->Options.NoDosDevice = TRUE;
+ }
+
+ //
+ // It this an ISO boot ramdisk?
+ //
+ if (Input->DiskType == RAMDISK_BOOT_DISK)
+ {
+ //
+ // Does it need a drive letter?
+ //
+ if (!Input->Options.NoDriveLetter)
+ {
+ //
+ // Build it and take over the existing symbolic link
+ //
+ _snwprintf(LocalBuffer,
+ 30,
+ L"\\DosDevices\\%wc:",
+ Input->DriveLetter);
+ RtlInitUnicodeString(&DriveString, LocalBuffer);
+ IoDeleteSymbolicLink(&DriveString);
+ IoCreateSymbolicLink(&DriveString, &DeviceName);
+
+ //
+ // Save the drive letter
+ //
+ DriveExtension->DriveLetter = Input->DriveLetter;
+ }
+ }
+
+ }
+
+ //
+ // Setup the device object flags
+ //
+ DeviceObject->Flags |= (DO_XIP | DO_POWER_PAGABLE | DO_DIRECT_IO);
+ DeviceObject->AlignmentRequirement = 1;
+
+ //
+ // Build the drive FDO
+ //
+ *NewDriveExtension = DriveExtension;
+ DriveExtension->Type = RamdiskDrive;
+ DiskLength = Input->DiskLength;
+ ExInitializeFastMutex(&DriveExtension->DiskListLock);
+ IoInitializeRemoveLock(&DriveExtension->RemoveLock,
+ TAG('R', 'a', 'm', 'd'),
+ 0,
+ 1);
+ DriveExtension->DriveDeviceName = DeviceName;
+ DriveExtension->SymbolicLinkName = SymbolicLinkName;
+ DriveExtension->GuidString = GuidString;
+ DriveExtension->DiskGuid = Input->DiskGuid;
+ DriveExtension->PhysicalDeviceObject = DeviceObject;
+ DriveExtension->DeviceObject = RamdiskBusFdo;
+ DriveExtension->AttachedDevice = RamdiskBusFdo;
+ DriveExtension->DiskType = Input->DiskType;
+ DriveExtension->DiskOptions = Input->Options;
+ DriveExtension->DiskLength = DiskLength;
+ DriveExtension->DiskOffset = Input->DiskOffset;
+ DriveExtension->BasePage = Input->BasePage;
+ DriveExtension->BytesPerSector = 0;
+ DriveExtension->SectorsPerTrack = 0;
+ DriveExtension->NumberOfHeads = 0;
+
+ //
+ // Make sure we don't free it later
+ //
+ DeviceName.Buffer = NULL;
+ SymbolicLinkName.Buffer = NULL;
+ GuidString.Buffer = NULL;
+
+ //
+ // Check if this is an boot disk, or a registry ram drive
+ //
+ if (!(Input->Options.ExportAsCd) &&
+ (Input->DiskType == RAMDISK_BOOT_DISK))
+ {
+ //
+ // Not an ISO boot, but it's a boot FS -- map it to figure out the
+ // drive settings
+ //
+ CurrentOffset.QuadPart = 0;
+ BaseAddress = RamdiskMapPages(DriveExtension,
+ CurrentOffset,
+ PAGE_SIZE,
+ &BytesRead);
+ if (BaseAddress)
+ {
+ //
+ // Get the data
+ //
+ BootSector = (PPACKED_BOOT_SECTOR)BaseAddress;
+ FatUnpackBios(&BiosBlock, &BootSector->PackedBpb);
+ BytesPerSector = BiosBlock.BytesPerSector;
+ SectorsPerTrack = BiosBlock.SectorsPerTrack;
+ Heads = BiosBlock.Heads;
+
+ //
+ // Save it
+ //
+ DriveExtension->BytesPerSector = BytesPerSector;
+ DriveExtension->SectorsPerTrack = SectorsPerTrack;
+ DriveExtension->NumberOfHeads = Heads;
+
+ //
+ // Unmap now
+ //
+ CurrentOffset.QuadPart = 0;
+ RamdiskUnmapPages(DriveExtension,
+ BaseAddress,
+ CurrentOffset,
+ BytesRead);
+ }
+ else
+ {
+ //
+ // Fail
+ //
+ Status = STATUS_INSUFFICIENT_RESOURCES;
+ goto FailCreate;
+ }
+ }
+
+ //
+ // Check if the drive settings haven't been set yet
+ //
+ if ((DriveExtension->BytesPerSector == 0) ||
+ (DriveExtension->SectorsPerTrack == 0) ||
+ (DriveExtension->NumberOfHeads == 0))
+ {
+ //
+ // Check if this is a CD
+ //
+ if (Input->Options.ExportAsCd)
+ {
+ //
+ // Setup partition parameters default for ISO 9660
+ //
+ DriveExtension->BytesPerSector = 2048;
+ DriveExtension->SectorsPerTrack = 32;
+ DriveExtension->NumberOfHeads = 64;
+ }
+ else
+ {
+ //
+ // Setup partition parameters default for FAT
+ //
+ DriveExtension->BytesPerSector = 512;
+ DriveExtension->SectorsPerTrack = 128;
+ DriveExtension->NumberOfHeads = 16;
+ }
+ }
+
+ //
+ // Calculate the cylinder size
+ //
+ CylinderSize.QuadPart = DriveExtension->BytesPerSector *
+ DriveExtension->SectorsPerTrack *
+ DriveExtension->NumberOfHeads;
+ CylinderCount = DiskLength.QuadPart / CylinderSize.QuadPart;
+ SizeByCylinders = CylinderSize.QuadPart * CylinderCount;
+ DriveExtension->Cylinders = CylinderCount;
+ if ((DiskLength.HighPart > 0) || (SizeByCylinders < DiskLength.LowPart))
+ {
+ //
+ // Align cylinder size up
+ //
+ DriveExtension->Cylinders++;
+ }
+
+ //
+ // Acquire the disk lock
+ //
+ KeEnterCriticalRegion();
+ ExAcquireFastMutex(&DeviceExtension->DiskListLock);
+
+ //
+ // Insert us
+ //
+ InsertTailList(&DeviceExtension->DiskList,
&DriveExtension->DiskList);
+
+ //
+ // Release the lock
+ //
+ ExReleaseFastMutex(&DeviceExtension->DiskListLock);
+ KeLeaveCriticalRegion();
+
+ //
+ // Clear init flag
+ //
+ DeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
+ return STATUS_SUCCESS;
+ }
+
+FailCreate:
UNIMPLEMENTED;
while (TRUE);
return STATUS_SUCCESS;
@@ -274,7 +781,8 @@
{
PRAMDISK_CREATE_INPUT Input;
ULONG Length;
- PRAMDISK_EXTENSION DeviceExtension;
+ PRAMDISK_BUS_EXTENSION DeviceExtension;
+ PRAMDISK_DRIVE_EXTENSION DriveExtension;
ULONG DiskType;
PWCHAR FileNameStart, FileNameEnd;
NTSTATUS Status;
@@ -283,7 +791,7 @@
//
// Get the device extension and our input data
//
- DeviceExtension = (PRAMDISK_EXTENSION)DeviceObject->DeviceExtension;
+ DeviceExtension = DeviceObject->DeviceExtension;
Length = IoStackLocation->Parameters.DeviceIoControl.InputBufferLength;
Input = (PRAMDISK_CREATE_INPUT)Irp->AssociatedIrp.SystemBuffer;
@@ -303,12 +811,12 @@
// Validate the disk type
//
DiskType = Input->DiskType;
- if (DiskType == FILE_DEVICE_CONTROLLER) return STATUS_INVALID_PARAMETER;
+ if (DiskType == RAMDISK_WIM_DISK) return STATUS_INVALID_PARAMETER;
//
// Look at the disk type
//
- if (DiskType == FILE_DEVICE_CD_ROM_FILE_SYSTEM)
+ if (DiskType == RAMDISK_BOOT_DISK)
{
//
// We only allow this as an early-init boot
@@ -325,18 +833,18 @@
//
// Validate the disk type
//
- if ((Input->Options.ExportAsCd) && (DiskType !=
FILE_DEVICE_CD_ROM_FILE_SYSTEM))
+ if ((Input->Options.ExportAsCd) && (DiskType != RAMDISK_BOOT_DISK))
{
//
// If the type isn't CDFS, it has to at least be raw CD
//
- if (DiskType != FILE_DEVICE_CD_ROM) return STATUS_INVALID_PARAMETER;
+ if (DiskType != RAMDISK_MEMORY_MAPPED_DISK) return STATUS_INVALID_PARAMETER;
}
//
// Check if this is an actual file
//
- if (DiskType <= FILE_DEVICE_CD_ROM)
+ if (DiskType <= RAMDISK_MEMORY_MAPPED_DISK)
{
//
// Validate the file name
@@ -353,7 +861,7 @@
Status = RamdiskCreateDiskDevice(DeviceExtension,
Input,
ValidateOnly,
- &DeviceObject);
+ &DriveExtension);
if (NT_SUCCESS(Status))
{
//
@@ -367,6 +875,152 @@
// We're done
//
return Status;
+}
+
+VOID
+NTAPI
+RamdiskWorkerThread(IN PDEVICE_OBJECT DeviceObject,
+ IN PVOID Context)
+{
+ PRAMDISK_BUS_EXTENSION DeviceExtension;
+ NTSTATUS Status;
+ PIO_STACK_LOCATION IoStackLocation;
+ PIRP Irp = Context;
+
+ //
+ // Get the stack location
+ //
+ IoStackLocation = IoGetCurrentIrpStackLocation(Irp);
+
+ //
+ // Free the work item
+ //
+ IoFreeWorkItem(Irp->Tail.Overlay.DriverContext[0]);
+
+ //
+ // Grab the device extension and lock it
+ //
+ DeviceExtension = DeviceObject->DeviceExtension;
+ Status = IoAcquireRemoveLock(&DeviceExtension->RemoveLock, Irp);
+ if (NT_SUCCESS(Status))
+ {
+ //
+ // Discriminate by major code
+ //
+ switch (IoStackLocation->MajorFunction)
+ {
+ //
+ // Device control
+ //
+ case IRP_MJ_DEVICE_CONTROL:
+
+ //
+ // Let's take a look at the IOCTL
+ //
+ switch (IoStackLocation->Parameters.DeviceIoControl.IoControlCode)
+ {
+ //
+ // Ramdisk create request
+ //
+ case FSCTL_CREATE_RAM_DISK:
+
+ //
+ // This time we'll do it for real
+ //
+ Status = RamdiskCreateRamdisk(DeviceObject, Irp, FALSE);
+ break;
+
+ case IOCTL_DISK_SET_PARTITION_INFO:
+
+ DPRINT1("Set partition info request\n");
+ UNIMPLEMENTED;
+ while (TRUE);
+ break;
+
+ case IOCTL_DISK_GET_DRIVE_LAYOUT:
+
+ DPRINT1("Get drive layout request\n");
+ UNIMPLEMENTED;
+ while (TRUE);
+ break;
+
+ case IOCTL_DISK_GET_PARTITION_INFO:
+
+ DPRINT1("Get partitinon info request\n");
+ UNIMPLEMENTED;
+ while (TRUE);
+ break;
+
+ default:
+
+ DPRINT1("Invalid request\n");
+ UNIMPLEMENTED;
+ while (TRUE);
+ break;
+ }
+
+ //
+ // We're here
+ //
+ break;
+
+ //
+ // Read or write request
+ //
+ case IRP_MJ_READ:
+ case IRP_MJ_WRITE:
+
+ DPRINT1("Read/Write request\n");
+ UNIMPLEMENTED;
+ while (TRUE);
+ break;
+
+ //
+ // Internal request (SCSI?)
+ //
+ case IRP_MJ_INTERNAL_DEVICE_CONTROL:
+
+ DPRINT1("SCSI request\n");
+ UNIMPLEMENTED;
+ while (TRUE);
+ break;
+
+ //
+ // Flush request
+ //
+ case IRP_MJ_FLUSH_BUFFERS:
+
+ DPRINT1("Flush request\n");
+ UNIMPLEMENTED;
+ while (TRUE);
+ break;
+
+ //
+ // Anything else
+ //
+ default:
+
+ DPRINT1("Invalid request: %lx\n",
IoStackLocation->MajorFunction);
+ UNIMPLEMENTED;
+ while (TRUE);
+ break;
+ }
+
+ //
+ // Complete the I/O
+ //
+ IoReleaseRemoveLock(&DeviceExtension->RemoveLock, Irp);
+ Irp->IoStatus.Status = Status;
+ Irp->IoStatus.Information = 0;
+ return IoCompleteRequest(Irp, IO_DISK_INCREMENT);
+ }
+
+ //
+ // Fail the I/O
+ //
+ Irp->IoStatus.Status = Status;
+ Irp->IoStatus.Information = 0;
+ return IoCompleteRequest(Irp, IO_NO_INCREMENT);
}
NTSTATUS
@@ -721,8 +1375,11 @@
{
NTSTATUS Status;
PIO_STACK_LOCATION IoStackLocation = IoGetCurrentIrpStackLocation(Irp);
- PRAMDISK_EXTENSION DeviceExtension = DeviceObject->DeviceExtension;
- ULONG Information = 0;
+ PRAMDISK_BUS_EXTENSION DeviceExtension = DeviceObject->DeviceExtension;
+ PRAMDISK_DRIVE_EXTENSION DriveExtension = (PVOID)DeviceExtension;
+ ULONG Information;
+ PCDROM_TOC Toc;
+ PDISK_GEOMETRY DiskGeometry;
//
// Grab the remove lock
@@ -740,9 +1397,15 @@
}
//
- // Check if this is an FDO or PDO
- //
- if (DeviceExtension->Type == RamdiskFdo)
+ // Setup some defaults
+ //
+ Status = STATUS_INVALID_DEVICE_REQUEST;
+ Information = 0;
+
+ //
+ // Check if this is an bus device or the drive
+ //
+ if (DeviceExtension->Type == RamdiskBus)
{
//
// Check what the request is
@@ -773,16 +1436,266 @@
else
{
//
- // PDO code not yet done
- //
- ASSERT(FALSE);
+ // Check what the request is
+ //
+ switch (IoStackLocation->Parameters.DeviceIoControl.IoControlCode)
+ {
+ case IOCTL_DISK_CHECK_VERIFY:
+ case IOCTL_STORAGE_CHECK_VERIFY:
+ case IOCTL_STORAGE_CHECK_VERIFY2:
+ case IOCTL_CDROM_CHECK_VERIFY:
+
+ UNIMPLEMENTED;
+ while (TRUE);
+ break;
+
+ case IOCTL_STORAGE_GET_MEDIA_TYPES:
+ case IOCTL_DISK_GET_MEDIA_TYPES:
+ case IOCTL_DISK_GET_DRIVE_GEOMETRY:
+ case IOCTL_CDROM_GET_DRIVE_GEOMETRY:
+
+ //
+ // Validate the length
+ //
+ if (IoStackLocation->Parameters.DeviceIoControl.
+ OutputBufferLength < sizeof(DISK_GEOMETRY))
+ {
+ //
+ // Invalid length
+ //
+ Status = STATUS_BUFFER_TOO_SMALL;
+ break;
+ }
+
+ //
+ // Fill it out
+ //
+ DiskGeometry = Irp->AssociatedIrp.SystemBuffer;
+ DiskGeometry->Cylinders.QuadPart = DriveExtension->Cylinders;
+ DiskGeometry->BytesPerSector = DriveExtension->BytesPerSector;
+ DiskGeometry->SectorsPerTrack = DriveExtension->SectorsPerTrack;
+ DiskGeometry->TracksPerCylinder = DriveExtension->NumberOfHeads;
+ DiskGeometry->MediaType = DriveExtension->DiskOptions.Fixed ?
+ FixedMedia : RemovableMedia;
+
+ //
+ // We're done
+ //
+ Status = STATUS_SUCCESS;
+ Information = sizeof(DISK_GEOMETRY);
+ break;
+
+ //
+ // Hack to support ReactOS's broken CDFS
+ //
+ case IOCTL_CDROM_GET_LAST_SESSION:
+
+ //
+ // Validate the length
+ //
+ if (IoStackLocation->Parameters.DeviceIoControl.
+ OutputBufferLength < RAMDISK_SESSION_SIZE)
+ {
+ //
+ // Invalid length
+ //
+ Status = STATUS_BUFFER_TOO_SMALL;
+ break;
+ }
+
+ //
+ // Fill out the TOC
+ //
+ Toc = Irp->AssociatedIrp.SystemBuffer;
+ Toc->Length[0] = 0;
+ Toc->Length[1] = RAMDISK_SESSION_SIZE - sizeof(Toc->Length);
+ Toc->FirstTrack = 1;
+ Toc->LastTrack = 1;
+ Toc->TrackData[0].Adr = 1;
+ Toc->TrackData[0].Control = TOC_DATA_TRACK;
+ Toc->TrackData[0].TrackNumber = 1;
+ Toc->TrackData[0].Address[0] =
+ Toc->TrackData[0].Address[1] =
+ Toc->TrackData[0].Address[2] =
+ Toc->TrackData[0].Address[3] = 0;
+
+ //
+ // We're done
+ //
+ Status = STATUS_SUCCESS;
+ Information = RAMDISK_SESSION_SIZE;
+ break;
+
+ case IOCTL_CDROM_READ_TOC:
+
+ //
+ // Validate the length
+ //
+ if (IoStackLocation->Parameters.DeviceIoControl.
+ OutputBufferLength < sizeof(CDROM_TOC))
+ {
+ //
+ // Invalid length
+ //
+ Status = STATUS_BUFFER_TOO_SMALL;
+ break;
+ }
+
+ //
+ // Clear the TOC
+ //
+ Toc = Irp->AssociatedIrp.SystemBuffer;
+ RtlZeroMemory(Toc, sizeof(CDROM_TOC));
+
+ //
+ // Fill it out
+ //
+ Toc->Length[0] = 0;
+ Toc->Length[1] = RAMDISK_TOC_SIZE - sizeof(Toc->Length);
+ Toc->FirstTrack = 1;
+ Toc->LastTrack = 1;
+ Toc->TrackData[0].Adr = 1;
+ Toc->TrackData[0].Control = TOC_DATA_TRACK;
+ Toc->TrackData[0].TrackNumber = 1;
+
+ //
+ // We're done
+ //
+ Status = STATUS_SUCCESS;
+ Information = RAMDISK_TOC_SIZE;
+ break;
+
+ case IOCTL_DISK_SET_PARTITION_INFO:
+
+ UNIMPLEMENTED;
+ while (TRUE);
+ break;
+
+ case IOCTL_DISK_GET_PARTITION_INFO:
+
+ //
+ // Validate the length
+ //
+ if (IoStackLocation->Parameters.DeviceIoControl.
+ OutputBufferLength < sizeof(PARTITION_INFORMATION))
+ {
+ //
+ // Invalid length
+ //
+ Status = STATUS_BUFFER_TOO_SMALL;
+ break;
+ }
+
+ //
+ // Check if we need to do this sync or async
+ //
+ if (DriveExtension->DiskType > RAMDISK_MEMORY_MAPPED_DISK)
+ {
+ //
+ // Call the helper function
+ //
+ Status = RamdiskGetPartitionInfo(Irp, DriveExtension);
+ }
+ else
+ {
+ //
+ // Do it asynchronously later
+ //
+ goto CallWorker;
+ }
+
+ //
+ // We're done
+ //
+ Information = Irp->IoStatus.Information;
+ break;
+
+ case IOCTL_DISK_GET_DRIVE_LAYOUT:
+
+ UNIMPLEMENTED;
+ while (TRUE);
+ break;
+
+ case IOCTL_DISK_GET_LENGTH_INFO:
+
+ UNIMPLEMENTED;
+ while (TRUE);
+ break;
+
+ case IOCTL_DISK_IS_WRITABLE:
+
+ UNIMPLEMENTED;
+ while (TRUE);
+ break;
+
+ case IOCTL_SCSI_MINIPORT:
+
+ UNIMPLEMENTED;
+ while (TRUE);
+ break;
+
+ case IOCTL_STORAGE_QUERY_PROPERTY:
+
+ UNIMPLEMENTED;
+ while (TRUE);
+ break;
+
+ case IOCTL_MOUNTDEV_QUERY_UNIQUE_ID:
+
+ UNIMPLEMENTED;
+ while (TRUE);
+ break;
+
+ case IOCTL_MOUNTDEV_QUERY_STABLE_GUID:
+
+ UNIMPLEMENTED;
+ while (TRUE);
+ break;
+
+ case IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS:
+
+ UNIMPLEMENTED;
+ while (TRUE);
+ break;
+
+ case IOCTL_VOLUME_SET_GPT_ATTRIBUTES:
+
+ UNIMPLEMENTED;
+ while (TRUE);
+ break;
+
+ case IOCTL_VOLUME_GET_GPT_ATTRIBUTES:
+
+ UNIMPLEMENTED;
+ while (TRUE);
+ break;
+
+ case IOCTL_VOLUME_OFFLINE:
+
+ UNIMPLEMENTED;
+ while (TRUE);
+ break;
+
+ default:
+
+ //
+ // Drive code not emulated
+ //
+ DPRINT1("IOCTL: %lx\n",
IoStackLocation->Parameters.DeviceIoControl.IoControlCode);
+ break;
+ }
+
+ //
+ // If requests drop down here, we just return them complete them
+ //
+ goto CompleteRequest;
}
//
// Queue the request to our worker thread
//
- UNIMPLEMENTED;
- while (TRUE);
+CallWorker:
+ Status = SendIrpToThread(DeviceObject, Irp);
CompleteRequest:
//
@@ -803,6 +1716,211 @@
// Return status
//
return Status;
+}
+
+NTSTATUS
+NTAPI
+RamdiskQueryDeviceRelations(IN DEVICE_RELATION_TYPE Type,
+ IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp)
+{
+ PRAMDISK_BUS_EXTENSION DeviceExtension;
+ PRAMDISK_DRIVE_EXTENSION DriveExtension;
+ PDEVICE_RELATIONS DeviceRelations, OurDeviceRelations;
+ ULONG Count, DiskCount, FinalCount;
+ PLIST_ENTRY ListHead, NextEntry;
+ PDEVICE_OBJECT* DriveDeviceObject;
+ RAMDISK_DEVICE_STATE State;
+
+ //
+ // Get the device extension and check if this is a drive
+ //
+ DeviceExtension = DeviceObject->DeviceExtension;
+ if (DeviceExtension->Type == RamdiskDrive)
+ {
+ //
+ // FIXME: TODO
+ //
+ UNIMPLEMENTED;
+ while (TRUE);
+ }
+
+ //
+ // Anything but bus relations, we don't handle
+ //
+ if (Type) goto PassToNext;
+
+ //
+ // Acquire the disk list lock
+ //
+ KeEnterCriticalRegion();
+ ExAcquireFastMutex(&DeviceExtension->DiskListLock);
+
+ //
+ // Did a device already fill relations?
+ //
+ DeviceRelations = (PDEVICE_RELATIONS)Irp->IoStatus.Information;
+ if (DeviceRelations)
+ {
+ //
+ // Use the data
+ //
+ Count = DeviceRelations->Count;
+ }
+ else
+ {
+ //
+ // We're the first
+ //
+ Count = 0;
+ }
+
+ //
+ // Now loop our drives
+ //
+ DiskCount = 0;
+ ListHead = &DeviceExtension->DiskList;
+ NextEntry = ListHead->Flink;
+ while (NextEntry != ListHead)
+ {
+ //
+ // As long as it wasn't removed, count it in
+ //
+ DriveExtension = CONTAINING_RECORD(NextEntry,
+ RAMDISK_DRIVE_EXTENSION,
+ DiskList);
+ if (DriveExtension->State < RamdiskStateBusRemoved) DiskCount++;
+
+ //
+ // Move to the next one
+ //
+ NextEntry = NextEntry->Flink;
+ }
+
+ //
+ // Now we know our final count
+ //
+ FinalCount = Count + DiskCount;
+
+ //
+ // Allocate the structure
+ //
+ OurDeviceRelations = ExAllocatePoolWithTag(PagedPool,
+ FIELD_OFFSET(DEVICE_RELATIONS,
+ Objects) +
+ FinalCount *
+ sizeof(PDEVICE_OBJECT),
+ TAG('R', 'a', 'm',
'd'));
+ if (!OurDeviceRelations)
+ {
+ //
+ // Fail
+ //
+ ExReleaseFastMutex(&DeviceExtension->DiskListLock);
+ KeLeaveCriticalRegion();
+ Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
+ IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ return STATUS_INSUFFICIENT_RESOURCES;
+ }
+
+ //
+ // Check if we already had some relations
+ //
+ if (Count)
+ {
+ //
+ // Copy them in
+ //
+ RtlCopyMemory(OurDeviceRelations->Objects,
+ DeviceRelations->Objects,
+ Count * sizeof(PDEVICE_OBJECT));
+ }
+
+ //
+ // Save the count
+ //
+ OurDeviceRelations->Count = FinalCount;
+
+ //
+ // Now loop our drives again
+ //
+ ListHead = &DeviceExtension->DiskList;
+ NextEntry = ListHead->Flink;
+ while (NextEntry != ListHead)
+ {
+ //
+ // Go to the end of the list
+ //
+ DriveDeviceObject = &OurDeviceRelations->Objects[Count];
+
+ //
+ // Get the drive state
+ //
+ DriveExtension = CONTAINING_RECORD(NextEntry,
+ RAMDISK_DRIVE_EXTENSION,
+ DiskList);
+ State = DriveExtension->State;
+
+ //
+ // If it was removed or enumerated, we don't touch the device object
+ //
+ if (State >= RamdiskStateBusRemoved)
+ {
+ //
+ // If it was removed, we still have to keep track of this though
+ //
+ if (State == RamdiskStateBusRemoved)
+ {
+ //
+ // Mark it as enumerated now, but don't actually reference it
+ //
+ DriveExtension->State = RamdiskStateEnumerated;
+ }
+ }
+ else
+ {
+ //
+ // First time it's enumerated, reference the device object
+ //
+ ObReferenceObject(DriveExtension->DeviceObject);
+
+ //
+ // Save the object pointer, and move on
+ //
+ *DriveDeviceObject++ = DriveExtension->DeviceObject;
+ }
+
+ if (DriveExtension->State < RamdiskStateBusRemoved) DiskCount++;
+
+ //
+ // Move to the next one
+ //
+ NextEntry = NextEntry->Flink;
+ }
+
+ //
+ // Release the lock
+ //
+ ExReleaseFastMutex(&DeviceExtension->DiskListLock);
+ KeLeaveCriticalRegion();
+
+ //
+ // Cleanup old relations
+ //
+ if (DeviceRelations) ExFreePool(DeviceRelations);
+
+ //
+ // Complete our IRP
+ //
+ Irp->IoStatus.Information = (ULONG_PTR)OurDeviceRelations;
+ Irp->IoStatus.Status = STATUS_SUCCESS;
+
+ //
+ // Pass to the next driver
+ //
+PassToNext:
+ IoCopyCurrentIrpStackLocationToNext(Irp);
+ return IoCallDriver(DeviceExtension->AttachedDevice, Irp);
}
NTSTATUS
@@ -811,7 +1929,7 @@
IN PIRP Irp)
{
PIO_STACK_LOCATION IoStackLocation;
- PRAMDISK_EXTENSION DeviceExtension;
+ PRAMDISK_BUS_EXTENSION DeviceExtension;
NTSTATUS Status;
UCHAR Minor;
@@ -913,9 +2031,9 @@
case IRP_MN_QUERY_ID:
//
- // Are we a PDO?
- //
- if (DeviceExtension->Type == RamdiskPdo)
+ // Are we a drive?
+ //
+ if (DeviceExtension->Type == RamdiskDrive)
{
DPRINT1("PnP IRP: %lx\n", Minor);
while (TRUE);
@@ -925,9 +2043,9 @@
case IRP_MN_QUERY_BUS_INFORMATION:
//
- // Are we a PDO?
- //
- if (DeviceExtension->Type == RamdiskPdo)
+ // Are we a drive?
+ //
+ if (DeviceExtension->Type == RamdiskDrive)
{
DPRINT1("PnP IRP: %lx\n", Minor);
while (TRUE);
@@ -943,9 +2061,9 @@
case IRP_MN_QUERY_DEVICE_TEXT:
//
- // Are we a PDO?
- //
- if (DeviceExtension->Type == RamdiskPdo)
+ // Are we a drive?
+ //
+ if (DeviceExtension->Type == RamdiskDrive)
{
DPRINT1("PnP IRP: %lx\n", Minor);
while (TRUE);
@@ -954,16 +2072,22 @@
case IRP_MN_QUERY_DEVICE_RELATIONS:
- DPRINT1("PnP IRP: %lx\n", Minor);
- while (TRUE);
- break;
+ //
+ // Call our main routine
+ //
+ Status = RamdiskQueryDeviceRelations(IoStackLocation->
+ Parameters.
+ QueryDeviceRelations.Type,
+ DeviceObject,
+ Irp);
+ goto ReleaseAndReturn;
case IRP_MN_QUERY_CAPABILITIES:
//
- // Are we a PDO?
- //
- if (DeviceExtension->Type == RamdiskPdo)
+ // Are we a drive?
+ //
+ if (DeviceExtension->Type == RamdiskDrive)
{
DPRINT1("PnP IRP: %lx\n", Minor);
while (TRUE);
@@ -986,9 +2110,9 @@
}
//
- // Are we an FDO?
- //
- if (DeviceExtension->Type == RamdiskFdo)
+ // Are we the bus?
+ //
+ if (DeviceExtension->Type == RamdiskBus)
{
//
// Do we have an attached device?
@@ -1064,23 +2188,23 @@
RamdiskAddDevice(IN PDRIVER_OBJECT DriverObject,
IN PDEVICE_OBJECT PhysicalDeviceObject)
{
- PRAMDISK_EXTENSION DeviceExtension;
+ PRAMDISK_BUS_EXTENSION DeviceExtension;
PDEVICE_OBJECT AttachedDevice;
NTSTATUS Status;
UNICODE_STRING DeviceName;
PDEVICE_OBJECT DeviceObject;
//
- // Only create the FDO once
+ // Only create the bus FDO once
//
if (RamdiskBusFdo) return STATUS_DEVICE_ALREADY_ATTACHED;
//
- // Create the FDO
+ // Create the bus FDO
//
RtlInitUnicodeString(&DeviceName, L"\\Device\\Ramdisk");
Status = IoCreateDevice(DriverObject,
- sizeof(RAMDISK_EXTENSION),
+ sizeof(RAMDISK_BUS_EXTENSION),
&DeviceName,
FILE_DEVICE_BUS_EXTENDER,
FILE_DEVICE_SECURE_OPEN,
@@ -1089,26 +2213,27 @@
if (NT_SUCCESS(Status))
{
//
- // Initialize the FDO extension
- //
- DeviceExtension = (PRAMDISK_EXTENSION)DeviceObject->DeviceExtension;
- RtlZeroMemory(DeviceObject->DeviceExtension, sizeof(RAMDISK_EXTENSION));
-
- //
- // Set FDO flags
+ // Initialize the bus FDO extension
+ //
+ DeviceExtension = DeviceObject->DeviceExtension;
+ RtlZeroMemory(DeviceObject->DeviceExtension,
+ sizeof(RAMDISK_BUS_EXTENSION));
+
+ //
+ // Set bus FDO flags
//
DeviceObject->Flags |= DO_POWER_PAGABLE | DO_DIRECT_IO;
//
- // Setup the FDO extension
- //
- DeviceExtension->Type = RamdiskFdo;
+ // Setup the bus FDO extension
+ //
+ DeviceExtension->Type = RamdiskBus;
ExInitializeFastMutex(&DeviceExtension->DiskListLock);
IoInitializeRemoveLock(&DeviceExtension->RemoveLock,
TAG('R', 'a', 'm', 'd'),
0,
1);
- InitializeListHead(&DeviceExtension->DiskListHead);
+ InitializeListHead(&DeviceExtension->DiskList);
DeviceExtension->PhysicalDeviceObject = PhysicalDeviceObject;
DeviceExtension->DeviceObject = DeviceObject;
@@ -1118,7 +2243,7 @@
Status = IoRegisterDeviceInterface(PhysicalDeviceObject,
&RamdiskBusInterface,
NULL,
- &DeviceExtension->SymbolicLinkName);
+ &DeviceExtension->BusDeviceName);
if (!NT_SUCCESS(Status))
{
//
@@ -1139,14 +2264,14 @@
//
// Fail
//
- IoSetDeviceInterfaceState(&DeviceExtension->SymbolicLinkName, 0);
- RtlFreeUnicodeString(&DeviceExtension->SymbolicLinkName);
+ IoSetDeviceInterfaceState(&DeviceExtension->BusDeviceName, 0);
+ RtlFreeUnicodeString(&DeviceExtension->BusDeviceName);
IoDeleteDevice(DeviceObject);
return STATUS_NO_SUCH_DEVICE;
}
//
- // FDO is initialized
+ // Bus FDO is initialized
//
RamdiskBusFdo = DeviceObject;
@@ -1300,7 +2425,9 @@
// the required keys when reporting a detected device.
// We hack around this ourselves.
//
-
RtlCreateUnicodeString(&((PEXTENDED_DEVOBJ_EXTENSION)PhysicalDeviceObject->DeviceObjectExtension)->DeviceNode->InstancePath,
+ RtlCreateUnicodeString(&((PEXTENDED_DEVOBJ_EXTENSION)
+ PhysicalDeviceObject->DeviceObjectExtension)
+ ->DeviceNode->InstancePath,
L"Root\\UNKNOWN\\0000");
//
Modified: branches/pierre-fsd/drivers/storage/class/ramdisk/ramdisk.rbuild
URL:
http://svn.reactos.org/svn/reactos/branches/pierre-fsd/drivers/storage/clas…
==============================================================================
--- branches/pierre-fsd/drivers/storage/class/ramdisk/ramdisk.rbuild [iso-8859-1]
(original)
+++ branches/pierre-fsd/drivers/storage/class/ramdisk/ramdisk.rbuild [iso-8859-1] Sat Nov
14 18:49:19 2009
@@ -6,4 +6,5 @@
<library>hal</library>
<file>ramdisk.c</file>
<file>ramdisk.rc</file>
+ <compilerflag>-fms-extensions</compilerflag>
</module>
Modified: branches/pierre-fsd/include/reactos/drivers/ntddrdsk.h
URL:
http://svn.reactos.org/svn/reactos/branches/pierre-fsd/include/reactos/driv…
==============================================================================
--- branches/pierre-fsd/include/reactos/drivers/ntddrdsk.h [iso-8859-1] (original)
+++ branches/pierre-fsd/include/reactos/drivers/ntddrdsk.h [iso-8859-1] Sat Nov 14
18:49:19 2009
@@ -37,6 +37,14 @@
#define FSCTL_CREATE_RAM_DISK CTL_CODE(FILE_DEVICE_VIRTUAL_DISK, 0x0000,
METHOD_BUFFERED, FILE_ANY_ACCESS)
//
+// Disk Types
+//
+#define RAMDISK_REGISTRY_DISK 1 // Loaded from the registry
+#define RAMDISK_MEMORY_MAPPED_DISK 2 // Loaded from the registry
+#define RAMDISK_BOOT_DISK 3 // Used as a boot device
+#define RAMDISK_WIM_DISK 4 // Used as an installation device
+
+//
// Options when creating a ramdisk
//
typedef struct _RAMDISK_CREATE_OPTIONS
@@ -58,8 +66,8 @@
GUID DiskGuid;
ULONG DiskType;
RAMDISK_CREATE_OPTIONS Options;
- ULONGLONG DiskLength;
- ULONG DiskOffset;
+ LARGE_INTEGER DiskLength;
+ LONG DiskOffset;
union
{
struct
Modified: branches/pierre-fsd/ntoskrnl/io/iomgr/ramdisk.c
URL:
http://svn.reactos.org/svn/reactos/branches/pierre-fsd/ntoskrnl/io/iomgr/ra…
==============================================================================
--- branches/pierre-fsd/ntoskrnl/io/iomgr/ramdisk.c [iso-8859-1] (original)
+++ branches/pierre-fsd/ntoskrnl/io/iomgr/ramdisk.c [iso-8859-1] Sat Nov 14 18:49:19 2009
@@ -83,10 +83,10 @@
//
RtlZeroMemory(&RamdiskCreate, sizeof(RamdiskCreate));
RamdiskCreate.Version = sizeof(RamdiskCreate);
- RamdiskCreate.DiskType = FILE_DEVICE_CD_ROM_FILE_SYSTEM;
+ RamdiskCreate.DiskType = RAMDISK_BOOT_DISK;
RamdiskCreate.BasePage = MemoryDescriptor->BasePage;
RamdiskCreate.DiskOffset = 0;
- RamdiskCreate.DiskLength = MemoryDescriptor->PageCount << PAGE_SHIFT;
+ RamdiskCreate.DiskLength.QuadPart = MemoryDescriptor->PageCount <<
PAGE_SHIFT;
RamdiskCreate.DiskGuid = RAMDISK_BOOTDISK_GUID;
RamdiskCreate.DriveLetter = L'C';
RamdiskCreate.Options.Fixed = TRUE;
@@ -124,7 +124,7 @@
//
// Reduce the disk length
//
- RamdiskCreate.DiskLength -= RamdiskCreate.DiskOffset;
+ RamdiskCreate.DiskLength.QuadPart -= RamdiskCreate.DiskOffset;
//
// Check for length parameter
@@ -141,7 +141,7 @@
//
// Set the offset
//
- RamdiskCreate.DiskLength = _atoi64(LengthValue + 1);
+ RamdiskCreate.DiskLength.QuadPart = _atoi64(LengthValue + 1);
}
}
}