partmgr.c File Reference

#include "partmgr.h"

Include dependency graph for partmgr.c:

Go to the source code of this file.

Functions
static PDRIVE_LAYOUT_INFORMATION	PartMgrConvertExtendedToLayout (_In_ CONST PDRIVE_LAYOUT_INFORMATION_EX LayoutEx)
static PDRIVE_LAYOUT_INFORMATION_EX	PartMgrConvertLayoutToExtended (_In_ CONST PDRIVE_LAYOUT_INFORMATION Layout)
static BOOLEAN	PartMgrIsDiskSuperFloppy (_In_ PFDO_EXTENSION FdoExtension)
	Detects whether a disk is a "super-floppy", i.e. an unpartitioned disk with only a valid VBR, as reported by IoReadPartitionTable() and IoWritePartitionTable(): only one single partition starting at offset zero and spanning the whole disk, without hidden sectors, whose type is FAT16 non-bootable.
static VOID	PartMgrUpdatePartitionDevices (_In_ PFDO_EXTENSION FdoExtension, _Inout_ PDRIVE_LAYOUT_INFORMATION_EX NewLayout)
static NTSTATUS	PartMgrGetDriveLayout (_In_ PFDO_EXTENSION FdoExtension, _Out_ PDRIVE_LAYOUT_INFORMATION_EX *DriveLayout)
	Retrieves the disk partition layout from the given disk FDO.
static NTSTATUS	FdoIoctlDiskGetDriveGeometryEx (_In_ PFDO_EXTENSION FdoExtension, _In_ PIRP Irp)
static NTSTATUS	FdoIoctlDiskGetPartitionInfo (_In_ PFDO_EXTENSION FdoExtension, _In_ PIRP Irp)
static NTSTATUS	FdoIoctlDiskGetPartitionInfoEx (_In_ PFDO_EXTENSION FdoExtension, _In_ PIRP Irp)
static NTSTATUS	FdoIoctlDiskGetDriveLayout (_In_ PFDO_EXTENSION FdoExtension, _In_ PIRP Irp)
static NTSTATUS	FdoIoctlDiskGetDriveLayoutEx (_In_ PFDO_EXTENSION FdoExtension, _In_ PIRP Irp)
static NTSTATUS	FdoIoctlDiskSetDriveLayout (_In_ PFDO_EXTENSION FdoExtension, _In_ PIRP Irp)
static NTSTATUS	FdoIoctlDiskSetDriveLayoutEx (_In_ PFDO_EXTENSION FdoExtension, _In_ PIRP Irp)
static NTSTATUS	FdoIoctlDiskUpdateProperties (_In_ PFDO_EXTENSION FdoExtension, _In_ PIRP Irp)
static NTSTATUS	FdoIoctlDiskCreateDisk (_In_ PFDO_EXTENSION FdoExtension, _In_ PIRP Irp)
static NTSTATUS	FdoIoctlDiskDeleteDriveLayout (_In_ PFDO_EXTENSION FdoExtension, _In_ PIRP Irp)
static NTSTATUS	FdoHandleStartDevice (_In_ PFDO_EXTENSION FdoExtension, _In_ PIRP Irp)
static NTSTATUS	PartMgrRefreshDiskData (_In_ PFDO_EXTENSION FdoExtension)
	Refreshes all the cached disk FDO data. The geometry of the disk and its partition layout cache is updated.
static NTSTATUS	FdoHandleDeviceRelations (_In_ PFDO_EXTENSION FdoExtension, _In_ PIRP Irp)
static NTSTATUS	FdoHandleRemoveDevice (_In_ PFDO_EXTENSION FdoExtension, _In_ PIRP Irp)
static NTSTATUS	FdoHandleSurpriseRemoval (_In_ PFDO_EXTENSION FdoExtension, _In_ PIRP Irp)
static NTSTATUS NTAPI	PartMgrAddDevice (_In_ PDRIVER_OBJECT DriverObject, _In_ PDEVICE_OBJECT PhysicalDeviceObject)
static NTSTATUS NTAPI	PartMgrDeviceControl (_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp)
static NTSTATUS NTAPI	PartMgrPnp (_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp)
static NTSTATUS NTAPI	PartMgrReadWrite (_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp)
NTSTATUS NTAPI	PartMgrPower (_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp)
NTSTATUS NTAPI	PartMgrShutdownFlush (_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp)
VOID NTAPI	PartMgrUnload (_In_ PDRIVER_OBJECT DriverObject)
NTSTATUS NTAPI	DriverEntry (_In_ PDRIVER_OBJECT DriverObject, _In_ PUNICODE_STRING RegistryPath)

