partmgr.h File Reference

#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"
#include <pshpack1.h>
#include <poppack.h>

Include dependency graph for partmgr.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_DISK_GEOMETRY_EX_INTERNAL
union	_BASIC_VOLUME_UNIQUE_ID
struct	_FDO_EXTENSION
struct	_PARTITION_EXTENSION

Macros
#define	TAG_PARTMGR   'MtrP'
#define	DMIO_ID_SIGNATURE   (*(ULONGLONG*)"DMIO:ID:")

Typedefs
typedef struct _DISK_GEOMETRY_EX_INTERNAL	DISK_GEOMETRY_EX_INTERNAL
typedef struct _DISK_GEOMETRY_EX_INTERNAL *	PDISK_GEOMETRY_EX_INTERNAL
typedef union _BASIC_VOLUME_UNIQUE_ID	BASIC_VOLUME_UNIQUE_ID
typedef union _BASIC_VOLUME_UNIQUE_ID *	PBASIC_VOLUME_UNIQUE_ID
typedef struct _FDO_EXTENSION	FDO_EXTENSION
typedef struct _FDO_EXTENSION *	PFDO_EXTENSION
typedef struct _PARTITION_EXTENSION	PARTITION_EXTENSION
typedef struct _PARTITION_EXTENSION *	PPARTITION_EXTENSION

Functions
	C_ASSERT (RTL_FIELD_SIZE(BASIC_VOLUME_UNIQUE_ID, Mbr)==0x0C)
	C_ASSERT (RTL_FIELD_SIZE(BASIC_VOLUME_UNIQUE_ID, Gpt)==0x18)
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)
FORCEINLINE BOOLEAN	VerifyIrpOutBufferSize (_In_ PIRP Irp, _In_ SIZE_T Size)
FORCEINLINE BOOLEAN	VerifyIrpInBufferSize (_In_ PIRP Irp, _In_ SIZE_T Size)
FORCEINLINE VOID	PartMgrAcquireLayoutLock (_In_ PFDO_EXTENSION FDOExtension)
FORCEINLINE VOID	PartMgrReleaseLayoutLock (_In_ PFDO_EXTENSION FDOExtension)

Macro Definition Documentation

DMIO_ID_SIGNATURE

#define DMIO_ID_SIGNATURE   (*(ULONGLONG*)"DMIO:ID:")

Definition at line 55 of file partmgr.h.

TAG_PARTMGR

#define TAG_PARTMGR   'MtrP'

Definition at line 23 of file partmgr.h.

Typedef Documentation

BASIC_VOLUME_UNIQUE_ID

typedef union _BASIC_VOLUME_UNIQUE_ID BASIC_VOLUME_UNIQUE_ID

DISK_GEOMETRY_EX_INTERNAL

typedef struct _DISK_GEOMETRY_EX_INTERNAL DISK_GEOMETRY_EX_INTERNAL

FDO_EXTENSION

typedef struct _FDO_EXTENSION FDO_EXTENSION

PARTITION_EXTENSION

typedef struct _PARTITION_EXTENSION PARTITION_EXTENSION

PBASIC_VOLUME_UNIQUE_ID

typedef union _BASIC_VOLUME_UNIQUE_ID * PBASIC_VOLUME_UNIQUE_ID

PDISK_GEOMETRY_EX_INTERNAL

typedef struct _DISK_GEOMETRY_EX_INTERNAL * PDISK_GEOMETRY_EX_INTERNAL

PFDO_EXTENSION

typedef struct _FDO_EXTENSION * PFDO_EXTENSION

PPARTITION_EXTENSION

typedef struct _PARTITION_EXTENSION * PPARTITION_EXTENSION

Function Documentation

C_ASSERT() [1/2]

C_ASSERT

(

RTL_FIELD_SIZE(BASIC_VOLUME_UNIQUE_ID, Gpt)

= =0x18

)

C_ASSERT() [2/2]

C_ASSERT

(

RTL_FIELD_SIZE(BASIC_VOLUME_UNIQUE_ID, Mbr)

= =0x0C

)

ForwardIrpAndForget()

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

Definition at line 5 of file utils.c.

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

IssueSyncIoControlRequest()

NTSTATUS IssueSyncIoControlRequest	(	_In_ UINT32	IoControlCode,
		_In_ PDEVICE_OBJECT	DeviceObject,
		_In_ PVOID	InputBuffer,
		_In_ ULONG	InputBufferLength,
		_In_ PVOID	OutputBuffer,
		_In_ ULONG	OutputBufferLength,
		_In_ BOOLEAN	InternalDeviceIoControl
	)

