typedef struct _RAMDISK_DRIVE_EXTENSION
{
- //
- // Inherited base class
- //
+ /* Inherited base class */
RAMDISK_EXTENSION;
- //
- // Data we get from the creator
- //
+ /* Data we get from the creator */
GUID DiskGuid;
UNICODE_STRING GuidString;
UNICODE_STRING SymbolicLinkName;
WCHAR DriveLetter;
ULONG BasePage;
- //
- // Data we get from the disk
- //
+ /* Data we get from the disk */
ULONG BytesPerSector;
ULONG SectorsPerTrack;
ULONG NumberOfHeads;
ULONG MinView, DefView, MinViewLength, DefViewLength, MaxViewLength;
RTL_QUERY_REGISTRY_TABLE QueryTable[10];
- //
- // Set defaults
- //
+ /* Set defaults */
MaximumViewLength = 0x10000000u;
MaximumPerDiskViewLength = 0x10000000u;
ReportDetectedDevice = 0;
MinimumViewLength = 0x10000u;
DefaultViewLength = 0x100000u;
- //
- // Setup the query table and query the registry
- //
+ /* Setup the query table and query the registry */
RtlZeroMemory(QueryTable, sizeof(QueryTable));
QueryTable[0].Flags = 1;
QueryTable[0].Name = L"Parameters";
NULL,
NULL);
- //
- // Parse minimum view count, cannot be bigger than 256 or smaller than 2
- //
+ /* Parse minimum view count, cannot be bigger than 256 or smaller than 2 */
MinView = MinimumViewCount;
if (MinimumViewCount >= 2)
{
}
MinimumViewCount = MinView;
- //
- // Parse default view count, cannot be bigger than 256 or smaller than minimum
- //
+ /* Parse default view count, cannot be bigger than 256 or smaller than minimum */
DefView = DefaultViewCount;
if (DefaultViewCount >= MinView)
{
}
DefaultViewCount = DefView;
- //
- // Parse maximum view count, cannot be bigger than 256 or smaller than default
- //
+ /* Parse maximum view count, cannot be bigger than 256 or smaller than default */
if (MaximumViewCount >= DefView)
{
if (MaximumViewCount > 256) MaximumViewCount = 256;
MaximumViewCount = DefView;
}
- //
- // Parse minimum view length, cannot be bigger than 1GB or smaller than 64KB
- //
+ /* Parse minimum view length, cannot be bigger than 1GB or smaller than 64KB */
MinViewLength = MinimumViewLength;
if (MinimumViewLength >= 0x10000)
{
}
MinimumViewLength = MinViewLength;
- //
- // Parse default view length, cannot be bigger than 1GB or smaller than minimum
- //
+ /* Parse default view length, cannot be bigger than 1GB or smaller than minimum */
DefViewLength = DefaultViewLength;
if (DefaultViewLength >= MinViewLength)
{
}
DefaultViewLength = DefViewLength;
- //
- // Parse maximum view length, cannot be bigger than 1GB or smaller than default
- //
+ /* Parse maximum view length, cannot be bigger than 1GB or smaller than default */
MaxViewLength = MaximumViewLength;
if (MaximumViewLength >= DefViewLength)
{
}
MaximumViewLength = MaxViewLength;
- //
- // Parse maximum view length per disk, cannot be smaller than 16MB
- //
+ /* Parse maximum view length per disk, cannot be smaller than 16MB */
if (MaximumPerDiskViewLength >= 0x1000000)
{
if (MaxViewLength > 0xFFFFFFFF) MaximumPerDiskViewLength = -1;
LARGE_INTEGER ActualOffset;
LARGE_INTEGER ActualPages;
- //
- // We only support boot disks for now
- //
+ /* We only support boot disks for now */
ASSERT(DeviceExtension->DiskType == RAMDISK_BOOT_DISK);
- //
- // Calculate the actual offset in the drive
- //
+ /* Calculate the actual offset in the drive */
ActualOffset.QuadPart = DeviceExtension->DiskOffset + Offset.QuadPart;
- //
- // Convert to pages
- //
+ /* Convert to pages */
ActualPages.QuadPart = ActualOffset.QuadPart >> PAGE_SHIFT;
- //
- // Now add the base page
- //
+ /* Now add the base page */
ActualPages.QuadPart = DeviceExtension->BasePage + ActualPages.QuadPart;
- //
- // Calculate final amount of bytes
- //
+ /* Calculate final amount of bytes */
PhysicalAddress.QuadPart = ActualPages.QuadPart << PAGE_SHIFT;
- //
- // Calculate pages spanned for the mapping
- //
+ /* Calculate pages spanned for the mapping */
ActualLength = ADDRESS_AND_SIZE_TO_SPAN_PAGES(ActualOffset.QuadPart, Length);
- //
- // And convert this back to bytes
- //
+ /* And convert this back to bytes */
ActualLength <<= PAGE_SHIFT;
- //
- // Get the offset within the page
- //
+ /* Get the offset within the page */
PageOffset = BYTE_OFFSET(ActualOffset.QuadPart);
- //
- // Map the I/O Space from the loader
- //
+ /* Map the I/O Space from the loader */
MappedBase = MmMapIoSpace(PhysicalAddress, ActualLength, MmCached);
- //
- // Return actual offset within the page as well as the length
- //
+ /* Return actual offset within the page as well as the length */
if (MappedBase) MappedBase = (PVOID)((ULONG_PTR)MappedBase + PageOffset);
*OutputLength = Length;
return MappedBase;
SIZE_T ActualLength;
ULONG PageOffset;
- //
- // We only support boot disks for now
- //
+ /* We only support boot disks for now */
ASSERT(DeviceExtension->DiskType == RAMDISK_BOOT_DISK);
- //
- // Calculate the actual offset in the drive
- //
+ /* Calculate the actual offset in the drive */
ActualOffset.QuadPart = DeviceExtension->DiskOffset + Offset.QuadPart;
- //
- // Calculate pages spanned for the mapping
- //
+ /* Calculate pages spanned for the mapping */
ActualLength = ADDRESS_AND_SIZE_TO_SPAN_PAGES(ActualOffset.QuadPart, Length);
- //
- // And convert this back to bytes
- //
+ /* And convert this back to bytes */
ActualLength <<= PAGE_SHIFT;
- //
- // Get the offset within the page
- //
+ /* Get the offset within the page */
PageOffset = BYTE_OFFSET(ActualOffset.QuadPart);
- //
- // Calculate actual base address where we mapped this
- //
+ /* Calculate actual base address where we mapped this */
BaseAddress = (PVOID)((ULONG_PTR)BaseAddress - PageOffset);
- //
- // Unmap the I/O space we got from the loader
- //
+ /* Unmap the I/O space we got from the loader */
MmUnmapIoSpace(BaseAddress, ActualLength);
}
LARGE_INTEGER CurrentOffset, CylinderSize, DiskLength;
ULONG CylinderCount, SizeByCylinders;
- //
- // Check if we're a boot RAM disk
- //
+ /* Check if we're a boot RAM disk */
DiskType = Input->DiskType;
if (DiskType >= RAMDISK_BOOT_DISK)
{
- //
- // Check if we're an ISO
- //
+ /* Check if we're an ISO */
if (DiskType == RAMDISK_BOOT_DISK)
{
- //
- // NTLDR mounted us somewhere
- //
+ /* NTLDR mounted us somewhere */
BasePage = Input->BasePage;
if (!BasePage) return STATUS_INVALID_PARAMETER;
- //
- // Sanitize disk options
- //
+ /* Sanitize disk options */
Input->Options.Fixed = TRUE;
Input->Options.Readonly = Input->Options.ExportAsCd |
Input->Options.Readonly;
}
else
{
- //
- // The only other possibility is a WIM disk
- //
+ /* The only other possibility is a WIM disk */
if (DiskType != RAMDISK_WIM_DISK)
{
- //
- // Fail
- //
+ /* Fail */
return STATUS_INVALID_PARAMETER;
}
- //
- // Read the view count instead
- //
+ /* Read the view count instead */
// ViewCount = Input->ViewCount;
- //
- // Sanitize disk options
- //
+ /* Sanitize disk options */
Input->Options.Hidden = FALSE;
Input->Options.NoDosDevice = FALSE;
Input->Options.Readonly = FALSE;
Input->Options.Fixed = TRUE;
}
- //
- // Are we just validating and returning to the user?
- //
+ /* Are we just validating and returning to the user? */
if (ValidateOnly) return STATUS_SUCCESS;
- //
- // Build the GUID string
- //
+ /* Build the GUID string */
Status = RtlStringFromGUID(&Input->DiskGuid, &GuidString);
if (!(NT_SUCCESS(Status)) || !(GuidString.Buffer))
{
- //
- // Fail
- //
+ /* Fail */
Status = STATUS_INSUFFICIENT_RESOURCES;
goto FailCreate;
}
- //
- // Allocate our device name
- //
+ /* Allocate our device name */
Length = GuidString.Length + 32;
- Buffer = ExAllocatePoolWithTag(NonPagedPool,
- Length,
- 'dmaR');
+ Buffer = ExAllocatePoolWithTag(NonPagedPool, Length, 'dmaR');
if (!Buffer)
{
- //
- // Fail
- //
+ /* Fail */
Status = STATUS_INSUFFICIENT_RESOURCES;
goto FailCreate;
}
- //
- // Build the device name string
- //
+ /* 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
- //
+ /* Create the drive device */
Status = IoCreateDevice(DeviceExtension->DeviceObject->DriverObject,
sizeof(RAMDISK_DRIVE_EXTENSION),
&DeviceName,
&DeviceObject);
if (!NT_SUCCESS(Status)) goto FailCreate;
- //
- // Grab the drive extension
- //
+ /* Grab the drive extension */
DriveExtension = DeviceObject->DeviceExtension;
- //
- // Check if we need a DOS device
- //
+ /* Check if we need a DOS device */
if (!Input->Options.NoDosDevice)
{
- //
- // Build the symbolic link name
- //
+ /* Build the symbolic link name */
SymbolicLinkName.MaximumLength = GuidString.Length + 36;
SymbolicLinkName.Length = GuidString.Length + 34;
Buffer = ExAllocatePoolWithTag(NonPagedPool,
SymbolicLinkName.Buffer = Buffer;
if (Buffer)
{
- //
- // Create it
- //
+ /* Create it */
wcsncpy(Buffer,
L"\\GLOBAL??\\Ramdisk",
SymbolicLinkName.MaximumLength / sizeof(WCHAR));
Status = IoCreateSymbolicLink(&SymbolicLinkName, &DeviceName);
if (!NT_SUCCESS(Status))
{
- //
- // Nevermind...
- //
+ /* Nevermind... */
Input->Options.NoDosDevice = TRUE;
ExFreePool(Buffer);
SymbolicLinkName.Buffer = NULL;
}
else
{
- //
- // No DOS device
- //
+ /* No DOS device */
Input->Options.NoDosDevice = TRUE;
}
- //
- // It this an ISO boot ramdisk?
- //
+ /* Is this an ISO boot ramdisk? */
if (Input->DiskType == RAMDISK_BOOT_DISK)
{
- //
- // Does it need a drive letter?
- //
+ /* Does it need a drive letter? */
if (!Input->Options.NoDriveLetter)
{
- //
- // Build it and take over the existing symbolic link
- //
+ /* Build it and take over the existing symbolic link */
_snwprintf(LocalBuffer,
30,
L"\\DosDevices\\%wc:",
IoDeleteSymbolicLink(&DriveString);
IoCreateSymbolicLink(&DriveString, &DeviceName);
- //
- // Save the drive letter
- //
+ /* Save the drive letter */
DriveExtension->DriveLetter = Input->DriveLetter;
}
}
}
- //
- // Setup the device object flags
- //
+ /* Setup the device object flags */
DeviceObject->Flags |= (DO_XIP | DO_POWER_PAGABLE | DO_DIRECT_IO);
DeviceObject->AlignmentRequirement = 1;
- //
- // Build the drive FDO
- //
+ /* Build the drive FDO */
*NewDriveExtension = DriveExtension;
DriveExtension->Type = RamdiskDrive;
DiskLength = Input->DiskLength;
ExInitializeFastMutex(&DriveExtension->DiskListLock);
- IoInitializeRemoveLock(&DriveExtension->RemoveLock,
- 'dmaR',
- 1,
- 0);
+ IoInitializeRemoveLock(&DriveExtension->RemoveLock, 'dmaR', 1, 0);
DriveExtension->DriveDeviceName = DeviceName;
DriveExtension->SymbolicLinkName = SymbolicLinkName;
DriveExtension->GuidString = GuidString;
DriveExtension->SectorsPerTrack = 0;
DriveExtension->NumberOfHeads = 0;
- //
- // Make sure we don't free it later
- //
+ /* 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
- //
+ /* Check if this is a 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
- //
+ /* 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,
&BytesRead);
if (BaseAddress)
{
- //
- // Get the data
- //
+ /* Get the data */
BootSector = (PPACKED_BOOT_SECTOR)BaseAddress;
FatUnpackBios(&BiosBlock, &BootSector->PackedBpb);
BytesPerSector = BiosBlock.BytesPerSector;
SectorsPerTrack = BiosBlock.SectorsPerTrack;
Heads = BiosBlock.Heads;
- //
- // Save it
- //
+ /* Save it */
DriveExtension->BytesPerSector = BytesPerSector;
DriveExtension->SectorsPerTrack = SectorsPerTrack;
DriveExtension->NumberOfHeads = Heads;
- //
- // Unmap now
- //
+ /* Unmap now */
CurrentOffset.QuadPart = 0;
RamdiskUnmapPages(DriveExtension,
BaseAddress,
}
else
{
- //
- // Fail
- //
+ /* Fail */
Status = STATUS_INSUFFICIENT_RESOURCES;
goto FailCreate;
}
}
- //
- // Check if the drive settings haven't been set yet
- //
+ /* 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
- //
+ /* Check if this is a CD */
if (Input->Options.ExportAsCd)
{
- //
- // Setup partition parameters default for ISO 9660
- //
+ /* Setup partition parameters default for ISO 9660 */
DriveExtension->BytesPerSector = 2048;
DriveExtension->SectorsPerTrack = 32;
DriveExtension->NumberOfHeads = 64;
}
else
{
- //
- // Setup partition parameters default for FAT
- //
+ /* Setup partition parameters default for FAT */
DriveExtension->BytesPerSector = 512;
DriveExtension->SectorsPerTrack = 128;
DriveExtension->NumberOfHeads = 16;
}
}
- //
- // Calculate the cylinder size
- //
+ /* Calculate the cylinder size */
CylinderSize.QuadPart = DriveExtension->BytesPerSector *
DriveExtension->SectorsPerTrack *
DriveExtension->NumberOfHeads;
DriveExtension->Cylinders = CylinderCount;
if ((DiskLength.HighPart > 0) || (SizeByCylinders < DiskLength.LowPart))
{
- //
- // Align cylinder size up
- //
+ /* Align cylinder size up */
DriveExtension->Cylinders++;
}
- //
- // Acquire the disk lock
- //
+ /* Acquire the disk lock */
KeEnterCriticalRegion();
ExAcquireFastMutex(&DeviceExtension->DiskListLock);
- //
- // Insert us
- //
+ /* Insert us */
InsertTailList(&DeviceExtension->DiskList, &DriveExtension->DiskList);
- //
- // Release the lock
- //
+ /* Release the lock */
ExReleaseFastMutex(&DeviceExtension->DiskListLock);
KeLeaveCriticalRegion();
- //
- // Clear init flag
- //
+ /* Clear init flag */
DeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
return STATUS_SUCCESS;
}
NTSTATUS Status;
PIO_STACK_LOCATION IoStackLocation = IoGetCurrentIrpStackLocation(Irp);
- //
- // Get the device extension and our input data
- //
+ /* Get the device extension and our input data */
DeviceExtension = DeviceObject->DeviceExtension;
Length = IoStackLocation->Parameters.DeviceIoControl.InputBufferLength;
Input = (PRAMDISK_CREATE_INPUT)Irp->AssociatedIrp.SystemBuffer;
- //
- // Validate input parameters
- //
+ /* Validate input parameters */
if ((Length < sizeof(RAMDISK_CREATE_INPUT)) ||
(Input->Version != sizeof(RAMDISK_CREATE_INPUT)))
{
- //
- // Invalid input
- //
return STATUS_INVALID_PARAMETER;
}
- //
- // Validate the disk type
- //
+ /* Validate the disk type */
DiskType = Input->DiskType;
if (DiskType == RAMDISK_WIM_DISK) return STATUS_INVALID_PARAMETER;
- //
- // Look at the disk type
- //
+ /* Look at the disk type */
if (DiskType == RAMDISK_BOOT_DISK)
{
- //
- // We only allow this as an early-init boot
- //
+ /* We only allow this as an early-init boot */
if (!KeLoaderBlock) return STATUS_INVALID_PARAMETER;
- //
- // Save command-line flags
- //
+ /* Save command-line flags */
if (ExportBootDiskAsCd) Input->Options.ExportAsCd = TRUE;
if (IsWinPEBoot) Input->Options.NoDriveLetter = TRUE;
}
- //
- // Validate the disk type
- //
+ /* Validate the disk type */
if ((Input->Options.ExportAsCd) && (DiskType != RAMDISK_BOOT_DISK))
{
- //
- // If the type isn't CDFS, it has to at least be raw CD
- //
+ /* If the type isn't CDFS, it has to at least be raw CD */
if (DiskType != RAMDISK_MEMORY_MAPPED_DISK) return STATUS_INVALID_PARAMETER;
}
- //
- // Check if this is an actual file
- //
+ /* Check if this is an actual file */
if (DiskType <= RAMDISK_MEMORY_MAPPED_DISK)
{
- //
- // Validate the file name
- //
+ /* Validate the file name */
FileNameStart = (PWCHAR)((ULONG_PTR)Input + Length);
FileNameEnd = Input->FileName + 1;
while ((FileNameEnd < FileNameStart) && *(FileNameEnd)) FileNameEnd++;
if (FileNameEnd == FileNameStart) return STATUS_INVALID_PARAMETER;
}
- //
- // Create the actual device
- //
+ /* Create the actual device */
Status = RamdiskCreateDiskDevice(DeviceExtension,
Input,
ValidateOnly,
&DriveExtension);
if (NT_SUCCESS(Status))
{
- //
- // Invalidate and set success
- //
+ /* Invalidate and set success */
IoInvalidateDeviceRelations(DeviceExtension->PhysicalDeviceObject, 0);
Irp->IoStatus.Information = STATUS_SUCCESS;
}
- //
- // We're done
- //
+ /* We're done */
return Status;
}
ULONG Length;
PIO_STACK_LOCATION IoStackLocation;
- //
- // Validate the length
- //
+ /* Validate the length */
IoStackLocation = IoGetCurrentIrpStackLocation(Irp);
if (IoStackLocation->Parameters.DeviceIoControl.
OutputBufferLength < sizeof(PARTITION_INFORMATION))
{
- //
- // Invalid length
- //
+ /* Invalid length */
Status = STATUS_BUFFER_TOO_SMALL;
Irp->IoStatus.Status = Status;
Irp->IoStatus.Information = 0;
return Status;
}
- //
- // Map the partition table
- //
+ /* Map the partition table */
BaseAddress = RamdiskMapPages(DeviceExtension, Zero, PAGE_SIZE, &Length);
if (!BaseAddress)
{
- //
- // No memory
- //
+ /* No memory */
Status = STATUS_INSUFFICIENT_RESOURCES;
Irp->IoStatus.Status = Status;
Irp->IoStatus.Information = 0;
return Status;
}
- //
- // Fill out the information
- //
+ /* Fill out the information */
PartitionInfo = Irp->AssociatedIrp.SystemBuffer;
PartitionInfo->StartingOffset.QuadPart = DeviceExtension->BytesPerSector;
PartitionInfo->PartitionLength.QuadPart = DeviceExtension->BytesPerSector *
PartitionType);
PartitionInfo->RewritePartition = FALSE;
- //
- // Unmap the partition table
- //
+ /* Unmap the partition table */
RamdiskUnmapPages(DeviceExtension, BaseAddress, Zero, Length);
- //
- // Done
- //
+ /* Done */
Irp->IoStatus.Status = STATUS_SUCCESS;
Irp->IoStatus.Information = sizeof(PARTITION_INFORMATION);
return STATUS_SUCCESS;
LARGE_INTEGER Zero = {{0, 0}};
PPARTITION_INFORMATION PartitionInfo;
- //
- // First validate input
- //
+ /* First validate input */
Stack = IoGetCurrentIrpStackLocation(Irp);
if (Stack->Parameters.DeviceIoControl.InputBufferLength < sizeof(PARTITION_INFORMATION))
{
goto SetAndQuit;
}
- //
- // Map to get MBR
- //
+ /* Map to get MBR */
BaseAddress = RamdiskMapPages(DeviceExtension, Zero, PAGE_SIZE, &BytesRead);
if (BaseAddress == NULL)
{
goto SetAndQuit;
}
- //
- // Set the new partition type
- // On partition 0, field system indicator
- //
+ /* Set the new partition type on partition 0, field system indicator */
PartitionInfo = (PPARTITION_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
*((PCHAR)BaseAddress + 450) = PartitionInfo->PartitionType;
- //
- // And unmap
- //
+ /* And unmap */
RamdiskUnmapPages(DeviceExtension, BaseAddress, Zero, BytesRead);
Status = STATUS_SUCCESS;
PIO_STACK_LOCATION IoStackLocation;
PIRP Irp = Context;
- //
- // Get the stack location
- //
+ /* Get the stack location */
IoStackLocation = IoGetCurrentIrpStackLocation(Irp);
- //
- // Free the work item
- //
+ /* Free the work item */
IoFreeWorkItem(Irp->Tail.Overlay.DriverContext[0]);
- //
- // Grab the device extension and lock it
- //
+ /* Grab the device extension and lock it */
DeviceExtension = DeviceObject->DeviceExtension;
Status = IoAcquireRemoveLock(&DeviceExtension->RemoveLock, Irp);
if (NT_SUCCESS(Status))
{
- //
- // Discriminate by major code
- //
+ /* Discriminate by major code */
switch (IoStackLocation->MajorFunction)
{
- //
- // Device control
- //
+ /* Device control */
case IRP_MJ_DEVICE_CONTROL:
{
- //
- // Let's take a look at the IOCTL
- //
+ /* Let's take a look at the IOCTL */
switch (IoStackLocation->Parameters.DeviceIoControl.IoControlCode)
{
- //
- // Ramdisk create request
- //
+ /* Ramdisk create request */
case FSCTL_CREATE_RAM_DISK:
{
- //
- // This time we'll do it for real
- //
+ /* This time we'll do it for real */
Status = RamdiskCreateRamdisk(DeviceObject, Irp, FALSE);
break;
}
break;
}
- //
- // We're here
- //
+ /* We're here */
break;
}
- //
- // Read or write request
- //
+ /* Read or write request */
case IRP_MJ_READ:
case IRP_MJ_WRITE:
UNIMPLEMENTED_DBGBREAK("Read/Write request\n");
break;
- //
- // Internal request (SCSI?)
- //
+ /* Internal request (SCSI?) */
case IRP_MJ_INTERNAL_DEVICE_CONTROL:
UNIMPLEMENTED_DBGBREAK("SCSI request\n");
break;
- //
- // Flush request
- //
+ /* Flush request */
case IRP_MJ_FLUSH_BUFFERS:
UNIMPLEMENTED_DBGBREAK("Flush request\n");
break;
- //
- // Anything else
- //
+ /* Anything else */
default:
- UNIMPLEMENTED_DBGBREAK("Invalid request: %lx\n", IoStackLocation->MajorFunction);
+ UNIMPLEMENTED_DBGBREAK("Invalid request: %lx\n",
+ IoStackLocation->MajorFunction);
break;
}
- //
- // Complete the I/O
- //
+ /* Complete the I/O */
IoReleaseRemoveLock(&DeviceExtension->RemoveLock, Irp);
Irp->IoStatus.Status = Status;
Irp->IoStatus.Information = 0;
return;
}
- //
- // Fail the I/O
- //
+ /* Fail the I/O */
Irp->IoStatus.Status = Status;
Irp->IoStatus.Information = 0;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
{
PIO_WORKITEM WorkItem;
- //
- // Mark the IRP pending
- //
+ /* Mark the IRP pending */
IoMarkIrpPending(Irp);
- //
- // Allocate a work item
- //
+ /* Allocate a work item */
WorkItem = IoAllocateWorkItem(DeviceObject);
if (WorkItem)
{
- //
- // Queue it up
- //
+ /* Queue it up */
Irp->Tail.Overlay.DriverContext[0] = WorkItem;
IoQueueWorkItem(WorkItem, RamdiskWorkerThread, DelayedWorkQueue, Irp);
return STATUS_PENDING;
}
else
{
- //
- // Fail
- //
+ /* Fail */
return STATUS_INSUFFICIENT_RESOURCES;
}
}
PVOID Source, Destination;
NTSTATUS Status;
- //
- // Get the MDL and check if it's mapped
- //
+ /* Get the MDL and check if it's mapped */
Mdl = Irp->MdlAddress;
if (Mdl->MdlFlags & (MDL_MAPPED_TO_SYSTEM_VA | MDL_SOURCE_IS_NONPAGED_POOL))
{
- //
- // Use the mapped address
- //
+ /* Use the mapped address */
SystemVa = Mdl->MappedSystemVa;
}
else
{
- //
- // Map it ourselves
- //
+ /* Map it ourselves */
SystemVa = MmMapLockedPagesSpecifyCache(Mdl,
0,
MmCached,
NormalPagePriority);
}
- //
- // Make sure we were able to map it
- //
+ /* Make sure we were able to map it */
CurrentBase = SystemVa;
if (!SystemVa) return STATUS_INSUFFICIENT_RESOURCES;
- //
- // Initialize default
- //
+ /* Initialize default */
Irp->IoStatus.Information = 0;
- //
- // Get the I/O Stack Location and capture the data
- //
+ /* Get the I/O Stack Location and capture the data */
IoStackLocation = IoGetCurrentIrpStackLocation(Irp);
CurrentOffset = IoStackLocation->Parameters.Read.ByteOffset;
BytesLeft = IoStackLocation->Parameters.Read.Length;
if (!BytesLeft) return STATUS_INVALID_PARAMETER;
- //
- // Do the copy loop
- //
+ /* Do the copy loop */
while (TRUE)
{
- //
- // Map the pages
- //
+ /* Map the pages */
BaseAddress = RamdiskMapPages(DeviceExtension,
CurrentOffset,
BytesLeft,
&BytesRead);
if (!BaseAddress) return STATUS_INSUFFICIENT_RESOURCES;
- //
- // Update our lengths
- //
+ /* Update our lengths */
Irp->IoStatus.Information += BytesRead;
CopyLength = BytesRead;
- //
- // Check if this was a read or write
- //
+ /* Check if this was a read or write */
Status = STATUS_SUCCESS;
if (IoStackLocation->MajorFunction == IRP_MJ_READ)
{
- //
- // Set our copy parameters
- //
+ /* Set our copy parameters */
Destination = CurrentBase;
Source = BaseAddress;
goto DoCopy;
}
else if (IoStackLocation->MajorFunction == IRP_MJ_WRITE)
{
- //
- // Set our copy parameters
- //
+ /* Set our copy parameters */
Destination = BaseAddress;
Source = CurrentBase;
DoCopy:
- //
- // Copy the data
- //
+ /* Copy the data */
RtlCopyMemory(Destination, Source, CopyLength);
}
else
{
- //
- // Prepare us for failure
- //
+ /* Prepare us for failure */
BytesLeft = CopyLength;
Status = STATUS_INVALID_PARAMETER;
}
- //
- // Unmap the pages
- //
- RamdiskUnmapPages(DeviceExtension,
- BaseAddress,
- CurrentOffset,
- BytesRead);
-
- //
- // Update offset and bytes left
- //
+ /* Unmap the pages */
+ RamdiskUnmapPages(DeviceExtension, BaseAddress, CurrentOffset, BytesRead);
+
+ /* Update offset and bytes left */
BytesLeft -= BytesRead;
CurrentOffset.QuadPart += BytesRead;
CurrentBase = (PVOID)((ULONG_PTR)CurrentBase + BytesRead);
- //
- // Check if we're done
- //
+ /* Check if we're done */
if (!BytesLeft) return Status;
}
}
RamdiskOpenClose(IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
{
- //
- // Complete the IRP
- //
+ /* Complete the IRP */
Irp->IoStatus.Information = 1;
Irp->IoStatus.Status = STATUS_SUCCESS;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
IN PIRP Irp)
{
PRAMDISK_DRIVE_EXTENSION DeviceExtension;
- // ULONG Length;
- // LARGE_INTEGER ByteOffset;
+ //ULONG Length;
+ //LARGE_INTEGER ByteOffset;
PIO_STACK_LOCATION IoStackLocation;
NTSTATUS Status, ReturnStatus;
- //
- // Get the device extension and make sure this isn't a bus
- //
+ /* Get the device extension and make sure this isn't a bus */
DeviceExtension = DeviceObject->DeviceExtension;
if (DeviceExtension->Type == RamdiskBus)
{
- //
- // Fail
- //
+ /* Fail */
Status = STATUS_INVALID_DEVICE_REQUEST;
goto Complete;
}
- //
- // Capture parameters
- //
+ /* Capture parameters */
IoStackLocation = IoGetCurrentIrpStackLocation(Irp);
- // Length = IoStackLocation->Parameters.Read.Length;
- // ByteOffset = IoStackLocation->Parameters.Read.ByteOffset;
+ //Length = IoStackLocation->Parameters.Read.Length;
+ //ByteOffset = IoStackLocation->Parameters.Read.ByteOffset;
- //
- // FIXME: Validate offset
- //
+ /* FIXME: Validate offset */
- //
- // FIXME: Validate sector
- //
+ /* FIXME: Validate sector */
- //
- // Validate write
- //
+ /* Validate write */
if ((IoStackLocation->MajorFunction == IRP_MJ_WRITE) &&
(DeviceExtension->DiskOptions.Readonly))
{
- //
- // Fail, this is read-only
- //
+ /* Fail, this is read-only */
Status = STATUS_MEDIA_WRITE_PROTECTED;
goto Complete;
}
- //
- // See if we want to do this sync or async
- //
+ /* See if we want to do this sync or async */
if (DeviceExtension->DiskType > RAMDISK_MEMORY_MAPPED_DISK)
{
- //
- // Do it sync
- //
+ /* Do it sync */
Status = RamdiskReadWriteReal(Irp, DeviceExtension);
goto Complete;
}
- //
- // Queue it to the worker
- //
+ /* Queue it to the worker */
Status = SendIrpToThread(DeviceObject, Irp);
ReturnStatus = STATUS_PENDING;
- //
- // Check if we're pending or not
- //
+ /* Check if we're pending or not */
if (Status != STATUS_PENDING)
{
Complete:
- //
- // Complete the IRP
- //
+ /* Complete the IRP */
Irp->IoStatus.Status = Status;
IoCompleteRequest(Irp, IO_DISK_INCREMENT);
ReturnStatus = Status;
}
- //
- // Return to caller
- //
+ /* Return to caller */
return ReturnStatus;
}
PCDROM_TOC Toc;
PDISK_GEOMETRY DiskGeometry;
- //
- // Grab the remove lock
- //
+ /* Grab the remove lock */
Status = IoAcquireRemoveLock(&DeviceExtension->RemoveLock, Irp);
if (!NT_SUCCESS(Status))
{
- //
- // Fail the IRP
- //
+ /* Fail the IRP */
Irp->IoStatus.Information = 0;
Irp->IoStatus.Status = Status;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return Status;
}
- //
- // Setup some defaults
- //
+ /* Setup some defaults */
Status = STATUS_INVALID_DEVICE_REQUEST;
Information = 0;
- //
- // Check if this is an bus device or the drive
- //
+ /* Check if this is an bus device or the drive */
if (DeviceExtension->Type == RamdiskBus)
{
- //
- // Check what the request is
- //
+ /* Check what the request is */
switch (IoStackLocation->Parameters.DeviceIoControl.IoControlCode)
{
- //
- // Request to create a ramdisk
- //
+ /* Request to create a ramdisk */
case FSCTL_CREATE_RAM_DISK:
{
- //
- // Do it
- //
+ /* Do it */
Status = RamdiskCreateRamdisk(DeviceObject, Irp, TRUE);
if (!NT_SUCCESS(Status)) goto CompleteRequest;
break;
default:
{
- //
- // We don't handle anything else yet
- //
- UNIMPLEMENTED_DBGBREAK("FSCTL: 0x%lx is UNSUPPORTED!\n", IoStackLocation->Parameters.DeviceIoControl.IoControlCode);
+ /* We don't handle anything else yet */
+ UNIMPLEMENTED_DBGBREAK("FSCTL: 0x%lx is UNSUPPORTED!\n",
+ IoStackLocation->Parameters.DeviceIoControl.IoControlCode);
}
}
}
else
{
- //
- // Check what the request is
- //
+ /* Check what the request is */
switch (IoStackLocation->Parameters.DeviceIoControl.IoControlCode)
{
case IOCTL_DISK_CHECK_VERIFY:
case IOCTL_STORAGE_CHECK_VERIFY2:
case IOCTL_CDROM_CHECK_VERIFY:
{
- //
- // Just pretend it's OK, don't do more
- //
+ /* Just pretend it's OK, don't do more */
Status = STATUS_SUCCESS;
break;
}
case IOCTL_DISK_GET_DRIVE_GEOMETRY:
case IOCTL_CDROM_GET_DRIVE_GEOMETRY:
{
- //
- // Validate the length
- //
+ /* Validate the length */
if (IoStackLocation->Parameters.DeviceIoControl.
OutputBufferLength < sizeof(DISK_GEOMETRY))
{
- //
- // Invalid length
- //
+ /* Invalid length */
Status = STATUS_BUFFER_TOO_SMALL;
break;
}
- //
- // Fill it out
- //
+ /* Fill it out */
DiskGeometry = Irp->AssociatedIrp.SystemBuffer;
DiskGeometry->Cylinders.QuadPart = DriveExtension->Cylinders;
DiskGeometry->BytesPerSector = DriveExtension->BytesPerSector;
DiskGeometry->MediaType = DriveExtension->DiskOptions.Fixed ?
FixedMedia : RemovableMedia;
- //
- // We're done
- //
+ /* We're done */
Status = STATUS_SUCCESS;
Information = sizeof(DISK_GEOMETRY);
break;
case IOCTL_CDROM_READ_TOC:
{
- //
- // Validate the length
- //
+ /* Validate the length */
if (IoStackLocation->Parameters.DeviceIoControl.
OutputBufferLength < sizeof(CDROM_TOC))
{
- //
- // Invalid length
- //
+ /* Invalid length */
Status = STATUS_BUFFER_TOO_SMALL;
break;
}
- //
- // Clear the TOC
- //
+ /* Clear the TOC */
Toc = Irp->AssociatedIrp.SystemBuffer;
RtlZeroMemory(Toc, sizeof(CDROM_TOC));
- //
- // Fill it out
- //
+ /* Fill it out */
Toc->Length[0] = 0;
Toc->Length[1] = RAMDISK_TOC_SIZE - sizeof(Toc->Length);
Toc->FirstTrack = 1;
Toc->TrackData[0].Control = TOC_DATA_TRACK;
Toc->TrackData[0].TrackNumber = 1;
- //
- // We're done
- //
+ /* We're done */
Status = STATUS_SUCCESS;
Information = RAMDISK_TOC_SIZE;
break;
case IOCTL_DISK_GET_PARTITION_INFO:
{
- //
- // Validate the length
- //
+ /* Validate the length */
if (IoStackLocation->Parameters.DeviceIoControl.
OutputBufferLength < sizeof(PARTITION_INFORMATION))
{
- //
- // Invalid length
- //
+ /* Invalid length */
Status = STATUS_BUFFER_TOO_SMALL;
break;
}
- //
- // Check if we need to do this sync or async
- //
+ /* Check if we need to do this sync or async */
if (DriveExtension->DiskType > RAMDISK_MEMORY_MAPPED_DISK)
{
- //
- // Call the helper function
- //
+ /* Call the helper function */
Status = RamdiskGetPartitionInfo(Irp, DriveExtension);
}
else
{
- //
- // Do it asynchronously later
- //
+ /* Do it asynchronously later */
goto CallWorker;
}
- //
- // We're done
- //
+ /* We're done */
Information = Irp->IoStatus.Information;
break;
}
case IOCTL_VOLUME_GET_GPT_ATTRIBUTES:
case IOCTL_VOLUME_OFFLINE:
{
- UNIMPLEMENTED_DBGBREAK("IOCTL: 0x%lx is UNIMPLEMENTED!\n", IoStackLocation->Parameters.DeviceIoControl.IoControlCode);
+ UNIMPLEMENTED_DBGBREAK("IOCTL: 0x%lx is UNIMPLEMENTED!\n",
+ IoStackLocation->Parameters.DeviceIoControl.IoControlCode);
break;
}
default:
{
- //
- // Drive code not emulated
- //
- DPRINT1("IOCTL: 0x%lx is UNSUPPORTED!\n", IoStackLocation->Parameters.DeviceIoControl.IoControlCode);
+ /* Drive code not emulated */
+ DPRINT1("IOCTL: 0x%lx is UNSUPPORTED!\n",
+ IoStackLocation->Parameters.DeviceIoControl.IoControlCode);
break;
}
}
- //
- // If requests drop down here, we just return them complete them
- //
+ /* If requests drop down here, we just return them complete them */
goto CompleteRequest;
}
- //
- // Queue the request to our worker thread
- //
+ /* Queue the request to our worker thread */
CallWorker:
Status = SendIrpToThread(DeviceObject, Irp);
CompleteRequest:
- //
- // Release the lock
- //
+ /* Release the lock */
IoReleaseRemoveLock(&DeviceExtension->RemoveLock, Irp);
if (Status != STATUS_PENDING)
{
- //
- // Complete the request
- //
+ /* Complete the request */
Irp->IoStatus.Status = Status;
Irp->IoStatus.Information = Information;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
}
- //
- // Return status
- //
+ /* Return status */
return Status;
}
PDEVICE_OBJECT* DriveDeviceObject;
RAMDISK_DEVICE_STATE State;
- //
- // Get the device extension and check if this is a drive
- //
+ /* Get the device extension and check if this is a drive */
DeviceExtension = DeviceObject->DeviceExtension;
if (DeviceExtension->Type == RamdiskDrive)
{
NTSTATUS Status;
PDEVICE_RELATIONS DeviceRelations;
- //
- // We're a child device, only handle target device relations
- //
+ /* We're a child device, only handle target device relations */
if (Type != TargetDeviceRelation)
{
Status = Irp->IoStatus.Status;
return Status;
}
- //
- // Allocate a buffer big enough to contain only one DO
- //
- DeviceRelations = ExAllocatePoolWithTag(PagedPool, sizeof(DeviceRelations), 'dmaR');
+ /* Allocate a buffer big enough to contain only one DO */
+ DeviceRelations = ExAllocatePoolWithTag(PagedPool,
+ sizeof(DeviceRelations),
+ 'dmaR');
if (DeviceRelations != NULL)
{
- //
- // Reference the DO and add it to the buffer
- //
+ /* Reference the DO and add it to the buffer */
ObReferenceObject(DeviceObject);
DeviceRelations->Objects[0] = DeviceObject;
DeviceRelations->Count = 1;
Status = STATUS_INSUFFICIENT_RESOURCES;
}
- //
- // Return our processing & complete
- //
+ /* Return our processing & complete */
Irp->IoStatus.Information = (ULONG_PTR)DeviceRelations;
Irp->IoStatus.Status = Status;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return Status;
}
- //
- // Anything but bus relations, we don't handle
- //
+ /* We don't handle anything but bus relations */
if (Type != BusRelations) goto PassToNext;
- //
- // Acquire the disk list lock
- //
+ /* Acquire the disk list lock */
KeEnterCriticalRegion();
ExAcquireFastMutex(&DeviceExtension->DiskListLock);
- //
- // Did a device already fill relations?
- //
+ /* Did a device already fill relations? */
DeviceRelations = (PDEVICE_RELATIONS)Irp->IoStatus.Information;
if (DeviceRelations)
{
- //
- // Use the data
- //
+ /* Use the data */
Count = DeviceRelations->Count;
}
else
{
- //
- // We're the first
- //
+ /* We're the first */
Count = 0;
}
- //
- // Now loop our drives
- //
+ /* 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
- //
+ /* 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
- //
+ /* Move to the next one */
NextEntry = NextEntry->Flink;
}
- //
- // Now we know our final count
- //
+ /* Now we know our final count */
FinalCount = Count + DiskCount;
- //
- // Allocate the structure
- //
+ /* Allocate the structure */
OurDeviceRelations = ExAllocatePoolWithTag(PagedPool,
FIELD_OFFSET(DEVICE_RELATIONS,
Objects) +
'dmaR');
if (!OurDeviceRelations)
{
- //
- // Fail
- //
+ /* Fail */
ExReleaseFastMutex(&DeviceExtension->DiskListLock);
KeLeaveCriticalRegion();
Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
return STATUS_INSUFFICIENT_RESOURCES;
}
- //
- // Check if we already had some relations
- //
+ /* Check if we already had some relations */
if (Count)
{
- //
- // Copy them in
- //
+ /* Copy them in */
RtlCopyMemory(OurDeviceRelations->Objects,
DeviceRelations->Objects,
Count * sizeof(PDEVICE_OBJECT));
}
- //
- // Save the count
- //
+ /* Save the count */
OurDeviceRelations->Count = FinalCount;
- //
- // Now loop our drives again
- //
+ /* Now loop our drives again */
ListHead = &DeviceExtension->DiskList;
NextEntry = ListHead->Flink;
while (NextEntry != ListHead)
{
- //
- // Go to the end of the list
- //
+ /* Go to the end of the list */
DriveDeviceObject = &OurDeviceRelations->Objects[Count];
- //
- // Get the drive state
- //
+ /* 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 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 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
- //
+ /* Mark it as enumerated now, but don't actually reference it */
DriveExtension->State = RamdiskStateEnumerated;
}
}
else
{
- //
- // First time it's enumerated, reference the device object
- //
+ /* First time it's enumerated, reference the device object */
ObReferenceObject(DriveExtension->DeviceObject);
- //
- // Save the object pointer, and move on
- //
+ /* Save the object pointer and move on */
*DriveDeviceObject++ = DriveExtension->PhysicalDeviceObject;
}
if (DriveExtension->State < RamdiskStateBusRemoved) DiskCount++;
- //
- // Move to the next one
- //
+ /* Move to the next one */
NextEntry = NextEntry->Flink;
}
- //
- // Release the lock
- //
+ /* Release the lock */
ExReleaseFastMutex(&DeviceExtension->DiskListLock);
KeLeaveCriticalRegion();
- //
- // Cleanup old relations
- //
+ /* Cleanup old relations */
if (DeviceRelations) ExFreePool(DeviceRelations);
- //
- // Complete our IRP
- //
+ /* Complete our IRP */
Irp->IoStatus.Information = (ULONG_PTR)OurDeviceRelations;
Irp->IoStatus.Status = STATUS_SUCCESS;
- //
- // Pass to the next driver
- //
+ /* Pass to the next driver */
PassToNext:
IoCopyCurrentIrpStackLocationToNext(Irp);
return IoCallDriver(DeviceExtension->AttachedDevice, Irp);
DeviceExtension = DeviceObject->DeviceExtension;
- //
- // Acquire disks list lock
- //
+ /* Acquire disks list lock */
KeEnterCriticalRegion();
ExAcquireFastMutex(&DeviceExtension->DiskListLock);
- //
- // Loop over drives
- //
+ /* Loop over drives */
ListHead = &DeviceExtension->DiskList;
NextEntry = ListHead->Flink;
while (NextEntry != ListHead)
RAMDISK_DRIVE_EXTENSION,
DiskList);
- //
- // Delete the disk
- //
+ /* Delete the disk */
IoAcquireRemoveLock(&DriveExtension->RemoveLock, NULL);
RamdiskDeleteDiskDevice(DriveExtension->PhysicalDeviceObject, NULL);
- //
- // RamdiskDeleteDiskDevice releases list lock, so reacquire it
- //
+ /* RamdiskDeleteDiskDevice releases list lock, so reacquire it */
KeEnterCriticalRegion();
ExAcquireFastMutex(&DeviceExtension->DiskListLock);
}
- //
- // Release disks list lock
- //
+ /* Release disks list lock */
ExReleaseFastMutex(&DeviceExtension->DiskListLock);
KeLeaveCriticalRegion();
- //
- // Prepare to pass to the lower driver
- //
+ /* Prepare to pass to the lower driver */
IoSkipCurrentIrpStackLocation(Irp);
- //
- // Here everything went fine
- //
+ /* Here everything went fine */
Irp->IoStatus.Status = STATUS_SUCCESS;
- //
- // Call lower driver
- //
+ /* Call lower driver */
Status = IoCallDriver(DeviceExtension->AttachedDevice, Irp);
- //
- // Update state
- //
+ /* Update state */
DeviceExtension->State = RamdiskStateBusRemoved;
- //
- // Release the lock, and ensure that everyone
- // has finished its job before we continue
- // The lock has been acquired by the dispatcher
- //
+ /* Release the lock and ensure that everyone has finished its job before
+ * we continue. The lock has been acquired by the dispatcher */
IoReleaseRemoveLockAndWait(&DeviceExtension->RemoveLock, Irp);
- //
- // If there's a drive name
- //
+ /* If there's a drive name */
if (DeviceExtension->DriveDeviceName.Buffer)
{
- //
- // Inform it's going to be disabled
- // and free the drive name
- //
+ /* Inform it's going to be disabled and free the drive name */
IoSetDeviceInterfaceState(&DeviceExtension->DriveDeviceName, FALSE);
RtlFreeUnicodeString(&DeviceExtension->DriveDeviceName);
}
- //
- // Part from the stack, detach from lower device
- //
+ /* Part from the stack, detach from lower device */
IoDetachDevice(DeviceExtension->AttachedDevice);
- //
- // Finally, delete device
- //
+ /* Finally, delete device */
RamdiskBusFdo = NULL;
IoDeleteDevice(DeviceObject);
- //
- // Return status from lower driver
- //
+ /* Return status from lower driver */
return Status;
}
Status = STATUS_SUCCESS;
IoStackLocation = IoGetCurrentIrpStackLocation(Irp);
- //
- // Get what is being queried
- //
+ /* Get what is being queried */
switch (IoStackLocation->Parameters.QueryId.IdType)
{
case BusQueryDeviceID:
{
- //
- // Allocate a buffer long enough to receive Ramdisk\RamDisk in any case
- // In case we don't have RAMDISK_REGISTRY_DISK, we then need two more
- // chars to store Ramdisk\RamVolume instead
- //
+ /* Allocate a buffer long enough to receive Ramdisk\RamDisk in any case
+ * In case we don't have RAMDISK_REGISTRY_DISK, we then need two more
+ * chars to store Ramdisk\RamVolume instead */
StringLength = 4 * (DriveExtension->DiskType != RAMDISK_REGISTRY_DISK) + sizeof(L"Ramdisk\\RamDisk");
OutputString = ExAllocatePoolWithTag(PagedPool, StringLength, 'dmaR');
if (OutputString == NULL)
case BusQueryHardwareIDs:
{
- //
- // Allocate a buffer long enough to receive Ramdisk\RamDisk in any case
- // In case we don't have RAMDISK_REGISTRY_DISK, we then need two more
- // chars to store Ramdisk\RamVolume instead
- // We also need an extra char, because it is required that the string
- // is null-terminated twice
- //
+ /* Allocate a buffer long enough to receive Ramdisk\RamDisk in any case
+ * In case we don't have RAMDISK_REGISTRY_DISK, we then need two more
+ * chars to store Ramdisk\RamVolume instead
+ * We also need an extra char, because it is required that the string
+ * is null-terminated twice */
StringLength = 4 * (DriveExtension->DiskType != RAMDISK_REGISTRY_DISK) +
sizeof(UNICODE_NULL) + sizeof(L"Ramdisk\\RamDisk");
OutputString = ExAllocatePoolWithTag(PagedPool, StringLength, 'dmaR');
case BusQueryInstanceID:
{
- OutputString = ExAllocatePoolWithTag(PagedPool, DriveExtension->GuidString.MaximumLength, 'dmaR');
+ OutputString = ExAllocatePoolWithTag(PagedPool,
+ DriveExtension->GuidString.MaximumLength,
+ 'dmaR');
if (OutputString == NULL)
{
Status = STATUS_INSUFFICIENT_RESOURCES;
break;
}
- wcsncpy(OutputString, DriveExtension->GuidString.Buffer, DriveExtension->GuidString.MaximumLength / sizeof(WCHAR));
+ wcsncpy(OutputString,
+ DriveExtension->GuidString.Buffer,
+ DriveExtension->GuidString.MaximumLength / sizeof(WCHAR));
break;
}
case BusQueryDeviceSerialNumber:
{
- //
- // Nothing to do
- //
+ /* Nothing to do */
break;
}
}
DeviceCapabilities = IoStackLocation->Parameters.DeviceCapabilities.Capabilities;
DriveExtension = DeviceObject->DeviceExtension;
- //
- // Validate our input buffer
- //
- if (DeviceCapabilities->Version != 1 || DeviceCapabilities->Size < sizeof(DEVICE_CAPABILITIES))
+ /* Validate our input buffer */
+ if (DeviceCapabilities->Version != 1 ||
+ DeviceCapabilities->Size < sizeof(DEVICE_CAPABILITIES))
{
Status = STATUS_UNSUCCESSFUL;
}
else
{
- //
- // And set everything we know about our capabilities
- //
+ /* And set everything we know about our capabilities */
DeviceCapabilities->Removable = MarkRamdisksAsRemovable;
DeviceCapabilities->UniqueID = TRUE;
DeviceCapabilities->SilentInstall = TRUE;
DeviceTextType = IoStackLocation->Parameters.QueryDeviceText.DeviceTextType;
Status = STATUS_SUCCESS;
- //
- // Just copy our constants, according to the input
- //
+ /* Just copy our constants, according to the input */
switch (DeviceTextType)
{
case DeviceTextDescription:
PPNP_BUS_INFORMATION PnpBusInfo;
NTSTATUS Status = STATUS_SUCCESS;
- //
- // Allocate output memory
- //
+ /* Allocate output memory */
PnpBusInfo = ExAllocatePoolWithTag(PagedPool, sizeof(PNP_BUS_INFORMATION), 'dmaR');
if (PnpBusInfo == NULL)
{
}
else
{
- //
- // Copy our bus GUID and set our legacy type
- //
+ /* Copy our bus GUID and set our legacy type */
RtlCopyMemory(&PnpBusInfo->BusTypeGuid, &GUID_BUS_TYPE_RAMDISK, sizeof(GUID));
PnpBusInfo->LegacyBusType = PNPBus;
PnpBusInfo->BusNumber = 0;
IN PVOID Context)
{
- //
- // Just set the event to unlock caller
- //
+ /* Just set the event to unlock caller */
KeSetEvent((PKEVENT)Context, 0, FALSE);
return STATUS_MORE_PROCESSING_REQUIRED;
UCHAR Minor;
KEVENT Event;
- //
- // Get the device extension and stack location
- //
+ /* Get the device extension and stack location */
DeviceExtension = DeviceObject->DeviceExtension;
IoStackLocation = IoGetCurrentIrpStackLocation(Irp);
Minor = IoStackLocation->MinorFunction;
- //
- // Check if the bus is removed
- //
+ /* Check if the bus is removed */
if (DeviceExtension->State == RamdiskStateBusRemoved)
{
- //
- // Only remove-device and query-id are allowed
- //
+ /* Only remove-device and query-id are allowed */
if ((Minor != IRP_MN_REMOVE_DEVICE) && (Minor != IRP_MN_QUERY_ID))
{
- //
- // Fail anything else
- //
+ /* Fail anything else */
Status = STATUS_NO_SUCH_DEVICE;
Irp->IoStatus.Status = Status;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
}
}
- //
- // Acquire the remove lock
- //
+ /* Acquire the remove lock */
Status = IoAcquireRemoveLock(&DeviceExtension->RemoveLock, Irp);
if (!NT_SUCCESS(Status))
{
- //
- // Fail the IRP
- //
+ /* Fail the IRP */
Irp->IoStatus.Information = 0;
Irp->IoStatus.Status = Status;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return Status;
}
- //
- // Query the IRP type
- //
+ /* Query the IRP type */
switch (Minor)
{
case IRP_MN_START_DEVICE:
DEVICE_INSTALL_STATE InstallState;
PRAMDISK_DRIVE_EXTENSION DriveExtension = (PRAMDISK_DRIVE_EXTENSION)DeviceExtension;
- //
- // If we already have a drive name, free it
- //
+ /* If we already have a drive name, free it */
if (DriveExtension->DriveDeviceName.Buffer)
{
ExFreePool(DriveExtension->DriveDeviceName.Buffer);
}
- //
- // Register our device interface
- //
+ /* Register our device interface */
if (DriveExtension->DiskType != RAMDISK_REGISTRY_DISK)
{
Status = IoRegisterDeviceInterface(DeviceObject,
&DriveExtension->DriveDeviceName);
}
- //
- // If we were asked not to assign a drive letter or
- // if getting a name failed, just return saying
- // we're now started
- //
+ /* If we were asked not to assign a drive letter or if getting
+ * a name failed, just return saying we're now started */
if (DriveExtension->DiskOptions.NoDriveLetter ||
DriveExtension->DriveDeviceName.Buffer == NULL)
{
break;
}
- //
- // Now get our installation state
- //
- Status = IoGetDeviceProperty(DeviceObject, DevicePropertyInstallState,
- sizeof(InstallState), &InstallState, &ResultLength);
- //
- // If querying the information failed, assume success
- //
+ /* Now get our installation state */
+ Status = IoGetDeviceProperty(DeviceObject,
+ DevicePropertyInstallState,
+ sizeof(InstallState),
+ &InstallState,
+ &ResultLength);
+ /* If querying the information failed, assume success */
if (!NT_SUCCESS(Status))
{
InstallState = InstallStateInstalled;
}
- //
- // If we were properly installed, then, enable the interface
- //
+ /* If we were properly installed, then, enable the interface */
if (InstallState == InstallStateInstalled)
{
Status = IoSetDeviceInterfaceState(&DriveExtension->DriveDeviceName, TRUE);
}
- //
- // We're fine & up
- //
+ /* We're fine & up */
DriveExtension->State = RamdiskStateStarted;
Irp->IoStatus.Status = Status;
break;
}
- //
- // Prepare next stack to pass it down
- //
+ /* Prepare next stack to pass it down */
IoCopyCurrentIrpStackLocationToNext(Irp);
- //
- // Initialize our notification event & our completion routine
- //
+ /* Initialize our notification event & our completion routine */
KeInitializeEvent(&Event, NotificationEvent, FALSE);
IoSetCompletionRoutine(Irp, RamdiskIoCompletionRoutine, &Event, TRUE, TRUE, TRUE);
- //
- // Call lower driver
- //
+ /* Call lower driver */
Status = IoCallDriver(DeviceExtension->AttachedDevice, Irp);
if (Status == STATUS_PENDING)
{
Status = Irp->IoStatus.Status;
}
- //
- // If it succeed to start, then, enable ourselve and we're up!
- //
+ /* If it succeed to start then enable ourselves and we're up! */
if (NT_SUCCESS(Status))
{
Status = IoSetDeviceInterfaceState(&DeviceExtension->DriveDeviceName, TRUE);
case IRP_MN_REMOVE_DEVICE:
{
- //
- // Remove the proper device
- //
+ /* Remove the proper device */
if (DeviceExtension->Type == RamdiskBus)
{
Status = RamdiskRemoveBusDevice(DeviceObject, Irp);
- //
- // Return here, lower device has already been called
- // And remove lock released. This is needed by the function.
- //
+ /* Return here, lower device has already been called
+ * And remove lock released. This is needed by the function. */
return Status;
}
else
{
Status = RamdiskDeleteDiskDevice(DeviceObject, Irp);
- //
- // Complete the IRP here and return
- // Here again we don't have to release remove lock
- // This has already been done by the function.
- //
+ /* Complete the IRP here and return
+ * Here again we don't have to release remove lock
+ * This has already been done by the function. */
Irp->IoStatus.Status = Status;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return Status;
case IRP_MN_QUERY_ID:
{
- //
- // Are we a drive?
- //
+ /* Are we a drive? */
if (DeviceExtension->Type == RamdiskDrive)
{
Status = RamdiskQueryId((PRAMDISK_DRIVE_EXTENSION)DeviceExtension, Irp);
case IRP_MN_QUERY_BUS_INFORMATION:
{
- //
- // Are we a drive?
- //
+ /* Are we a drive? */
if (DeviceExtension->Type == RamdiskDrive)
{
Status = RamdiskQueryBusInformation(DeviceObject, Irp);
case IRP_MN_QUERY_DEVICE_TEXT:
{
- //
- // Are we a drive?
- //
+ /* Are we a drive? */
if (DeviceExtension->Type == RamdiskDrive)
{
Status = RamdiskQueryDeviceText((PRAMDISK_DRIVE_EXTENSION)DeviceExtension, Irp);
case IRP_MN_QUERY_DEVICE_RELATIONS:
{
- //
- // Call our main routine
- //
+ /* Call our main routine */
Status = RamdiskQueryDeviceRelations(IoStackLocation->
Parameters.
QueryDeviceRelations.Type,
case IRP_MN_QUERY_CAPABILITIES:
{
- //
- // Are we a drive?
- //
+ /* Are we a drive? */
if (DeviceExtension->Type == RamdiskDrive)
{
Status = RamdiskQueryCapabilities(DeviceObject, Irp);
case IRP_MN_QUERY_RESOURCES:
case IRP_MN_QUERY_RESOURCE_REQUIREMENTS:
{
- //
- // Complete immediately without touching it
- //
+ /* Complete immediately without touching it */
IoCompleteRequest(Irp, IO_NO_INCREMENT);
goto ReleaseAndReturn;
}
break;
}
- //
- // Are we the bus?
- //
+ /* Are we the bus? */
if (DeviceExtension->Type == RamdiskBus)
{
- //
- // Do we have an attached device?
- //
+ /* Do we have an attached device? */
if (DeviceExtension->AttachedDevice)
{
- //
- // Forward the IRP
- //
+ /* Forward the IRP */
IoSkipCurrentIrpStackLocation(Irp);
Status = IoCallDriver(DeviceExtension->AttachedDevice, Irp);
}
}
- //
- // Release the lock and return status
- //
+ /* Release the lock and return status */
ReleaseAndReturn:
IoReleaseRemoveLock(&DeviceExtension->RemoveLock, Irp);
return Status;
DeviceExtension = DeviceObject->DeviceExtension;
- //
- // If we have a device extension, take extra caution
- // with the lower driver
- //
+ /* If we have a device extension, take extra caution with the lower driver */
if (DeviceExtension != NULL)
{
PoStartNextPowerIrp(Irp);
- //
- // Device has not been removed yet, so
- // pass to the attached/lower driver
- //
+ /* Device has not been removed yet, so pass to the attached/lower driver */
if (DeviceExtension->State < RamdiskStateBusRemoved)
{
IoSkipCurrentIrpStackLocation(Irp);
return PoCallDriver(DeviceExtension->AttachedDevice, Irp);
}
- //
- // Otherwise, simply complete the IRP
- // Notifying that deletion is pending
- //
+ /* Otherwise, simply complete the IRP notifying that deletion is pending */
else
{
Irp->IoStatus.Status = STATUS_DELETE_PENDING;
}
}
- //
- // Get stack and deal with minor functions
- //
+ /* Get stack and deal with minor functions */
IoStackLocation = IoGetCurrentIrpStackLocation(Irp);
switch (IoStackLocation->MinorFunction)
{
case IRP_MN_SET_POWER:
{
- //
- // If setting device power state
- // it's all fine and return success
- //
+ /* If setting device power state it's all fine and return success */
if (DevicePowerState)
{
Irp->IoStatus.Status = STATUS_SUCCESS;
}
- //
- // Get appropriate status for return
- //
+ /* Get appropriate status for return */
Status = Irp->IoStatus.Status;
PoStartNextPowerIrp(Irp);
IoCompleteRequest(Irp, IO_NO_INCREMENT);
case IRP_MN_QUERY_POWER:
{
- //
- // We can obviously accept all states
- // So just return success
- //
- Status =
- Irp->IoStatus.Status = STATUS_SUCCESS;
+ /* We can obviously accept all states so just return success */
+ Status = Irp->IoStatus.Status = STATUS_SUCCESS;
PoStartNextPowerIrp(Irp);
IoCompleteRequest(Irp, IO_NO_INCREMENT);
break;
default:
{
- //
- // Just complete and save status for return
- //
+ /* Just complete and save status for return */
Status = Irp->IoStatus.Status;
PoStartNextPowerIrp(Irp);
IoCompleteRequest(Irp, IO_NO_INCREMENT);
DeviceExtension = DeviceObject->DeviceExtension;
- //
- // If we have a device extension, forward the IRP
- // to the attached device
- //
+ /* If we have a device extension, forward the IRP to the attached device */
if (DeviceExtension != NULL)
{
IoSkipCurrentIrpStackLocation(Irp);
Status = IoCallDriver(DeviceExtension->AttachedDevice, Irp);
}
- //
- // Otherwise just complete the request
- // And return the status with which we complete it
- //
+ /* Otherwise just complete the request
+ * And return the status with which we complete it */
else
{
Status = Irp->IoStatus.Status;
DeviceExtension = DeviceObject->DeviceExtension;
- //
- // Having a proper device is mandatory
- //
+ /* Having a proper device is mandatory */
if (DeviceExtension->State > RamdiskStateStopped)
{
Status = STATUS_DEVICE_DOES_NOT_EXIST;
goto CompleteIRP;
}
- //
- // Acquire the remove lock
- //
+ /* Acquire the remove lock */
Status = IoAcquireRemoveLock(&DeviceExtension->RemoveLock, Irp);
if (!NT_SUCCESS(Status))
{
goto CompleteIRP;
}
- //
- // Queue the IRP for worker
- //
+ /* Queue the IRP for worker */
Status = SendIrpToThread(DeviceObject, Irp);
if (Status != STATUS_PENDING)
{
goto CompleteIRP;
}
- //
- // Release the remove lock
- //
+ /* Release the remove lock */
IoReleaseRemoveLock(&DeviceExtension->RemoveLock, Irp);
goto Quit;
DeviceExtension = DeviceObject->DeviceExtension;
- //
- // Ensure we have drive extension
- // Only perform flush on disks that have been created
- // from registry entries
- //
+ /* Ensure we have drive extension
+ * Only perform flush on disks that have been created
+ * from registry entries */
if (DeviceExtension->Type != RamdiskDrive ||
DeviceExtension->DiskType > RAMDISK_MEMORY_MAPPED_DISK)
{
return STATUS_SUCCESS;
}
- //
- // Queue the IRP for worker
- //
+ /* Queue the IRP for worker */
Status = SendIrpToThread(DeviceObject, Irp);
if (Status != STATUS_PENDING)
{
- //
- // Queueing failed - complete the IRP
- // and return failure
- //
+ /* Queuing failed - complete the IRP and return failure */
Irp->IoStatus.Information = 0;
Irp->IoStatus.Status = Status;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
NTAPI
RamdiskUnload(IN PDRIVER_OBJECT DriverObject)
{
- //
- // Just release registry path if previously allocated
- //
+ /* Just release registry path if previously allocated */
if (DriverRegistryPath.Buffer)
{
ExFreePoolWithTag(DriverRegistryPath.Buffer, 'dmaR');
UNICODE_STRING DeviceName;
PDEVICE_OBJECT DeviceObject;
- //
- // Only create the bus FDO once
- //
+ /* Only create the bus FDO once */
if (RamdiskBusFdo) return STATUS_DEVICE_ALREADY_ATTACHED;
- //
- // Create the bus FDO
- //
+ /* Create the bus FDO */
RtlInitUnicodeString(&DeviceName, L"\\Device\\Ramdisk");
Status = IoCreateDevice(DriverObject,
sizeof(RAMDISK_BUS_EXTENSION),
&DeviceObject);
if (NT_SUCCESS(Status))
{
- //
- // Initialize the bus FDO extension
- //
+ /* Initialize the bus FDO extension */
DeviceExtension = DeviceObject->DeviceExtension;
RtlZeroMemory(DeviceObject->DeviceExtension,
sizeof(RAMDISK_BUS_EXTENSION));
- //
- // Set bus FDO flags
- //
+ /* Set bus FDO flags */
DeviceObject->Flags |= DO_POWER_PAGABLE | DO_DIRECT_IO;
- //
- // Setup the bus FDO extension
- //
+ /* Setup the bus FDO extension */
DeviceExtension->Type = RamdiskBus;
ExInitializeFastMutex(&DeviceExtension->DiskListLock);
- IoInitializeRemoveLock(&DeviceExtension->RemoveLock,
- 'dmaR',
- 1,
- 0);
+ IoInitializeRemoveLock(&DeviceExtension->RemoveLock, 'dmaR', 1, 0);
InitializeListHead(&DeviceExtension->DiskList);
DeviceExtension->PhysicalDeviceObject = PhysicalDeviceObject;
DeviceExtension->DeviceObject = DeviceObject;
- //
- // Register the RAM disk device interface
- //
+ /* Register the RAM disk device interface */
Status = IoRegisterDeviceInterface(PhysicalDeviceObject,
&RamdiskBusInterface,
NULL,
&DeviceExtension->BusDeviceName);
if (!NT_SUCCESS(Status))
{
- //
- // Fail
- //
+ /* Fail */
IoDeleteDevice(DeviceObject);
return Status;
}
- //
- // Attach us to the device stack
- //
+ /* Attach us to the device stack */
AttachedDevice = IoAttachDeviceToDeviceStack(DeviceObject,
PhysicalDeviceObject);
DeviceExtension->AttachedDevice = AttachedDevice;
if (!AttachedDevice)
{
- //
- // Fail
- //
+ /* Fail */
IoSetDeviceInterfaceState(&DeviceExtension->BusDeviceName, 0);
RtlFreeUnicodeString(&DeviceExtension->BusDeviceName);
IoDeleteDevice(DeviceObject);
return STATUS_NO_SUCH_DEVICE;
}
- //
- // Bus FDO is initialized
- //
+ /* Bus FDO is initialized */
RamdiskBusFdo = DeviceObject;
- //
- // Loop for loader block
- //
+ /* Loop for loader block */
if (KeLoaderBlock)
{
- //
- // Are we being booted from setup? Not yet supported
- //
+ /* Are we being booted from setup? Not yet supported */
if (KeLoaderBlock->SetupLdrBlock)
DPRINT1("FIXME: RamdiskAddDevice is UNSUPPORTED when being started from SETUPLDR!\n");
- // ASSERT(!KeLoaderBlock->SetupLdrBlock);
+ //ASSERT(!KeLoaderBlock->SetupLdrBlock);
}
- //
- // All done
- //
+ /* All done */
DeviceObject->Flags &= DO_DEVICE_INITIALIZING;
Status = STATUS_SUCCESS;
}
- //
- // Return status
- //
+ /* Return status */
return Status;
}
NTSTATUS Status;
DPRINT("RAM Disk Driver Initialized\n");
- //
- // Query ramdisk parameters
- //
+ /* Query ramdisk parameters */
QueryParameters(RegistryPath);
- //
- // Save the registry path
- //
+ /* Save the registry path */
DriverRegistryPath = *RegistryPath;
DriverRegistryPath.Buffer = ExAllocatePoolWithTag(PagedPool,
RegistryPath->Length +
if (!DriverRegistryPath.Buffer) return STATUS_INSUFFICIENT_RESOURCES;
RtlCopyUnicodeString(&DriverRegistryPath, RegistryPath);
- //
- // Set device routines
- //
+ /* Set device routines */
DriverObject->MajorFunction[IRP_MJ_CREATE] = RamdiskOpenClose;
DriverObject->MajorFunction[IRP_MJ_CLOSE] = RamdiskOpenClose;
DriverObject->MajorFunction[IRP_MJ_READ] = RamdiskReadWrite;
DriverObject->DriverExtension->AddDevice = RamdiskAddDevice;
DriverObject->DriverUnload = RamdiskUnload;
- //
- // Check for a loader block
- //
+ /* Check for a loader block */
if (KeLoaderBlock)
{
- //
- // Get the boot device name
- //
+ /* Get the boot device name */
BootDeviceName = KeLoaderBlock->ArcBootDeviceName;
if (BootDeviceName)
{
- //
- // Check if we're booting from ramdisk
- //
+ /* Check if we're booting from ramdisk */
if ((strlen(BootDeviceName) >= 10) &&
!(_strnicmp(BootDeviceName, "ramdisk(0)", 10)))
{
- //
- // We'll have to tell the PnP Manager
- //
+ /* We'll have to tell the PnP Manager */
ReportDetectedDevice = TRUE;
- //
- // Check for a command line
- //
+ /* Check for a command line */
CommandLine = KeLoaderBlock->LoadOptions;
if (CommandLine)
{
- //
- // Check if this is an ISO boot
- //
+ /* Check if this is an ISO boot */
if (strstr(CommandLine, "RDEXPORTASCD"))
{
- //
- // Remember for later
- //
+ /* Remember for later */
ExportBootDiskAsCd = TRUE;
}
- //
- // Check if this is PE boot
- //
+ /* Check if this is PE boot */
if (strstr(CommandLine, "MININT"))
{
- //
- // Remember for later
- //
+ /* Remember for later */
IsWinPEBoot = TRUE;
}
}
}
}
- //
- // Installing from Ramdisk isn't supported yet
- //
+ /* Installing from Ramdisk isn't supported yet */
if (KeLoaderBlock->SetupLdrBlock)
DPRINT1("FIXME: Installing from RamDisk is UNSUPPORTED!\n");
- // ASSERT(!KeLoaderBlock->SetupLdrBlock);
+ //ASSERT(!KeLoaderBlock->SetupLdrBlock);
- //
- // Are we reporting the device
- //
+ /* Are we reporting the device */
if (ReportDetectedDevice)
{
- //
- // Do it
- //
+ /* Do it */
Status = IoReportDetectedDevice(DriverObject,
InterfaceTypeUndefined,
0xFFFFFFFF,
&PhysicalDeviceObject);
if (NT_SUCCESS(Status))
{
- //
- // Create the device object
- //
+ /* Create the device object */
Status = RamdiskAddDevice(DriverObject, PhysicalDeviceObject);
if (NT_SUCCESS(Status))
{
- //
- // We're done
- //
+ /* We're done */
PhysicalDeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
Status = STATUS_SUCCESS;
}
}
else
{
- //
- // Done
- //
+ /* Done */
Status = STATUS_SUCCESS;
}
- //
- // Done
- //
+ /* Done */
return Status;
}
projects / reactos.git / commitdiff