Ros-diffs November 2020

ros-diffs@reactos.org

18 participants
162 discussions

[reactos] 01/01: [PARTMGR] Add the Partition Manager driver

by Victor Perevertkin

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=bd8226afe7f34c9135db1… commit bd8226afe7f34c9135db1543638144177aab2081 Author: Victor Perevertkin <victor.perevertkin(a)reactos.org> AuthorDate: Fri Nov 13 03:04:15 2020 +0300 Commit: Victor Perevertkin <victor.perevertkin(a)reactos.org> CommitDate: Fri Nov 13 03:04:15 2020 +0300 [PARTMGR] Add the Partition Manager driver This driver works as complement to disk.sys/classpnp.sys from Windows 10 Manages partition PDOs and exposes them as volumes to mountmgr.sys. The driver is almost complete, just some minor IOCTLs missing (will be added on demand) --- drivers/storage/CMakeLists.txt | 1 + drivers/storage/partmgr/CMakeLists.txt | 19 + drivers/storage/partmgr/debug.h | 14 + drivers/storage/partmgr/guid.c | 11 + drivers/storage/partmgr/partition.c | 816 ++++++++++++++++++ drivers/storage/partmgr/partmgr.c | 1373 +++++++++++++++++++++++++++++++ drivers/storage/partmgr/partmgr.h | 192 +++++ drivers/storage/partmgr/partmgr.rc | 5 + drivers/storage/partmgr/partmgr_reg.inf | 7 + drivers/storage/partmgr/utils.c | 73 ++ 10 files changed, 2511 insertions(+) diff --git a/drivers/storage/CMakeLists.txt b/drivers/storage/CMakeLists.txt index b3f0f02a4c4..44c5131d8f6 100644 --- a/drivers/storage/CMakeLists.txt +++ b/drivers/storage/CMakeLists.txt @@ -2,4 +2,5 @@ add_subdirectory(class) add_subdirectory(floppy) add_subdirectory(ide) add_subdirectory(mountmgr) +add_subdirectory(partmgr) add_subdirectory(port) diff --git a/drivers/storage/partmgr/CMakeLists.txt b/drivers/storage/partmgr/CMakeLists.txt new file mode 100644 index 00000000000..275fc305fb4 --- /dev/null +++ b/drivers/storage/partmgr/CMakeLists.txt @@ -0,0 +1,19 @@ + +list(APPEND SOURCE + partition.c + partmgr.c + utils.c) + +list(APPEND PCH_SKIP_SOURCE + guid.c) + +add_library(partmgr MODULE + ${SOURCE} + ${PCH_SKIP_SOURCE} + partmgr.rc) + +add_pch(partmgr partmgr.h "${PCH_SKIP_SOURCE}") +set_module_type(partmgr kernelmodedriver) +add_importlibs(partmgr ntoskrnl hal) +add_registry_inf(partmgr_reg.inf) +add_cd_file(TARGET partmgr DESTINATION reactos/system32/drivers NO_CAB FOR all) diff --git a/drivers/storage/partmgr/debug.h b/drivers/storage/partmgr/debug.h new file mode 100644 index 00000000000..4ff75db66e3 --- /dev/null +++ b/drivers/storage/partmgr/debug.h @@ -0,0 +1,14 @@ +/* + * PROJECT: Partition manager driver + * LICENSE: GPL-2.0-or-later (https://spdx.org/licenses/GPL-2.0-or-later) + * PURPOSE: Debug helpers + * COPYRIGHT: 2020 Victor Perevertkin (victor.perevertkin(a)reactos.org) + */ + +#include <reactos/debug.h> + +#define ERR(fmt, ...) ERR__(DPFLTR_DISK_ID, fmt, ##__VA_ARGS__) +#define WARN(fmt, ...) WARN__(DPFLTR_DISK_ID, fmt, ##__VA_ARGS__) +#define TRACE(fmt, ...) TRACE__(DPFLTR_DISK_ID, fmt, ##__VA_ARGS__) +#define INFO(fmt, ...) INFO__(DPFLTR_DISK_ID, fmt, ##__VA_ARGS__) +// #define FDPRINT(lvl, fmt, ...) FDPRINT__(DPFLTR_DISK_ID, lvl, fmt, __VA_ARGS__) diff --git a/drivers/storage/partmgr/guid.c b/drivers/storage/partmgr/guid.c new file mode 100644 index 00000000000..9aa431750c7 --- /dev/null +++ b/drivers/storage/partmgr/guid.c @@ -0,0 +1,11 @@ +/* DO NOT USE THE PRECOMPILED HEADER FOR THIS FILE! */ + +#include <ntdef.h> +#include <initguid.h> +#include <wdmguid.h> + +#define DEVICE_TYPE ULONG +#include <ntdddisk.h> +#include <ioevent.h> + +/* NO CODE HERE, THIS IS JUST REQUIRED FOR THE GUID DEFINITIONS */ diff --git a/drivers/storage/partmgr/partition.c b/drivers/storage/partmgr/partition.c new file mode 100644 index 00000000000..694836d3ae0 --- /dev/null +++ b/drivers/storage/partmgr/partition.c @@ -0,0 +1,816 @@ +/* + * PROJECT: Partition manager driver + * LICENSE: GPL-2.0-or-later (https://spdx.org/licenses/GPL-2.0-or-later) + * PURPOSE: Partition device code + * COPYRIGHT: 2020 Victor Perevertkin (victor.perevertkin(a)reactos.org) + */ + +#include "partmgr.h" + +static const WCHAR PartitionSymLinkFormat[] = L"\\Device\\Harddisk%u\\Partition%u"; + + +CODE_SEG("PAGE") +NTSTATUS +PartitionCreateDevice( + _In_ PDEVICE_OBJECT FDObject, + _In_ PPARTITION_INFORMATION_EX PartitionEntry, + _In_ UINT32 PdoNumber, + _In_ PARTITION_STYLE PartitionStyle, + _Out_ PDEVICE_OBJECT *PDO) +{ + PAGED_CODE(); + + static UINT32 HarddiskVolumeNextId = 1; // this is 1-based + + WCHAR nameBuf[64]; + UNICODE_STRING deviceName; + + // create the device object + + swprintf(nameBuf, L"\\Device\\HarddiskVolume%u", HarddiskVolumeNextId++); + RtlCreateUnicodeString(&deviceName, nameBuf); + + PDEVICE_OBJECT partitionDevice; + NTSTATUS status = IoCreateDevice(FDObject->DriverObject, + sizeof(PARTITION_EXTENSION), + &deviceName, + FILE_DEVICE_DISK, + FILE_DEVICE_SECURE_OPEN, + FALSE, + &partitionDevice); + + if (!NT_SUCCESS(status)) + { + ERR("Unable to create device object %wZ\n", &deviceName); + return status; + } + + INFO("Created device object %p %wZ\n", partitionDevice, &deviceName); + + PPARTITION_EXTENSION partExt = partitionDevice->DeviceExtension; + RtlZeroMemory(partExt, sizeof(*partExt)); + + partitionDevice->StackSize = FDObject->StackSize; + partitionDevice->Flags |= DO_DIRECT_IO; + + if (PartitionStyle == PARTITION_STYLE_MBR) + { + partExt->Mbr.PartitionType = PartitionEntry->Mbr.PartitionType; + partExt->Mbr.BootIndicator = PartitionEntry->Mbr.BootIndicator; + partExt->Mbr.HiddenSectors = PartitionEntry->Mbr.HiddenSectors; + } + else + { + partExt->Gpt.PartitionType = PartitionEntry->Gpt.PartitionType; + partExt->Gpt.PartitionId = PartitionEntry->Gpt.PartitionType; + partExt->Gpt.Attributes = PartitionEntry->Gpt.Attributes; + + RtlCopyMemory(partExt->Gpt.Name, PartitionEntry->Gpt.Name, sizeof(partExt->Gpt.Name)); + } + + partExt->DeviceName = deviceName; + partExt->StartingOffset = PartitionEntry->StartingOffset.QuadPart; + partExt->PartitionLength = PartitionEntry->PartitionLength.QuadPart; + partExt->OnDiskNumber = PartitionEntry->PartitionNumber; // the "physical" partition number + partExt->DetectedNumber = PdoNumber; // counts only partitions with PDO created + + partExt->DeviceObject = partitionDevice; + partExt->LowerDevice = FDObject; + + partitionDevice->Flags &= ~DO_DEVICE_INITIALIZING; + + *PDO = partitionDevice; + + return status; +} + +static +CODE_SEG("PAGE") +NTSTATUS +PartitionHandleStartDevice( + _In_ PPARTITION_EXTENSION PartExt, + _In_ PIRP Irp) +{ + PAGED_CODE(); + + // fix the damn kernel! + if (PartExt->DeviceRemoved) + { + DPRINT1("IRP_MN_START_DEVICE after IRP_MN_REMOVE_DEVICE!\n"); + return STATUS_SUCCESS; + } + + // first, create a symbolic link for our device + WCHAR nameBuf[64]; + UNICODE_STRING partitionSymlink, interfaceName; + PFDO_EXTENSION fdoExtension = PartExt->LowerDevice->DeviceExtension; + + // \\Device\\Harddisk%u\\Partition%u + swprintf(nameBuf, PartitionSymLinkFormat, + fdoExtension->DiskData.DeviceNumber, PartExt->DetectedNumber); + + if (!RtlCreateUnicodeString(&partitionSymlink, nameBuf)) + { + return STATUS_INSUFFICIENT_RESOURCES; + } + + NTSTATUS status = IoCreateSymbolicLink(&partitionSymlink, &PartExt->DeviceName); + + if (!NT_SUCCESS(status)) + { + return status; + } + + PartExt->SymlinkCreated = TRUE; + + TRACE("Symlink created %wZ -> %wZ\n", &PartExt->DeviceName, &partitionSymlink); + + // our partition device will have two interfaces: + // GUID_DEVINTERFACE_PARTITION and GUID_DEVINTERFACE_VOLUME + // the former one is used to notify mountmgr about new device + + status = IoRegisterDeviceInterface(PartExt->DeviceObject, + &GUID_DEVINTERFACE_PARTITION, + NULL, + &interfaceName); + + if (!NT_SUCCESS(status)) + { + return status; + } + + PartExt->PartitionInterfaceName = interfaceName; + status = IoSetDeviceInterfaceState(&interfaceName, TRUE); + + INFO("Partition interface %wZ\n", &interfaceName); + + if (!NT_SUCCESS(status)) + { + RtlFreeUnicodeString(&interfaceName); + RtlInitUnicodeString(&PartExt->PartitionInterfaceName, NULL); + return status; + } + + status = IoRegisterDeviceInterface(PartExt->DeviceObject, + &GUID_DEVINTERFACE_VOLUME, + NULL, + &interfaceName); + + if (!NT_SUCCESS(status)) + { + return status; + } + + PartExt->VolumeInterfaceName = interfaceName; + status = IoSetDeviceInterfaceState(&interfaceName, TRUE); + + INFO("Volume interface %wZ\n", &interfaceName); + + if (!NT_SUCCESS(status)) + { + RtlFreeUnicodeString(&interfaceName); + RtlInitUnicodeString(&PartExt->VolumeInterfaceName, NULL); + return status; + } + + return STATUS_SUCCESS; +} + +CODE_SEG("PAGE") +NTSTATUS +PartitionHandleRemove( + _In_ PPARTITION_EXTENSION PartExt, + _In_ BOOLEAN FinalRemove) +{ + NTSTATUS status; + + PAGED_CODE(); + + // remove the symbolic link + if (PartExt->SymlinkCreated) + { + WCHAR nameBuf[64]; + UNICODE_STRING partitionSymlink; + PFDO_EXTENSION fdoExtension = PartExt->LowerDevice->DeviceExtension; + + swprintf(nameBuf, PartitionSymLinkFormat, + fdoExtension->DiskData.DeviceNumber, PartExt->DetectedNumber); + + RtlInitUnicodeString(&partitionSymlink, nameBuf); + + status = IoDeleteSymbolicLink(&partitionSymlink); + + if (!NT_SUCCESS(status)) + { + return status; + } + PartExt->SymlinkCreated = FALSE; + + INFO("Symlink removed %wZ -> %wZ\n", &PartExt->DeviceName, &partitionSymlink); + } + + // release device interfaces + if (PartExt->PartitionInterfaceName.Buffer) + { + status = IoSetDeviceInterfaceState(&PartExt->PartitionInterfaceName, FALSE); + if (!NT_SUCCESS(status)) + { + return status; + } + RtlFreeUnicodeString(&PartExt->PartitionInterfaceName); + RtlInitUnicodeString(&PartExt->PartitionInterfaceName, NULL); + } + + if (PartExt->VolumeInterfaceName.Buffer) + { + status = IoSetDeviceInterfaceState(&PartExt->VolumeInterfaceName, FALSE); + if (!NT_SUCCESS(status)) + { + return status; + } + RtlFreeUnicodeString(&PartExt->VolumeInterfaceName); + RtlInitUnicodeString(&PartExt->VolumeInterfaceName, NULL); + } + + if (FinalRemove) + { + // fix the damn kernel! + if (PartExt->DeviceRemoved) + { + DPRINT1("Double IRP_MN_REMOVE_DEVICE!\n"); + return STATUS_SUCCESS; + } + + PartExt->DeviceRemoved = TRUE; + + ASSERT(PartExt->DeviceName.Buffer); + if (PartExt->DeviceName.Buffer) + { + INFO("Removed device %wZ\n", &PartExt->DeviceName); + RtlFreeUnicodeString(&PartExt->DeviceName); + } + + IoDeleteDevice(PartExt->DeviceObject); + } + + return STATUS_SUCCESS; +} + +static +CODE_SEG("PAGE") +NTSTATUS +PartitionHandleDeviceRelations( + _In_ PPARTITION_EXTENSION PartExt, + _In_ PIRP Irp) +{ + PAGED_CODE(); + + // fix the damn kernel! + if (PartExt->DeviceRemoved) + { + DPRINT1("QDR after device removal!\n"); + return STATUS_DEVICE_DOES_NOT_EXIST; + } + + PIO_STACK_LOCATION ioStack = IoGetCurrentIrpStackLocation(Irp); + DEVICE_RELATION_TYPE type = ioStack->Parameters.QueryDeviceRelations.Type; + + if (type == TargetDeviceRelation) + { + // Device relations has one entry built in to it's size. + PDEVICE_RELATIONS deviceRelations = + ExAllocatePoolZero(PagedPool, sizeof(DEVICE_RELATIONS), TAG_PARTMGR); + + if (deviceRelations != NULL) + { + deviceRelations->Count = 1; + deviceRelations->Objects[0] = PartExt->DeviceObject; + ObReferenceObject(deviceRelations->Objects[0]); + + Irp->IoStatus.Information = (ULONG_PTR)deviceRelations; + return STATUS_SUCCESS; + } + else + { + return STATUS_INSUFFICIENT_RESOURCES; + } + } + else + { + Irp->IoStatus.Information = 0; + return Irp->IoStatus.Status; + } +} + +static +CODE_SEG("PAGE") +NTSTATUS +PartitionHandleQueryId( + _In_ PPARTITION_EXTENSION PartExt, + _In_ PIRP Irp) +{ + PIO_STACK_LOCATION ioStack = IoGetCurrentIrpStackLocation(Irp); + BUS_QUERY_ID_TYPE idType = ioStack->Parameters.QueryId.IdType; + UNICODE_STRING idString; + NTSTATUS status; + + PAGED_CODE(); + + switch (idType) + { + case BusQueryDeviceID: + status = RtlCreateUnicodeString(&idString, L"STORAGE\\Partition") + ? STATUS_SUCCESS : STATUS_INSUFFICIENT_RESOURCES; + break; + case BusQueryHardwareIDs: + case BusQueryCompatibleIDs: + { + static WCHAR volumeID[] = L"STORAGE\\Volume\0"; + + idString.Buffer = ExAllocatePoolWithTag(PagedPool, sizeof(volumeID), TAG_PARTMGR); + RtlCopyMemory(idString.Buffer, volumeID, sizeof(volumeID)); + + status = STATUS_SUCCESS; + break; + } + case BusQueryInstanceID: + { + WCHAR string[64]; + PFDO_EXTENSION fdoExtension = PartExt->LowerDevice->DeviceExtension; + + PartMgrAcquireLayoutLock(fdoExtension); + + if (fdoExtension->DiskData.PartitionStyle == PARTITION_STYLE_MBR) + { + swprintf(string, L"S%08lx_O%I64x_L%I64x", + fdoExtension->DiskData.Mbr.Signature, + PartExt->StartingOffset, + PartExt->PartitionLength); + } + else + { + swprintf(string, + L"S%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02xS_O%I64x_L%I64x", + fdoExtension->DiskData.Gpt.DiskId.Data1, + fdoExtension->DiskData.Gpt.DiskId.Data2, + fdoExtension->DiskData.Gpt.DiskId.Data3, + fdoExtension->DiskData.Gpt.DiskId.Data4[0], + fdoExtension->DiskData.Gpt.DiskId.Data4[1], + fdoExtension->DiskData.Gpt.DiskId.Data4[2], + fdoExtension->DiskData.Gpt.DiskId.Data4[3], + fdoExtension->DiskData.Gpt.DiskId.Data4[4], + fdoExtension->DiskData.Gpt.DiskId.Data4[5], + fdoExtension->DiskData.Gpt.DiskId.Data4[6], + fdoExtension->DiskData.Gpt.DiskId.Data4[7], + PartExt->StartingOffset, + PartExt->PartitionLength); + } + + PartMgrReleaseLayoutLock(fdoExtension); + + status = RtlCreateUnicodeString(&idString, string) + ? STATUS_SUCCESS : STATUS_INSUFFICIENT_RESOURCES; + break; + } + default: + status = STATUS_NOT_SUPPORTED; + break; + } + + Irp->IoStatus.Information = NT_SUCCESS(status) ? (ULONG_PTR) idString.Buffer : 0; + return status; +} + +static +CODE_SEG("PAGE") +NTSTATUS +PartitionHandleQueryCapabilities( + _In_ PPARTITION_EXTENSION PartExt, + _In_ PIRP Irp) +{ + PIO_STACK_LOCATION ioStack = IoGetCurrentIrpStackLocation(Irp); + PDEVICE_CAPABILITIES devCaps = ioStack->Parameters.DeviceCapabilities.Capabilities; + + PAGED_CODE(); + ASSERT(devCaps); + + devCaps->SilentInstall = TRUE; + devCaps->RawDeviceOK = TRUE; + devCaps->NoDisplayInUI = TRUE; + devCaps->Address = PartExt->OnDiskNumber; + devCaps->UniqueID = 1; + + return STATUS_SUCCESS; +} + +CODE_SEG("PAGE") +NTSTATUS +PartitionHandlePnp( + _In_ PDEVICE_OBJECT DeviceObject, + _In_ PIRP Irp) +{ + PPARTITION_EXTENSION partExt = DeviceObject->DeviceExtension; + PIO_STACK_LOCATION ioStack = IoGetCurrentIrpStackLocation(Irp); + NTSTATUS status; + + PAGED_CODE(); + + switch (ioStack->MinorFunction) + { + case IRP_MN_START_DEVICE: + { + status = PartitionHandleStartDevice(partExt, Irp); + break; + } + case IRP_MN_QUERY_DEVICE_RELATIONS: + { + status = PartitionHandleDeviceRelations(partExt, Irp); + break; + } + case IRP_MN_QUERY_STOP_DEVICE: + case IRP_MN_QUERY_REMOVE_DEVICE: + case IRP_MN_CANCEL_STOP_DEVICE: + case IRP_MN_CANCEL_REMOVE_DEVICE: + case IRP_MN_STOP_DEVICE: + { + status = STATUS_SUCCESS; + break; + } + case IRP_MN_SURPRISE_REMOVAL: + { + status = PartitionHandleRemove(partExt, FALSE); + break; + } + case IRP_MN_REMOVE_DEVICE: + { + status = PartitionHandleRemove(partExt, TRUE); + break; + } + case IRP_MN_QUERY_ID: + { + status = PartitionHandleQueryId(partExt, Irp); + break; + } + case IRP_MN_QUERY_CAPABILITIES: + { + status = PartitionHandleQueryCapabilities(partExt, Irp); + break; + } + default: + { + Irp->IoStatus.Information = 0; + status = STATUS_NOT_SUPPORTED; + } + } + + Irp->IoStatus.Status = status; + IoCompleteRequest(Irp, IO_NO_INCREMENT); + return status; +} + +NTSTATUS +PartitionHandleDeviceControl( + _In_ PDEVICE_OBJECT DeviceObject, + _In_ PIRP Irp) +{ + PIO_STACK_LOCATION ioStack = IoGetCurrentIrpStackLocation(Irp); + PPARTITION_EXTENSION partExt = DeviceObject->DeviceExtension; + PFDO_EXTENSION fdoExtension = partExt->LowerDevice->DeviceExtension; + NTSTATUS status; + + ASSERT(!partExt->IsFDO); + + if (!partExt->IsEnumerated) + { + Irp->IoStatus.Status = STATUS_DEVICE_DOES_NOT_EXIST; + IoCompleteRequest(Irp, IO_NO_INCREMENT); + return STATUS_DEVICE_DOES_NOT_EXIST; + } + + switch (ioStack->Parameters.DeviceIoControl.IoControlCode) + { + // disk stuff + case IOCTL_DISK_GET_PARTITION_INFO: + { + if (!VerifyIrpOutBufferSize(Irp, sizeof(PARTITION_INFORMATION))) + { + status = STATUS_BUFFER_TOO_SMALL; + break; + } + + PartMgrAcquireLayoutLock(fdoExtension); + + // not supported on anything other than MBR + if (fdoExtension->DiskData.PartitionStyle != PARTITION_STYLE_MBR) + { + status = STATUS_INVALID_DEVICE_REQUEST; + PartMgrReleaseLayoutLock(fdoExtension); + break; + } + + PPARTITION_INFORMATION partInfo = Irp->AssociatedIrp.SystemBuffer; + + *partInfo = (PARTITION_INFORMATION){ + .PartitionType = partExt->Mbr.PartitionType, + .StartingOffset.QuadPart = partExt->StartingOffset, + .PartitionLength.QuadPart = partExt->PartitionLength, + .HiddenSectors = partExt->Mbr.HiddenSectors, + .PartitionNumber = partExt->DetectedNumber, + .BootIndicator = partExt->Mbr.BootIndicator, + .RecognizedPartition = partExt->Mbr.RecognizedPartition, + .RewritePartition = FALSE, + }; + + PartMgrReleaseLayoutLock(fdoExtension); + + Irp->IoStatus.Information = sizeof(*partInfo); + status = STATUS_SUCCESS; + break; + } + case IOCTL_DISK_GET_PARTITION_INFO_EX: + { + if (!VerifyIrpOutBufferSize(Irp, sizeof(PARTITION_INFORMATION_EX))) + { + status = STATUS_BUFFER_TOO_SMALL; + break; + } + + PPARTITION_INFORMATION_EX partInfoEx = Irp->AssociatedIrp.SystemBuffer; + + PartMgrAcquireLayoutLock(fdoExtension); + + *partInfoEx = (PARTITION_INFORMATION_EX){ + .StartingOffset.QuadPart = partExt->StartingOffset, + .PartitionLength.QuadPart = partExt->PartitionLength, + .PartitionNumber = partExt->DetectedNumber, + .PartitionStyle = fdoExtension->DiskData.PartitionStyle, + .RewritePartition = FALSE, + }; + + if (fdoExtension->DiskData.PartitionStyle == PARTITION_STYLE_MBR) + { + partInfoEx->Mbr = (PARTITION_INFORMATION_MBR){ + .PartitionType = partExt->Mbr.PartitionType, + .HiddenSectors = partExt->Mbr.HiddenSectors, + .BootIndicator = partExt->Mbr.BootIndicator, + .RecognizedPartition = partExt->Mbr.RecognizedPartition, + }; + } + else + { + partInfoEx->Gpt = (PARTITION_INFORMATION_GPT){ + .PartitionType = partExt->Gpt.PartitionType, + .PartitionId = partExt->Gpt.PartitionId, + .Attributes = partExt->Gpt.Attributes, + }; + + RtlCopyMemory(partInfoEx->Gpt.Name, + partExt->Gpt.Name, + sizeof(partInfoEx->Gpt.Name)); + } + + PartMgrReleaseLayoutLock(fdoExtension); + + Irp->IoStatus.Information = sizeof(*partInfoEx); + status = STATUS_SUCCESS; + break; + } + case IOCTL_DISK_SET_PARTITION_INFO: + { + PSET_PARTITION_INFORMATION inputBuffer = Irp->AssociatedIrp.SystemBuffer; + if (!VerifyIrpInBufferSize(Irp, sizeof(*inputBuffer))) + { + status = STATUS_INFO_LENGTH_MISMATCH; + break; + } + + PartMgrAcquireLayoutLock(fdoExtension); + + // these functions use on disk numbers, not detected ones + status = IoSetPartitionInformation(fdoExtension->LowerDevice, + fdoExtension->DiskData.BytesPerSector, + partExt->OnDiskNumber, + inputBuffer->PartitionType); + + if (NT_SUCCESS(status)) + { + partExt->Mbr.PartitionType = inputBuffer->PartitionType; + } + + PartMgrReleaseLayoutLock(fdoExtension); + + Irp->IoStatus.Information = 0; + break; + } + case IOCTL_DISK_SET_PARTITION_INFO_EX: + { + PSET_PARTITION_INFORMATION_EX inputBuffer = Irp->AssociatedIrp.SystemBuffer; + if (!VerifyIrpInBufferSize(Irp, sizeof(*inputBuffer))) + { + status = STATUS_INFO_LENGTH_MISMATCH; + break; + } + + PartMgrAcquireLayoutLock(fdoExtension); + + // these functions use on disk numbers, not detected ones + status = IoSetPartitionInformationEx(fdoExtension->LowerDevice, + partExt->OnDiskNumber, + inputBuffer); + + if (NT_SUCCESS(status)) + { + if (fdoExtension->DiskData.PartitionStyle == PARTITION_STYLE_MBR) + { + partExt->Mbr.PartitionType = inputBuffer->Mbr.PartitionType; + } + else + { + partExt->Gpt.PartitionType = inputBuffer->Gpt.PartitionType; + partExt->Gpt.PartitionId = inputBuffer->Gpt.PartitionId; + partExt->Gpt.Attributes = inputBuffer->Gpt.Attributes; + + RtlMoveMemory(partExt->Gpt.Name, + inputBuffer->Gpt.Name, + sizeof(partExt->Gpt.Name)); + } + } + + PartMgrReleaseLayoutLock(fdoExtension); + + Irp->IoStatus.Information = 0; + break; + } + case IOCTL_DISK_GET_LENGTH_INFO: + { + PGET_LENGTH_INFORMATION lengthInfo = Irp->AssociatedIrp.SystemBuffer; + if (!VerifyIrpOutBufferSize(Irp, sizeof(*lengthInfo))) + { + status = STATUS_BUFFER_TOO_SMALL; + break; + } + + PartMgrAcquireLayoutLock(fdoExtension); + + lengthInfo->Length.QuadPart = partExt->PartitionLength; + + PartMgrReleaseLayoutLock(fdoExtension); + + status = STATUS_SUCCESS; + Irp->IoStatus.Information = sizeof(*lengthInfo); + break; + } + case IOCTL_DISK_VERIFY: + { + PVERIFY_INFORMATION verifyInfo = Irp->AssociatedIrp.SystemBuffer; + if (!VerifyIrpInBufferSize(Irp, sizeof(*verifyInfo))) + { + status = STATUS_INFO_LENGTH_MISMATCH; + break; + } + + // Partition device should just adjust the starting offset + verifyInfo->StartingOffset.QuadPart += partExt->StartingOffset; + return ForwardIrpAndForget(DeviceObject, Irp); + } + case IOCTL_DISK_UPDATE_PROPERTIES: + { + fdoExtension->LayoutValid = FALSE; + IoInvalidateDeviceRelations(fdoExtension->PhysicalDiskDO, BusRelations); + + status = STATUS_SUCCESS; + break; + } + case IOCTL_STORAGE_MEDIA_REMOVAL: + { + return ForwardIrpAndForget(DeviceObject, Irp); + } + // volume stuff (most of that should be in volmgr.sys one it is implemented) + case IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS: + { + PVOLUME_DISK_EXTENTS volExts = Irp->AssociatedIrp.SystemBuffer; + + // we fill only one extent entry so sizeof(*volExts) is enough + if (!VerifyIrpOutBufferSize(Irp, sizeof(*volExts))) + { + status = STATUS_BUFFER_TOO_SMALL; + break; + } + + PartMgrAcquireLayoutLock(fdoExtension); + + // the only type of volume we support right now is disk partition + // so this structure is simple + + *volExts = (VOLUME_DISK_EXTENTS) { + .NumberOfDiskExtents = 1, + .Extents = {{ + .DiskNumber = fdoExtension->DiskData.DeviceNumber, + .StartingOffset.QuadPart = partExt->StartingOffset, + .ExtentLength.QuadPart = partExt->PartitionLength + }} + }; + + PartMgrReleaseLayoutLock(fdoExtension); + + status = STATUS_SUCCESS; + Irp->IoStatus.Information = sizeof(*volExts); + break; + } + case IOCTL_VOLUME_ONLINE: + { + status = STATUS_SUCCESS; + break; + } + case IOCTL_VOLUME_GET_GPT_ATTRIBUTES: + { + PVOLUME_GET_GPT_ATTRIBUTES_INFORMATION gptAttrs = Irp->AssociatedIrp.SystemBuffer; + if (!VerifyIrpOutBufferSize(Irp, sizeof(*gptAttrs))) + { + status = STATUS_BUFFER_TOO_SMALL; + break; + } + + // not supported on anything other than GPT + if (fdoExtension->DiskData.PartitionStyle != PARTITION_STYLE_GPT) + { + status = STATUS_INVALID_DEVICE_REQUEST; + break; + } + + gptAttrs->GptAttributes = partExt->Gpt.Attributes; + + status = STATUS_SUCCESS; + Irp->IoStatus.Information = sizeof(*gptAttrs); + break; + } + // mountmgr stuff + case IOCTL_MOUNTDEV_QUERY_DEVICE_NAME: + { + PMOUNTDEV_NAME name = Irp->AssociatedIrp.SystemBuffer; + + if (!VerifyIrpOutBufferSize(Irp, sizeof(USHORT))) + { + status = STATUS_BUFFER_TOO_SMALL; + break; + } + + name->NameLength = partExt->DeviceName.Length; + + // return NameLength back + if (!VerifyIrpOutBufferSize(Irp, sizeof(USHORT) + name->NameLength)) + { + Irp->IoStatus.Information = sizeof(USHORT); + status = STATUS_BUFFER_OVERFLOW; + break; + } + + RtlCopyMemory(name->Name, partExt->DeviceName.Buffer, name->NameLength); + + status = STATUS_SUCCESS; + Irp->IoStatus.Information = sizeof(USHORT) + name->NameLength; + break; + } + case IOCTL_MOUNTDEV_QUERY_UNIQUE_ID: + { + PMOUNTDEV_UNIQUE_ID uniqueId = Irp->AssociatedIrp.SystemBuffer; + + if (!partExt->VolumeInterfaceName.Buffer) + { + status = STATUS_INVALID_PARAMETER; + break; + } + + if (!VerifyIrpOutBufferSize(Irp, sizeof(USHORT))) + { + status = STATUS_BUFFER_TOO_SMALL; + break; + } + + uniqueId->UniqueIdLength = partExt->VolumeInterfaceName.Length; + + // return UniqueIdLength back + if (!VerifyIrpOutBufferSize(Irp, sizeof(USHORT) + uniqueId->UniqueIdLength)) + { + Irp->IoStatus.Information = sizeof(USHORT); + status = STATUS_BUFFER_OVERFLOW; + break; + } + + RtlCopyMemory(uniqueId->UniqueId, + partExt->VolumeInterfaceName.Buffer, + uniqueId->UniqueIdLength); + + status = STATUS_SUCCESS; + Irp->IoStatus.Information = sizeof(USHORT) + uniqueId->UniqueIdLength; + break; + } + default: + return ForwardIrpAndForget(DeviceObject, Irp); + } + + Irp->IoStatus.Status = status; + IoCompleteRequest(Irp, IO_NO_INCREMENT); + return status; +} diff --git a/drivers/storage/partmgr/partmgr.c b/drivers/storage/partmgr/partmgr.c new file mode 100644 index 00000000000..8abfdccedd6 --- /dev/null +++ b/drivers/storage/partmgr/partmgr.c @@ -0,0 +1,1373 @@ +/* + * PROJECT: Partition manager driver + * LICENSE: GPL-2.0-or-later (https://spdx.org/licenses/GPL-2.0-or-later) + * PURPOSE: Main file + * COPYRIGHT: 2020 Victor Perevertkin (victor.perevertkin(a)reactos.org) + */ + +/* The Partition Manager Driver in ReactOS complements disk.sys/classpnp.sys drivers + * (which are derived from Windows 10 drivers) so does not do exactly what Windows 2003 partmgr.sys + * does. Here is acts like both partition and volume manager, because volmgr.sys does not (yet) + * exist in ReactOS. Thus handles some IOCTL_VOLUME_*, and IOCTL_MOUNTMGR_* IOCTLs. + */ + +#include "partmgr.h" + + +static +CODE_SEG("PAGE") +PDRIVE_LAYOUT_INFORMATION +PartMgrConvertExtendedToLayout( + _In_ CONST PDRIVE_LAYOUT_INFORMATION_EX LayoutEx) +{ + PDRIVE_LAYOUT_INFORMATION Layout; + PPARTITION_INFORMATION Partition; + PPARTITION_INFORMATION_EX PartitionEx; + + PAGED_CODE(); + + ASSERT(LayoutEx); + + if (LayoutEx->PartitionStyle != PARTITION_STYLE_MBR) + { + ASSERT(FALSE); + return NULL; + } + + size_t layoutSize = FIELD_OFFSET(DRIVE_LAYOUT_INFORMATION, PartitionEntry[0]) + + LayoutEx->PartitionCount * sizeof (PARTITION_INFORMATION); + + Layout = ExAllocatePoolWithTag(PagedPool, layoutSize, TAG_PARTMGR); + + if (Layout == NULL) + { + return NULL; + } + + Layout->Signature = LayoutEx->Mbr.Signature; + Layout->PartitionCount = LayoutEx->PartitionCount; + + for (UINT32 i = 0; i < LayoutEx->PartitionCount; i++) + { + Partition = &Layout->PartitionEntry[i]; + PartitionEx = &LayoutEx->PartitionEntry[i]; + + Partition->StartingOffset = PartitionEx->StartingOffset; + Partition->PartitionLength = PartitionEx->PartitionLength; + Partition->RewritePartition = PartitionEx->RewritePartition; + Partition->PartitionNumber = PartitionEx->PartitionNumber; + + Partition->PartitionType = PartitionEx->Mbr.PartitionType; + Partition->BootIndicator = PartitionEx->Mbr.BootIndicator; + Partition->RecognizedPartition = PartitionEx->Mbr.RecognizedPartition; + Partition->HiddenSectors = PartitionEx->Mbr.HiddenSectors; + } + + return Layout; +} + +static +CODE_SEG("PAGE") +PDRIVE_LAYOUT_INFORMATION_EX +PartMgrConvertLayoutToExtended( + _In_ CONST PDRIVE_LAYOUT_INFORMATION Layout) +{ + PDRIVE_LAYOUT_INFORMATION_EX layoutEx; + + PAGED_CODE(); + + ASSERT(Layout != NULL); + + size_t layoutSize = FIELD_OFFSET(DRIVE_LAYOUT_INFORMATION_EX, PartitionEntry[0]) + + Layout->PartitionCount * sizeof (PARTITION_INFORMATION_EX); + + layoutEx = ExAllocatePoolUninitialized(PagedPool, layoutSize, TAG_PARTMGR); + + if (layoutEx == NULL) + { + return NULL; + } + + layoutEx->PartitionStyle = PARTITION_STYLE_MBR; + layoutEx->PartitionCount = Layout->PartitionCount; + layoutEx->Mbr.Signature = Layout->Signature; + + for (UINT32 i = 0; i < Layout->PartitionCount; i++) + { + PPARTITION_INFORMATION part = &Layout->PartitionEntry[i]; + + layoutEx->PartitionEntry[i] = (PARTITION_INFORMATION_EX) { + .PartitionStyle = PARTITION_STYLE_MBR, + .StartingOffset = part->StartingOffset, + .PartitionLength = part->PartitionLength, + .RewritePartition = part->RewritePartition, + .PartitionNumber = part->PartitionNumber, + .Mbr = { + .PartitionType = part->PartitionType, + .BootIndicator = part->BootIndicator, + .RecognizedPartition = part->RecognizedPartition, + .HiddenSectors = part->HiddenSectors, + } + }; + } + + return layoutEx; +} + +static +CODE_SEG("PAGE") +VOID +PartMgrUpdatePartitionDevices( + _In_ PFDO_EXTENSION FdoExtension, + _Inout_ PDRIVE_LAYOUT_INFORMATION_EX NewLayout) +{ + NTSTATUS status; + PSINGLE_LIST_ENTRY curEntry, prevEntry; + UINT32 totalPartitions = 0; + + // Clear the partition numbers from the list entries + for (UINT32 i = 0; i < NewLayout->PartitionCount; i++) + { + NewLayout->PartitionEntry[i].PartitionNumber = 0; + } + + // iterate over old partition list + prevEntry = &FdoExtension->PartitionList; + curEntry = FdoExtension->PartitionList.Next; + while (curEntry != NULL) + { + PPARTITION_EXTENSION partExt = CONTAINING_RECORD(curEntry, PARTITION_EXTENSION, ListEntry); + UINT32 partNumber = 0; // count detected partitions for device symlinks + BOOLEAN found = FALSE; + PPARTITION_INFORMATION_EX partEntry; + + // trying to find this partition in returned layout + for (UINT32 i = 0; i < NewLayout->PartitionCount; i++) + { + partEntry = &NewLayout->PartitionEntry[i]; + + // skip unused and container partitions + if (NewLayout->PartitionStyle == PARTITION_STYLE_MBR && + (partEntry->Mbr.PartitionType == PARTITION_ENTRY_UNUSED || + IsContainerPartition(partEntry->Mbr.PartitionType))) + { + continue; + } + + partNumber++; + + // skip already found partitions + if (partEntry->PartitionNumber) + { + continue; + } + + // skip if partitions are not equal + if (partEntry->StartingOffset.QuadPart != partExt->StartingOffset || + partEntry->PartitionLength.QuadPart != partExt->PartitionLength) + { + continue; + } + + // found matching partition - processing it + found = TRUE; + break; + } + + if (found) + { + // update (possibly changed) partition metadata + if (NewLayout->PartitionStyle == PARTITION_STYLE_MBR) + { + partExt->Mbr.PartitionType = partEntry->Mbr.PartitionType; + partExt->Mbr.BootIndicator = partEntry->Mbr.BootIndicator; + } + else + { + partExt->Gpt.PartitionType = partEntry->Gpt.PartitionType; + partExt->Gpt.PartitionId = partEntry->Gpt.PartitionId; + partExt->Gpt.Attributes = partEntry->Gpt.Attributes; + + RtlCopyMemory(partExt->Gpt.Name, partEntry->Gpt.Name, sizeof(partExt->Gpt.Name)); + } + + partExt->OnDiskNumber = partNumber; + partEntry->PartitionNumber = partNumber; // mark it as a found one + totalPartitions++; + } + else + { + // detach the device from the list + prevEntry->Next = curEntry->Next; + curEntry = prevEntry; + partExt->Attached = FALSE; + + // enumerated PDOs will receive IRP_MN_REMOVE_DEVICE + if (!partExt->IsEnumerated) + { + PartitionHandleRemove(partExt, TRUE); + } + } + + prevEntry = curEntry; + curEntry = curEntry->Next; + } + + UINT32 partNumber = 0; + UINT32 pdoNumber = 1; + + // now looking through remaining "new" partitions + for (UINT32 i = 0; i < NewLayout->PartitionCount; i++) + { + PPARTITION_INFORMATION_EX partEntry = &NewLayout->PartitionEntry[i]; + + // again, skip unused and container partitions + if (NewLayout->PartitionStyle == PARTITION_STYLE_MBR && + (partEntry->Mbr.PartitionType == PARTITION_ENTRY_UNUSED || + IsContainerPartition(partEntry->Mbr.PartitionType))) + { + continue; + } + + partNumber++; + + // and skip processed partitions + if (partEntry->PartitionNumber != 0) + { + continue; + } + + // find the first free PDO index + for (PSINGLE_LIST_ENTRY curEntry = FdoExtension->PartitionList.Next; + curEntry != NULL; + curEntry = curEntry->Next) + { + PPARTITION_EXTENSION partExt = CONTAINING_RECORD(curEntry, + PARTITION_EXTENSION, + ListEntry); + + if (partExt->DetectedNumber == pdoNumber) + { + // found a matching pdo number - restart the search + curEntry = FdoExtension->PartitionList.Next; + pdoNumber++; + } + } + + partEntry->PartitionNumber = partNumber; + + PDEVICE_OBJECT partitionDevice; + status = PartitionCreateDevice(FdoExtension->DeviceObject, + partEntry, + pdoNumber, + NewLayout->PartitionStyle, + &partitionDevice); + + if (!NT_SUCCESS(status)) + { + partEntry->PartitionNumber = 0; + continue; + } + + totalPartitions++; + + // insert the structure to the partition list + curEntry = FdoExtension->PartitionList.Next; + prevEntry = NULL; + while (curEntry != NULL) + { + PPARTITION_EXTENSION curPart = CONTAINING_RECORD(curEntry, + PARTITION_EXTENSION, + ListEntry); + if (curPart->OnDiskNumber < partNumber) + { + prevEntry = curEntry; + curEntry = curPart->ListEntry.Next; + } + else + { // we found where to put the partition + break; + } + } + + PPARTITION_EXTENSION partExt = partitionDevice->DeviceExtension; + + if (prevEntry) + { + // insert after prevEntry + partExt->ListEntry.Next = prevEntry->Next; + prevEntry->Next = &partExt->ListEntry; + } + else + { + // insert in the beginning + partExt->ListEntry.Next = FdoExtension->PartitionList.Next; + FdoExtension->PartitionList.Next = &partExt->ListEntry; + } + + partExt->Attached = TRUE; + } + + FdoExtension->EnumeratedPartitionsTotal = totalPartitions; +} + +// requires partitioning lock held +static +CODE_SEG("PAGE") +NTSTATUS +PartMgrGetDriveLayout( + _In_ PFDO_EXTENSION FdoExtension, + _Out_ PDRIVE_LAYOUT_INFORMATION_EX *DriveLayout) +{ + PAGED_CODE(); + + if (FdoExtension->LayoutValid) + { + *DriveLayout = FdoExtension->LayoutCache; + return STATUS_SUCCESS; + } + + PDRIVE_LAYOUT_INFORMATION_EX layoutEx = NULL; + NTSTATUS status = IoReadPartitionTableEx(FdoExtension->LowerDevice, &layoutEx); + + if (!NT_SUCCESS(status)) + { + return status; + } + + if (FdoExtension->LayoutCache) + { + ExFreePool(FdoExtension->LayoutCache); + } + + FdoExtension->LayoutCache = layoutEx; + FdoExtension->LayoutValid = TRUE; + + *DriveLayout = layoutEx; + + return status; +} + +static +CODE_SEG("PAGE") +NTSTATUS +FdoIoctlDiskGetDriveGeometryEx( + _In_ PFDO_EXTENSION FdoExtension, + _In_ PIRP Irp) +{ + PIO_STACK_LOCATION ioStack = IoGetCurrentIrpStackLocation(Irp); + + PAGED_CODE(); + + // We're patching the DISK_PARTITION_INFO part of the returned structure + // as disk.sys doesn't really know about the partition table on a disk + + PDISK_GEOMETRY_EX_INTERNAL geometryEx = Irp->AssociatedIrp.SystemBuffer; + size_t outBufferLength = ioStack->Parameters.DeviceIoControl.OutputBufferLength; + NTSTATUS status; + + status = IssueSyncIoControlRequest(IOCTL_DISK_GET_DRIVE_GEOMETRY_EX, + FdoExtension->LowerDevice, + NULL, + 0, + geometryEx, + outBufferLength, + FALSE); + + if (!NT_SUCCESS(status)) + { + return status; + } + + // if DISK_PARTITION_INFO fits the output size + if (outBufferLength >= FIELD_OFFSET(DISK_GEOMETRY_EX_INTERNAL, Detection)) + { + PartMgrAcquireLayoutLock(FdoExtension); + + geometryEx->Partition.SizeOfPartitionInfo = sizeof(geometryEx->Partition); + geometryEx->Partition.PartitionStyle = FdoExtension->DiskData.PartitionStyle; + + switch (geometryEx->Partition.PartitionStyle) + { + case PARTITION_STYLE_MBR: + geometryEx->Partition.Mbr.Signature = FdoExtension->DiskData.Mbr.Signature; + // checksum? + break; + + case PARTITION_STYLE_GPT: + geometryEx->Partition.Gpt.DiskId = FdoExtension->DiskData.Gpt.DiskId; + break; + + default: + RtlZeroMemory(&geometryEx->Partition, sizeof(geometryEx->Partition)); + } + + PartMgrReleaseLayoutLock(FdoExtension); + } + + // the logic is copied from disk.sys + Irp->IoStatus.Information = min(outBufferLength, sizeof(DISK_GEOMETRY_EX_INTERNAL)); + + return status; +} + +static +CODE_SEG("PAGE") +NTSTATUS +FdoIoctlDiskGetPartitionInfo( + _In_ PFDO_EXTENSION FdoExtension, + _In_ PIRP Irp) +{ + PPARTITION_INFORMATION partInfo = Irp->AssociatedIrp.SystemBuffer; + + PAGED_CODE(); + + if (!VerifyIrpOutBufferSize(Irp, sizeof(*partInfo))) + { + return STATUS_BUFFER_TOO_SMALL; + } + + PartMgrAcquireLayoutLock(FdoExtension); + + *partInfo = (PARTITION_INFORMATION){ + .PartitionType = PARTITION_ENTRY_UNUSED, + .StartingOffset.QuadPart = 0, + .PartitionLength.QuadPart = FdoExtension->DiskData.DiskSize, + .HiddenSectors = 0, + .PartitionNumber = 0, + .BootIndicator = FALSE, + .RewritePartition = FALSE, + .RecognizedPartition = FALSE, + }; + + PartMgrReleaseLayoutLock(FdoExtension); + + Irp->IoStatus.Information = sizeof(*partInfo); + return STATUS_SUCCESS; +} + +static +CODE_SEG("PAGE") +NTSTATUS +FdoIoctlDiskGetPartitionInfoEx( + _In_ PFDO_EXTENSION FdoExtension, + _In_ PIRP Irp) +{ + PPARTITION_INFORMATION_EX partInfoEx = Irp->AssociatedIrp.SystemBuffer; + + PAGED_CODE(); + + if (!VerifyIrpOutBufferSize(Irp, sizeof(*partInfoEx))) + { + return STATUS_BUFFER_TOO_SMALL; + } + + PartMgrAcquireLayoutLock(FdoExtension); + + // most of the fields a zeroed for Partition0 + *partInfoEx = (PARTITION_INFORMATION_EX){ + .PartitionLength.QuadPart = FdoExtension->DiskData.DiskSize, + .PartitionStyle = FdoExtension->DiskData.PartitionStyle, + }; + + PartMgrReleaseLayoutLock(FdoExtension); + + Irp->IoStatus.Information = sizeof(*partInfoEx); + return STATUS_SUCCESS; +} + +static +CODE_SEG("PAGE") +NTSTATUS +FdoIoctlDiskGetDriveLayout( + _In_ PFDO_EXTENSION FdoExtension, + _In_ PIRP Irp) +{ + PAGED_CODE(); + + PartMgrAcquireLayoutLock(FdoExtension); + + PDRIVE_LAYOUT_INFORMATION_EX layoutEx; + NTSTATUS status = PartMgrGetDriveLayout(FdoExtension, &layoutEx); + + if (!NT_SUCCESS(status)) + { + PartMgrReleaseLayoutLock(FdoExtension); + return status; + } + + // checking this value from layoutEx in case it has been changed + if (layoutEx->PartitionStyle != PARTITION_STYLE_MBR) + { + PartMgrReleaseLayoutLock(FdoExtension); + return STATUS_INVALID_DEVICE_REQUEST; + } + + size_t size = FIELD_OFFSET(DRIVE_LAYOUT_INFORMATION, PartitionEntry[0]); + size += layoutEx->PartitionCount * sizeof(PARTITION_INFORMATION); + + if (!VerifyIrpOutBufferSize(Irp, size)) + { + PartMgrReleaseLayoutLock(FdoExtension); + return STATUS_BUFFER_TOO_SMALL; + } + + PDRIVE_LAYOUT_INFORMATION partitionList = PartMgrConvertExtendedToLayout(layoutEx); + + PartMgrReleaseLayoutLock(FdoExtension); + + if (partitionList == NULL) + { + Irp->IoStatus.Information = 0; + return STATUS_INSUFFICIENT_RESOURCES; + } + + RtlMoveMemory(Irp->AssociatedIrp.SystemBuffer, partitionList, size); + ExFreePoolWithTag(partitionList, TAG_PARTMGR); + + Irp->IoStatus.Information = size; + return STATUS_SUCCESS; +} + +static +CODE_SEG("PAGE") +NTSTATUS +FdoIoctlDiskGetDriveLayoutEx( + _In_ PFDO_EXTENSION FdoExtension, + _In_ PIRP Irp) +{ + PAGED_CODE(); + + PartMgrAcquireLayoutLock(FdoExtension); + + PDRIVE_LAYOUT_INFORMATION_EX layoutEx; + NTSTATUS status = PartMgrGetDriveLayout(FdoExtension, &layoutEx); + if (!NT_SUCCESS(status)) + { + PartMgrReleaseLayoutLock(FdoExtension); + return status; + } + + size_t size = FIELD_OFFSET(DRIVE_LAYOUT_INFORMATION_EX, PartitionEntry[0]); + size += layoutEx->PartitionCount * sizeof(PARTITION_INFORMATION_EX); + + if (!VerifyIrpOutBufferSize(Irp, size)) + { + PartMgrReleaseLayoutLock(FdoExtension); + return STATUS_BUFFER_TOO_SMALL; + } + + RtlCopyMemory(Irp->AssociatedIrp.SystemBuffer, layoutEx, size); + + PartMgrReleaseLayoutLock(FdoExtension); + + Irp->IoStatus.Information = size; + return STATUS_SUCCESS; +} + +static +CODE_SEG("PAGE") +NTSTATUS +FdoIoctlDiskSetDriveLayout( + _In_ PFDO_EXTENSION FdoExtension, + _In_ PIRP Irp) +{ + PDRIVE_LAYOUT_INFORMATION layoutInfo = Irp->AssociatedIrp.SystemBuffer; + + PAGED_CODE(); + + if (!VerifyIrpInBufferSize(Irp, sizeof(*layoutInfo))) + { + return STATUS_INFO_LENGTH_MISMATCH; + } + + size_t layoutSize = FIELD_OFFSET(DRIVE_LAYOUT_INFORMATION, PartitionEntry[0]); + layoutSize += layoutInfo->PartitionCount * sizeof(PARTITION_INFORMATION); + + if (!VerifyIrpInBufferSize(Irp, layoutSize)) + { + return STATUS_INFO_LENGTH_MISMATCH; + } + + PDRIVE_LAYOUT_INFORMATION_EX layoutEx = PartMgrConvertLayoutToExtended(layoutInfo); + + if (layoutEx == NULL) + { + Irp->IoStatus.Information = 0; + return STATUS_INSUFFICIENT_RESOURCES; + } + + PartMgrAcquireLayoutLock(FdoExtension); + + // this in fact updates the bus relations + PartMgrUpdatePartitionDevices(FdoExtension, layoutEx); + + // write the partition table to the disk + NTSTATUS status = IoWritePartitionTableEx(FdoExtension->LowerDevice, layoutEx); + if (NT_SUCCESS(status)) + { + // save the layout cache + if (FdoExtension->LayoutCache) + { + ExFreePool(FdoExtension->LayoutCache); + } + FdoExtension->LayoutCache = layoutEx; + FdoExtension->LayoutValid = TRUE; + + // set updated partition numbers + for (UINT32 i = 0; i < layoutInfo->PartitionCount; i++) + { + PPARTITION_INFORMATION part = &layoutInfo->PartitionEntry[i]; + + part->PartitionNumber = layoutEx->PartitionEntry[i].PartitionNumber; + } + } + else + { + FdoExtension->LayoutValid = FALSE; + } + + PartMgrReleaseLayoutLock(FdoExtension); + + IoInvalidateDeviceRelations(FdoExtension->PhysicalDiskDO, BusRelations); + + // notify everyone that the disk layout has changed + TARGET_DEVICE_CUSTOM_NOTIFICATION notification; + + notification.Event = GUID_IO_DISK_LAYOUT_CHANGE; + notification.Version = 1; + notification.Size = FIELD_OFFSET(TARGET_DEVICE_CUSTOM_NOTIFICATION, CustomDataBuffer); + notification.FileObject = NULL; + notification.NameBufferOffset = -1; + + IoReportTargetDeviceChangeAsynchronous(FdoExtension->PhysicalDiskDO, + &notification, + NULL, + NULL); + + Irp->IoStatus.Information = layoutSize; + return STATUS_SUCCESS; +} + +static +CODE_SEG("PAGE") +NTSTATUS +FdoIoctlDiskSetDriveLayoutEx( + _In_ PFDO_EXTENSION FdoExtension, + _In_ PIRP Irp) +{ + PDRIVE_LAYOUT_INFORMATION_EX layoutEx, layoutUser = Irp->AssociatedIrp.SystemBuffer; + NTSTATUS status; + + PAGED_CODE(); + + if (!VerifyIrpInBufferSize(Irp, sizeof(*layoutUser))) + { + return STATUS_INFO_LENGTH_MISMATCH; + } + + size_t layoutSize = FIELD_OFFSET(DRIVE_LAYOUT_INFORMATION_EX, PartitionEntry[0]); + layoutSize += layoutUser->PartitionCount * sizeof(PARTITION_INFORMATION_EX); + + if (!VerifyIrpInBufferSize(Irp, layoutSize)) + { + return STATUS_INFO_LENGTH_MISMATCH; + } + + // we need to copy the structure from the IRP input buffer + layoutEx = ExAllocatePoolWithTag(PagedPool, layoutSize, TAG_PARTMGR); + if (!layoutEx) + { + Irp->IoStatus.Information = 0; + return STATUS_INSUFFICIENT_RESOURCES; + } + + RtlCopyMemory(layoutEx, layoutUser, layoutSize); + + PartMgrAcquireLayoutLock(FdoExtension); + + // if partition count is 0, it's the same as IOCTL_DISK_CREATE_DISK + if (layoutEx->PartitionCount == 0) + { + CREATE_DISK createDisk = {0}; + createDisk.PartitionStyle = layoutEx->PartitionStyle; + if (createDisk.PartitionStyle == PARTITION_STYLE_MBR) + { + createDisk.Mbr.Signature = layoutEx->Mbr.Signature; + } + else if (createDisk.PartitionStyle == PARTITION_STYLE_GPT) + { + createDisk.Gpt.DiskId = layoutEx->Gpt.DiskId; + } + + status = IoCreateDisk(FdoExtension->LowerDevice, &createDisk); + } + else + { + // this in fact updates the bus relations + PartMgrUpdatePartitionDevices(FdoExtension, layoutEx); + + // write the partition table to the disk + status = IoWritePartitionTableEx(FdoExtension->LowerDevice, layoutEx); + if (NT_SUCCESS(status)) + { + // set updated partition numbers + for (UINT32 i = 0; i < layoutEx->PartitionCount; i++) + { + PPARTITION_INFORMATION_EX part = &layoutEx->PartitionEntry[i]; + + part->PartitionNumber = layoutEx->PartitionEntry[i].PartitionNumber; + } + } + } + + // update the layout cache + if (NT_SUCCESS(status)) + { + if (FdoExtension->LayoutCache) + { + ExFreePool(FdoExtension->LayoutCache); + } + FdoExtension->LayoutCache = layoutEx; + FdoExtension->LayoutValid = TRUE; + } + else + { + FdoExtension->LayoutValid = FALSE; + } + + PartMgrReleaseLayoutLock(FdoExtension); + + IoInvalidateDeviceRelations(FdoExtension->PhysicalDiskDO, BusRelations); + + // notify everyone that the disk layout has changed + TARGET_DEVICE_CUSTOM_NOTIFICATION notification; + + notification.Event = GUID_IO_DISK_LAYOUT_CHANGE; + notification.Version = 1; + notification.Size = FIELD_OFFSET(TARGET_DEVICE_CUSTOM_NOTIFICATION, CustomDataBuffer); + notification.FileObject = NULL; + notification.NameBufferOffset = -1; + + IoReportTargetDeviceChangeAsynchronous(FdoExtension->PhysicalDiskDO, + &notification, + NULL, + NULL); + + Irp->IoStatus.Information = layoutSize; + return STATUS_SUCCESS; +} + +static +CODE_SEG("PAGE") +NTSTATUS +FdoIoctlDiskUpdateProperties( + _In_ PFDO_EXTENSION FdoExtension, + _In_ PIRP Irp) +{ + PAGED_CODE(); + + PartMgrAcquireLayoutLock(FdoExtension); + FdoExtension->LayoutValid = FALSE; + PartMgrReleaseLayoutLock(FdoExtension); + + IoInvalidateDeviceRelations(FdoExtension->PhysicalDiskDO, BusRelations); + return STATUS_SUCCESS; +} + +static +CODE_SEG("PAGE") +NTSTATUS +FdoIoctlDiskCreateDisk( + _In_ PFDO_EXTENSION FdoExtension, + _In_ PIRP Irp) +{ + PAGED_CODE(); + + PCREATE_DISK createDisk = Irp->AssociatedIrp.SystemBuffer; + if (!VerifyIrpInBufferSize(Irp, sizeof(*createDisk))) + { + return STATUS_INFO_LENGTH_MISMATCH; + } + + PartMgrAcquireLayoutLock(FdoExtension); + + NTSTATUS status = IoCreateDisk(FdoExtension->LowerDevice, createDisk); + + FdoExtension->LayoutValid = FALSE; + PartMgrReleaseLayoutLock(FdoExtension); + + IoInvalidateDeviceRelations(FdoExtension->PhysicalDiskDO, BusRelations); + return status; +} + +static +CODE_SEG("PAGE") +NTSTATUS +FdoIoctlDiskDeleteDriveLayout( + _In_ PFDO_EXTENSION FdoExtension, + _In_ PIRP Irp) +{ + CREATE_DISK createDisk = { .PartitionStyle = PARTITION_STYLE_RAW }; + + PAGED_CODE(); + + PartMgrAcquireLayoutLock(FdoExtension); + + NTSTATUS status = IoCreateDisk(FdoExtension->LowerDevice, &createDisk); + + FdoExtension->LayoutValid = FALSE; + PartMgrReleaseLayoutLock(FdoExtension); + + IoInvalidateDeviceRelations(FdoExtension->PhysicalDiskDO, BusRelations); + return status; +} + +static +CODE_SEG("PAGE") +NTSTATUS +FdoHandleStartDevice( + _In_ PFDO_EXTENSION FdoExtension, + _In_ PIRP Irp) +{ + // obtain the disk device number + // this is not expected to change thus not in PartMgrRefreshDiskData + STORAGE_DEVICE_NUMBER deviceNumber; + NTSTATUS status = IssueSyncIoControlRequest(IOCTL_STORAGE_GET_DEVICE_NUMBER, + FdoExtension->LowerDevice, + NULL, + 0, + &deviceNumber, + sizeof(deviceNumber), + FALSE); + if (!NT_SUCCESS(status)) + { + return status; + } + + FdoExtension->DiskData.DeviceNumber = deviceNumber.DeviceNumber; + return status; +} + +// requires partitioning lock held +static +CODE_SEG("PAGE") +NTSTATUS +PartMgrRefreshDiskData( + _In_ PFDO_EXTENSION FdoExtension) +{ + NTSTATUS status; + + PAGED_CODE(); + + // get the DiskSize and BytesPerSector + DISK_GEOMETRY_EX geometryEx; + status = IssueSyncIoControlRequest(IOCTL_DISK_GET_DRIVE_GEOMETRY_EX, + FdoExtension->LowerDevice, + NULL, + 0, + &geometryEx, + sizeof(geometryEx), + FALSE); + if (!NT_SUCCESS(status)) + { + return status; + } + + FdoExtension->DiskData.DiskSize = geometryEx.DiskSize.QuadPart; + FdoExtension->DiskData.BytesPerSector = geometryEx.Geometry.BytesPerSector; + + // get the partition style-related info + PDRIVE_LAYOUT_INFORMATION_EX layoutEx = NULL; + status = PartMgrGetDriveLayout(FdoExtension, &layoutEx); + if (!NT_SUCCESS(status)) + { + return status; + } + + FdoExtension->DiskData.PartitionStyle = layoutEx->PartitionStyle; + if (FdoExtension->DiskData.PartitionStyle == PARTITION_STYLE_MBR) + { + FdoExtension->DiskData.Mbr.Signature = layoutEx->Mbr.Signature; + // FdoExtension->DiskData.Mbr.Checksum = geometryEx.Partition.Mbr.CheckSum; + } + else + { + FdoExtension->DiskData.Gpt.DiskId = layoutEx->Gpt.DiskId; + } + + return STATUS_SUCCESS; +} + +static +CODE_SEG("PAGE") +NTSTATUS +FdoHandleDeviceRelations( + _In_ PFDO_EXTENSION FdoExtension, + _In_ PIRP Irp) +{ + PIO_STACK_LOCATION ioStack = IoGetCurrentIrpStackLocation(Irp); + DEVICE_RELATION_TYPE type = ioStack->Parameters.QueryDeviceRelations.Type; + + PAGED_CODE(); + + if (type == BusRelations) + { + PartMgrAcquireLayoutLock(FdoExtension); + + NTSTATUS status = PartMgrRefreshDiskData(FdoExtension); + if (!NT_SUCCESS(status)) + { + PartMgrReleaseLayoutLock(FdoExtension); + Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES; + Irp->IoStatus.Information = 0; + IoCompleteRequest(Irp, IO_NO_INCREMENT); + return Irp->IoStatus.Status; + } + + INFO("Partition style %u\n", FdoExtension->DiskData.PartitionStyle); + + // PartMgrAcquireLayoutLock calls PartMgrGetDriveLayout inside + // so we're sure here that it returns only cached layout + PDRIVE_LAYOUT_INFORMATION_EX layoutEx; + PartMgrGetDriveLayout(FdoExtension, &layoutEx); + + PartMgrUpdatePartitionDevices(FdoExtension, layoutEx); + + // now fill the DeviceRelations structure + TRACE("Reporting %u partitions\n", FdoExtension->EnumeratedPartitionsTotal); + + PDEVICE_RELATIONS deviceRelations = + ExAllocatePoolWithTag(PagedPool, + sizeof(DEVICE_RELATIONS) + + sizeof(PDEVICE_OBJECT) + * (FdoExtension->EnumeratedPartitionsTotal - 1), + TAG_PARTMGR); + + if (!deviceRelations) + { + PartMgrReleaseLayoutLock(FdoExtension); + Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES; + Irp->IoStatus.Information = 0; + IoCompleteRequest(Irp, IO_NO_INCREMENT); + return Irp->IoStatus.Status; + } + + deviceRelations->Count = 0; + + PSINGLE_LIST_ENTRY curEntry = FdoExtension->PartitionList.Next; + while (curEntry != NULL) + { + PPARTITION_EXTENSION partExt = CONTAINING_RECORD(curEntry, + PARTITION_EXTENSION, + ListEntry); + + // mark the PDO to know that we don't need to manually delete it + partExt->IsEnumerated = TRUE; + deviceRelations->Objects[deviceRelations->Count++] = partExt->DeviceObject; + ObReferenceObject(partExt->DeviceObject); + + curEntry = partExt->ListEntry.Next; + } + + ASSERT(deviceRelations->Count == FdoExtension->EnumeratedPartitionsTotal); + + PartMgrReleaseLayoutLock(FdoExtension); + + Irp->IoStatus.Information = (ULONG_PTR)deviceRelations; + Irp->IoStatus.Status = STATUS_SUCCESS; + } + + IoSkipCurrentIrpStackLocation(Irp); + return IoCallDriver(FdoExtension->LowerDevice, Irp); +} + +static +CODE_SEG("PAGE") +NTSTATUS +FdoHandleRemoveDevice( + _In_ PFDO_EXTENSION FdoExtension, + _In_ PIRP Irp) +{ + PAGED_CODE(); + + for (PSINGLE_LIST_ENTRY curEntry = FdoExtension->PartitionList.Next; + curEntry != NULL; + curEntry = curEntry->Next) + { + PPARTITION_EXTENSION partExt = CONTAINING_RECORD(curEntry, + PARTITION_EXTENSION, + ListEntry); + + ASSERT(partExt->DeviceRemoved); + } + + // Send the IRP down the stack + IoSkipCurrentIrpStackLocation(Irp); + Irp->IoStatus.Status = STATUS_SUCCESS; + NTSTATUS status = IoCallDriver(FdoExtension->LowerDevice, Irp); + + IoDetachDevice(FdoExtension->LowerDevice); + IoDeleteDevice(FdoExtension->DeviceObject); + return status; +} + +static +CODE_SEG("PAGE") +NTSTATUS +FdoHandleSurpriseRemoval( + _In_ PFDO_EXTENSION FdoExtension, + _In_ PIRP Irp) +{ + PAGED_CODE(); + + // all enumerated child devices should receive IRP_MN_REMOVE_DEVICE + // removing only non-enumerated ones here + for (PSINGLE_LIST_ENTRY curEntry = FdoExtension->PartitionList.Next; + curEntry != NULL; + curEntry = curEntry->Next) + { + PPARTITION_EXTENSION partExt = CONTAINING_RECORD(curEntry, + PARTITION_EXTENSION, + ListEntry); + + if (partExt->IsEnumerated) + { + PartitionHandleRemove(partExt, TRUE); + } + } + + // Send the IRP down the stack + IoSkipCurrentIrpStackLocation(Irp); + Irp->IoStatus.Status = STATUS_SUCCESS; + return IoCallDriver(FdoExtension->LowerDevice, Irp); +} + +static +CODE_SEG("PAGE") +NTSTATUS +NTAPI +PartMgrAddDevice( + _In_ PDRIVER_OBJECT DriverObject, + _In_ PDEVICE_OBJECT PhysicalDeviceObject) +{ + PDEVICE_OBJECT deviceObject; + + PAGED_CODE(); + + NTSTATUS status = IoCreateDevice(DriverObject, + sizeof(FDO_EXTENSION), + 0, + FILE_DEVICE_BUS_EXTENDER, + FILE_AUTOGENERATED_DEVICE_NAME | FILE_DEVICE_SECURE_OPEN, + FALSE, + &deviceObject); + + if (!NT_SUCCESS(status)) + { + ERR("Failed to create FDO 0x%x\n", status); + return status; + } + + PFDO_EXTENSION deviceExtension = deviceObject->DeviceExtension; + RtlZeroMemory(deviceExtension, sizeof(*deviceExtension)); + + deviceExtension->IsFDO = TRUE; + deviceExtension->DeviceObject = deviceObject; + deviceExtension->LowerDevice = IoAttachDeviceToDeviceStack(deviceObject, PhysicalDeviceObject); + deviceExtension->PhysicalDiskDO = PhysicalDeviceObject; + KeInitializeEvent(&deviceExtension->SyncEvent, SynchronizationEvent, TRUE); + + // the the attaching failed + if (!deviceExtension->LowerDevice) + { + IoDeleteDevice(deviceObject); + + return STATUS_DEVICE_REMOVED; + } + deviceObject->Flags |= DO_DIRECT_IO | DO_POWER_PAGABLE; + + // device is initialized + deviceObject->Flags &= ~DO_DEVICE_INITIALIZING; + + return STATUS_SUCCESS; +} + +static +NTSTATUS +NTAPI +PartMgrDeviceControl( + _In_ PDEVICE_OBJECT DeviceObject, + _In_ PIRP Irp) +{ + PIO_STACK_LOCATION ioStack = IoGetCurrentIrpStackLocation(Irp); + PFDO_EXTENSION fdoExtension = DeviceObject->DeviceExtension; + NTSTATUS status; + + // Note: IRP_MJ_DEVICE_CONTROL handler in the storage stack must be able to pass IOCTLs + // at an IRQL higher than PASSIVE_LEVEL + + INFO("IRP_MJ_DEVICE_CONTROL %p Irp %p IOCTL %x isFdo: %u\n", + DeviceObject, Irp, ioStack->Parameters.DeviceIoControl.IoControlCode, fdoExtension->IsFDO); + + if (!fdoExtension->IsFDO) + { + return PartitionHandleDeviceControl(DeviceObject, Irp); + } + + switch (ioStack->Parameters.DeviceIoControl.IoControlCode) + { + case IOCTL_DISK_GET_DRIVE_GEOMETRY_EX: + status = FdoIoctlDiskGetDriveGeometryEx(fdoExtension, Irp); + break; + + case IOCTL_DISK_GET_PARTITION_INFO: + status = FdoIoctlDiskGetPartitionInfo(fdoExtension, Irp); + break; + + case IOCTL_DISK_GET_PARTITION_INFO_EX: + status = FdoIoctlDiskGetPartitionInfoEx(fdoExtension, Irp); + break; + + case IOCTL_DISK_GET_DRIVE_LAYOUT: + status = FdoIoctlDiskGetDriveLayout(fdoExtension, Irp); + break; + + case IOCTL_DISK_GET_DRIVE_LAYOUT_EX: + status = FdoIoctlDiskGetDriveLayoutEx(fdoExtension, Irp); + break; + + case IOCTL_DISK_SET_DRIVE_LAYOUT: + status = FdoIoctlDiskSetDriveLayout(fdoExtension, Irp); + break; + + case IOCTL_DISK_SET_DRIVE_LAYOUT_EX: + status = FdoIoctlDiskSetDriveLayoutEx(fdoExtension, Irp); + break; + + case IOCTL_DISK_UPDATE_PROPERTIES: + status = FdoIoctlDiskUpdateProperties(fdoExtension, Irp); + break; + + case IOCTL_DISK_CREATE_DISK: + status = FdoIoctlDiskCreateDisk(fdoExtension, Irp); + break; + + case IOCTL_DISK_DELETE_DRIVE_LAYOUT: + status = FdoIoctlDiskDeleteDriveLayout(fdoExtension, Irp); + break; + // case IOCTL_DISK_GROW_PARTITION: // todo + default: + return ForwardIrpAndForget(DeviceObject, Irp); + } + + Irp->IoStatus.Status = status; + IoCompleteRequest(Irp, IO_NO_INCREMENT); + return status; +} + +static +CODE_SEG("PAGE") +NTSTATUS +NTAPI +PartMgrPnp( + _In_ PDEVICE_OBJECT DeviceObject, + _In_ PIRP Irp) +{ + PAGED_CODE(); + + PFDO_EXTENSION fdoExtension = DeviceObject->DeviceExtension; + PIO_STACK_LOCATION ioStack = IoGetCurrentIrpStackLocation(Irp); + + INFO("IRP_MJ_PNP %p Irp %p %s isFDO: %u\n", + DeviceObject, Irp, GetIRPMinorFunctionString(ioStack->MinorFunction), fdoExtension->IsFDO); + + if (!fdoExtension->IsFDO) + { + return PartitionHandlePnp(DeviceObject, Irp); + } + + switch (ioStack->MinorFunction) { + + case IRP_MN_START_DEVICE: + { + NTSTATUS status; + + // if this is sent to the FDO so we should forward it down the + // attachment chain before we can start the FDO + + if (!IoForwardIrpSynchronously(fdoExtension->LowerDevice, Irp)) + { + status = STATUS_UNSUCCESSFUL; + } + else + { + status = FdoHandleStartDevice(fdoExtension, Irp); + } + + Irp->IoStatus.Status = status; + IoCompleteRequest(Irp, IO_NO_INCREMENT); + return status; + } + case IRP_MN_QUERY_DEVICE_RELATIONS: + { + return FdoHandleDeviceRelations(fdoExtension, Irp); + } + case IRP_MN_SURPRISE_REMOVAL: + { + return FdoHandleSurpriseRemoval(fdoExtension, Irp); + } + case IRP_MN_REMOVE_DEVICE: + { + return FdoHandleRemoveDevice(fdoExtension, Irp); + } + case IRP_MN_QUERY_STOP_DEVICE: + case IRP_MN_QUERY_REMOVE_DEVICE: + case IRP_MN_CANCEL_STOP_DEVICE: + case IRP_MN_CANCEL_REMOVE_DEVICE: + case IRP_MN_STOP_DEVICE: + { + Irp->IoStatus.Status = STATUS_SUCCESS; + // fallthrough + } + default: + { + IoSkipCurrentIrpStackLocation(Irp); + return IoCallDriver(fdoExtension->LowerDevice, Irp); + } + } +} + +static +NTSTATUS +NTAPI +PartMgrReadWrite( + _In_ PDEVICE_OBJECT DeviceObject, + _In_ PIRP Irp) +{ + PPARTITION_EXTENSION partExt = DeviceObject->DeviceExtension; + PIO_STACK_LOCATION ioStack = IoGetCurrentIrpStackLocation(Irp); + + if (!partExt->IsFDO) + { + if (!partExt->IsEnumerated) + { + Irp->IoStatus.Status = STATUS_DEVICE_DOES_NOT_EXIST; + IoCompleteRequest(Irp, IO_NO_INCREMENT); + return STATUS_DEVICE_DOES_NOT_EXIST; + } + else + { + ioStack->Parameters.Read.ByteOffset.QuadPart += partExt->StartingOffset; + } + } + + IoSkipCurrentIrpStackLocation(Irp); + return IoCallDriver(partExt->LowerDevice, Irp); +} + +DRIVER_DISPATCH PartMgrPower; +NTSTATUS +NTAPI +PartMgrPower( + _In_ PDEVICE_OBJECT DeviceObject, + _In_ PIRP Irp) +{ + PPARTITION_EXTENSION partExt = DeviceObject->DeviceExtension; + PIO_STACK_LOCATION ioStack = IoGetCurrentIrpStackLocation(Irp); + + PoStartNextPowerIrp(Irp); + + if (!partExt->IsFDO) + { + NTSTATUS status; + + if (!partExt->IsEnumerated) + { + status = STATUS_DEVICE_DOES_NOT_EXIST; + } + else if (ioStack->MinorFunction == IRP_MN_SET_POWER || + ioStack->MinorFunction == IRP_MN_QUERY_POWER) + { + status = STATUS_SUCCESS; + } + else + { + status = Irp->IoStatus.Status; + } + + Irp->IoStatus.Status = status; + IoCompleteRequest(Irp, IO_NO_INCREMENT); + return status; + } + else + { + IoSkipCurrentIrpStackLocation(Irp); + return PoCallDriver(partExt->LowerDevice, Irp); + } +} + +DRIVER_DISPATCH PartMgrShutdownFlush; +NTSTATUS +NTAPI +PartMgrShutdownFlush( + _In_ PDEVICE_OBJECT DeviceObject, + _In_ PIRP Irp) +{ + PPARTITION_EXTENSION partExt = DeviceObject->DeviceExtension; + PDEVICE_OBJECT lowerDevice; + + // forward to the partition0 device in both cases + if (!partExt->IsFDO) + { + if (!partExt->IsEnumerated) + { + Irp->IoStatus.Status = STATUS_DEVICE_DOES_NOT_EXIST; + IoCompleteRequest(Irp, IO_NO_INCREMENT); + return STATUS_DEVICE_DOES_NOT_EXIST; + } + else + { + PFDO_EXTENSION fdoExtension = partExt->LowerDevice->DeviceExtension; + lowerDevice = fdoExtension->LowerDevice; + } + } + else + { + lowerDevice = partExt->LowerDevice; + } + + IoSkipCurrentIrpStackLocation(Irp); + return IoCallDriver(lowerDevice, Irp); +} + +CODE_SEG("PAGE") +VOID +NTAPI +PartMgrUnload( + _In_ PDRIVER_OBJECT DriverObject) +{ + +} + +CODE_SEG("INIT") +NTSTATUS +NTAPI +DriverEntry( + _In_ PDRIVER_OBJECT DriverObject, + _In_ PUNICODE_STRING RegistryPath) +{ + DriverObject->DriverUnload = PartMgrUnload; + DriverObject->DriverExtension->AddDevice = PartMgrAddDevice; + DriverObject->MajorFunction[IRP_MJ_CREATE] = ForwardIrpAndForget; + DriverObject->MajorFunction[IRP_MJ_CLOSE] = ForwardIrpAndForget; + DriverObject->MajorFunction[IRP_MJ_READ] = PartMgrReadWrite; + DriverObject->MajorFunction[IRP_MJ_WRITE] = PartMgrReadWrite; + DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = PartMgrDeviceControl; + DriverObject->MajorFunction[IRP_MJ_PNP] = PartMgrPnp; + DriverObject->MajorFunction[IRP_MJ_SHUTDOWN] = PartMgrShutdownFlush; + DriverObject->MajorFunction[IRP_MJ_FLUSH_BUFFERS] = PartMgrShutdownFlush; + DriverObject->MajorFunction[IRP_MJ_POWER] = PartMgrPower; + + return STATUS_SUCCESS; +} diff --git a/drivers/storage/partmgr/partmgr.h b/drivers/storage/partmgr/partmgr.h new file mode 100644 index 00000000000..05a0ee6bbbd --- /dev/null +++ b/drivers/storage/partmgr/partmgr.h @@ -0,0 +1,192 @@ +/* + * PROJECT: Partition manager driver + * LICENSE: GPL-2.0-or-later (https://spdx.org/licenses/GPL-2.0-or-later) + * PURPOSE: Main header + * COPYRIGHT: 2020 Victor Perevertkin (victor.perevertkin(a)reactos.org) + */ + +#ifndef _PARTMGR_H_ +#define _PARTMGR_H_ + +#include <ntifs.h> +#include <mountdev.h> +#include <ntddvol.h> +#include <ntdddisk.h> +#include <ndk/psfuncs.h> +#include <ndk/section_attribs.h> +#include <ioevent.h> +#include <stdio.h> +#include <debug/driverdbg.h> + +#include "debug.h" + +#define TAG_PARTMGR 'MtrP' + +// from disk.sys +typedef struct _DISK_GEOMETRY_EX_INTERNAL +{ + DISK_GEOMETRY Geometry; + INT64 DiskSize; + DISK_PARTITION_INFO Partition; + DISK_DETECTION_INFO Detection; +} DISK_GEOMETRY_EX_INTERNAL, *PDISK_GEOMETRY_EX_INTERNAL; + +typedef struct _FDO_EXTENSION +{ + BOOLEAN IsFDO; + PDEVICE_OBJECT DeviceObject; + PDEVICE_OBJECT LowerDevice; + PDEVICE_OBJECT PhysicalDiskDO; + KEVENT SyncEvent; + + BOOLEAN LayoutValid; + PDRIVE_LAYOUT_INFORMATION_EX LayoutCache; + + SINGLE_LIST_ENTRY PartitionList; + UINT32 EnumeratedPartitionsTotal; + + struct { + UINT64 DiskSize; + UINT32 DeviceNumber; + UINT32 BytesPerSector; + PARTITION_STYLE PartitionStyle; + union { + struct { + UINT32 Signature; + } Mbr; + struct { + GUID DiskId; + } Gpt; + }; + } DiskData; +} FDO_EXTENSION, *PFDO_EXTENSION; + +typedef struct _PARTITION_EXTENSION +{ + BOOLEAN IsFDO; + PDEVICE_OBJECT DeviceObject; + PDEVICE_OBJECT LowerDevice; + PDEVICE_OBJECT Part0Device; + + UINT64 StartingOffset; + UINT64 PartitionLength; + SINGLE_LIST_ENTRY ListEntry; + + UINT32 DetectedNumber; + UINT32 OnDiskNumber; // partition number for issuing Io requests to the kernel + BOOLEAN IsEnumerated; // reported via IRP_MN_QUERY_DEVICE_RELATIONS + BOOLEAN SymlinkCreated; + BOOLEAN DeviceRemoved; // !!! + BOOLEAN Attached; // attached to PartitionList of the FDO + union + { + struct + { + GUID PartitionType; + GUID PartitionId; + UINT64 Attributes; + WCHAR Name[36]; + } Gpt; + struct + { + UINT8 PartitionType; + BOOLEAN BootIndicator; + BOOLEAN RecognizedPartition; + UINT32 HiddenSectors; + } Mbr; + }; + UNICODE_STRING PartitionInterfaceName; + UNICODE_STRING VolumeInterfaceName; + UNICODE_STRING DeviceName; +} PARTITION_EXTENSION, *PPARTITION_EXTENSION; + +NTSTATUS +PartitionCreateDevice( + _In_ PDEVICE_OBJECT FDObject, + _In_ PPARTITION_INFORMATION_EX PartitionEntry, + _In_ UINT32 OnDiskNumber, + _In_ PARTITION_STYLE PartitionStyle, + _Out_ PDEVICE_OBJECT *PDO); + +NTSTATUS +PartitionHandleRemove( + _In_ PPARTITION_EXTENSION PartExt, + _In_ BOOLEAN FinalRemove); + +NTSTATUS +PartitionHandlePnp( + _In_ PDEVICE_OBJECT DeviceObject, + _In_ PIRP Irp); + +NTSTATUS +PartitionHandleDeviceControl( + _In_ PDEVICE_OBJECT DeviceObject, + _In_ PIRP Irp); + +NTSTATUS +NTAPI +ForwardIrpAndForget( + _In_ PDEVICE_OBJECT DeviceObject, + _In_ PIRP Irp); + +NTSTATUS +IssueSyncIoControlRequest( + _In_ UINT32 IoControlCode, + _In_ PDEVICE_OBJECT DeviceObject, + _In_ PVOID InputBuffer, + _In_ ULONG InputBufferLength, + _In_ PVOID OutputBuffer, + _In_ ULONG OutputBufferLength, + _In_ BOOLEAN InternalDeviceIoControl); + +inline +BOOLEAN +VerifyIrpOutBufferSize( + _In_ PIRP Irp, + _In_ SIZE_T Size) +{ + PIO_STACK_LOCATION ioStack = IoGetCurrentIrpStackLocation(Irp); + if (ioStack->Parameters.DeviceIoControl.OutputBufferLength < Size) + { + Irp->IoStatus.Information = Size; + return FALSE; + } + return TRUE; +} + +inline +BOOLEAN +VerifyIrpInBufferSize( + _In_ PIRP Irp, + _In_ SIZE_T Size) +{ + PIO_STACK_LOCATION ioStack = IoGetCurrentIrpStackLocation(Irp); + if (ioStack->Parameters.DeviceIoControl.InputBufferLength < Size) + { + Irp->IoStatus.Information = Size; + return FALSE; + } + return TRUE; +} + +inline +VOID +PartMgrAcquireLayoutLock( + _In_ PFDO_EXTENSION FDOExtension) +{ + PAGED_CODE(); + + KeWaitForSingleObject(&FDOExtension->SyncEvent, Executive, KernelMode, FALSE, NULL); +} + +inline +VOID +PartMgrReleaseLayoutLock( + _In_ PFDO_EXTENSION FDOExtension) +{ + PAGED_CODE(); + + KeSetEvent(&FDOExtension->SyncEvent, IO_NO_INCREMENT, FALSE); +} + +#endif // _PARTMGR_H_ diff --git a/drivers/storage/partmgr/partmgr.rc b/drivers/storage/partmgr/partmgr.rc new file mode 100644 index 00000000000..29c32a5ad4e --- /dev/null +++ b/drivers/storage/partmgr/partmgr.rc @@ -0,0 +1,5 @@ +#define REACTOS_VERSION_DLL +#define REACTOS_STR_FILE_DESCRIPTION "Partition Manager" +#define REACTOS_STR_INTERNAL_NAME "partmgr" +#define REACTOS_STR_ORIGINAL_FILENAME "partmgr.sys" +#include <reactos/version.rc> diff --git a/drivers/storage/partmgr/partmgr_reg.inf b/drivers/storage/partmgr/partmgr_reg.inf new file mode 100644 index 00000000000..de0e3c5178c --- /dev/null +++ b/drivers/storage/partmgr/partmgr_reg.inf @@ -0,0 +1,7 @@ +[AddReg] +HKLM,"SYSTEM\CurrentControlSet\Services\partmgr","ErrorControl",0x00010001,0x00000000 +HKLM,"SYSTEM\CurrentControlSet\Services\partmgr","DisplayName",0x00000000,"Partition Manager" +HKLM,"SYSTEM\CurrentControlSet\Services\partmgr","Group",0x00000000,"Boot Bus Extender" +HKLM,"SYSTEM\CurrentControlSet\Services\partmgr","ImagePath",0x00020000,"system32\drivers\partmgr.sys" +HKLM,"SYSTEM\CurrentControlSet\Services\partmgr","Start",0x00010001,0x00000000 +HKLM,"SYSTEM\CurrentControlSet\Services\partmgr","Type",0x00010001,0x00000001 diff --git a/drivers/storage/partmgr/utils.c b/drivers/storage/partmgr/utils.c new file mode 100644 index 00000000000..38751850dae --- /dev/null +++ b/drivers/storage/partmgr/utils.c @@ -0,0 +1,73 @@ +#include "partmgr.h" + +NTSTATUS +NTAPI +ForwardIrpAndForget( + _In_ PDEVICE_OBJECT DeviceObject, + _In_ PIRP Irp) +{ + // this part of a structure is identical in both FDO and PDO + PDEVICE_OBJECT LowerDevice = ((PFDO_EXTENSION)DeviceObject->DeviceExtension)->LowerDevice; + + ASSERT(LowerDevice); + + IoSkipCurrentIrpStackLocation(Irp); + return IoCallDriver(LowerDevice, Irp); +} + +NTSTATUS +IssueSyncIoControlRequest( + _In_ UINT32 IoControlCode, + _In_ PDEVICE_OBJECT DeviceObject, + _In_ PVOID InputBuffer, + _In_ ULONG InputBufferLength, + _In_ PVOID OutputBuffer, + _In_ ULONG OutputBufferLength, + _In_ BOOLEAN InternalDeviceIoControl) +{ + PIRP Irp; + IO_STATUS_BLOCK IoStatusBlock; + PKEVENT Event; + NTSTATUS Status; + PAGED_CODE(); + + /* Allocate a non-paged event */ + Event = ExAllocatePoolWithTag(NonPagedPool, sizeof(*Event), TAG_PARTMGR); + if (!Event) + { + return STATUS_INSUFFICIENT_RESOURCES; + } + + /* Initialize it */ + KeInitializeEvent(Event, NotificationEvent, FALSE); + + /* Build the IRP */ + Irp = IoBuildDeviceIoControlRequest(IoControlCode, + DeviceObject, + InputBuffer, + InputBufferLength, + OutputBuffer, + OutputBufferLength, + InternalDeviceIoControl, + Event, + &IoStatusBlock); + if (!Irp) + { + /* Fail, free the event */ + ExFreePoolWithTag(Event, TAG_PARTMGR); + return STATUS_INSUFFICIENT_RESOURCES; + } + + /* Call the driver and check if it's pending */ + Status = IoCallDriver(DeviceObject, Irp); + if (Status == STATUS_PENDING) + { + /* Wait on the driver */ + KeWaitForSingleObject(Event, Executive, KernelMode, FALSE, NULL); + Status = IoStatusBlock.Status; + } + + /* Free the event and return the Status */ + ExFreePoolWithTag(Event, TAG_PARTMGR); + return Status; +}