Definition at line 19 of file utils.c.

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

Referenced by FdoHandleStartDevice(), FdoIoctlDiskGetDriveGeometryEx(), PartMgrRefreshDiskData(), and VolumeDeleteMountPoints().

PartitionCreateDevice()

NTSTATUS PartitionCreateDevice	(	_In_ PDEVICE_OBJECT	FDObject,
		_In_ PPARTITION_INFORMATION_EX	PartitionEntry,
		_In_ UINT32	OnDiskNumber,
		_In_ PARTITION_STYLE	PartitionStyle,
		_Out_ PDEVICE_OBJECT *	PDO
	)

Definition at line 15 of file partition.c.

{
    PAGED_CODE();
 
    static UINT32 HarddiskVolumeNextId = 1; // this is 1-based
 
    WCHAR nameBuf[64];
    UNICODE_STRING deviceName;
    UINT32 volumeNum;
 
    // create the device object
 
    volumeNum = HarddiskVolumeNextId++;
    swprintf(nameBuf, L"\\Device\\HarddiskVolume%lu", volumeNum);
    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.PartitionId;
        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->VolumeNumber = volumeNum;
 
    partExt->DeviceObject = partitionDevice;
    partExt->LowerDevice = FDObject;
 
    partitionDevice->Flags &= ~DO_DEVICE_INITIALIZING;
 
    *PDO = partitionDevice;
 
    return status;
}

Referenced by PartMgrUpdatePartitionDevices().

PartitionHandleDeviceControl()

NTSTATUS PartitionHandleDeviceControl	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_In_ PIRP	Irp
	)

Definition at line 563 of file partition.c.