Variables
DRIVER_DISPATCH	PartMgrPower
DRIVER_DISPATCH	PartMgrShutdownFlush

Function Documentation

DriverEntry()

NTSTATUS NTAPI DriverEntry	(	_In_ PDRIVER_OBJECT	DriverObject,
		_In_ PUNICODE_STRING	RegistryPath
	)

Definition at line 1487 of file partmgr.c.

{
    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;
}

FdoHandleDeviceRelations()

static NTSTATUS FdoHandleDeviceRelations ( _In_ PFDO_EXTENSION  FdoExtension, _In_ PIRP  Irp  )

static

Definition at line 1040 of file partmgr.c.

{
    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);
 
        // PartMgrRefreshDiskData() calls PartMgrGetDriveLayout() inside
        // so we're sure here that it returns only the 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);
}

Referenced by PartMgrPnp().

FdoHandleRemoveDevice()

static NTSTATUS FdoHandleRemoveDevice ( _In_ PFDO_EXTENSION  FdoExtension, _In_ PIRP  Irp  )

static

Definition at line 1123 of file partmgr.c.

{
    PAGED_CODE();
 
    if (FdoExtension->DiskInterfaceName.Buffer)
    {
        IoSetDeviceInterfaceState(&FdoExtension->DiskInterfaceName, FALSE);
        RtlFreeUnicodeString(&FdoExtension->DiskInterfaceName);
        RtlInitUnicodeString(&FdoExtension->DiskInterfaceName, NULL);
    }
 
    // 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;
}

Referenced by PartMgrPnp().

FdoHandleStartDevice()

static NTSTATUS FdoHandleStartDevice ( _In_ PFDO_EXTENSION  FdoExtension, _In_ PIRP  Irp  )

static

Definition at line 947 of file partmgr.c.

{
    // 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;
 
    // register the disk interface
    // partmgr.sys from Windows 8.1 also registers a mysterious GUID_DEVINTERFACE_HIDDEN_DISK here
    UNICODE_STRING interfaceName;
    status = IoRegisterDeviceInterface(FdoExtension->PhysicalDiskDO,
                                       &GUID_DEVINTERFACE_DISK,
                                       NULL,
                                       &interfaceName);
 
    if(!NT_SUCCESS(status))
    {
        ERR("Failed to register GUID_DEVINTERFACE_DISK, status %x\n", status);
        return status;
    }
 
    FdoExtension->DiskInterfaceName = interfaceName;
    status = IoSetDeviceInterfaceState(&interfaceName, TRUE);
 
    INFO("Disk interface %wZ\n", &interfaceName);
 
    if (!NT_SUCCESS(status))
    {
        RtlFreeUnicodeString(&interfaceName);
        RtlInitUnicodeString(&FdoExtension->DiskInterfaceName, NULL);
    }
 
    return status;
}

Referenced by PartMgrPnp().

FdoHandleSurpriseRemoval()

static NTSTATUS FdoHandleSurpriseRemoval ( _In_ PFDO_EXTENSION  FdoExtension, _In_ PIRP  Irp  )

static

Definition at line 1149 of file partmgr.c.

{
    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);
}

Referenced by PartMgrPnp().

FdoIoctlDiskCreateDisk()

static NTSTATUS FdoIoctlDiskCreateDisk ( _In_ PFDO_EXTENSION  FdoExtension, _In_ PIRP  Irp  )

static

Definition at line 899 of file partmgr.c.

{
    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;
}

Referenced by PartMgrDeviceControl().

FdoIoctlDiskDeleteDriveLayout()

static NTSTATUS FdoIoctlDiskDeleteDriveLayout ( _In_ PFDO_EXTENSION  FdoExtension, _In_ PIRP  Irp  )

static

Definition at line 925 of file partmgr.c.

{
    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;
}

Referenced by PartMgrDeviceControl().

FdoIoctlDiskGetDriveGeometryEx()

static NTSTATUS FdoIoctlDiskGetDriveGeometryEx ( _In_ PFDO_EXTENSION  FdoExtension, _In_ PIRP  Irp  )