4 years, 1 month

[reactos] 01/01: [MOUNTMGR] Volumes with NO_DRIVE_LETTER attribute should not be mounted, not the opposite

by Victor Perevertkin

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=bbfc515eb3cf208d8637d… commit bbfc515eb3cf208d8637d3631c1d833e3e0778d1 Author: Victor Perevertkin <victor.perevertkin(a)reactos.org> AuthorDate: Thu Nov 12 19:19:27 2020 +0300 Commit: Victor Perevertkin <victor.perevertkin(a)reactos.org> CommitDate: Thu Nov 12 19:19:27 2020 +0300 [MOUNTMGR] Volumes with NO_DRIVE_LETTER attribute should not be mounted, not the opposite --- drivers/storage/mountmgr/mountmgr.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/drivers/storage/mountmgr/mountmgr.c b/drivers/storage/mountmgr/mountmgr.c index 9ec66ed7217..e733d322766 100644 --- a/drivers/storage/mountmgr/mountmgr.c +++ b/drivers/storage/mountmgr/mountmgr.c @@ -282,8 +282,7 @@ QueryDeviceInformation(IN PUNICODE_STRING SymbolicName, Status = STATUS_SUCCESS; } /* Check if it has a drive letter */ - else if (!(GptAttributes.GptAttributes & - GPT_BASIC_DATA_ATTRIBUTE_NO_DRIVE_LETTER)) + else if (GptAttributes.GptAttributes & GPT_BASIC_DATA_ATTRIBUTE_NO_DRIVE_LETTER) { *GptDriveLetter = FALSE; }