{
    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 once 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_QUERY_VOLUME_NUMBER:
        {
            PVOLUME_NUMBER volNum = Irp->AssociatedIrp.SystemBuffer;
            if (!VerifyIrpOutBufferSize(Irp, sizeof(*volNum)))
            {
                status = STATUS_BUFFER_TOO_SMALL;
                break;
            }
 
            PartMgrAcquireLayoutLock(fdoExtension);
 
            volNum->VolumeNumber = partExt->VolumeNumber;
            RtlCopyMemory(volNum->VolumeManagerName,
                          L"VOLMGR  ", // Must be 8 space-padded characters
                          sizeof(volNum->VolumeManagerName));
 
            PartMgrReleaseLayoutLock(fdoExtension);
 
            status = STATUS_SUCCESS;
            Irp->IoStatus.Information = sizeof(*volNum);
            break;
        }
        case IOCTL_VOLUME_IS_PARTITION:
        {
            // The only type of volume we support right now is disk partition
            // so we just return success. A more robust algorithm would be
            // to check whether the volume has only one single extent, that
            // covers the whole partition on which it lies upon. If this is
            // not the case, return STATUS_UNSUCCESSFUL instead.
            status = STATUS_SUCCESS;
            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 notifications (these should be in volmgr.sys once it is implemented)
        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:
        {
            const SIZE_T headerSize = FIELD_OFFSET(MOUNTDEV_UNIQUE_ID, UniqueId);
            PMOUNTDEV_UNIQUE_ID uniqueId = Irp->AssociatedIrp.SystemBuffer;
            PBASIC_VOLUME_UNIQUE_ID basicVolId = (PBASIC_VOLUME_UNIQUE_ID)&uniqueId->UniqueId;
            PUNICODE_STRING InterfaceName;
 
            // Check whether the minimal header size was provided
            if (!VerifyIrpOutBufferSize(Irp, headerSize))
            {
                status = STATUS_BUFFER_TOO_SMALL;
                break;
            }
 
            PartMgrAcquireLayoutLock(fdoExtension);
 
            InterfaceName = &partExt->VolumeInterfaceName;
            if (fdoExtension->IsSuperFloppy)
                InterfaceName = &fdoExtension->DiskInterfaceName;
 
            // Calculate and return the necessary data size
            if ((fdoExtension->DiskData.PartitionStyle == PARTITION_STYLE_MBR) &&
                !fdoExtension->IsSuperFloppy)
            {
                uniqueId->UniqueIdLength = sizeof(basicVolId->Mbr);
            }
            else if (fdoExtension->DiskData.PartitionStyle == PARTITION_STYLE_GPT)
            {
                uniqueId->UniqueIdLength = sizeof(basicVolId->Gpt);
            }
            else
            {
                if (!InterfaceName->Buffer || !InterfaceName->Length)
                {
                    PartMgrReleaseLayoutLock(fdoExtension);
                    status = STATUS_INVALID_PARAMETER;
                    break;
                }
                uniqueId->UniqueIdLength = InterfaceName->Length;
            }
 
            // Return UniqueIdLength back
            if (!VerifyIrpOutBufferSize(Irp, headerSize + uniqueId->UniqueIdLength))
            {
                PartMgrReleaseLayoutLock(fdoExtension);
                Irp->IoStatus.Information = headerSize;
                status = STATUS_BUFFER_OVERFLOW;
                break;
            }
 
            //
            // Write the UniqueId
            //
            // Format:
            // - Basic volume on MBR disk: disk Mbr.Signature + partition StartingOffset (length: 0x0C)
            // - Basic volume on GPT disk: "DMIO:ID:" + Gpt.PartitionGuid (length: 0x18)
            // - Volume on Basic disk (NT <= 4): 8-byte FTDisk identifier (length: 0x08)
            // - Volume on Dynamic disk (NT 5+): "DMIO:ID:" + dmio VolumeGuid (length: 0x18)
            // - Super-floppy (single-partition with StartingOffset == 0),
            //   or Removable media: DiskInterfaceName.
            // - As fallback, we use the VolumeInterfaceName.
            //
            if ((fdoExtension->DiskData.PartitionStyle == PARTITION_STYLE_MBR) &&
                !fdoExtension->IsSuperFloppy)
            {
                basicVolId->Mbr.Signature = fdoExtension->DiskData.Mbr.Signature;
                basicVolId->Mbr.StartingOffset = partExt->StartingOffset;
            }
            else if (fdoExtension->DiskData.PartitionStyle == PARTITION_STYLE_GPT)
            {
                basicVolId->Gpt.Signature = DMIO_ID_SIGNATURE;
                basicVolId->Gpt.PartitionGuid = partExt->Gpt.PartitionId;
            }
            else
            {
                RtlCopyMemory(uniqueId->UniqueId,
                              InterfaceName->Buffer,
                              uniqueId->UniqueIdLength);
            }
 
            PartMgrReleaseLayoutLock(fdoExtension);
 
            status = STATUS_SUCCESS;
            Irp->IoStatus.Information = headerSize + uniqueId->UniqueIdLength;
            break;
        }
        case IOCTL_MOUNTDEV_QUERY_SUGGESTED_LINK_NAME:
        case IOCTL_MOUNTDEV_LINK_CREATED:
        case IOCTL_MOUNTDEV_LINK_DELETED:
#if (NTDDI_VERSION >= NTDDI_WS03)
        /* Deprecated Windows 2000/XP versions of IOCTL_MOUNTDEV_LINK_[CREATED|DELETED]
         * without access protection, that were updated in Windows 2003 */
        case CTL_CODE(MOUNTDEVCONTROLTYPE, 4, METHOD_BUFFERED, FILE_ANY_ACCESS):
        case CTL_CODE(MOUNTDEVCONTROLTYPE, 5, METHOD_BUFFERED, FILE_ANY_ACCESS):
#endif
        case IOCTL_MOUNTDEV_QUERY_STABLE_GUID:
        case IOCTL_MOUNTDEV_UNIQUE_ID_CHANGE_NOTIFY:
        {
            WARN("Ignored MountMgr notification: 0x%lX\n",
                 ioStack->Parameters.DeviceIoControl.IoControlCode);
            status = STATUS_NOT_IMPLEMENTED;
            break;
        }
        default:
            return ForwardIrpAndForget(DeviceObject, Irp);
    }
 
    Irp->IoStatus.Status = status;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
    return status;
}

Referenced by PartMgrDeviceControl().

PartitionHandlePnp()

NTSTATUS PartitionHandlePnp	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_In_ PIRP	Irp
	)

Definition at line 499 of file partition.c.

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

Referenced by PartMgrPnp().

PartitionHandleRemove()

NTSTATUS PartitionHandleRemove	(	_In_ PPARTITION_EXTENSION	PartExt,
		_In_ BOOLEAN	FinalRemove
	)

Definition at line 276 of file partition.c.