static

Definition at line 451 of file partmgr.c.

{
    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;
    ULONG 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;
}

Referenced by PartMgrDeviceControl().

FdoIoctlDiskGetDriveLayout()

static NTSTATUS FdoIoctlDiskGetDriveLayout ( _In_ PFDO_EXTENSION  FdoExtension, _In_ PIRP  Irp  )

static

Definition at line 579 of file partmgr.c.

{
    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;
}

Referenced by PartMgrDeviceControl().

FdoIoctlDiskGetDriveLayoutEx()

static NTSTATUS FdoIoctlDiskGetDriveLayoutEx ( _In_ PFDO_EXTENSION  FdoExtension, _In_ PIRP  Irp  )

static

Definition at line 631 of file partmgr.c.

{
    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;
}

Referenced by PartMgrDeviceControl().

FdoIoctlDiskGetPartitionInfo()

static NTSTATUS FdoIoctlDiskGetPartitionInfo ( _In_ PFDO_EXTENSION  FdoExtension, _In_ PIRP  Irp  )

static

Definition at line 514 of file partmgr.c.

{
    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;
}

Referenced by PartMgrDeviceControl().

FdoIoctlDiskGetPartitionInfoEx()

static NTSTATUS FdoIoctlDiskGetPartitionInfoEx ( _In_ PFDO_EXTENSION  FdoExtension, _In_ PIRP  Irp  )

static

Definition at line 549 of file partmgr.c.

{
    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;
}

Referenced by PartMgrDeviceControl().

FdoIoctlDiskSetDriveLayout()

static NTSTATUS FdoIoctlDiskSetDriveLayout ( _In_ PFDO_EXTENSION  FdoExtension, _In_ PIRP  Irp  )

static

Definition at line 667 of file partmgr.c.

{
    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);
 
    // If the current disk is super-floppy but the user changes
    // the number of partitions to > 1, fail the call.
    if (FdoExtension->IsSuperFloppy && (layoutEx->PartitionCount > 1))
    {
        PartMgrReleaseLayoutLock(FdoExtension);
        return STATUS_INVALID_DEVICE_REQUEST;
    }
 
    // 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;
        }
 
        FdoExtension->IsSuperFloppy = PartMgrIsDiskSuperFloppy(FdoExtension);
    }
    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;
}

Referenced by PartMgrDeviceControl().

FdoIoctlDiskSetDriveLayoutEx()

static NTSTATUS FdoIoctlDiskSetDriveLayoutEx ( _In_ PFDO_EXTENSION  FdoExtension, _In_ PIRP  Irp  )

static

Definition at line 761 of file partmgr.c.

{
    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 the current disk is super-floppy but the user changes either
    // the disk type or the number of partitions to > 1, fail the call.
    if (FdoExtension->IsSuperFloppy &&
        ((layoutEx->PartitionStyle != PARTITION_STYLE_MBR) ||
         (layoutEx->PartitionCount > 1)))
    {
        PartMgrReleaseLayoutLock(FdoExtension);
        return STATUS_INVALID_DEVICE_REQUEST;
    }
 
    // 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;
 
        FdoExtension->IsSuperFloppy = PartMgrIsDiskSuperFloppy(FdoExtension);
    }
    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;
}

Referenced by PartMgrDeviceControl().

FdoIoctlDiskUpdateProperties()

static NTSTATUS FdoIoctlDiskUpdateProperties ( _In_ PFDO_EXTENSION  FdoExtension, _In_ PIRP  Irp  )

static

Definition at line 882 of file partmgr.c.

{
    PAGED_CODE();
 
    PartMgrAcquireLayoutLock(FdoExtension);
    FdoExtension->LayoutValid = FALSE;
    PartMgrReleaseLayoutLock(FdoExtension);
 
    IoInvalidateDeviceRelations(FdoExtension->PhysicalDiskDO, BusRelations);
    return STATUS_SUCCESS;
}

Referenced by PartMgrDeviceControl().

PartMgrAddDevice()

static NTSTATUS NTAPI PartMgrAddDevice ( _In_ PDRIVER_OBJECT  DriverObject, _In_ PDEVICE_OBJECT  PhysicalDeviceObject  )

static

Definition at line 1181 of file partmgr.c.

{
    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;
}

Referenced by DriverEntry().

PartMgrConvertExtendedToLayout()