4 years, 1 month

[reactos] 01/01: [NTOS:PNP] Enumerate the device tree after loading boot drivers and HAL

by Victor Perevertkin

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=d6ef8f97e943f6568da3f… commit d6ef8f97e943f6568da3f4c74ff55746480accba Author: Victor Perevertkin <victor.perevertkin(a)reactos.org> AuthorDate: Tue Nov 10 01:56:59 2020 +0300 Commit: Victor Perevertkin <victor.perevertkin(a)reactos.org> CommitDate: Tue Nov 10 01:59:49 2020 +0300 [NTOS:PNP] Enumerate the device tree after loading boot drivers and HAL --- ntoskrnl/io/iomgr/driver.c | 6 ++++++ ntoskrnl/io/iomgr/iomgr.c | 7 +++++++ 2 files changed, 13 insertions(+) diff --git a/ntoskrnl/io/iomgr/driver.c b/ntoskrnl/io/iomgr/driver.c index 3c4f3433ecf..9fd8c9b87c5 100644 --- a/ntoskrnl/io/iomgr/driver.c +++ b/ntoskrnl/io/iomgr/driver.c @@ -1122,6 +1122,12 @@ IopInitializeBootDrivers(VOID) /* Initialize it */ IopInitializeBuiltinDriver(LdrEntry); + /* Start the devices found by a driver (if any) */ + PiQueueDeviceAction(IopRootDeviceNode->PhysicalDeviceObject, + PiActionEnumRootDevices, + NULL, + NULL); + /* Next entry */ NextEntry = NextEntry->Flink; } diff --git a/ntoskrnl/io/iomgr/iomgr.c b/ntoskrnl/io/iomgr/iomgr.c index ecdf3fbdb5e..0173cf4911d 100644 --- a/ntoskrnl/io/iomgr/iomgr.c +++ b/ntoskrnl/io/iomgr/iomgr.c @@ -543,6 +543,13 @@ IoInitSystem(IN PLOADER_PARAMETER_BLOCK LoaderBlock) /* Initialize HAL Root Bus Driver */ HalInitPnpDriver(); + /* Reenumerate what HAL has added (synchronously) + * This function call should eventually become a 2nd stage of the PnP initialization */ + PiQueueDeviceAction(IopRootDeviceNode->PhysicalDeviceObject, + PiActionEnumRootDevices, + NULL, + NULL); + /* Make loader block available for the whole kernel */ IopLoaderBlock = LoaderBlock;