{
    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", &partitionSymlink, &PartExt->DeviceName);
    }
 
    // 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)
    {
        /* Notify MountMgr to delete all associated mount points.
         * MountMgr does not automatically remove these in order to support
         * drive letter persistence for online/offline volume transitions,
         * or volumes arrival/removal on removable devices. */
        status = VolumeDeleteMountPoints(PartExt);
        if (!NT_SUCCESS(status))
        {
            ERR("VolumeDeleteMountPoints(%wZ) failed with status 0x%08lx\n",
                &PartExt->DeviceName, status);
            /* Failure isn't major, continue proceeding with volume removal */
        }
 
        /* Notify MountMgr of volume removal */
        status = IoSetDeviceInterfaceState(&PartExt->VolumeInterfaceName, FALSE);
        if (!NT_SUCCESS(status))
        {
            return status;
        }
        RtlFreeUnicodeString(&PartExt->VolumeInterfaceName);
        RtlInitUnicodeString(&PartExt->VolumeInterfaceName, NULL);
    }
 
    if (FinalRemove)
    {
        ASSERT(PartExt->DeviceName.Buffer);
        if (PartExt->DeviceName.Buffer)
        {
            INFO("Removed device %wZ\n", &PartExt->DeviceName);
            RtlFreeUnicodeString(&PartExt->DeviceName);
        }
 
        IoDeleteDevice(PartExt->DeviceObject);
    }
 
    return STATUS_SUCCESS;
}

Referenced by FdoHandleSurpriseRemoval(), PartitionHandlePnp(), and PartMgrUpdatePartitionDevices().

PartMgrAcquireLayoutLock()

FORCEINLINE VOID PartMgrAcquireLayoutLock

(

_In_ PFDO_EXTENSION

FDOExtension

)

Definition at line 202 of file partmgr.h.

{
    PAGED_CODE();
 
    KeWaitForSingleObject(&FDOExtension->SyncEvent, Executive, KernelMode, FALSE, NULL);
}

Referenced by FdoHandleDeviceRelations(), FdoIoctlDiskCreateDisk(), FdoIoctlDiskDeleteDriveLayout(), FdoIoctlDiskGetDriveGeometryEx(), FdoIoctlDiskGetDriveLayout(), FdoIoctlDiskGetDriveLayoutEx(), FdoIoctlDiskGetPartitionInfo(), FdoIoctlDiskGetPartitionInfoEx(), FdoIoctlDiskSetDriveLayout(), FdoIoctlDiskSetDriveLayoutEx(), FdoIoctlDiskUpdateProperties(), PartitionHandleDeviceControl(), and PartitionHandleQueryId().

PartMgrReleaseLayoutLock()

FORCEINLINE VOID PartMgrReleaseLayoutLock

(

_In_ PFDO_EXTENSION

FDOExtension

)

Definition at line 212 of file partmgr.h.

{
    PAGED_CODE();
 
    KeSetEvent(&FDOExtension->SyncEvent, IO_NO_INCREMENT, FALSE);
}

Referenced by FdoHandleDeviceRelations(), FdoIoctlDiskCreateDisk(), FdoIoctlDiskDeleteDriveLayout(), FdoIoctlDiskGetDriveGeometryEx(), FdoIoctlDiskGetDriveLayout(), FdoIoctlDiskGetDriveLayoutEx(), FdoIoctlDiskGetPartitionInfo(), FdoIoctlDiskGetPartitionInfoEx(), FdoIoctlDiskSetDriveLayout(), FdoIoctlDiskSetDriveLayoutEx(), FdoIoctlDiskUpdateProperties(), PartitionHandleDeviceControl(), and PartitionHandleQueryId().

VerifyIrpInBufferSize()

FORCEINLINE BOOLEAN VerifyIrpInBufferSize	(	_In_ PIRP	Irp,
		_In_ SIZE_T	Size
	)

Definition at line 187 of file partmgr.h.

{
    PIO_STACK_LOCATION ioStack = IoGetCurrentIrpStackLocation(Irp);
    if (ioStack->Parameters.DeviceIoControl.InputBufferLength < Size)
    {
        Irp->IoStatus.Information = Size;
        return FALSE;
    }
    return TRUE;
}

Referenced by FdoIoctlDiskCreateDisk(), FdoIoctlDiskSetDriveLayout(), FdoIoctlDiskSetDriveLayoutEx(), PartitionHandleDeviceControl(), and ScsiPortDeviceControl().

VerifyIrpOutBufferSize()

FORCEINLINE BOOLEAN VerifyIrpOutBufferSize	(	_In_ PIRP	Irp,
		_In_ SIZE_T	Size
	)

Definition at line 172 of file partmgr.h.

{
    PIO_STACK_LOCATION ioStack = IoGetCurrentIrpStackLocation(Irp);
    if (ioStack->Parameters.DeviceIoControl.OutputBufferLength < Size)
    {
        Irp->IoStatus.Information = Size;
        return FALSE;
    }
    return TRUE;
}

Referenced by FdoIoctlDiskGetDriveLayout(), FdoIoctlDiskGetDriveLayoutEx(), FdoIoctlDiskGetPartitionInfo(), FdoIoctlDiskGetPartitionInfoEx(), PartitionHandleDeviceControl(), and ScsiPortDeviceControl().