static PDRIVE_LAYOUT_INFORMATION PartMgrConvertExtendedToLayout ( _In_ CONST PDRIVE_LAYOUT_INFORMATION_EX  LayoutEx )

static

Definition at line 20 of file partmgr.c.

{
    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;
}

Referenced by FdoIoctlDiskGetDriveLayout().

PartMgrConvertLayoutToExtended()

static PDRIVE_LAYOUT_INFORMATION_EX PartMgrConvertLayoutToExtended ( _In_ CONST PDRIVE_LAYOUT_INFORMATION  Layout )

static

Definition at line 72 of file partmgr.c.

{
    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;
}

Referenced by FdoIoctlDiskSetDriveLayout().

PartMgrDeviceControl()

static NTSTATUS NTAPI PartMgrDeviceControl ( _In_ PDEVICE_OBJECT  DeviceObject, _In_ PIRP  Irp  )

static

Definition at line 1230 of file partmgr.c.

{
    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;
}

Referenced by DriverEntry().

PartMgrGetDriveLayout()

static NTSTATUS PartMgrGetDriveLayout ( _In_ PFDO_EXTENSION  FdoExtension, _Out_ PDRIVE_LAYOUT_INFORMATION_EX *  DriveLayout  )

static

Retrieves the disk partition layout from the given disk FDO.

If the disk layout cache is valid, just return it; otherwise, read the partition table layout from disk and update the cache.

Note

Requires partitioning lock held.

Definition at line 408 of file partmgr.c.

{
    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;
 
    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;
    }
 
    FdoExtension->IsSuperFloppy = PartMgrIsDiskSuperFloppy(FdoExtension);
 
    *DriveLayout = layoutEx;
    return status;
}

Referenced by FdoHandleDeviceRelations(), FdoIoctlDiskGetDriveLayout(), FdoIoctlDiskGetDriveLayoutEx(), and PartMgrRefreshDiskData().

PartMgrIsDiskSuperFloppy()

static BOOLEAN PartMgrIsDiskSuperFloppy ( _In_ PFDO_EXTENSION  FdoExtension )

static

Detects whether a disk is a "super-floppy", i.e. an unpartitioned disk with only a valid VBR, as reported by IoReadPartitionTable() and IoWritePartitionTable(): only one single partition starting at offset zero and spanning the whole disk, without hidden sectors, whose type is FAT16 non-bootable.

Accessing \Device\HarddiskN\Partition0 or Partition1 on such disks returns the same data.

Note

• Requires partitioning lock held.
• Uses the cached disk partition layout.

Definition at line 135 of file partmgr.c.

{
    PPARTITION_INFORMATION_EX PartitionInfo;
 
    PAGED_CODE();
 
    ASSERT(FdoExtension->LayoutValid && FdoExtension->LayoutCache);
 
    /* We must be MBR and have only one partition */
    ASSERT(FdoExtension->DiskData.PartitionStyle == FdoExtension->LayoutCache->PartitionStyle);
    if (FdoExtension->DiskData.PartitionStyle != PARTITION_STYLE_MBR)
        return FALSE;
    if (FdoExtension->LayoutCache->PartitionCount != 1)
        return FALSE;
 
    /* Get the single partition entry */
    PartitionInfo = FdoExtension->LayoutCache->PartitionEntry;
    ASSERT(FdoExtension->DiskData.PartitionStyle == PartitionInfo->PartitionStyle);
 
    /* The single partition must start at the beginning of the disk */
    if (!(PartitionInfo->StartingOffset.QuadPart == 0 &&
          PartitionInfo->Mbr.HiddenSectors == 0))
    {
        return FALSE;
    }
 
    /* The disk signature is usually set to 1; warn in case it's not */
    ASSERT(FdoExtension->DiskData.Mbr.Signature == FdoExtension->LayoutCache->Mbr.Signature);
    if (FdoExtension->DiskData.Mbr.Signature != 1)
    {
        WARN("Super-Floppy disk %lu signature %08x != 1!\n",
             FdoExtension->DiskData.DeviceNumber, FdoExtension->DiskData.Mbr.Signature);
    }
 
    /* The partition must be recognized and report as FAT16 non-bootable */
    if ((PartitionInfo->Mbr.RecognizedPartition != TRUE) ||
        (PartitionInfo->Mbr.PartitionType != PARTITION_FAT_16) ||
        (PartitionInfo->Mbr.BootIndicator != FALSE))
    {
        WARN("Super-Floppy disk %lu does not return default settings!\n"
             "    RecognizedPartition = %s, expected TRUE\n"
             "    PartitionType = 0x%02x, expected 0x04 (PARTITION_FAT_16)\n"
             "    BootIndicator = %s, expected FALSE\n",
             FdoExtension->DiskData.DeviceNumber,
             PartitionInfo->Mbr.RecognizedPartition ? "TRUE" : "FALSE",
             PartitionInfo->Mbr.PartitionType,
             PartitionInfo->Mbr.BootIndicator ? "TRUE" : "FALSE");
    }
 
    /* The partition and disk sizes should agree */
    if (PartitionInfo->PartitionLength.QuadPart != FdoExtension->DiskData.DiskSize)
    {
        WARN("PartitionLength = %I64u is different from DiskSize = %I64u\n",
             PartitionInfo->PartitionLength.QuadPart, FdoExtension->DiskData.DiskSize);
    }
 
    return TRUE;
}