4 years, 1 month

[reactos] 01/01: [BOOTDATA] Add an empty SystemPrefix value (#3362)

by Adam Słaboń

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=334abba1c3853b6121c64… commit 334abba1c3853b6121c646fb1583c2bffac4d04a Author: Adam Słaboń <asaillen456esx(a)gmail.com> AuthorDate: Mon Nov 9 23:46:35 2020 +0100 Commit: GitHub <noreply(a)github.com> CommitDate: Mon Nov 9 23:46:35 2020 +0100 [BOOTDATA] Add an empty SystemPrefix value (#3362) This gets "ReactOS" with Win2003 NT kernel + HAL boot a bit further. (The "SystemPrefix" REG_DWORD value is part of license information in Win2000/XP/2003.) --- boot/bootdata/hivesys.inf | 1 + 1 file changed, 1 insertion(+) diff --git a/boot/bootdata/hivesys.inf b/boot/bootdata/hivesys.inf index 30bb1a01944..8b1a02c38f1 100644 --- a/boot/bootdata/hivesys.inf +++ b/boot/bootdata/hivesys.inf @@ -2220,6 +2220,7 @@ HKLM,"SYSTEM\Setup","CmdLine",0x00000000,"setup -newsetup" HKLM,"SYSTEM\Setup","OsLoaderPath",0x00000000,"\" HKLM,"SYSTEM\Setup","SetupType",0x00010001,0x00000001 HKLM,"SYSTEM\Setup","SystemPartition",0x00000000,"\Device\Harddisk0\Partition1" +HKLM,"SYSTEM\Setup","SystemPrefix",0x00000001 HKLM,"SYSTEM\Setup","SystemSetupInProgress",0x00010001,0x00000001 ; Debug channels

4 years, 1 month

[reactos] 01/01: [XDK] Update the definition of DEBUG_DEVICE_DESCRIPTOR and related structures with Vista, 7, 8, 10 additions. CORE-17360

by Hermès Bélusca-Maïto

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=be01e6d76f821eaa0c6fb… commit be01e6d76f821eaa0c6fb4661c61fa2799f17ab9 Author: Hermès Bélusca-Maïto <hermes.belusca-maito(a)reactos.org> AuthorDate: Mon Nov 9 22:33:02 2020 +0100 Commit: Hermès Bélusca-Maïto <hermes.belusca-maito(a)reactos.org> CommitDate: Mon Nov 9 22:33:02 2020 +0100 [XDK] Update the definition of DEBUG_DEVICE_DESCRIPTOR and related structures with Vista,7,8,10 additions. CORE-17360 Information from: - https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/ntddk/ns-ntdd… - https://www.vergiliusproject.com - https://codemachine.com --- sdk/include/xdk/kdtypes.h | 86 +++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 84 insertions(+), 2 deletions(-) diff --git a/sdk/include/xdk/kdtypes.h b/sdk/include/xdk/kdtypes.h index 1c7efbcc405..fbe32dde0b2 100644 --- a/sdk/include/xdk/kdtypes.h +++ b/sdk/include/xdk/kdtypes.h @@ -5,7 +5,17 @@ $if (_NTDDK_) typedef struct _DEBUG_DEVICE_ADDRESS { UCHAR Type; BOOLEAN Valid; - UCHAR Reserved[2]; +#if (NTDDI_VERSION >= NTDDI_WIN10_RS3) + union { +#endif + UCHAR Reserved[2]; +#if (NTDDI_VERSION >= NTDDI_WIN10_RS3) + struct { + UCHAR BitWidth; + UCHAR AccessSize; + }; + }; +#endif PUCHAR TranslatedAddress; ULONG Length; } DEBUG_DEVICE_ADDRESS, *PDEBUG_DEVICE_ADDRESS; @@ -19,19 +29,91 @@ typedef struct _DEBUG_MEMORY_REQUIREMENTS { BOOLEAN Aligned; } DEBUG_MEMORY_REQUIREMENTS, *PDEBUG_MEMORY_REQUIREMENTS; +#if (NTDDI_VERSION >= NTDDI_WIN8) +typedef enum { + KdNameSpacePCI, + KdNameSpaceACPI, + KdNameSpaceAny, + KdNameSpaceNone, + KdNameSpaceMax, /* Maximum namespace enumerator */ +} KD_NAMESPACE_ENUM, *PKD_NAMESPACE_ENUM; +#endif + +#if (NTDDI_VERSION >= NTDDI_WIN10) +typedef struct _DEBUG_TRANSPORT_DATA { + ULONG HwContextSize; + BOOLEAN UseSerialFraming; +#if (NTDDI_VERSION >= NTDDI_WIN10_RS5) + BOOLEAN ValidUSBCoreId; + UCHAR USBCoreId; +#endif +} DEBUG_TRANSPORT_DATA, *PDEBUG_TRANSPORT_DATA; +#endif + +#define MAXIMUM_DEBUG_BARS 6 + +#if (NTDDI_VERSION >= NTDDI_WIN10) +#define DBG_DEVICE_FLAG_HAL_SCRATCH_ALLOCATED 0x01 +#define DBG_DEVICE_FLAG_BARS_MAPPED 0x02 +#define DBG_DEVICE_FLAG_SCRATCH_ALLOCATED 0x04 +#endif +#if (NTDDI_VERSION >= NTDDI_WIN10_RS2) +#define DBG_DEVICE_FLAG_UNCACHED_MEMORY 0x08 +#endif +#if (NTDDI_VERSION >= NTDDI_WIN10_RS3) +#define DBG_DEVICE_FLAG_SYNTHETIC 0x10 +#endif + typedef struct _DEBUG_DEVICE_DESCRIPTOR { ULONG Bus; +#if (NTDDI_VERSION >= NTDDI_VISTA) && (NTDDI_VERSION < NTDDI_WIN8) + USHORT Segment; +#endif ULONG Slot; +#if (NTDDI_VERSION >= NTDDI_WIN8) USHORT Segment; +#endif USHORT VendorID; USHORT DeviceID; UCHAR BaseClass; UCHAR SubClass; UCHAR ProgIf; +#if (NTDDI_VERSION >= NTDDI_WIN8) +#if (NTDDI_VERSION >= NTDDI_WIN10) + union { +#endif + UCHAR Flags; +#if (NTDDI_VERSION >= NTDDI_WIN10) + struct { + UCHAR DbgHalScratchAllocated : 1; + UCHAR DbgBarsMapped : 1; + UCHAR DbgScratchAllocated : 1; + }; + }; +#endif +#endif BOOLEAN Initialized; +#if (NTDDI_VERSION >= NTDDI_VISTA) BOOLEAN Configured; - DEBUG_DEVICE_ADDRESS BaseAddress[6]; +#endif + DEBUG_DEVICE_ADDRESS BaseAddress[MAXIMUM_DEBUG_BARS]; DEBUG_MEMORY_REQUIREMENTS Memory; +#if (NTDDI_VERSION >= NTDDI_WIN10_19H1) + ULONG Dbg2TableIndex; +#endif +#if (NTDDI_VERSION >= NTDDI_WIN8) + USHORT PortType; + USHORT PortSubtype; + PVOID OemData; + ULONG OemDataLength; + KD_NAMESPACE_ENUM NameSpace; + PWCHAR NameSpacePath; + ULONG NameSpacePathLength; +#endif +#if (NTDDI_VERSION >= NTDDI_WIN10) + ULONG TransportType; + DEBUG_TRANSPORT_DATA TransportData; +#endif } DEBUG_DEVICE_DESCRIPTOR, *PDEBUG_DEVICE_DESCRIPTOR; typedef NTSTATUS

4 years, 1 month

[reactos] 01/01: |CMAKE] Use RULE_LAUNCH_COMPILE property to handle ccache

by Jérôme Gardou

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=bf04126e025fdcabe3608… commit bf04126e025fdcabe360822d3d2fbc68b1841a50 Author: Jérôme Gardou <jerome.gardou(a)reactos.org> AuthorDate: Mon Nov 9 10:06:44 2020 +0100 Commit: Jérôme Gardou <jerome.gardou(a)reactos.org> CommitDate: Mon Nov 9 10:47:19 2020 +0100 |CMAKE] Use RULE_LAUNCH_COMPILE property to handle ccache --- CMakeLists.txt | 1 + sdk/cmake/gcc.cmake | 4 ++-- toolchain-clang.cmake | 6 ------ toolchain-gcc.cmake | 6 ------ 4 files changed, 3 insertions(+), 14 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index f81d9274381..103b1c5bf90 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -161,6 +161,7 @@ Enable this if the module uses typeid or dynamic_cast. You will probably need to if(ENABLE_CCACHE) message(WARNING "-- Disabling precompiled headers support (ccache).") option(PCH "Whether to use precompiled headers" OFF) + set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE ccache) elseif(GCC) message(WARNING "-- Disabling precompiled headers on GCC by default CORE-17108.") option(PCH "Whether to use precompiled headers" OFF) diff --git a/sdk/cmake/gcc.cmake b/sdk/cmake/gcc.cmake index 216c24c54a4..5fac4f059f4 100644 --- a/sdk/cmake/gcc.cmake +++ b/sdk/cmake/gcc.cmake @@ -246,9 +246,9 @@ if((CMAKE_C_COMPILER_ID STREQUAL "GNU") AND set(_compress_debug_sections_flag "-Wa,--compress-debug-sections") endif() -set(CMAKE_C_COMPILE_OBJECT "${CCACHE} <CMAKE_C_COMPILER> <DEFINES> ${_compress_debug_sections_flag} <INCLUDES> <FLAGS> -o <OBJECT> -c <SOURCE>") +set(CMAKE_C_COMPILE_OBJECT "<CMAKE_C_COMPILER> <DEFINES> ${_compress_debug_sections_flag} <INCLUDES> <FLAGS> -o <OBJECT> -c <SOURCE>") # FIXME: Once the GCC toolchain bugs are fixed, add _compress_debug_sections_flag to CXX too -set(CMAKE_CXX_COMPILE_OBJECT "${CCACHE} <CMAKE_CXX_COMPILER> <DEFINES> <INCLUDES> <FLAGS> -o <OBJECT> -c <SOURCE>") +set(CMAKE_CXX_COMPILE_OBJECT "<CMAKE_CXX_COMPILER> <DEFINES> <INCLUDES> <FLAGS> -o <OBJECT> -c <SOURCE>") set(CMAKE_ASM_COMPILE_OBJECT "<CMAKE_ASM_COMPILER> ${_compress_debug_sections_flag} -x assembler-with-cpp -o <OBJECT> -I${REACTOS_SOURCE_DIR}/sdk/include/asm -I${REACTOS_BINARY_DIR}/sdk/include/asm <INCLUDES> <FLAGS> <DEFINES> -D__ASM__ -c <SOURCE>") set(CMAKE_RC_COMPILE_OBJECT "<CMAKE_RC_COMPILER> -O coff <INCLUDES> <FLAGS> -DRC_INVOKED -D__WIN32__=1 -D__FLAT__=1 ${I18N_DEFS} <DEFINES> <SOURCE> <OBJECT>") diff --git a/toolchain-clang.cmake b/toolchain-clang.cmake index af3caeccda4..da3ffc782e7 100644 --- a/toolchain-clang.cmake +++ b/toolchain-clang.cmake @@ -24,12 +24,6 @@ if(NOT DEFINED MINGW_TOOLCHAIN_SUFFIX) set(MINGW_TOOLCHAIN_SUFFIX "" CACHE STRING "MinGW Toolchain Suffix") endif() -if(ENABLE_CCACHE) - set(CCACHE "ccache" CACHE STRING "ccache") -else() - set(CCACHE "" CACHE STRING "ccache") -endif() - # The name of the target operating system set(CMAKE_SYSTEM_NAME Windows) set(CMAKE_SYSTEM_PROCESSOR i686) diff --git a/toolchain-gcc.cmake b/toolchain-gcc.cmake index d2801733ec4..276225ec663 100644 --- a/toolchain-gcc.cmake +++ b/toolchain-gcc.cmake @@ -30,12 +30,6 @@ if(NOT DEFINED MINGW_TOOLCHAIN_SUFFIX) set(MINGW_TOOLCHAIN_SUFFIX "" CACHE STRING "MinGW Toolchain Suffix") endif() -if(ENABLE_CCACHE) - set(CCACHE "ccache" CACHE STRING "ccache") -else() - set(CCACHE "" CACHE STRING "ccache") -endif() - # The name of the target operating system set(CMAKE_SYSTEM_NAME Windows) set(CMAKE_SYSTEM_PROCESSOR i686)

4 years, 1 month

[reactos] 01/01: [KDGDB] Always use kernel stack to get stack frame

by Jérôme Gardou

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=3acbec4851c99911b6574… commit 3acbec4851c99911b65741a3fe191bb9d066cf9a Author: Jérôme Gardou <jerome.gardou(a)reactos.org> AuthorDate: Fri Nov 6 09:38:17 2020 +0100 Commit: Jérôme Gardou <jerome.gardou(a)reactos.org> CommitDate: Mon Nov 9 10:47:05 2020 +0100 [KDGDB] Always use kernel stack to get stack frame --- drivers/base/kdgdb/i386_sup.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/drivers/base/kdgdb/i386_sup.c b/drivers/base/kdgdb/i386_sup.c index 0a357a149f0..82492d415a3 100644 --- a/drivers/base/kdgdb/i386_sup.c +++ b/drivers/base/kdgdb/i386_sup.c @@ -100,6 +100,7 @@ thread_to_reg(PETHREAD Thread, enum reg_name reg_name, unsigned short* size) return NULL; } } +#if 0 else if (Thread->Tcb.TrapFrame) { PKTRAP_FRAME TrapFrame = Thread->Tcb.TrapFrame; @@ -128,6 +129,7 @@ thread_to_reg(PETHREAD Thread, enum reg_name reg_name, unsigned short* size) KDDBGPRINT("Unhandled regname: %d.\n", reg_name); } } +#endif else { static PULONG Esp; @@ -213,7 +215,7 @@ gdb_send_registers(void) } } } - + return finish_gdb_packet(); }