Referenced by FdoIoctlDiskSetDriveLayout(), FdoIoctlDiskSetDriveLayoutEx(), and PartMgrGetDriveLayout().

PartMgrPnp()

static NTSTATUS NTAPI PartMgrPnp ( _In_ PDEVICE_OBJECT  DeviceObject, _In_ PIRP  Irp  )

static

Definition at line 1304 of file partmgr.c.

{
    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);
        }
    }
}

Referenced by DriverEntry().

PartMgrPower()

NTSTATUS NTAPI PartMgrPower	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_In_ PIRP	Irp
	)

Definition at line 1403 of file partmgr.c.

{
    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);
    }
}

PartMgrReadWrite()

static NTSTATUS NTAPI PartMgrReadWrite ( _In_ PDEVICE_OBJECT  DeviceObject, _In_ PIRP  Irp  )

static

Definition at line 1375 of file partmgr.c.

{
    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);
}

Referenced by DriverEntry().

PartMgrRefreshDiskData()

static NTSTATUS PartMgrRefreshDiskData ( _In_ PFDO_EXTENSION  FdoExtension )

static

Refreshes all the cached disk FDO data. The geometry of the disk and its partition layout cache is updated.

Note

Requires partitioning lock held.

Definition at line 1006 of file partmgr.c.

{
    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;
 
    return STATUS_SUCCESS;
}

Referenced by FdoHandleDeviceRelations().

PartMgrShutdownFlush()

NTSTATUS NTAPI PartMgrShutdownFlush	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_In_ PIRP	Irp
	)

Definition at line 1444 of file partmgr.c.

{
    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);
}

PartMgrUnload()

VOID NTAPI PartMgrUnload

(

_In_ PDRIVER_OBJECT

DriverObject

)

Definition at line 1478 of file partmgr.c.

{
 
}

Referenced by DriverEntry().

PartMgrUpdatePartitionDevices()

static VOID PartMgrUpdatePartitionDevices ( _In_ PFDO_EXTENSION  FdoExtension, _Inout_ PDRIVE_LAYOUT_INFORMATION_EX  NewLayout  )

static

Definition at line 198 of file partmgr.c.

{
    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;
        }
 
        // mark partition as removable if parent device is removable
        if (FdoExtension->LowerDevice->Characteristics & FILE_REMOVABLE_MEDIA)
            partitionDevice->Characteristics |= FILE_REMOVABLE_MEDIA;
 
        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 at the beginning
            partExt->ListEntry.Next = FdoExtension->PartitionList.Next;
            FdoExtension->PartitionList.Next = &partExt->ListEntry;
        }
 
        partExt->Attached = TRUE;
    }
 
    FdoExtension->EnumeratedPartitionsTotal = totalPartitions;
}

Referenced by FdoHandleDeviceRelations(), FdoIoctlDiskSetDriveLayout(), and FdoIoctlDiskSetDriveLayoutEx().

Variable Documentation

PartMgrPower

DRIVER_DISPATCH PartMgrPower

Definition at line 1400 of file partmgr.c.

Referenced by DriverEntry().

PartMgrShutdownFlush

DRIVER_DISPATCH PartMgrShutdownFlush

Definition at line 1441 of file partmgr.c.

Referenced by DriverEntry().