4 years, 1 month

[reactos] 01/01: [HALX86] Drop hacks in HalpAddDevice to work around PnP synchronization bugs

by Victor Perevertkin

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=f75318b606fd97548ebef… commit f75318b606fd97548ebefe751289d769f9625d28 Author: Victor Perevertkin <victor.perevertkin(a)reactos.org> AuthorDate: Mon Nov 9 01:28:50 2020 +0300 Commit: Victor Perevertkin <victor.perevertkin(a)reactos.org> CommitDate: Mon Nov 9 01:28:50 2020 +0300 [HALX86] Drop hacks in HalpAddDevice to work around PnP synchronization bugs Our PnP manager handles OS boot in a synchronous manner thus we don't need it anymore. This effectively reverts f23e722, d974e84, 3aff101 and 4a9fcb6 CORE-5686 --- hal/halx86/acpi/halpnpdd.c | 96 ++++++++++++++++++-------------------------- hal/halx86/legacy/halpnpdd.c | 78 ++++++++++++++--------------------- 2 files changed, 69 insertions(+), 105 deletions(-) diff --git a/hal/halx86/acpi/halpnpdd.c b/hal/halx86/acpi/halpnpdd.c index beec1190f76..03c195293a5 100644 --- a/hal/halx86/acpi/halpnpdd.c +++ b/hal/halx86/acpi/halpnpdd.c @@ -50,59 +50,6 @@ PDRIVER_OBJECT HalpDriverObject; /* PRIVATE FUNCTIONS **********************************************************/ -VOID -NTAPI -HalpReportDetectedDevices(IN PDRIVER_OBJECT DriverObject, - IN PVOID Context, - IN ULONG Count) -{ - PFDO_EXTENSION FdoExtension = Context; - PPDO_EXTENSION PdoExtension; - PDEVICE_OBJECT PdoDeviceObject; - PDESCRIPTION_HEADER Wdrt; - NTSTATUS Status; - - /* Create the PDO */ - Status = IoCreateDevice(DriverObject, - sizeof(PDO_EXTENSION), - NULL, - FILE_DEVICE_BUS_EXTENDER, - FILE_AUTOGENERATED_DEVICE_NAME, - FALSE, - &PdoDeviceObject); - if (!NT_SUCCESS(Status)) - { - /* Fail */ - DPRINT1("HAL: Could not create ACPI device object status=0x%08x\n", Status); - return; - } - - /* Setup the PDO device extension */ - PdoExtension = PdoDeviceObject->DeviceExtension; - PdoExtension->ExtensionType = PdoExtensionType; - PdoExtension->PhysicalDeviceObject = PdoDeviceObject; - PdoExtension->ParentFdoExtension = FdoExtension; - PdoExtension->PdoType = AcpiPdo; - - /* Add the PDO to the head of the list */ - PdoExtension->Next = FdoExtension->ChildPdoList; - FdoExtension->ChildPdoList = PdoExtension; - - /* Initialization is finished */ - PdoDeviceObject->Flags &= ~DO_DEVICE_INITIALIZING; - - /* Find the ACPI watchdog table */ - Wdrt = HalAcpiGetTable(0, 'TRDW'); - if (Wdrt) - { - /* FIXME: TODO */ - DPRINT1("You have an ACPI Watchdog. That's great! You should be proud ;-)\n"); - } - - /* This will load the ACPI driver (IO initialization will wait for this operation to finish) */ - IoInvalidateDeviceRelations(FdoExtension->PhysicalDeviceObject, BusRelations); -} - NTSTATUS NTAPI HalpAddDevice(IN PDRIVER_OBJECT DriverObject, @@ -110,7 +57,10 @@ HalpAddDevice(IN PDRIVER_OBJECT DriverObject, { NTSTATUS Status; PFDO_EXTENSION FdoExtension; + PPDO_EXTENSION PdoExtension; PDEVICE_OBJECT DeviceObject, AttachedDevice; + PDEVICE_OBJECT PdoDeviceObject; + PDESCRIPTION_HEADER Wdrt; DPRINT("HAL: PnP Driver ADD!\n"); @@ -151,10 +101,42 @@ HalpAddDevice(IN PDRIVER_OBJECT DriverObject, /* Save the attachment */ FdoExtension->AttachedDeviceObject = AttachedDevice; - /* Register for reinitialization to report devices later */ - IoRegisterBootDriverReinitialization(DriverObject, - HalpReportDetectedDevices, - FdoExtension); + /* Create the PDO */ + Status = IoCreateDevice(DriverObject, + sizeof(PDO_EXTENSION), + NULL, + FILE_DEVICE_BUS_EXTENDER, + FILE_AUTOGENERATED_DEVICE_NAME, + FALSE, + &PdoDeviceObject); + if (!NT_SUCCESS(Status)) + { + /* Fail */ + DPRINT1("HAL: Could not create ACPI device object status=0x%08x\n", Status); + return Status; + } + + /* Setup the PDO device extension */ + PdoExtension = PdoDeviceObject->DeviceExtension; + PdoExtension->ExtensionType = PdoExtensionType; + PdoExtension->PhysicalDeviceObject = PdoDeviceObject; + PdoExtension->ParentFdoExtension = FdoExtension; + PdoExtension->PdoType = AcpiPdo; + + /* Add the PDO to the head of the list */ + PdoExtension->Next = FdoExtension->ChildPdoList; + FdoExtension->ChildPdoList = PdoExtension; + + /* Initialization is finished */ + PdoDeviceObject->Flags &= ~DO_DEVICE_INITIALIZING; + + /* Find the ACPI watchdog table */ + Wdrt = HalAcpiGetTable(0, 'TRDW'); + if (Wdrt) + { + /* FIXME: TODO */ + DPRINT1("You have an ACPI Watchdog. That's great! You should be proud ;-)\n"); + } /* Return status */ DPRINT("Device added %lx\n", Status); diff --git a/hal/halx86/legacy/halpnpdd.c b/hal/halx86/legacy/halpnpdd.c index 4bf1ff3f18d..716b0d269e7 100644 --- a/hal/halx86/legacy/halpnpdd.c +++ b/hal/halx86/legacy/halpnpdd.c @@ -50,50 +50,6 @@ PDRIVER_OBJECT HalpDriverObject; /* PRIVATE FUNCTIONS **********************************************************/ -VOID -NTAPI -HalpReportDetectedDevices(IN PDRIVER_OBJECT DriverObject, - IN PVOID Context, - IN ULONG Count) -{ - PFDO_EXTENSION FdoExtension = Context; - PPDO_EXTENSION PdoExtension; - PDEVICE_OBJECT PdoDeviceObject; - NTSTATUS Status; - - /* Create the PDO */ - Status = IoCreateDevice(DriverObject, - sizeof(PDO_EXTENSION), - NULL, - FILE_DEVICE_BUS_EXTENDER, - FILE_AUTOGENERATED_DEVICE_NAME, - FALSE, - &PdoDeviceObject); - if (!NT_SUCCESS(Status)) - { - /* Fail */ - DPRINT1("HAL: Could not create ACPI device object status=0x%08x\n", Status); - return; - } - - /* Setup the PDO device extension */ - PdoExtension = PdoDeviceObject->DeviceExtension; - PdoExtension->ExtensionType = PdoExtensionType; - PdoExtension->PhysicalDeviceObject = PdoDeviceObject; - PdoExtension->ParentFdoExtension = FdoExtension; - PdoExtension->PdoType = AcpiPdo; - - /* Add the PDO to the head of the list */ - PdoExtension->Next = FdoExtension->ChildPdoList; - FdoExtension->ChildPdoList = PdoExtension; - - /* Initialization is finished */ - PdoDeviceObject->Flags &= ~DO_DEVICE_INITIALIZING; - - /* Invalidate device relations since we added a new device */ - IoInvalidateDeviceRelations(FdoExtension->PhysicalDeviceObject, BusRelations); -} - NTSTATUS NTAPI HalpAddDevice(IN PDRIVER_OBJECT DriverObject, @@ -101,7 +57,9 @@ HalpAddDevice(IN PDRIVER_OBJECT DriverObject, { NTSTATUS Status; PFDO_EXTENSION FdoExtension; + PPDO_EXTENSION PdoExtension; PDEVICE_OBJECT DeviceObject, AttachedDevice; + PDEVICE_OBJECT PdoDeviceObject; // PDESCRIPTION_HEADER Wdrt; DPRINT("HAL: PnP Driver ADD!\n"); @@ -143,10 +101,34 @@ HalpAddDevice(IN PDRIVER_OBJECT DriverObject, /* Save the attachment */ FdoExtension->AttachedDeviceObject = AttachedDevice; - /* Register for reinitialization to report devices later */ - IoRegisterBootDriverReinitialization(DriverObject, - HalpReportDetectedDevices, - FdoExtension); + /* Create the PDO */ + Status = IoCreateDevice(DriverObject, + sizeof(PDO_EXTENSION), + NULL, + FILE_DEVICE_BUS_EXTENDER, + FILE_AUTOGENERATED_DEVICE_NAME, + FALSE, + &PdoDeviceObject); + if (!NT_SUCCESS(Status)) + { + /* Fail */ + DPRINT1("HAL: Could not create ACPI device object status=0x%08x\n", Status); + return Status; + } + + /* Setup the PDO device extension */ + PdoExtension = PdoDeviceObject->DeviceExtension; + PdoExtension->ExtensionType = PdoExtensionType; + PdoExtension->PhysicalDeviceObject = PdoDeviceObject; + PdoExtension->ParentFdoExtension = FdoExtension; + PdoExtension->PdoType = AcpiPdo; + + /* Add the PDO to the head of the list */ + PdoExtension->Next = FdoExtension->ChildPdoList; + FdoExtension->ChildPdoList = PdoExtension; + + /* Initialization is finished */ + PdoDeviceObject->Flags &= ~DO_DEVICE_INITIALIZING; /* Return status */ DPRINT("Device added %lx\n", Status);

4 years, 1 month

[reactos] 01/01: [GITHUB] Enable amd64 artefacts and other minor changes

by Victor Perevertkin

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=05a5edef12c20b0828d88… commit 05a5edef12c20b0828d88594b439d55479fd0f54 Author: Victor Perevertkin <victor.perevertkin(a)reactos.org> AuthorDate: Mon Nov 9 00:08:18 2020 +0300 Commit: Victor Perevertkin <victor.perevertkin(a)reactos.org> CommitDate: Mon Nov 9 00:08:18 2020 +0300 [GITHUB] Enable amd64 artefacts and other minor changes - Enable artefacts upload for amd64 builds - Use environment files instead of ::set-env due to security issue - Upgrade upload-artifact and cache packages to v2 --- .github/workflows/build.yml | 56 ++++++++++++++++++++++----------------------- 1 file changed, 28 insertions(+), 28 deletions(-) diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 5cae31e3834..a3c56f1c208 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -17,7 +17,7 @@ jobs: with: path: src - name: Set up cache for ccache - uses: actions/cache@v1 + uses: actions/cache@v2 with: path: ccache key: ccache-gcc-i386-${{github.sha}} @@ -25,10 +25,10 @@ jobs: ccache-gcc-i386- - name: Set ccache settings run: | - echo "::set-env name=CCACHE_BASEDIR::${{github.workspace}}" - echo "::set-env name=CCACHE_DIR::${{github.workspace}}/ccache" - echo "::set-env name=CCACHE_MAXSIZE::1G" - echo "::set-env name=CCACHE_SLOPPINESS::time_macros" + echo "CCACHE_BASEDIR=${{github.workspace}}" >> $GITHUB_ENV + echo "CCACHE_DIR=${{github.workspace}}/ccache" >> $GITHUB_ENV + echo "CCACHE_MAXSIZE=1G" >> $GITHUB_ENV + echo "CCACHE_SLOPPINESS=time_macros" >> $GITHUB_ENV - name: Configure run: | mkdir build @@ -45,12 +45,12 @@ jobs: - name: Print ccache statistics run: ccache -s - name: Upload bootcd - uses: actions/upload-artifact@v1 + uses: actions/upload-artifact@v2 with: name: reactos-gcc-i386-${{github.sha}} path: build/bootcd.iso - name: Upload livecd - uses: actions/upload-artifact@v1 + uses: actions/upload-artifact@v2 with: name: reactos-gcc-i386-${{github.sha}} path: build/livecd.iso @@ -65,9 +65,9 @@ jobs: run: | curl -O https://svn.reactos.org/storage/vperevertkin/flexbison.7z 7z x flexbison.7z -O${{github.workspace}}\bin - echo "::add-path::${{github.workspace}}\bin" - echo "::set-env name=BISON_PKGDATADIR::${{github.workspace}}\bin\share\bison" - echo "::set-env name=M4::${{github.workspace}}\bin\m4.exe" + echo "${{github.workspace}}\bin" >> $GITHUB_PATH + echo "BISON_PKGDATADIR=${{github.workspace}}\bin\share\bison" >> $GITHUB_ENV + echo "M4=${{github.workspace}}\bin\m4.exe" >> $GITHUB_ENV - name: Add CL to PATH uses: ilammy/msvc-dev-cmd@v1 with: @@ -100,9 +100,9 @@ jobs: run: | curl -O https://svn.reactos.org/storage/vperevertkin/flexbison.7z 7z x flexbison.7z -O${{github.workspace}}\bin - echo "::add-path::${{github.workspace}}\bin" - echo "::set-env name=BISON_PKGDATADIR::${{github.workspace}}\bin\share\bison" - echo "::set-env name=M4::${{github.workspace}}\bin\m4.exe" + echo "${{github.workspace}}\bin" >> $GITHUB_PATH + echo "BISON_PKGDATADIR=${{github.workspace}}\bin\share\bison" >> $GITHUB_ENV + echo "M4=${{github.workspace}}\bin\m4.exe" >> $GITHUB_ENV - name: Add CL to PATH uses: ilammy/msvc-dev-cmd@v1 with: @@ -124,12 +124,12 @@ jobs: cmake --build . --target bootcd cmake --build . --target livecd - name: Upload bootcd - uses: actions/upload-artifact@v1 + uses: actions/upload-artifact@v2 with: name: reactos-msvc-i386-${{github.sha}} path: build/bootcd.iso - name: Upload livecd - uses: actions/upload-artifact@v1 + uses: actions/upload-artifact@v2 with: name: reactos-msvc-i386-${{github.sha}} path: build/livecd.iso @@ -144,9 +144,9 @@ jobs: run: | curl -O https://svn.reactos.org/storage/vperevertkin/flexbison.7z 7z x flexbison.7z -O${{github.workspace}}\bin - echo "::add-path::${{github.workspace}}\bin" - echo "::set-env name=BISON_PKGDATADIR::${{github.workspace}}\bin\share\bison" - echo "::set-env name=M4::${{github.workspace}}\bin\m4.exe" + echo "${{github.workspace}}\bin" >> $GITHUB_PATH + echo "BISON_PKGDATADIR=${{github.workspace}}\bin\share\bison" >> $GITHUB_ENV + echo "M4=${{github.workspace}}\bin\m4.exe" >> $GITHUB_ENV - name: Add CL to PATH uses: ilammy/msvc-dev-cmd@v1 with: @@ -168,13 +168,13 @@ jobs: run: | cmake --build . --target bootcd cmake --build . --target livecd - # - name: Upload bootcd - # uses: actions/upload-artifact@v1 - # with: - # name: reactos-msvc-amd64-${{github.sha}} - # path: build/bootcd.iso - # - name: Upload livecd - # uses: actions/upload-artifact@v1 - # with: - # name: reactos-msvc-amd64-${{github.sha}} - # path: build/livecd.iso + - name: Upload bootcd + uses: actions/upload-artifact@v2 + with: + name: reactos-msvc-amd64-${{github.sha}} + path: build/bootcd.iso + - name: Upload livecd + uses: actions/upload-artifact@v2 + with: + name: reactos-msvc-amd64-${{github.sha}} + path: build/livecd.iso

4 years, 1 month

[reactos] 01/01: [MOUNTMGR] Fix ReparseFile concatenation in OnlineMountedVolumes

by Victor Perevertkin

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=b8525ce7a59a3251a8a5e… commit b8525ce7a59a3251a8a5e624fe160f430fee36a9 Author: Victor Perevertkin <victor.perevertkin(a)reactos.org> AuthorDate: Sun Nov 8 23:32:25 2020 +0300 Commit: Victor Perevertkin <victor.perevertkin(a)reactos.org> CommitDate: Sun Nov 8 23:32:25 2020 +0300 [MOUNTMGR] Fix ReparseFile concatenation in OnlineMountedVolumes - ReparseFile was concatenated with itself, instead of ReparseIndex - Meanwhile, use RtlAppendUnicodeStringToString for concatenating strings instead of raw memory operations --- drivers/storage/mountmgr/database.c | 48 +++++++++++++++++++------------------ drivers/storage/mountmgr/device.c | 15 +++++++----- 2 files changed, 34 insertions(+), 29 deletions(-) diff --git a/drivers/storage/mountmgr/database.c b/drivers/storage/mountmgr/database.c index 1cde41a995f..118d37d1cfd 100644 --- a/drivers/storage/mountmgr/database.c +++ b/drivers/storage/mountmgr/database.c @@ -665,10 +665,12 @@ ReconcileThisDatabaseWithMasterWorker(IN PVOID Parameter) DatabaseHandle = OpenRemoteDatabase(DeviceInformation, FALSE); /* Prepare a string with reparse point index */ - ReparseFile.Length = DeviceInformation->DeviceName.Length + ReparseIndex.Length; - ReparseFile.MaximumLength = ReparseFile.Length + sizeof(UNICODE_NULL); + ReparseFile.Length = 0; + ReparseFile.MaximumLength = DeviceInformation->DeviceName.Length + + ReparseIndex.Length + + sizeof(UNICODE_NULL); ReparseFile.Buffer = AllocatePool(ReparseFile.MaximumLength); - if (ReparseFile.Buffer == NULL) + if (!ReparseFile.Buffer) { if (DatabaseHandle != 0) { @@ -678,10 +680,8 @@ ReconcileThisDatabaseWithMasterWorker(IN PVOID Parameter) goto ReleaseRDS; } - RtlCopyMemory(ReparseFile.Buffer, DeviceInformation->DeviceName.Buffer, - DeviceInformation->DeviceName.Length); - RtlCopyMemory((PVOID)((ULONG_PTR)ReparseFile.Buffer + DeviceInformation->DeviceName.Length), - ReparseIndex.Buffer, ReparseIndex.Length); + RtlAppendUnicodeStringToString(&ReparseFile, &DeviceInformation->DeviceName); + RtlAppendUnicodeStringToString(&ReparseFile, &ReparseIndex); ReparseFile.Buffer[ReparseFile.Length / sizeof(WCHAR)] = UNICODE_NULL; InitializeObjectAttributes(&ObjectAttributes, @@ -1477,18 +1477,18 @@ OnlineMountedVolumes(IN PDEVICE_EXTENSION DeviceExtension, } /* Prepare a string with reparse point index */ - ReparseFile.Length = DeviceInformation->DeviceName.Length + ReparseIndex.Length; - ReparseFile.MaximumLength = ReparseFile.Length + sizeof(UNICODE_NULL); + ReparseFile.Length = 0; + ReparseFile.MaximumLength = DeviceInformation->DeviceName.Length + + ReparseIndex.Length + + sizeof(UNICODE_NULL); ReparseFile.Buffer = AllocatePool(ReparseFile.MaximumLength); if (!ReparseFile.Buffer) { return; } - RtlCopyMemory(ReparseFile.Buffer, DeviceInformation->DeviceName.Buffer, - DeviceInformation->DeviceName.Length); - RtlCopyMemory((PVOID)((ULONG_PTR)ReparseFile.Buffer + DeviceInformation->DeviceName.Length), - ReparseFile.Buffer, ReparseFile.Length); + RtlAppendUnicodeStringToString(&ReparseFile, &DeviceInformation->DeviceName); + RtlAppendUnicodeStringToString(&ReparseFile, &ReparseIndex); ReparseFile.Buffer[ReparseFile.Length / sizeof(WCHAR)] = UNICODE_NULL; InitializeObjectAttributes(&ObjectAttributes, @@ -1700,8 +1700,10 @@ CreateRemoteDatabaseWorker(IN PDEVICE_OBJECT DeviceObject, DeviceInformation = WorkItem->DeviceInformation; /* Reconstruct appropriate string */ - DatabaseName.Length = DeviceInformation->DeviceName.Length + RemoteDatabase.Length; - DatabaseName.MaximumLength = DatabaseName.Length + sizeof(WCHAR); + DatabaseName.Length = 0; + DatabaseName.MaximumLength = DeviceInformation->DeviceName.Length + + RemoteDatabase.Length + + sizeof(UNICODE_NULL); DatabaseName.Buffer = AllocatePool(DatabaseName.MaximumLength); if (DatabaseName.Buffer == NULL) { @@ -1719,9 +1721,8 @@ CreateRemoteDatabaseWorker(IN PDEVICE_OBJECT DeviceObject, } /* Finish initiating strings */ - RtlCopyMemory(DatabaseName.Buffer, DeviceInformation->DeviceName.Buffer, DeviceInformation->DeviceName.Length); - RtlCopyMemory(DatabaseName.Buffer + (DeviceInformation->DeviceName.Length / sizeof(WCHAR)), - RemoteDatabase.Buffer, RemoteDatabase.Length); + RtlAppendUnicodeStringToString(&DatabaseName, &DeviceInformation->DeviceName); + RtlAppendUnicodeStringToString(&DatabaseName, &RemoteDatabase); DatabaseName.Buffer[DatabaseName.Length / sizeof(WCHAR)] = UNICODE_NULL; /* Create database */ @@ -1846,17 +1847,18 @@ OpenRemoteDatabase(IN PDEVICE_INFORMATION DeviceInformation, Database = 0; /* Get database name */ - DeviceRemoteDatabase.Length = DeviceInformation->DeviceName.Length + RemoteDatabase.Length; - DeviceRemoteDatabase.MaximumLength = DeviceRemoteDatabase.Length + sizeof(WCHAR); + DeviceRemoteDatabase.Length = 0; + DeviceRemoteDatabase.MaximumLength = DeviceInformation->DeviceName.Length + + RemoteDatabase.Length + + sizeof(UNICODE_NULL); DeviceRemoteDatabase.Buffer = AllocatePool(DeviceRemoteDatabase.MaximumLength); if (!DeviceRemoteDatabase.Buffer) { return 0; } - RtlCopyMemory(DeviceRemoteDatabase.Buffer, DeviceInformation->DeviceName.Buffer, DeviceInformation->DeviceName.Length); - RtlCopyMemory(DeviceRemoteDatabase.Buffer + (DeviceInformation->DeviceName.Length / sizeof(WCHAR)), - RemoteDatabase.Buffer, RemoteDatabase.Length); + RtlAppendUnicodeStringToString(&DeviceRemoteDatabase, &DeviceInformation->DeviceName); + RtlAppendUnicodeStringToString(&DeviceRemoteDatabase, &RemoteDatabase); DeviceRemoteDatabase.Buffer[DeviceRemoteDatabase.Length / sizeof(WCHAR)] = UNICODE_NULL; /* Open database */ diff --git a/drivers/storage/mountmgr/device.c b/drivers/storage/mountmgr/device.c index 9b762890ea6..ecdb0b21526 100644 --- a/drivers/storage/mountmgr/device.c +++ b/drivers/storage/mountmgr/device.c @@ -1075,18 +1075,21 @@ MountMgrValidateBackPointer(IN PASSOCIATED_DEVICE_ENTRY AssociatedDeviceEntry, PSYMLINK_INFORMATION SymlinkInformation; /* Initialize & allocate a string big enough to contain our complete mount point name */ - FullName.Length = AssociatedDeviceEntry->String.Length + AssociatedDeviceEntry->DeviceInformation->DeviceName.Length + sizeof(WCHAR); - FullName.MaximumLength = FullName.Length + sizeof(UNICODE_NULL); + FullName.Length = 0; + FullName.MaximumLength = AssociatedDeviceEntry->String.Length + + AssociatedDeviceEntry->DeviceInformation->DeviceName.Length + + sizeof(WCHAR) + + sizeof(UNICODE_NULL); FullName.Buffer = AllocatePool(FullName.MaximumLength); if (!FullName.Buffer) { return STATUS_INSUFFICIENT_RESOURCES; } - /* Create the path */ - RtlCopyMemory(FullName.Buffer, AssociatedDeviceEntry->DeviceInformation->DeviceName.Buffer, AssociatedDeviceEntry->DeviceInformation->DeviceName.Length); - FullName.Buffer[AssociatedDeviceEntry->DeviceInformation->DeviceName.Length / sizeof(WCHAR)] = L'\\'; - RtlCopyMemory(&FullName.Buffer[AssociatedDeviceEntry->DeviceInformation->DeviceName.Length / sizeof(WCHAR) + 1], AssociatedDeviceEntry->String.Buffer, AssociatedDeviceEntry->String.Length); + /* Create the path */ + RtlAppendUnicodeStringToString(&FullName, &AssociatedDeviceEntry->DeviceInformation->DeviceName); + FullName.Buffer[FullName.Length / sizeof(WCHAR)] = L'\\'; + RtlAppendUnicodeStringToString(&FullName, &AssociatedDeviceEntry->String); FullName.Buffer[FullName.Length / sizeof(WCHAR)] = UNICODE_NULL; /* Open it to query the reparse point */

4 years, 1 month

← Newer
1
...
8
9
10
11
12
13
14
...
17
Older →

Jump to page:

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Ros-diffs November 2020