windows-server-2003/drivers/storage/partmgr/partmgr.c

/*++

Copyright (C) Microsoft Corporation, 1997 - 1999

Module Name:

    partmgr.c

Abstract:

    This driver manages hides partitions from user mode, allowing access
    only from other device drivers.  This driver implements a notification
    protocol for other drivers that want to be alerted of changes to the
    partitions in the system.

Author:

    Norbert Kusters      18-Apr-1997

Environment:

    kernel mode only

Notes:
    PartMgr calls out to the volume managers using the IOCTL_INTERNAL_VOLMGR_XXXX 
    IOCTLs in a number of places having acquired the driver extension mutex.
    The Volume manager may then call back into PartMgr with that lock still held. 
    In these call backs manipulation of the structures utilised in the code which
    issued the IOCTL_INTERNAL_VOLMGR_XXXXs should be avoided. This includes the 
    following:-

        DriverExtension->VolumeManagerList
        DriverExtension->DeviceExtensionList
        DeviceExtension->PartitionList


Revision History:

--*/

#define RTL_USE_AVL_TABLES 0

#include <ntosp.h>
#include <stdio.h>
#include <ntddvol.h>
#include <initguid.h>
#include <ntdddisk.h>
#include <volmgr.h>
#include <wmikm.h>
#include <wmilib.h>
#include <pmwmireg.h>
#include <pmwmicnt.h>
#include <partmgr.h>
#include <ntiologc.h>
#include <ioevent.h>


#ifndef UMAX
#define UMAX(_P1, _P2) (((_P1) > (_P2)) ? (_P1) : (_P2))
#endif

#define LockDriver(_DriverExtension)    (KeWaitForSingleObject (&(_DriverExtension)->Mutex,     \
                                                               Executive,                       \
                                                               KernelMode,                      \
                                                               FALSE,                           \
                                                               NULL))

#define UnlockDriver(_DriverExtension)  (KeReleaseMutex (&(_DriverExtension)->Mutex, FALSE))



NTSTATUS
PmReadPartitionTableEx(
    IN PDEVICE_OBJECT DeviceObject,
    IN PDRIVE_LAYOUT_INFORMATION_EX* DriveLayout
    );


NTSTATUS
PmWritePartitionTableEx(
    IN  PDEVICE_OBJECT                  DeviceObject,
    IN  PDRIVE_LAYOUT_INFORMATION_EX    DriveLayout
    );

NTSTATUS
DriverEntry(
    IN PDRIVER_OBJECT DriverObject,
    IN PUNICODE_STRING RegistryPath
    );

VOID
PmTakePartition(
    IN  PVOLMGR_LIST_ENTRY  VolumeManagerEntry,
    IN  PDEVICE_OBJECT      Partition,
    IN  PDEVICE_OBJECT      WholeDiskPdo
    );

NTSTATUS
PmGivePartition(
    IN  PVOLMGR_LIST_ENTRY  VolumeManagerEntry,
    IN  PDEVICE_OBJECT      Partition,
    IN  PDEVICE_OBJECT      WholeDiskPdo
    );

NTSTATUS
PmFindPartition(
    IN  PDEVICE_EXTENSION       Extension,
    IN  ULONG                   PartitionNumber,
    OUT PPARTITION_LIST_ENTRY   *PartitionEntry
    );

NTSTATUS
PmQueryDeviceRelations(
    IN  PDEVICE_EXTENSION   Extension,
    IN  PIRP                Irp
    );

NTSTATUS
PmRemoveDevice(
    IN  PDEVICE_EXTENSION   Extension,
    IN  PIRP                Irp
    );

NTSTATUS
PmCreateClose(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp
    );

NTSTATUS
PmPnp(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp
    );

NTSTATUS
PmPower(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp
    );

VOID
PmPowerNotify (
    IN PDEVICE_OBJECT   DeviceObject,
    IN PVOID            WorkItem
    );

NTSTATUS
PmAddDevice(
    IN PDRIVER_OBJECT DriverObject,
    IN PDEVICE_OBJECT PhysicalDeviceObject
    );

NTSTATUS
PmVolumeManagerNotification(
    IN  PVOID   NotificationStructure,
    IN  PVOID   DriverExtension
    );

NTSTATUS
PmNotifyPartitions(
    IN PDEVICE_EXTENSION DeviceObject,
    IN PIRP              Irp
    );

NTSTATUS
PmBuildDependantVolumeRelations(
    IN PDEVICE_EXTENSION Extension,
    OUT PDEVICE_RELATIONS *Relations
    );

NTSTATUS
PmQueryDependantVolumeList(
    IN  PDEVICE_OBJECT VolumeManager,
    IN  PDEVICE_OBJECT Partition,
    IN  PDEVICE_OBJECT WholeDiskPdo,
    OUT PDEVICE_RELATIONS *DependantVolumes
    );

NTSTATUS
PmQueryRemovalRelations(
    IN  PDEVICE_EXTENSION   Extension,
    IN  PIRP                Irp
    );

NTSTATUS
PmStartPartition(
    IN  PDEVICE_OBJECT  Partition
    );

NTSTATUS
PmRemovePartition(
    IN PPARTITION_LIST_ENTRY Partition
    );

NTSTATUS
PmDeviceControl(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp
    );

NTSTATUS
PmGetPartitionInformation(
    IN  PDEVICE_OBJECT  Partition,
    IN  PFILE_OBJECT    FileObject,
    OUT PLONGLONG       PartitionOffset,
    OUT PLONGLONG       PartitionLength
    );

NTSTATUS
PmDiskGrowPartition(
    IN  PDEVICE_OBJECT  DeviceObject,
    IN  PIRP            Irp
    );

NTSTATUS
PmCheckForUnclaimedPartitions(
    IN  PDEVICE_OBJECT  DeviceObject
    );

NTSTATUS
PmChangePartitionIoctl(
    IN  PDEVICE_EXTENSION       Extension,
    IN  PPARTITION_LIST_ENTRY   Partition,
    IN  ULONG                   IoctlCode
    );

NTSTATUS
PmEjectVolumeManagers(
    IN PDEVICE_OBJECT DeviceObject
    );

VOID
PmAddSignatures(
    IN  PDEVICE_EXTENSION               Extension,
    IN  PDRIVE_LAYOUT_INFORMATION_EX    Layout
    );

RTL_GENERIC_COMPARE_RESULTS
PmTableSignatureCompareRoutine(
    IN  PRTL_GENERIC_TABLE  Table,
    IN  PVOID               First,
    IN  PVOID               Second
    );

RTL_GENERIC_COMPARE_RESULTS
PmTableGuidCompareRoutine(
    IN  PRTL_GENERIC_TABLE  Table,
    IN  PVOID               First,
    IN  PVOID               Second
    );

PVOID
PmTableAllocateRoutine(
    IN  PRTL_GENERIC_TABLE  Table,
    IN  CLONG               Size
    );

VOID
PmTableFreeRoutine(
    IN  PRTL_GENERIC_TABLE  Table,
    IN  PVOID               Buffer
    );

NTSTATUS
PmQueryDiskSignature(
    IN  PDEVICE_OBJECT  DeviceObject,
    IN  PIRP            Irp
    );

NTSTATUS
PmReadWrite(
    IN PDEVICE_OBJECT   DeviceObject,
    IN PIRP             Irp
    );

NTSTATUS
PmIoCompletion(
    IN PDEVICE_OBJECT   DeviceObject,
    IN PIRP             Irp,
    IN PVOID            Context
    );

NTSTATUS PmWmi(
    IN PDEVICE_OBJECT   DeviceObject,
    IN PIRP             Irp
    );

NTSTATUS
PmWmiFunctionControl(
    IN PDEVICE_OBJECT           DeviceObject,
    IN PIRP                     Irp,
    IN ULONG                    GuidIndex,
    IN WMIENABLEDISABLECONTROL  Function,
    IN BOOLEAN                  Enable
    );

VOID
PmDriverReinit(
    IN  PDRIVER_OBJECT  DriverObject,
    IN  PVOID           DriverExtension,
    IN  ULONG           Count
    );

BOOLEAN
PmIsRedundantPath(
    IN  PDEVICE_EXTENSION   Extension,
    IN  PDEVICE_EXTENSION   WinningExtension,
    IN  ULONG               Signature,
    IN  GUID*               Guid
    );

VOID
PmLogError(
    IN  PDEVICE_EXTENSION   Extension,
    IN  PDEVICE_EXTENSION   WinningExtension,
    IN  NTSTATUS            SpecificIoStatus
    );

ULONG
PmQueryRegistrySignature(
    );

VOID
PmQueryRegistryGuid(
    IN  PDO_EXTENSION   DriverExtension
    );

NTSTATUS
PmQueryRegistryGuidQueryRoutine(
    IN  PWSTR   ValueName,
    IN  ULONG   ValueType,
    IN  PVOID   ValueData,
    IN  ULONG   ValueLength,
    IN  PVOID   Context,
    IN  PVOID   EntryContext
    );

VOID 
PmSigCheckUpdateEpoch (
    IN PDEVICE_EXTENSION DeviceExtension,
    IN PLIST_ENTRY       CompletionList
    );

VOID
PmSigCheckCompleteNotificationIrps(
    IN PLIST_ENTRY CompletionList
    );

NTSTATUS
PmSigCheckFillInNotificationIrp (
    IN PDO_EXTENSION DriverExtension,
    IN PIRP          Irp
    );

NTSTATUS
PmSigCheckNotificationInsert (
    IN PDEVICE_EXTENSION DeviceExtension, 
    IN PIRP              Irp
    );

NTSTATUS
PmSigCheckNotificationCancel (
    IN PDEVICE_OBJECT DeviceObject, 
    IN PIRP           Irp
    );

NTSTATUS
PmCheckAndUpdateSignature (
    IN PDEVICE_EXTENSION DeviceExtension,
    IN BOOLEAN           IssueSigCheckNotifications,
    IN BOOLEAN           ForceSignatureCheck
    );

BOOLEAN
LockDriverWithTimeout(
    IN  PDO_EXTENSION   DriverExtension
    );

#ifdef ALLOC_PRAGMA
#pragma alloc_text(INIT, DriverEntry)
#pragma alloc_text(INIT, PmQueryRegistrySignature)
#pragma alloc_text(INIT, PmQueryRegistryGuid)
#pragma alloc_text(INIT, PmQueryRegistryGuidQueryRoutine)
#pragma alloc_text(PAGE, PmTakePartition)
#pragma alloc_text(PAGE, PmGivePartition)
#pragma alloc_text(PAGE, PmFindPartition)
#pragma alloc_text(PAGE, PmQueryDeviceRelations)
#pragma alloc_text(PAGE, PmRemoveDevice)
#pragma alloc_text(PAGE, PmCreateClose)
#pragma alloc_text(PAGE, PmPnp)
#pragma alloc_text(PAGE, PmAddDevice)
#pragma alloc_text(PAGE, PmVolumeManagerNotification)
#pragma alloc_text(PAGE, PmNotifyPartitions)
#pragma alloc_text(PAGE, PmBuildDependantVolumeRelations)
#pragma alloc_text(PAGE, PmQueryDependantVolumeList)
#pragma alloc_text(PAGE, PmQueryRemovalRelations)
#pragma alloc_text(PAGE, PmStartPartition)
#pragma alloc_text(PAGE, PmDeviceControl)
#pragma alloc_text(PAGE, PmGetPartitionInformation)
#pragma alloc_text(PAGE, PmDiskGrowPartition)
#pragma alloc_text(PAGE, PmCheckForUnclaimedPartitions)
#pragma alloc_text(PAGE, PmChangePartitionIoctl)
#pragma alloc_text(PAGE, PmEjectVolumeManagers)
#pragma alloc_text(PAGE, PmAddSignatures)
#pragma alloc_text(PAGE, PmTableSignatureCompareRoutine)
#pragma alloc_text(PAGE, PmTableGuidCompareRoutine)
#pragma alloc_text(PAGE, PmTableAllocateRoutine)
#pragma alloc_text(PAGE, PmTableFreeRoutine)
#pragma alloc_text(PAGE, PmQueryDiskSignature)
#pragma alloc_text(PAGE, PmWmi)
#pragma alloc_text(PAGE, PmWmiFunctionControl)
#pragma alloc_text(PAGE, PmReadPartitionTableEx)
#pragma alloc_text(PAGE, PmWritePartitionTableEx)
#pragma alloc_text(PAGE, PmDriverReinit)
#pragma alloc_text(PAGE, PmIsRedundantPath)
#pragma alloc_text(PAGE, PmLogError)
#pragma alloc_text(PAGE, PmSigCheckCompleteNotificationIrps)
#pragma alloc_text(PAGE, PmSigCheckFillInNotificationIrp)
#pragma alloc_text(PAGE, PmCheckAndUpdateSignature)
#pragma alloc_text(PAGE, LockDriverWithTimeout)
#endif

const GUID guidNull = { 0 };


BOOLEAN
LockDriverWithTimeout(
    IN  PDO_EXTENSION   DriverExtension
    )
{
    LARGE_INTEGER   timeout;
    NTSTATUS        status;

    timeout.QuadPart = -10*1000*1000*6; // 6 seconds.
    status = KeWaitForSingleObject(&DriverExtension->Mutex, Executive,
                                   KernelMode, FALSE, &timeout);

    return (status != STATUS_TIMEOUT);
}

NTSTATUS
PmPassThrough(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp
    )

/*++

Routine Description:

    This routine is the dispatch for IRP_MJ_PNP_POWER.

Arguments:

    DeviceObject    - Supplies the device object.

    Irp             - Supplies the IO request packet.

Return Value:

    NTSTATUS

--*/

{
    PDEVICE_EXTENSION   extension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;

    IoSkipCurrentIrpStackLocation(Irp);
    return IoCallDriver(extension->TargetObject, Irp);
}

NTSTATUS
PmSignalCompletion(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp,
    IN PVOID Event
    )

/*++

Routine Description:

    This routine will signal the event given as context.

Arguments:

    DeviceObject    - Supplies the device object.

    Irp             - Supplies the IO request packet.

    Event           - Supplies the event to signal.

Return Value:

    NTSTATUS

--*/

{
    KeSetEvent((PKEVENT) Event, IO_NO_INCREMENT, FALSE);
    return STATUS_MORE_PROCESSING_REQUIRED;
}

VOID
PmTakePartition(
    IN  PVOLMGR_LIST_ENTRY  VolumeManagerEntry,
    IN  PDEVICE_OBJECT      Partition,
    IN  PDEVICE_OBJECT      WholeDiskPdo
    )

/*++

Routine Description:

    This routine passes the given partition to the given volume manager
    and waits to see if the volume manager accepts the partition.  A success
    status indicates that the volume manager has accepted the partition.

Arguments:

    VolumeManager   - Supplies a volume manager.

    Partition       - Supplies a partition.

    WholeDiskPdo    - Supplies the whole disk PDO.

Return Value:

    NTSTATUS

--*/

{
    KEVENT                          event;
    VOLMGR_PARTITION_INFORMATION    input;
    PIRP                            irp;
    IO_STATUS_BLOCK                 ioStatus;
    NTSTATUS                        status;

    if (!VolumeManagerEntry) {
        return;
    }

    KeInitializeEvent(&event, NotificationEvent, FALSE);
    input.PartitionDeviceObject = Partition;
    input.WholeDiskPdo = WholeDiskPdo;

    irp = IoBuildDeviceIoControlRequest(IOCTL_INTERNAL_VOLMGR_PARTITION_REMOVED,
                                        VolumeManagerEntry->VolumeManager,
                                        &input, sizeof(input), NULL, 0, TRUE,
                                        &event, &ioStatus);
    if (!irp) {
        return;
    }

    status = IoCallDriver(VolumeManagerEntry->VolumeManager, irp);
    if (status == STATUS_PENDING) {
        KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
    }

    VolumeManagerEntry->RefCount--;
    if (!VolumeManagerEntry->RefCount) {
        VolumeManagerEntry->VolumeManager = NULL;
        ObDereferenceObject(VolumeManagerEntry->VolumeManagerFileObject);
        VolumeManagerEntry->VolumeManagerFileObject = NULL;
    }
}

NTSTATUS
PmGivePartition(
    IN  PVOLMGR_LIST_ENTRY  VolumeManagerEntry,
    IN  PDEVICE_OBJECT      Partition,
    IN  PDEVICE_OBJECT      WholeDiskPdo
    )

/*++

Routine Description:

    This routine passes the given partition to the given volume manager
    and waits to see if the volume manager accepts the partition.  A success
    status indicates that the volume manager has accepted the partition.

Arguments:

    VolumeManager   - Supplies a volume manager.

    Partition       - Supplies a partition.

    WholeDiskPdo    - Supplies the whole disk PDO.

Return Value:

    NTSTATUS

--*/

{
    NTSTATUS                        status;
    KEVENT                          event;
    VOLMGR_PARTITION_INFORMATION    input;
    PIRP                            irp;
    IO_STATUS_BLOCK                 ioStatus;

    if (!VolumeManagerEntry->RefCount) {
        status = IoGetDeviceObjectPointer(
                 &VolumeManagerEntry->VolumeManagerName, FILE_READ_DATA,
                 &VolumeManagerEntry->VolumeManagerFileObject,
                 &VolumeManagerEntry->VolumeManager);
        if (!NT_SUCCESS(status)) {
            return status;
        }
    }

    KeInitializeEvent(&event, NotificationEvent, FALSE);
    input.PartitionDeviceObject = Partition;
    input.WholeDiskPdo = WholeDiskPdo;

    irp = IoBuildDeviceIoControlRequest(IOCTL_INTERNAL_VOLMGR_PARTITION_ARRIVED,
                                        VolumeManagerEntry->VolumeManager,
                                        &input, sizeof(input),
                                        NULL, 0, TRUE, &event, &ioStatus);
    if (!irp) {
        if (!VolumeManagerEntry->RefCount) {
            VolumeManagerEntry->VolumeManager = NULL;
            ObDereferenceObject(VolumeManagerEntry->VolumeManagerFileObject);
            VolumeManagerEntry->VolumeManagerFileObject = NULL;
        }
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    status = IoCallDriver(VolumeManagerEntry->VolumeManager, irp);
    if (status == STATUS_PENDING) {
        KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
        status = ioStatus.Status;
    }

    if (NT_SUCCESS(status)) {
        VolumeManagerEntry->RefCount++;
    } else {
        if (!VolumeManagerEntry->RefCount) {
            VolumeManagerEntry->VolumeManager = NULL;
            ObDereferenceObject(VolumeManagerEntry->VolumeManagerFileObject);
            VolumeManagerEntry->VolumeManagerFileObject = NULL;
        }
    }

    return status;
}

NTSTATUS
PmFindPartition(
    IN  PDEVICE_EXTENSION       Extension,
    IN  ULONG                   PartitionNumber,
    OUT PPARTITION_LIST_ENTRY*  Partition
    )

{
    PLIST_ENTRY             l;
    PPARTITION_LIST_ENTRY   partition;
    KEVENT                  event;
    PIRP                    irp;
    STORAGE_DEVICE_NUMBER   deviceNumber;
    IO_STATUS_BLOCK         ioStatus;
    NTSTATUS                status;

    ASSERT(Partition);
    *Partition = NULL;

    for (l = Extension->PartitionList.Flink; l != &Extension->PartitionList;
         l = l->Flink) {

        partition = CONTAINING_RECORD(l, PARTITION_LIST_ENTRY, ListEntry);

        KeInitializeEvent(&event, NotificationEvent, FALSE);
        irp = IoBuildDeviceIoControlRequest(IOCTL_STORAGE_GET_DEVICE_NUMBER,
                                            partition->TargetObject, NULL, 0,
                                            &deviceNumber,
                                            sizeof(deviceNumber), FALSE,
                                            &event, &ioStatus);
        if (!irp) {
            return STATUS_INSUFFICIENT_RESOURCES;
        }

        status = IoCallDriver(partition->TargetObject, irp);
        if (status == STATUS_PENDING) {
            KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
            status = ioStatus.Status;
        }

        if (NT_SUCCESS(status) &&
            PartitionNumber == deviceNumber.PartitionNumber) {

            *Partition = partition;
            return status;
        }
    }

    return STATUS_NOT_FOUND;
}

NTSTATUS
PmChangePartitionIoctl(
    IN  PDEVICE_EXTENSION       Extension,
    IN  PPARTITION_LIST_ENTRY   Partition,
    IN  ULONG                   IoctlCode
    )

{
    PVOLMGR_LIST_ENTRY              volumeEntry;
    KEVENT                          event;
    VOLMGR_PARTITION_INFORMATION    input;
    PIRP                            irp;
    IO_STATUS_BLOCK                 ioStatus;
    NTSTATUS                        status;

    volumeEntry = Partition->VolumeManagerEntry;
    if (!volumeEntry) {
        return STATUS_SUCCESS;
    }

    KeInitializeEvent(&event, NotificationEvent, FALSE);

    input.PartitionDeviceObject = Partition->TargetObject;
    input.WholeDiskPdo = Partition->WholeDiskPdo;

    irp = IoBuildDeviceIoControlRequest(
            IoctlCode, volumeEntry->VolumeManager, &input, sizeof(input),
            NULL, 0, TRUE, &event, &ioStatus);
    if (!irp) {
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    status = IoCallDriver(volumeEntry->VolumeManager, irp);
    if (status == STATUS_PENDING) {
        KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
        status = ioStatus.Status;
    }

    return status;
}

NTSTATUS
PmStartPartition(
    IN  PDEVICE_OBJECT  Partition
    )

{
    PIRP                    irp;
    KEVENT                  event;
    PIO_STACK_LOCATION      irpSp;
    NTSTATUS                status;

    irp = IoAllocateIrp(Partition->StackSize, FALSE);
    if (!irp) {
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    KeInitializeEvent(&event, NotificationEvent, FALSE);
    irpSp = IoGetNextIrpStackLocation(irp);
    irpSp->MajorFunction = IRP_MJ_PNP;
    irpSp->MinorFunction = IRP_MN_START_DEVICE;
    irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
    IoSetCompletionRoutine(irp, PmSignalCompletion, &event, TRUE, TRUE, TRUE);

    IoCallDriver(Partition, irp);
    KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);

    status = irp->IoStatus.Status;

    IoFreeIrp(irp);

    return status;
}

NTSTATUS
PmQueryDeviceRelations(
    IN  PDEVICE_EXTENSION   Extension,
    IN  PIRP                Irp
    )

/*++

Routine Description:

    This routine processes the query device relations request.

Arguments:

    Extension   - Supplies the device extension.

    Irp         - Supplies the IO request packet.

Return Value:

    NTSTATUS

--*/

{
    NTSTATUS                        status;
    PDRIVE_LAYOUT_INFORMATION_EX    newLayout;
    KEVENT                          event;
    PDEVICE_RELATIONS               deviceRelations;
    PLIST_ENTRY                     l, b;
    PPARTITION_LIST_ENTRY           partition;
    ULONG                           i;
    PVOLMGR_LIST_ENTRY              volmgrEntry;
    LIST_ENTRY                      completionList;

    KeInitializeEvent(&event, NotificationEvent, FALSE);
    IoCopyCurrentIrpStackLocationToNext(Irp);
    IoSetCompletionRoutine(Irp, PmSignalCompletion, &event, TRUE, TRUE, TRUE);
    IoCallDriver(Extension->TargetObject, Irp);
    KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);

    if (!NT_SUCCESS(Irp->IoStatus.Status)) {
        return Irp->IoStatus.Status;
    }

    deviceRelations = (PDEVICE_RELATIONS) Irp->IoStatus.Information;


    PmCheckAndUpdateSignature (Extension, TRUE, FALSE);



    //
    // First notify clients of partitions that have gone away.
    //

    LockDriver (Extension->DriverExtension);


    for (l = Extension->PartitionList.Flink; l != &Extension->PartitionList;
         l = l->Flink) {

        partition = CONTAINING_RECORD(l, PARTITION_LIST_ENTRY, ListEntry);

        for (i = 0; i < deviceRelations->Count; i++) {
            if (partition->TargetObject == deviceRelations->Objects[i]) {
                break;
            }
        }

        if (i < deviceRelations->Count) {
            continue;
        }

        PmTakePartition(partition->VolumeManagerEntry,
                        partition->TargetObject, partition->WholeDiskPdo);

        //
        // We're pretending to be pnp.  Send a remove to the partition
        // object so it can delete it.
        //

        PmRemovePartition(partition);

        b = l->Blink;
        RemoveEntryList(l);
        l = b;

        ExFreePool(partition);
    }

    //
    // Then notify clients of new partitions.
    //

    for (i = 0; i < deviceRelations->Count; i++) {

        for (l = Extension->PartitionList.Flink;
             l != &Extension->PartitionList; l = l->Flink) {

            partition = CONTAINING_RECORD(l, PARTITION_LIST_ENTRY, ListEntry);

            if (deviceRelations->Objects[i] == partition->TargetObject) {
                break;
            }
        }

        if (l != &Extension->PartitionList) {
            
            //
            // Must attempt to start the partition even if it is in our list
            // because it may be stopped and need restarting.
            //

            PmStartPartition(deviceRelations->Objects[i]);
            continue;
        }

        if (Extension->DriverExtension->PastReinit) {

            //
            // Now that this partition is owned by the partition manager
            // make sure that nobody can open it another way.
            //

            deviceRelations->Objects[i]->Flags |= DO_DEVICE_INITIALIZING;
        }

        status = PmStartPartition(deviceRelations->Objects[i]);
        if (!NT_SUCCESS(status)) {
            continue;
        }

        partition = ExAllocatePoolWithTag(NonPagedPool,
                                          sizeof(PARTITION_LIST_ENTRY),
                                          PARTMGR_TAG_PARTITION_ENTRY);
        if (!partition) {
            continue;
        }

        partition->TargetObject = deviceRelations->Objects[i];
        partition->WholeDiskPdo = Extension->Pdo;
        partition->VolumeManagerEntry = NULL;
        InsertHeadList(&Extension->PartitionList, &partition->ListEntry);

        if (Extension->IsRedundantPath) {
            continue;
        }

        for (l = Extension->DriverExtension->VolumeManagerList.Flink;
             l != &Extension->DriverExtension->VolumeManagerList; l = l->Flink) {

            volmgrEntry = CONTAINING_RECORD(l, VOLMGR_LIST_ENTRY, ListEntry);

            status = PmGivePartition(volmgrEntry,
                                     partition->TargetObject,
                                     partition->WholeDiskPdo);

            if (NT_SUCCESS(status)) {
                partition->VolumeManagerEntry = volmgrEntry;
                break;
            }
        }
    }


    UnlockDriver (Extension->DriverExtension);

    deviceRelations->Count = 0;

    return Irp->IoStatus.Status;
}

VOID
PmTakeWholeDisk(
    IN  PVOLMGR_LIST_ENTRY  VolumeManagerEntry,
    IN  PDEVICE_OBJECT      WholeDiskPdo
    )

/*++

Routine Description:

    This routine alerts the volume manager that the given PDO is going away.

Arguments:

    VolumeManager   - Supplies a volume manager.

    WholeDiskPdo    - Supplies the whole disk PDO.

Return Value:

    NTSTATUS

--*/

{
    NTSTATUS                        status;
    KEVENT                          event;
    VOLMGR_WHOLE_DISK_INFORMATION   input;
    PIRP                            irp;
    IO_STATUS_BLOCK                 ioStatus;

    if (!VolumeManagerEntry) {
        return;
    }

    if (!VolumeManagerEntry->RefCount) {
        status = IoGetDeviceObjectPointer(
                 &VolumeManagerEntry->VolumeManagerName, FILE_READ_DATA,
                 &VolumeManagerEntry->VolumeManagerFileObject,
                 &VolumeManagerEntry->VolumeManager);
        if (!NT_SUCCESS(status)) {
            return;
        }
    }

    KeInitializeEvent(&event, NotificationEvent, FALSE);
    input.WholeDiskPdo = WholeDiskPdo;

    irp = IoBuildDeviceIoControlRequest(IOCTL_INTERNAL_VOLMGR_WHOLE_DISK_REMOVED,
                                        VolumeManagerEntry->VolumeManager,
                                        &input, sizeof(input), NULL, 0, TRUE,
                                        &event, &ioStatus);
    if (!irp) {
        if (!VolumeManagerEntry->RefCount) {
            VolumeManagerEntry->VolumeManager = NULL;
            ObDereferenceObject(VolumeManagerEntry->VolumeManagerFileObject);
            VolumeManagerEntry->VolumeManagerFileObject = NULL;
        }
        return;
    }

    status = IoCallDriver(VolumeManagerEntry->VolumeManager, irp);
    if (status == STATUS_PENDING) {
        KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
    }

    if (!VolumeManagerEntry->RefCount) {
        VolumeManagerEntry->VolumeManager = NULL;
        ObDereferenceObject(VolumeManagerEntry->VolumeManagerFileObject);
        VolumeManagerEntry->VolumeManagerFileObject = NULL;
    }
}

NTSTATUS
PmNotifyPartitions(
    IN PDEVICE_EXTENSION Extension,
    IN PIRP              Irp
    )

/*++

Routine Description:

    This routine notifies each partition stolen by the partmgr that it is
    about to be removed.

Arguments:

    Extension   - Supplies the device extension.

    Irp         - Supplies the IO request packet.

Return Value:

    NTSTATUS

--*/

{
    PIO_STACK_LOCATION      irpStack = IoGetCurrentIrpStackLocation(Irp);
    PLIST_ENTRY             l;
    PPARTITION_LIST_ENTRY   partition;
    NTSTATUS                status = STATUS_SUCCESS;
    KEVENT event;

    PAGED_CODE();

    KeInitializeEvent(&event, SynchronizationEvent, FALSE);

    LockDriver (Extension->DriverExtension);

    for(l = Extension->PartitionList.Flink;
        l != &(Extension->PartitionList);
        l = l->Flink) {

        partition = CONTAINING_RECORD(l, PARTITION_LIST_ENTRY, ListEntry);

        IoCopyCurrentIrpStackLocationToNext(Irp);
        IoSetCompletionRoutine(Irp,
                               PmSignalCompletion,
                               &event,
                               TRUE,
                               TRUE,
                               TRUE);

        status = IoCallDriver(partition->TargetObject, Irp);

        if(status == STATUS_PENDING) {

            KeWaitForSingleObject(&event,
                                  Executive,
                                  KernelMode,
                                  FALSE,
                                  NULL);

            status = Irp->IoStatus.Status;
        }

        if(!NT_SUCCESS(status)) {
            break;
        }
    }

    UnlockDriver (Extension->DriverExtension);

    return status;
}

NTSTATUS
PmRemoveDevice(
    IN  PDEVICE_EXTENSION   Extension,
    IN  PIRP                Irp
    )

/*++

Routine Description:

    This routine processes the query device relations request.

Arguments:

    Extension   - Supplies the device extension.

    Irp         - Supplies the I/O request packet.

Return Value:

    NTSTATUS

--*/

{
    NTSTATUS                        status;
    PDRIVE_LAYOUT_INFORMATION_EX    layout;
    PLIST_ENTRY                     l;
    PPARTITION_LIST_ENTRY           partition;
    PVOLMGR_LIST_ENTRY              volmgrEntry;


    LockDriver (Extension->DriverExtension);

    if (Extension->RemoveProcessed) {
        UnlockDriver (Extension->DriverExtension);
        return STATUS_SUCCESS;
    }

    Extension->RemoveProcessed = TRUE;

    Extension->IsStarted = FALSE;

    PmAddSignatures(Extension, NULL);

    for (l = Extension->PartitionList.Flink;
         l != &Extension->PartitionList; l = l->Flink) {

        partition = CONTAINING_RECORD(l, PARTITION_LIST_ENTRY, ListEntry);
        PmTakePartition(partition->VolumeManagerEntry,
                        partition->TargetObject, NULL);
    }

    status = PmNotifyPartitions(Extension, Irp);

    ASSERT(NT_SUCCESS(status));

    while (!IsListEmpty(&Extension->PartitionList)) {
        l = RemoveHeadList(&Extension->PartitionList);
        partition = CONTAINING_RECORD(l, PARTITION_LIST_ENTRY, ListEntry);
        ExFreePool(partition);
    }

    for (l = Extension->DriverExtension->VolumeManagerList.Flink;
         l != &Extension->DriverExtension->VolumeManagerList; l = l->Flink) {

        volmgrEntry = CONTAINING_RECORD(l, VOLMGR_LIST_ENTRY, ListEntry);
        PmTakeWholeDisk(volmgrEntry, Extension->Pdo);
    }

    RemoveEntryList(&Extension->ListEntry);

    if (Extension->WmilibContext != NULL) { // just to be safe
        IoWMIRegistrationControl(Extension->DeviceObject,
                                 WMIREG_ACTION_DEREGISTER);
        ExFreePool(Extension->WmilibContext);
        Extension->WmilibContext = NULL;
        PmWmiCounterDisable(&Extension->PmWmiCounterContext,
                            TRUE, TRUE);
        Extension->CountersEnabled = FALSE;
    }


    UnlockDriver (Extension->DriverExtension);

    return status;
}

VOID
PmPowerNotify (
    IN PDEVICE_OBJECT   DeviceObject,
    IN PVOID            PublicWorkItem
    )

/*++

Routine Description:

    This routine notifies volume managers about changes in
    the power state of the given disk.

Arguments:

    DeviceObject    - Supplies the device object.

    PublicWorkItem  - Supplies the public work item

Return Value:

    None    

--*/

{
    PDEVICE_EXTENSION       deviceExtension = DeviceObject->DeviceExtension;
    PDO_EXTENSION           driverExtension = deviceExtension->DriverExtension;
    KEVENT                  event;
    KIRQL                   irql;
    LIST_ENTRY              q;
    PLIST_ENTRY             l;
    BOOLEAN                 empty;
    PPM_POWER_WORK_ITEM     privateWorkItem; 
    PPARTITION_LIST_ENTRY   partition;
    VOLMGR_POWER_STATE      input;
    PIRP                    irp;
    IO_STATUS_BLOCK         ioStatus;
    NTSTATUS                status;
        

    LockDriver (driverExtension);

    KeAcquireSpinLock(&deviceExtension->SpinLock, &irql);
    if (IsListEmpty(&deviceExtension->PowerQueue)) {
        empty = TRUE;
    } else {
        empty = FALSE;
        q = deviceExtension->PowerQueue;
        InitializeListHead(&deviceExtension->PowerQueue);
    }
    KeReleaseSpinLock(&deviceExtension->SpinLock, irql);

    if (empty) {
        UnlockDriver (driverExtension);
        IoReleaseRemoveLock(&deviceExtension->RemoveLock, NULL);
        IoFreeWorkItem((PIO_WORKITEM) PublicWorkItem);
        return;
    }

    q.Flink->Blink = &q;
    q.Blink->Flink = &q;
    KeInitializeEvent(&event, NotificationEvent, FALSE);

    while (!IsListEmpty(&q)) {

        l = RemoveHeadList(&q);
        privateWorkItem = CONTAINING_RECORD(l, PM_POWER_WORK_ITEM, ListEntry);

        for (l = deviceExtension->PartitionList.Flink; 
             l != &deviceExtension->PartitionList; l = l->Flink) {

            partition = CONTAINING_RECORD(l, PARTITION_LIST_ENTRY, ListEntry);
            if (!partition->VolumeManagerEntry) {
                continue;
            }
        
            input.PartitionDeviceObject = partition->TargetObject;
            input.WholeDiskPdo = partition->WholeDiskPdo;
            input.PowerState = privateWorkItem->DevicePowerState;

            irp = IoBuildDeviceIoControlRequest(
                                    IOCTL_INTERNAL_VOLMGR_SET_POWER_STATE,
                                    partition->VolumeManagerEntry->VolumeManager,
                                    &input, sizeof(input), NULL, 0, TRUE,
                                    &event, &ioStatus);
            if (!irp) {
                continue;
            }
            status = IoCallDriver(partition->VolumeManagerEntry->VolumeManager, 
                                  irp);
            if (status == STATUS_PENDING) {
                KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
            }
            KeClearEvent(&event);
        }

        ExFreePool(privateWorkItem);        
    }
            
    UnlockDriver (driverExtension);
    IoReleaseRemoveLock(&deviceExtension->RemoveLock, NULL);
    IoFreeWorkItem((PIO_WORKITEM) PublicWorkItem);    
} 

NTSTATUS
PmPowerCompletion(
    IN PDEVICE_OBJECT   DeviceObject,
    IN PIRP             Irp,
    IN PVOID            Context
    )

/*++

Routine Description:

    This routine handles completion of an IRP_MN_SET_POWER irp.

Arguments:

    DeviceObject    - Supplies the device object.

    Irp             - Supplies the IO request packet.

    Context         - Not used.

Return Value:

    NTSTATUS

--*/

{
    PDEVICE_EXTENSION   deviceExtension = DeviceObject->DeviceExtension;
    PIO_STACK_LOCATION  irpStack        = IoGetCurrentIrpStackLocation(Irp);
    PIO_WORKITEM        publicWorkItem;
    PPM_POWER_WORK_ITEM privateWorkItem; 
    KIRQL               irql;

    ASSERT(irpStack->MajorFunction == IRP_MJ_POWER &&
           irpStack->MinorFunction == IRP_MN_SET_POWER);
    ASSERT(irpStack->Parameters.Power.Type == DevicePowerState);
    
    if (!NT_SUCCESS(Irp->IoStatus.Status)) {
        PoStartNextPowerIrp(Irp);
        IoReleaseRemoveLock(&deviceExtension->RemoveLock, NULL);
        return STATUS_SUCCESS;
    }

    publicWorkItem = IoAllocateWorkItem(DeviceObject);
    if (!publicWorkItem) {
        PoStartNextPowerIrp(Irp);
        IoReleaseRemoveLock(&deviceExtension->RemoveLock, NULL);
        return STATUS_SUCCESS;
    }
    
    privateWorkItem = (PPM_POWER_WORK_ITEM) ExAllocatePoolWithTag(NonPagedPool,
                                          sizeof(PM_POWER_WORK_ITEM),
                                          PARTMGR_TAG_POWER_WORK_ITEM);
    if (!privateWorkItem) {
        PoStartNextPowerIrp(Irp);
        IoReleaseRemoveLock(&deviceExtension->RemoveLock, NULL);
        IoFreeWorkItem(publicWorkItem);
        return STATUS_SUCCESS;
    }
    
    privateWorkItem->DevicePowerState = 
                        irpStack->Parameters.Power.State.DeviceState;
    
    KeAcquireSpinLock(&deviceExtension->SpinLock, &irql);
    InsertTailList(&deviceExtension->PowerQueue, &privateWorkItem->ListEntry);
    KeReleaseSpinLock(&deviceExtension->SpinLock, irql);
    
    IoQueueWorkItem(publicWorkItem, PmPowerNotify, DelayedWorkQueue, 
                    publicWorkItem);
    
    PoStartNextPowerIrp(Irp);
    return STATUS_SUCCESS;        
}

NTSTATUS
PmPower(
    IN PDEVICE_OBJECT   DeviceObject,
    IN PIRP             Irp
    )

/*++

Routine Description:

    This routine is the dispatch for IRP_MJ_POWER.

Arguments:

    DeviceObject    - Supplies the device object.

    Irp             - Supplies the IO request packet.

Return Value:

    NTSTATUS

--*/

{
    PIO_STACK_LOCATION  irpSp = IoGetCurrentIrpStackLocation(Irp);
    PDEVICE_EXTENSION   deviceExtension = 
                        (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
    NTSTATUS            status;
       
    status = IoAcquireRemoveLock (&deviceExtension->RemoveLock, NULL);
    if (!NT_SUCCESS (status)) {
        PoStartNextPowerIrp (Irp);
        Irp->IoStatus.Information = 0;
        Irp->IoStatus.Status = status;
        IoCompleteRequest (Irp, IO_NO_INCREMENT);
        return status;
    }
    
    if (irpSp->MinorFunction == IRP_MN_SET_POWER &&
        irpSp->Parameters.Power.Type == DevicePowerState) {

        IoCopyCurrentIrpStackLocationToNext(Irp);
        IoSetCompletionRoutine(Irp, PmPowerCompletion, NULL, TRUE, 
                               TRUE, TRUE);
        IoMarkIrpPending(Irp);
        PoCallDriver(deviceExtension->TargetObject, Irp);
        return STATUS_PENDING;
    }   
    
    PoStartNextPowerIrp(Irp);
    IoSkipCurrentIrpStackLocation(Irp);    
    status = PoCallDriver(deviceExtension->TargetObject, Irp);
    IoReleaseRemoveLock(&deviceExtension->RemoveLock, NULL);
    return status;
}

NTSTATUS
PmQueryRemovalRelations(
    IN  PDEVICE_EXTENSION   Extension,
    IN  PIRP                Irp
    )

/*++

Routine Description:

    This routine processes the query removal relations request.

Arguments:

    Extension   - Supplies the device extension.

    Irp         - Supplies the IO request packet.

Return Value:

    NTSTATUS

--*/

{
    NTSTATUS                status;
    KEVENT                  event;
    PDEVICE_RELATIONS       childRelationsList;
    PDEVICE_RELATIONS       volumeRelationsList;
    PDEVICE_RELATIONS       combinedRelationsList;
    ULONG                   i;
    ULONG                   j;
    ULONG                   combinedCount;


    status = Irp->IoStatus.Status;

    KeInitializeEvent(&event, NotificationEvent, FALSE);
    IoCopyCurrentIrpStackLocationToNext(Irp);
    IoSetCompletionRoutine(Irp, PmSignalCompletion, &event, TRUE, TRUE, TRUE);
    IoCallDriver(Extension->TargetObject, Irp);
    KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);

    if (!NT_SUCCESS(Irp->IoStatus.Status)) {
        Irp->IoStatus.Information = 0;
        if (status != Irp->IoStatus.Status) {
            return Irp->IoStatus.Status;
        }
    }


    childRelationsList = (PDEVICE_RELATIONS)Irp->IoStatus.Information;
    status = PmBuildDependantVolumeRelations(Extension, &volumeRelationsList);


    //
    // Enumerate and combine the two lists. For lack of a better
    // tag, use PARTMGR_TAG_DEPENDANT_VOLUME_LIST to represent
    // the combined list
    //

    if (!NT_SUCCESS(status)) {

        volumeRelationsList = NULL;

    } else {

        combinedCount =  ((NULL == volumeRelationsList) ? 0 : volumeRelationsList->Count)
                       + ((NULL == childRelationsList)  ? 0 : childRelationsList->Count);
    
        combinedRelationsList = ExAllocatePoolWithTag (
                                        PagedPool,
                                        (sizeof (DEVICE_RELATIONS) +
                                        (sizeof (PDEVICE_OBJECT) * combinedCount)),
                                        PARTMGR_TAG_DEPENDANT_VOLUME_LIST);


        if (NULL == combinedRelationsList) {
            status = STATUS_INSUFFICIENT_RESOURCES;
        }
    }


    if (NT_SUCCESS(status)) {
        RtlZeroMemory (combinedRelationsList,
                       (sizeof(DEVICE_RELATIONS) +
                       (sizeof(PDEVICE_OBJECT) * combinedCount)));

        combinedRelationsList->Count = combinedCount;

        i = j = 0;

        if (NULL != volumeRelationsList) {
            for (; i < volumeRelationsList->Count; i++) {
                combinedRelationsList->Objects [i] = volumeRelationsList->Objects [i];
            }
	}


        if (NULL != childRelationsList) {
            for (; j < childRelationsList->Count; i++, j++) {
                combinedRelationsList->Objects [i] = childRelationsList->Objects [j];
            }
        }
 

	status = STATUS_SUCCESS;
        Irp->IoStatus.Information = (ULONG_PTR) combinedRelationsList;

    } else {

        if (NULL != childRelationsList) {
            for (i = 0; i < childRelationsList->Count; i++) {
                ObDereferenceObject (childRelationsList->Objects [i]);
            }
        }

	if (NULL != volumeRelationsList) {
            for (i = 0; i < volumeRelationsList->Count; i++) {
                ObDereferenceObject (volumeRelationsList->Objects [i]);
            }
	}

        
        Irp->IoStatus.Information = 0;
    }



    if (NULL != childRelationsList) {
        ExFreePool (childRelationsList);
    }

    if (NULL != volumeRelationsList) {
        ExFreePool (volumeRelationsList);
    }

    return (status);
}

BOOLEAN
PmIsRedundantPath(
    IN  PDEVICE_EXTENSION   Extension,
    IN  PDEVICE_EXTENSION   WinningExtension,
    IN  ULONG               Signature,
    IN  GUID*               Guid
    )

{
    PDO_EXTENSION           driverExtension = Extension->DriverExtension;
    PDEVICE_EXTENSION       extension = WinningExtension;
    PGUID_TABLE_ENTRY       guidEntry;
    PSIGNATURE_TABLE_ENTRY  sigEntry;
    KEVENT                  event;
    PIRP                    irp;
    DISK_GEOMETRY           geometry, geometry2;
    IO_STATUS_BLOCK         ioStatus;
    NTSTATUS                status;
    ULONG                   bufferSize;
    ULONG                   readSize;
    PVOID                   buffer;
    LARGE_INTEGER           byteOffset;
    PUSHORT                 testWord;
    BOOLEAN                 isRedundant;

    KeInitializeEvent(&event, NotificationEvent, FALSE);
    irp = IoBuildDeviceIoControlRequest(IOCTL_DISK_GET_DRIVE_GEOMETRY,
                                        Extension->TargetObject, NULL, 0,
                                        &geometry, sizeof(geometry), FALSE,
                                        &event, &ioStatus);
    if (!irp) {
        return TRUE;
    }
    status = IoCallDriver(Extension->TargetObject, irp);
    if (status == STATUS_PENDING) {
        KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
        status = ioStatus.Status;
    }
    if (!NT_SUCCESS(status)) {
        return TRUE;
    }

    KeInitializeEvent(&event, NotificationEvent, FALSE);
    irp = IoBuildDeviceIoControlRequest(IOCTL_DISK_GET_DRIVE_GEOMETRY,
                                        extension->TargetObject, NULL, 0,
                                        &geometry2, sizeof(geometry2), FALSE,
                                        &event, &ioStatus);
    if (!irp) {
        return TRUE;
    }
    status = IoCallDriver(extension->TargetObject, irp);
    if (status == STATUS_PENDING) {
        KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
        status = ioStatus.Status;
    }
    if (!NT_SUCCESS(status)) {
        return TRUE;
    }

    if (geometry2.BytesPerSector > geometry.BytesPerSector) {
        geometry.BytesPerSector = geometry2.BytesPerSector;
    }

    byteOffset.QuadPart = 0;
    readSize = 512;
    if (readSize < geometry.BytesPerSector) {
        readSize = geometry.BytesPerSector;
    }

    bufferSize = 2*readSize;
    buffer = ExAllocatePoolWithTag(NonPagedPool, bufferSize < PAGE_SIZE ?
                                   PAGE_SIZE : bufferSize,
                                   PARTMGR_TAG_IOCTL_BUFFER);
    if (!buffer) {
        return TRUE;
    }

    KeInitializeEvent(&event, NotificationEvent, FALSE);
    irp = IoBuildSynchronousFsdRequest(IRP_MJ_READ, Extension->TargetObject,
                                       buffer, readSize, &byteOffset, &event,
                                       &ioStatus);
    if (!irp) {
        ExFreePool(buffer);
        return TRUE;
    }
    status = IoCallDriver(Extension->TargetObject, irp);
    if (status == STATUS_PENDING) {
        KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
        status = ioStatus.Status;
    }
    if (!NT_SUCCESS(status)) {
        ExFreePool(buffer);
        return TRUE;
    }

    KeInitializeEvent(&event, NotificationEvent, FALSE);
    irp = IoBuildSynchronousFsdRequest(IRP_MJ_READ, extension->TargetObject,
                                       (PCHAR) buffer + readSize, readSize,
                                       &byteOffset, &event, &ioStatus);
    if (!irp) {
        ExFreePool(buffer);
        return TRUE;
    }
    status = IoCallDriver(extension->TargetObject, irp);
    if (status == STATUS_PENDING) {
        KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
        status = ioStatus.Status;
    }
    if (!NT_SUCCESS(status)) {
        ExFreePool(buffer);
        return TRUE;
    }

    if (RtlCompareMemory(buffer, (PCHAR) buffer + readSize, readSize) !=
                         readSize) {

        ExFreePool(buffer);
        return FALSE;
    }

    testWord = (PUSHORT) ((PCHAR) buffer + 0x1BC);
    (*testWord)++;

    KeInitializeEvent(&event, NotificationEvent, FALSE);
    irp = IoBuildSynchronousFsdRequest(IRP_MJ_WRITE, Extension->TargetObject,
                                       buffer, readSize, &byteOffset, &event,
                                       &ioStatus);
    if (!irp) {
        ExFreePool(buffer);
        return TRUE;
    }
    status = IoCallDriver(Extension->TargetObject, irp);
    if (status == STATUS_PENDING) {
        KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
        status = ioStatus.Status;
    }
    if (!NT_SUCCESS(status)) {
        ExFreePool(buffer);
        return TRUE;
    }

    KeInitializeEvent(&event, NotificationEvent, FALSE);
    irp = IoBuildSynchronousFsdRequest(IRP_MJ_READ, extension->TargetObject,
                                       (PCHAR) buffer + readSize, readSize,
                                       &byteOffset, &event, &ioStatus);
    if (!irp) {
        isRedundant = TRUE;
        goto ResetTestWord;
    }
    status = IoCallDriver(extension->TargetObject, irp);
    if (status == STATUS_PENDING) {
        KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
        status = ioStatus.Status;
    }
    if (!NT_SUCCESS(status)) {
        isRedundant = TRUE;
        goto ResetTestWord;
    }

    if (RtlCompareMemory(buffer, (PCHAR) buffer + readSize, readSize) !=
                         readSize) {

        isRedundant = FALSE;
        goto ResetTestWord;
    }

    isRedundant = TRUE;

ResetTestWord:
    (*testWord)--;

    KeInitializeEvent(&event, NotificationEvent, FALSE);
    irp = IoBuildSynchronousFsdRequest(IRP_MJ_WRITE, Extension->TargetObject,
                                       buffer, readSize, &byteOffset, &event,
                                       &ioStatus);
    if (!irp) {
        ExFreePool(buffer);
        return isRedundant;
    }
    status = IoCallDriver(Extension->TargetObject, irp);
    if (status == STATUS_PENDING) {
        KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
        status = ioStatus.Status;
    }
    if (!NT_SUCCESS(status)) {
        ExFreePool(buffer);
        return isRedundant;
    }

    ExFreePool(buffer);

    return isRedundant;
}

VOID
PmLogError(
    IN  PDEVICE_EXTENSION   Extension,
    IN  PDEVICE_EXTENSION   WinningExtension,
    IN  NTSTATUS            SpecificIoStatus
    )

{
    KEVENT                                  event;
    PIRP                                    irp;
    STORAGE_DEVICE_NUMBER                   deviceNumber, winningDeviceNumber;
    IO_STATUS_BLOCK                         ioStatus;
    NTSTATUS                                status;
    WCHAR                                   buffer1[30], buffer2[30];
    UNICODE_STRING                          number, winningNumber;
    ULONG                                   extraSpace;
    PIO_ERROR_LOG_PACKET                    errorLogPacket;
    PWCHAR                                  p;
    GUID_IO_DISK_CLONE_ARRIVAL_INFORMATION  diskCloneArrivalInfo;
    UCHAR                                   notificationBuffer[sizeof(TARGET_DEVICE_CUSTOM_NOTIFICATION) + sizeof(GUID_IO_DISK_CLONE_ARRIVAL_INFORMATION)];
    PTARGET_DEVICE_CUSTOM_NOTIFICATION      notification = (PTARGET_DEVICE_CUSTOM_NOTIFICATION) notificationBuffer;

    KeInitializeEvent(&event, NotificationEvent, FALSE);
    irp = IoBuildDeviceIoControlRequest(IOCTL_STORAGE_GET_DEVICE_NUMBER,
                                        Extension->TargetObject, NULL, 0,
                                        &deviceNumber, sizeof(deviceNumber),
                                        FALSE, &event, &ioStatus);
    if (!irp) {
        return;
    }

    status = IoCallDriver(Extension->TargetObject, irp);
    if (status == STATUS_PENDING) {
        KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
        status = ioStatus.Status;
    }

    if (!NT_SUCCESS(status)) {
        return;
    }

    KeInitializeEvent(&event, NotificationEvent, FALSE);
    irp = IoBuildDeviceIoControlRequest(IOCTL_STORAGE_GET_DEVICE_NUMBER,
                                        WinningExtension->TargetObject, NULL,
                                        0, &winningDeviceNumber,
                                        sizeof(winningDeviceNumber),
                                        FALSE, &event, &ioStatus);
    if (!irp) {
        return;
    }

    status = IoCallDriver(WinningExtension->TargetObject, irp);
    if (status == STATUS_PENDING) {
        KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
        status = ioStatus.Status;
    }

    if (!NT_SUCCESS(status)) {
        return;
    }

    swprintf(buffer1, L"%d", deviceNumber.DeviceNumber);
    RtlInitUnicodeString(&number, buffer1);
    swprintf(buffer2, L"%d", winningDeviceNumber.DeviceNumber);
    RtlInitUnicodeString(&winningNumber, buffer2);
    extraSpace = number.Length + winningNumber.Length + 2*sizeof(WCHAR);
    extraSpace += sizeof(IO_ERROR_LOG_PACKET);
    if (extraSpace > 0xFF) {
        return;
    }

    errorLogPacket = (PIO_ERROR_LOG_PACKET)
                     IoAllocateErrorLogEntry(Extension->DeviceObject,
                                             (UCHAR) extraSpace);
    if (!errorLogPacket) {
        return;
    }

    errorLogPacket->ErrorCode = SpecificIoStatus;
    errorLogPacket->SequenceNumber = 0;
    errorLogPacket->FinalStatus = 0;
    errorLogPacket->UniqueErrorValue = 0;
    errorLogPacket->DumpDataSize = 0;
    errorLogPacket->RetryCount = 0;
    errorLogPacket->NumberOfStrings = 2;
    errorLogPacket->StringOffset = sizeof(IO_ERROR_LOG_PACKET);
    p = (PWCHAR) ((PCHAR) errorLogPacket + sizeof(IO_ERROR_LOG_PACKET));
    RtlCopyMemory(p, number.Buffer, number.Length);
    p[number.Length/sizeof(WCHAR)] = 0;
    p = (PWCHAR) ((PCHAR) errorLogPacket + sizeof(IO_ERROR_LOG_PACKET) +
                  number.Length + sizeof(WCHAR));
    RtlCopyMemory(p, winningNumber.Buffer, winningNumber.Length);
    p[winningNumber.Length/sizeof(WCHAR)] = 0;

    IoWriteErrorLogEntry(errorLogPacket);

    if (SpecificIoStatus == IO_WARNING_DUPLICATE_SIGNATURE) {
        diskCloneArrivalInfo.DiskNumber = deviceNumber.DeviceNumber;
        notification->Version = 1;
        notification->Size = (USHORT)
                             (FIELD_OFFSET(TARGET_DEVICE_CUSTOM_NOTIFICATION,
                                           CustomDataBuffer) +
                              sizeof(diskCloneArrivalInfo));
        RtlCopyMemory(&notification->Event, &GUID_IO_DISK_CLONE_ARRIVAL,
                      sizeof(GUID_IO_DISK_CLONE_ARRIVAL));
        notification->FileObject = NULL;
        notification->NameBufferOffset = -1;
        RtlCopyMemory(notification->CustomDataBuffer, &diskCloneArrivalInfo,
                      sizeof(diskCloneArrivalInfo));

        IoReportTargetDeviceChangeAsynchronous(WinningExtension->Pdo,
                                               notification, NULL, NULL);
    }
}

ULONG
PmQueryRegistrySignature(
    )

/*++

Routine Description:

    This routine checks a registry value for an MBR signature to be used
    for the bad signature case.  This is to facilitate OEM pre-install.

Arguments:

    None.

Return Value:

    A valid signature or 0.

--*/

{
    ULONG                       zero, signature;
    RTL_QUERY_REGISTRY_TABLE    queryTable[2];
    NTSTATUS                    status;

    zero = 0;
    signature = 0;

    RtlZeroMemory(queryTable, 2*sizeof(RTL_QUERY_REGISTRY_TABLE));
    queryTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT;
    queryTable[0].Name = L"BootDiskSig";
    queryTable[0].EntryContext = &signature;
    queryTable[0].DefaultType = REG_DWORD;
    queryTable[0].DefaultData = &zero;
    queryTable[0].DefaultLength = sizeof(ULONG);

    status = RtlQueryRegistryValues(RTL_REGISTRY_ABSOLUTE,
                                    L"\\Registry\\Machine\\System\\Setup",
                                    queryTable, NULL, NULL);
    if (!NT_SUCCESS(status)) {
        signature = zero;
    }

    RtlDeleteRegistryValue(RTL_REGISTRY_ABSOLUTE,
                           L"\\Registry\\Machine\\System\\Setup",
                           L"BootDiskSig");

    return signature;
}

NTSTATUS
PmQueryRegistryGuidQueryRoutine(
    IN  PWSTR   ValueName,
    IN  ULONG   ValueType,
    IN  PVOID   ValueData,
    IN  ULONG   ValueLength,
    IN  PVOID   Context,
    IN  PVOID   EntryContext
    )

/*++

Routine Description:

    This routine queries the unique id for the given value.

Arguments:

    ValueName       - Supplies the name of the registry value.

    ValueType       - Supplies the type of the registry value.

    ValueData       - Supplies the data of the registry value.

    ValueLength     - Supplies the length of the registry value.

    Context         - Pointer to the DeviceExtension->BootPartitionGuid field.

    EntryContext    - Not used.

Return Value:

    NTSTATUS

--*/

{
    if ((REG_BINARY == ValueType) && (sizeof (GUID) == ValueLength)) {
        RtlCopyMemory (Context, ValueData, sizeof (GUID));
    } else {
        RtlCopyMemory (Context, &guidNull, sizeof (GUID));
    }

    return (STATUS_SUCCESS);
}
VOID
PmQueryRegistryGuid(
    IN  PDO_EXTENSION   DriverExtension
    )

/*++

Routine Description:

    This routine checks a registry value for an GPT partition GUID to be used
    for the bad signature case.  This is to facilitate OEM pre-install.

Arguments:

    None.

Return Value:

    A valid signature or 0.

--*/

{
    RTL_QUERY_REGISTRY_TABLE    queryTable[2];
    NTSTATUS                    status;


    RtlZeroMemory(queryTable, 2*sizeof(RTL_QUERY_REGISTRY_TABLE));

    queryTable[0].QueryRoutine  = PmQueryRegistryGuidQueryRoutine;
    queryTable[0].Flags         = RTL_QUERY_REGISTRY_REQUIRED;
    queryTable[0].Name          = L"BootPartitionGuid";

    status = RtlQueryRegistryValues(RTL_REGISTRY_ABSOLUTE,
                                    L"\\Registry\\Machine\\System\\Setup",
                                    queryTable, 
                                    &DriverExtension->BootPartitionGuid, 
                                    NULL);

    if (NT_SUCCESS (status) && !IsEqualGUID (&guidNull, &DriverExtension->BootPartitionGuid)) {
        DriverExtension->BootPartitionGuidPresent = TRUE;
    } else {
        DriverExtension->BootPartitionGuid        = guidNull;
        DriverExtension->BootPartitionGuidPresent = FALSE;
    }

    RtlDeleteRegistryValue(RTL_REGISTRY_ABSOLUTE,
                           L"\\Registry\\Machine\\System\\Setup",
                           L"BootPartitionGuid");
}

VOID
PmAddSignatures(
    IN  PDEVICE_EXTENSION               Extension,
    IN  PDRIVE_LAYOUT_INFORMATION_EX    Layout
    )

/*++

Routine Description:

    This routine adds the disk and partition signature to their
    respective tables.  If a collision is detected, the signatures are
    changed and written back out.

Arguments:

    Extension   - Supplies the device extension.

Return Value:

    NTSTATUS

--*/

{
    PDO_EXTENSION           driverExtension = Extension->DriverExtension;
    PLIST_ENTRY             l;
    PSIGNATURE_TABLE_ENTRY  s;
    PGUID_TABLE_ENTRY       g;
    SIGNATURE_TABLE_ENTRY   sigEntry;
    GUID_TABLE_ENTRY        guidEntry;
    NTSTATUS                status;
    PVOID                   nodeOrParent, nodeOrParent2;
    TABLE_SEARCH_RESULT     searchResult, searchResult2;
    UUID                    uuid;
    PULONG                  p;
    ULONG                   i;
    BOOLEAN                 hasBootPartitionType;

    while (!IsListEmpty(&Extension->SignatureList)) {
        l = RemoveHeadList(&Extension->SignatureList);
        s = CONTAINING_RECORD(l, SIGNATURE_TABLE_ENTRY, ListEntry);
        RtlDeleteElementGenericTable(&driverExtension->SignatureTable, s);
    }

    while (!IsListEmpty(&Extension->GuidList)) {
        l = RemoveHeadList(&Extension->GuidList);
        g = CONTAINING_RECORD(l, GUID_TABLE_ENTRY, ListEntry);
        RtlDeleteElementGenericTable(&driverExtension->GuidTable, g);
    }

    if (!Layout) {
        return;
    }

    if (Layout->PartitionStyle == PARTITION_STYLE_MBR) {

        if (!Layout->PartitionCount && !Layout->Mbr.Signature) {
            // RAW disk.  No signature to validate.
            return;
        }

        if (Layout->PartitionCount > 0 &&
            Layout->PartitionEntry[0].PartitionLength.QuadPart > 0 &&
            Layout->PartitionEntry[0].StartingOffset.QuadPart == 0) {

            // Super floppy.  No signature to validate.
            return;
        }

        sigEntry.Signature = Layout->Mbr.Signature;
        s = RtlLookupElementGenericTableFull(
                &driverExtension->SignatureTable, &sigEntry,
                &nodeOrParent, &searchResult);
        if (s || !sigEntry.Signature ||
            Extension->DriverExtension->BootDiskSig) {

            if (s) {
                if (PmIsRedundantPath(Extension, s->Extension,
                                      sigEntry.Signature, NULL)) {

                    PmLogError(Extension, s->Extension,
                               IO_WARNING_DUPLICATE_PATH);

                    Extension->IsRedundantPath = TRUE;
                    return;
                }

                PmLogError(Extension, s->Extension,
                           IO_WARNING_DUPLICATE_SIGNATURE);
            }

            if (Extension->DriverExtension->BootDiskSig) {
                Layout->Mbr.Signature =
                        Extension->DriverExtension->BootDiskSig;
                Extension->DriverExtension->BootDiskSig = 0;
            } else {
                status = ExUuidCreate(&uuid);
                if (!NT_SUCCESS(status)) {
                    Extension->IsRedundantPath = TRUE;
                    return;
                }

                p = (PULONG) &uuid;
                Layout->Mbr.Signature = p[0] ^ p[1] ^ p[2] ^ p[3];
            }
            sigEntry.Signature = Layout->Mbr.Signature;

            if (driverExtension->PastReinit) {
                status = PmWritePartitionTableEx(Extension->TargetObject,
                                                 Layout);
                if (!NT_SUCCESS(status)) {
                    Extension->IsRedundantPath = TRUE;
                    return;
                }
            } else {
                Extension->DiskSignature = Layout->Mbr.Signature;
            }

            RtlLookupElementGenericTableFull(
                &driverExtension->SignatureTable, &sigEntry,
                &nodeOrParent, &searchResult);
        }

        s = RtlInsertElementGenericTableFull(&driverExtension->SignatureTable,
                                             &sigEntry, sizeof(sigEntry), NULL,
                                             nodeOrParent, searchResult);
        if (!s) {
            return;
        }

        InsertTailList(&Extension->SignatureList, &s->ListEntry);
        s->Extension = Extension;

        return;
    }

    ASSERT(Layout->PartitionStyle == PARTITION_STYLE_GPT);

    if (Layout->PartitionStyle != PARTITION_STYLE_GPT) {
        return;
    }

    if (Extension->DriverExtension->PastReinit) {

        p = (PULONG) &Layout->Gpt.DiskId;
        sigEntry.Signature = p[0] ^ p[1] ^ p[2] ^ p[3];
        guidEntry.Guid = Layout->Gpt.DiskId;

        s = RtlLookupElementGenericTableFull(
                &driverExtension->SignatureTable, &sigEntry,
                &nodeOrParent, &searchResult);
        g = RtlLookupElementGenericTableFull(
                &driverExtension->GuidTable, &guidEntry,
                &nodeOrParent2, &searchResult2);
        if (s || g || !sigEntry.Signature) {

            if (g) {
                if (PmIsRedundantPath(Extension, g->Extension, 0,
                                      &guidEntry.Guid)) {

                    PmLogError(Extension, g->Extension,
                               IO_WARNING_DUPLICATE_PATH);

                    Extension->IsRedundantPath = TRUE;
                    return;
                }

                PmLogError(Extension, g->Extension,
                           IO_WARNING_DUPLICATE_SIGNATURE);
            }

            status = ExUuidCreate(&uuid);
            if (!NT_SUCCESS(status)) {
                Extension->IsRedundantPath = TRUE;
                return;
            }

            Layout->Gpt.DiskId = uuid;
            status = PmWritePartitionTableEx(Extension->TargetObject, Layout);
            if (!NT_SUCCESS(status)) {
                Extension->IsRedundantPath = TRUE;
                return;
            }

            p = (PULONG) &Layout->Gpt.DiskId;
            sigEntry.Signature = p[0] ^ p[1] ^ p[2] ^ p[3];
            guidEntry.Guid = Layout->Gpt.DiskId;

            RtlLookupElementGenericTableFull(
                    &driverExtension->SignatureTable, &sigEntry,
                    &nodeOrParent, &searchResult);
            RtlLookupElementGenericTableFull(
                    &driverExtension->GuidTable, &guidEntry,
                    &nodeOrParent2, &searchResult2);
        }

        s = RtlInsertElementGenericTableFull(
                &driverExtension->SignatureTable, &sigEntry,
                sizeof(sigEntry), NULL, nodeOrParent, searchResult);
        if (!s) {
            return;
        }

        InsertTailList(&Extension->SignatureList, &s->ListEntry);
        s->Extension = Extension;

        g = RtlInsertElementGenericTableFull(
                &driverExtension->GuidTable, &guidEntry,
                sizeof(guidEntry), NULL, nodeOrParent2, searchResult2);
        if (!g) {
            return;
        }

        InsertTailList(&Extension->GuidList, &g->ListEntry);
        g->Extension = Extension;
    }

    for (i = 0; i < Layout->PartitionCount; i++) {

        p = (PULONG) &Layout->PartitionEntry[i].Gpt.PartitionId;
        sigEntry.Signature = p[0] | p[1] | p[2] | p[3];
        guidEntry.Guid = Layout->PartitionEntry[i].Gpt.PartitionId;

        if (driverExtension->BootPartitionGuidPresent) {

            hasBootPartitionType = 
                IsEqualGUID(&Layout->PartitionEntry[i].Gpt.PartitionType, &PARTITION_BASIC_DATA_GUID) || 
                IsEqualGUID(&Layout->PartitionEntry[i].Gpt.PartitionType, &PARTITION_LDM_DATA_GUID);
        }


        g = RtlLookupElementGenericTableFull(
                &driverExtension->GuidTable, &guidEntry,
                &nodeOrParent, &searchResult);
        if (g || !sigEntry.Signature ||
            (driverExtension->BootPartitionGuidPresent && hasBootPartitionType)) {

            if (driverExtension->BootPartitionGuidPresent && hasBootPartitionType) {
                uuid = Extension->DriverExtension->BootPartitionGuid;
                driverExtension->BootPartitionGuidPresent = FALSE;
            } else {
                status = ExUuidCreate(&uuid);
                if (!NT_SUCCESS(status)) {
                    Extension->IsRedundantPath = TRUE;
                    return;
                }
            }

            Layout->PartitionEntry[i].Gpt.PartitionId = uuid;
            status = PmWritePartitionTableEx(Extension->TargetObject, Layout);
            if (!NT_SUCCESS(status)) {
                Extension->IsRedundantPath = TRUE;
                return;
            }

            guidEntry.Guid = Layout->PartitionEntry[i].Gpt.PartitionId;

            RtlLookupElementGenericTableFull(
                    &driverExtension->GuidTable, &guidEntry,
                    &nodeOrParent, &searchResult);
        }

        g = RtlInsertElementGenericTableFull(
                &driverExtension->GuidTable, &guidEntry,
                sizeof(guidEntry), NULL, nodeOrParent, searchResult);
        if (!g) {
            return;
        }

        InsertTailList(&Extension->GuidList, &g->ListEntry);
        g->Extension = Extension;
    }
}

NTSTATUS
PmPnp(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp
    )

/*++

Routine Description:

    This routine is the dispatch for IRP_MJ_PNP.

Arguments:

    DeviceObject    - Supplies the device object.

    Irp             - Supplies the IO request packet.

Return Value:

    NTSTATUS

--*/

{
    PDEVICE_EXTENSION               extension = DeviceObject->DeviceExtension;
    PIO_STACK_LOCATION              irpSp = IoGetCurrentIrpStackLocation(Irp);
    KEVENT                          event;
    NTSTATUS                        status;
    PDEVICE_OBJECT                  targetObject;
    PDRIVE_LAYOUT_INFORMATION_EX    layout;
    LIST_ENTRY                      completionList;
    ULONG                           wmiRegistrationFlags;

    if (irpSp->MinorFunction == IRP_MN_DEVICE_USAGE_NOTIFICATION &&
        irpSp->Parameters.UsageNotification.Type == DeviceUsageTypePaging) {

        ULONG count;
        BOOLEAN setPagable;

        //
        // synchronize these irps.
        //

        KeWaitForSingleObject(&extension->PagingPathCountEvent,
                              Executive, KernelMode, FALSE, NULL);

        //
        // if removing last paging device, need to set DO_POWER_PAGABLE
        // bit here, and possible re-set it below on failure.
        //

        setPagable = FALSE;
        if (!irpSp->Parameters.UsageNotification.InPath &&
            extension->PagingPathCount == 0 ) {

            //
            // removing a paging file. if last removal,
            // must have DO_POWER_PAGABLE bits set
            //

            if (extension->PagingPathCount == 0) {
                if (!(DeviceObject->Flags & DO_POWER_INRUSH)) {
                    DeviceObject->Flags |= DO_POWER_PAGABLE;
                    setPagable = TRUE;
                }
            }

        }

        //
        // send the irp synchronously
        //

        KeInitializeEvent(&event, NotificationEvent, FALSE);
        IoCopyCurrentIrpStackLocationToNext(Irp);
        IoSetCompletionRoutine(Irp, PmSignalCompletion, &event, TRUE, TRUE, TRUE);
        status = IoCallDriver(extension->TargetObject, Irp);
        if (status == STATUS_PENDING) {
            KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
            status = Irp->IoStatus.Status;
        }

        //
        // now deal with the failure and success cases.
        // note that we are not allowed to fail the irp
        // once it is sent to the lower drivers.
        //

        if (NT_SUCCESS(status)) {

            IoAdjustPagingPathCount(
                &extension->PagingPathCount,
                irpSp->Parameters.UsageNotification.InPath);

            if (irpSp->Parameters.UsageNotification.InPath) {

                if (extension->PagingPathCount == 1) {
                    DeviceObject->Flags &= ~DO_POWER_PAGABLE;
                }
            }

        } else {

            //
            // cleanup the changes done above
            //

            if (setPagable == TRUE) {
                DeviceObject->Flags &= ~DO_POWER_PAGABLE;
                setPagable = FALSE;
            }

        }

        //
        // set the event so the next one can occur.
        //

        KeSetEvent(&extension->PagingPathCountEvent,
                   IO_NO_INCREMENT, FALSE);

        //
        // and complete the irp
        //
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
        return status;

    }

    if (extension->TargetObject->Characteristics & FILE_REMOVABLE_MEDIA) {

        targetObject = extension->TargetObject;

        if (IRP_MN_REMOVE_DEVICE == irpSp->MinorFunction) {

            KeWaitForSingleObject (&extension->DriverExtension->Mutex, 
                                   Executive,
                                   KernelMode, 
                                   FALSE,
                                   NULL);

            if (extension->WmilibContext != NULL) { 
                IoWMIRegistrationControl (extension->DeviceObject, WMIREG_ACTION_DEREGISTER);
                ExFreePool (extension->WmilibContext);
                extension->WmilibContext = NULL;
                PmWmiCounterDisable (&extension->PmWmiCounterContext, TRUE, TRUE);
                extension->CountersEnabled = FALSE;
            }

            RemoveEntryList (&extension->ListEntry);
            KeReleaseMutex (&extension->DriverExtension->Mutex, FALSE);

            IoDetachDevice (targetObject);
            IoDeleteDevice (extension->DeviceObject);
            }

        IoSkipCurrentIrpStackLocation(Irp);
        return IoCallDriver(targetObject, Irp);
    }

    switch (irpSp->MinorFunction) {

        case IRP_MN_QUERY_DEVICE_RELATIONS:
            switch (irpSp->Parameters.QueryDeviceRelations.Type) {
                case BusRelations:
                    status = PmQueryDeviceRelations(extension, Irp);
                    break;

                case RemovalRelations:
                    status = PmQueryRemovalRelations(extension, Irp);
                    break;

                default:
                    IoSkipCurrentIrpStackLocation(Irp);
                    return IoCallDriver(extension->TargetObject, Irp);

            }
            break;

        case IRP_MN_START_DEVICE:
            KeInitializeEvent(&event, NotificationEvent, FALSE);
            IoCopyCurrentIrpStackLocationToNext(Irp);
            IoSetCompletionRoutine(Irp, PmSignalCompletion, &event,
                                   TRUE, TRUE, TRUE);
            IoCallDriver(extension->TargetObject, Irp);
            KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
            status = Irp->IoStatus.Status;

            if (!NT_SUCCESS(status)) {
                break;
            }

            if (extension->TargetObject->Characteristics&
                FILE_REMOVABLE_MEDIA) {

                break;
            }

            PmDetermineDeviceNameAndNumber (DeviceObject, &wmiRegistrationFlags);


            LockDriver (extension->DriverExtension);
            extension->IsStarted = TRUE;
            UnlockDriver (extension->DriverExtension);

            PmCheckAndUpdateSignature (extension, TRUE, TRUE);


            //
            // Register its existence with WMI
            //
            PmRegisterDevice(DeviceObject, wmiRegistrationFlags);
            break;

        case IRP_MN_QUERY_STOP_DEVICE:
        case IRP_MN_CANCEL_STOP_DEVICE:
        case IRP_MN_STOP_DEVICE:
        case IRP_MN_QUERY_REMOVE_DEVICE:
        case IRP_MN_CANCEL_REMOVE_DEVICE:
            status = PmNotifyPartitions(extension, Irp);
            if (!NT_SUCCESS(status)) {
                break;
            }

            IoSkipCurrentIrpStackLocation(Irp);
            return IoCallDriver(extension->TargetObject, Irp);

        case IRP_MN_SURPRISE_REMOVAL:
        case IRP_MN_REMOVE_DEVICE:

            //
            // Notify all the children of their imminent removal.
            //

            PmRemoveDevice(extension, Irp);
            targetObject = extension->TargetObject;

            if (irpSp->MinorFunction == IRP_MN_REMOVE_DEVICE) {
                status = IoAcquireRemoveLock (&extension->RemoveLock, Irp);
                ASSERT(NT_SUCCESS(status));
                IoReleaseRemoveLockAndWait(&extension->RemoveLock, Irp);
                IoDetachDevice(targetObject);
                IoDeleteDevice(extension->DeviceObject);
            }

            IoSkipCurrentIrpStackLocation(Irp);
            return IoCallDriver(targetObject, Irp);

        default:
            IoSkipCurrentIrpStackLocation(Irp);
            return IoCallDriver(extension->TargetObject, Irp);
    }

    Irp->IoStatus.Status = status;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
    return status;
}

NTSTATUS
PmAddDevice(
    IN PDRIVER_OBJECT DriverObject,
    IN PDEVICE_OBJECT PhysicalDeviceObject
    )

/*++

Routine Description:

    This routine creates and initializes a new FDO for the corresponding
    PDO.

Arguments:

    DriverObject            - Supplies the FTDISK driver object.

    PhysicalDeviceObject    - Supplies the physical device object.

Return Value:

    NTSTATUS

--*/

{
    PDEVICE_OBJECT      attachedDevice;
    NTSTATUS            status;
    PDEVICE_OBJECT      deviceObject;
    PDEVICE_EXTENSION   extension;

    attachedDevice = IoGetAttachedDeviceReference(PhysicalDeviceObject);
    if (attachedDevice) {
        if (attachedDevice->Characteristics&FILE_REMOVABLE_MEDIA) {
            ObDereferenceObject(attachedDevice);
            return STATUS_SUCCESS;
        }
        ObDereferenceObject(attachedDevice);
    }

    status = IoCreateDevice(DriverObject, sizeof(DEVICE_EXTENSION),
                            NULL, FILE_DEVICE_UNKNOWN, 0, FALSE, &deviceObject);
    if (!NT_SUCCESS(status)) {
        return status;
    }

    deviceObject->Flags |= DO_DIRECT_IO;

    //
    // the storage stack explicitly requires DO_POWER_PAGABLE to be
    // set in all filter drivers *unless* DO_POWER_INRUSH is set.
    // this is true even if the attached device doesn't set DO_POWER_PAGABLE
    //
    if (attachedDevice->Flags & DO_POWER_INRUSH) {
        deviceObject->Flags |= DO_POWER_INRUSH;
    } else {
        deviceObject->Flags |= DO_POWER_PAGABLE;
    }

    extension = deviceObject->DeviceExtension;
    RtlZeroMemory(extension, sizeof(DEVICE_EXTENSION));
    extension->DeviceObject = deviceObject;
    extension->DriverExtension = IoGetDriverObjectExtension(DriverObject,
                                                            PmAddDevice);
    extension->TargetObject =
            IoAttachDeviceToDeviceStack(deviceObject, PhysicalDeviceObject);
    if (!extension->TargetObject) {
        IoDeleteDevice(deviceObject);
        return STATUS_NO_SUCH_DEVICE;
    }
    extension->Pdo = PhysicalDeviceObject;
    InitializeListHead(&extension->PartitionList);
    KeInitializeEvent(&extension->PagingPathCountEvent,
                      SynchronizationEvent, TRUE);
    InitializeListHead(&extension->SignatureList);
    InitializeListHead(&extension->GuidList);

    LockDriver (extension->DriverExtension);
    InsertTailList(&extension->DriverExtension->DeviceExtensionList,
                   &extension->ListEntry);
    UnlockDriver (extension->DriverExtension);

    deviceObject->DeviceType = extension->TargetObject->DeviceType;

    deviceObject->AlignmentRequirement =
            extension->TargetObject->AlignmentRequirement;

    extension->PhysicalDeviceName.Buffer
            = extension->PhysicalDeviceNameBuffer;

    // Allocate WMI library context

    extension->WmilibContext =
        ExAllocatePoolWithTag(PagedPool, sizeof(WMILIB_CONTEXT),
                                          PARTMGR_TAG_PARTITION_ENTRY);
    if (extension->WmilibContext != NULL)
    {
        RtlZeroMemory(extension->WmilibContext, sizeof(WMILIB_CONTEXT));
        extension->WmilibContext->GuidCount          = DiskperfGuidCount;
        extension->WmilibContext->GuidList           = DiskperfGuidList;
        extension->WmilibContext->QueryWmiRegInfo    = PmQueryWmiRegInfo;
        extension->WmilibContext->QueryWmiDataBlock  = PmQueryWmiDataBlock;
        extension->WmilibContext->WmiFunctionControl = PmWmiFunctionControl;
    }


    KeInitializeSpinLock(&extension->SpinLock);
    InitializeListHead(&extension->PowerQueue);    

    deviceObject->Flags &= ~DO_DEVICE_INITIALIZING;

    IoInitializeRemoveLock (&extension->RemoveLock, PARTMGR_TAG_REMOVE_LOCK,
                            2, 5); 

    return STATUS_SUCCESS;
}

VOID
PmUnload(
    IN  PDRIVER_OBJECT  DriverObject
    )

/*++

Routine Description:

    This routine unloads.

Arguments:

    DriverObject    - Supplies the driver object.

Return Value:

    None.

--*/

{
    PDO_EXTENSION   driverExtension;
    PDEVICE_OBJECT  deviceObject;

    while (deviceObject = DriverObject->DeviceObject) {
        IoDeleteDevice(deviceObject);
    }

    driverExtension = IoGetDriverObjectExtension(DriverObject, PmAddDevice);
    if (driverExtension) {
        IoUnregisterPlugPlayNotification(driverExtension->NotificationEntry);
    }
}

NTSTATUS
PmVolumeManagerNotification(
    IN  PVOID   NotificationStructure,
    IN  PVOID   DriverExtension
    )

/*++

Routine Description:

    This routine is called whenever a volume comes or goes.

Arguments:

    NotificationStructure   - Supplies the notification structure.

    RootExtension           - Supplies the root extension.

Return Value:

    NTSTATUS

--*/

{
    PDEVICE_INTERFACE_CHANGE_NOTIFICATION   notification = (PDEVICE_INTERFACE_CHANGE_NOTIFICATION) NotificationStructure;
    PDO_EXTENSION                           driverExtension = (PDO_EXTENSION) DriverExtension;
    PVOLMGR_LIST_ENTRY                      volmgrEntry;
    NTSTATUS                                status;
    PLIST_ENTRY                             l, ll;
    PDEVICE_EXTENSION                       extension;
    PPARTITION_LIST_ENTRY                   partition;
    PMWMICOUNTERLIB_CONTEXT                 input;
    PIRP                                    irp;
    KEVENT                                  event;
    IO_STATUS_BLOCK                         ioStatus;
    PFILE_OBJECT                            fileObject;
    PDEVICE_OBJECT                          deviceObject;

    LockDriver (driverExtension);

    if (IsEqualGUID(&notification->Event, &GUID_DEVICE_INTERFACE_ARRIVAL)) {

        for (l = driverExtension->VolumeManagerList.Flink;
             l != &driverExtension->VolumeManagerList; l = l->Flink) {

            volmgrEntry = CONTAINING_RECORD(l, VOLMGR_LIST_ENTRY, ListEntry);
            if (RtlEqualUnicodeString(notification->SymbolicLinkName,
                                      &volmgrEntry->VolumeManagerName,
                                      TRUE)) {

                UnlockDriver (driverExtension);
                return STATUS_SUCCESS;
            }
        }

        volmgrEntry = (PVOLMGR_LIST_ENTRY)
                      ExAllocatePoolWithTag(NonPagedPool,
                                            sizeof(VOLMGR_LIST_ENTRY),
                                            PARTMGR_TAG_VOLUME_ENTRY
                                            );
        if (!volmgrEntry) {
            UnlockDriver (driverExtension);
            return STATUS_SUCCESS;
        }

        volmgrEntry->VolumeManagerName.Length =
                notification->SymbolicLinkName->Length;
        volmgrEntry->VolumeManagerName.MaximumLength =
                volmgrEntry->VolumeManagerName.Length + sizeof(WCHAR);
        volmgrEntry->VolumeManagerName.Buffer = ExAllocatePoolWithTag(
                PagedPool, volmgrEntry->VolumeManagerName.MaximumLength,
                PARTMGR_TAG_VOLUME_ENTRY);
        if (!volmgrEntry->VolumeManagerName.Buffer) {
            ExFreePool(volmgrEntry);
            UnlockDriver (driverExtension);
            return STATUS_SUCCESS;
        }
        RtlCopyMemory(volmgrEntry->VolumeManagerName.Buffer,
                      notification->SymbolicLinkName->Buffer,
                      volmgrEntry->VolumeManagerName.Length);
        volmgrEntry->VolumeManagerName.Buffer[
                volmgrEntry->VolumeManagerName.Length/sizeof(WCHAR)] = 0;

        volmgrEntry->RefCount = 0;
        InsertTailList(&driverExtension->VolumeManagerList,
                       &volmgrEntry->ListEntry);
        volmgrEntry->VolumeManager = NULL;
        volmgrEntry->VolumeManagerFileObject = NULL;

        status = IoGetDeviceObjectPointer(&volmgrEntry->VolumeManagerName,
                                          FILE_READ_DATA, &fileObject,
                                          &deviceObject);

        if (NT_SUCCESS(status)) {
            input.PmWmiCounterEnable     = PmWmiCounterEnable;
            input.PmWmiCounterDisable    = PmWmiCounterDisable;
            input.PmWmiCounterIoStart    = PmWmiCounterIoStart;
            input.PmWmiCounterIoComplete = PmWmiCounterIoComplete;
            input.PmWmiCounterQuery      = PmWmiCounterQuery;

            KeInitializeEvent(&event, NotificationEvent, FALSE);

            irp = IoBuildDeviceIoControlRequest(
                    IOCTL_INTERNAL_VOLMGR_PMWMICOUNTERLIB_CONTEXT,
                    deviceObject, &input, sizeof(input), NULL, 0, TRUE,
                    &event, &ioStatus);

            if (irp) {
                status = IoCallDriver(deviceObject, irp);
                if (status == STATUS_PENDING) {
                    KeWaitForSingleObject(&event, Executive, KernelMode,
                                          FALSE, NULL);
                }
            }

            ObDereferenceObject(fileObject);
        }

        for (l = driverExtension->DeviceExtensionList.Flink;
             l != &driverExtension->DeviceExtensionList; l = l->Flink) {

            extension = CONTAINING_RECORD(l, DEVICE_EXTENSION, ListEntry);

            if (extension->IsRedundantPath) {
                continue;
            }

            for (ll = extension->PartitionList.Flink;
                 ll != &extension->PartitionList; ll = ll->Flink) {

                partition = CONTAINING_RECORD(ll, PARTITION_LIST_ENTRY,
                                              ListEntry);

                if (!partition->VolumeManagerEntry) {
                    status = PmGivePartition(volmgrEntry,
                                             partition->TargetObject,
                                             partition->WholeDiskPdo);
                    if (NT_SUCCESS(status)) {
                        partition->VolumeManagerEntry = volmgrEntry;
                    }
                }
            }
        }

        status = STATUS_SUCCESS;

    } else if (IsEqualGUID(&notification->Event,
                           &GUID_DEVICE_INTERFACE_REMOVAL)) {

        for (l = driverExtension->VolumeManagerList.Flink;
             l != &driverExtension->VolumeManagerList; l = l->Flink) {

            volmgrEntry = CONTAINING_RECORD(l, VOLMGR_LIST_ENTRY, ListEntry);
            if (RtlEqualUnicodeString(&volmgrEntry->VolumeManagerName,
                                      notification->SymbolicLinkName, TRUE)) {

                if (!volmgrEntry->RefCount) {
                    RemoveEntryList(l);
                    ExFreePool(volmgrEntry->VolumeManagerName.Buffer);
                    ExFreePool(volmgrEntry);
                }
                break;
            }
        }

        status = STATUS_SUCCESS;

    } else {
        status = STATUS_INVALID_PARAMETER;
    }

    UnlockDriver (driverExtension);

    return STATUS_SUCCESS;
}

NTSTATUS
PmGetPartitionInformation(
    IN  PDEVICE_OBJECT  Partition,
    IN  PFILE_OBJECT    FileObject,
    OUT PLONGLONG       PartitionOffset,
    OUT PLONGLONG       PartitionLength
    )

{
    KEVENT                  event;
    PIRP                    irp;
    PIO_STACK_LOCATION      irpSp;
    PARTITION_INFORMATION   partInfo;
    IO_STATUS_BLOCK         ioStatus;
    NTSTATUS                status;

    KeInitializeEvent(&event, NotificationEvent, FALSE);

    irp = IoBuildDeviceIoControlRequest(IOCTL_DISK_GET_PARTITION_INFO,
                                        Partition, NULL, 0, &partInfo,
                                        sizeof(partInfo), FALSE, &event,
                                        &ioStatus);
    if (!irp) {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
    irpSp = IoGetNextIrpStackLocation(irp);
    irpSp->FileObject = FileObject;

    status = IoCallDriver(Partition, irp);
    if (status == STATUS_PENDING) {
        KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
        status = ioStatus.Status;
    }

    if (!NT_SUCCESS(status)) {
        return status;
    }

    *PartitionOffset = partInfo.StartingOffset.QuadPart;
    *PartitionLength = partInfo.PartitionLength.QuadPart;

    return status;
}

VOID
PmDriverReinit(
    IN  PDRIVER_OBJECT  DriverObject,
    IN  PVOID           DriverExtension,
    IN  ULONG           Count
    )

{
    PDO_EXTENSION                   driverExtension = DriverExtension;
    PLIST_ENTRY                     l, ll;
    PDEVICE_EXTENSION               extension;
    PPARTITION_LIST_ENTRY           partition;
    NTSTATUS                        status;
    PDRIVE_LAYOUT_INFORMATION_EX    layout;


    LockDriver (driverExtension);

    InterlockedExchange(&driverExtension->PastReinit, TRUE);

    for (l = driverExtension->DeviceExtensionList.Flink;
         l != &driverExtension->DeviceExtensionList; l = l->Flink) {

        extension = CONTAINING_RECORD(l, DEVICE_EXTENSION, ListEntry);

        if (extension->TargetObject->Characteristics&FILE_REMOVABLE_MEDIA) {
            continue;
        }

        if (!extension->IsStarted) {
            continue;
        }

        for (ll = extension->PartitionList.Flink;
             ll != &extension->PartitionList; ll = ll->Flink) {

            partition = CONTAINING_RECORD(ll, PARTITION_LIST_ENTRY,
                                          ListEntry);

            partition->TargetObject->Flags |= DO_DEVICE_INITIALIZING;
        }

        status = PmReadPartitionTableEx(extension->TargetObject, &layout);
        if (!NT_SUCCESS(status)) {
            continue;
        }

        if (extension->DiskSignature) {
            if (layout->PartitionStyle == PARTITION_STYLE_MBR) {
                layout->Mbr.Signature = extension->DiskSignature;
                PmWritePartitionTableEx(extension->TargetObject, layout);
            }
            extension->DiskSignature = 0;
        }

        if (layout->PartitionStyle == PARTITION_STYLE_GPT) {
            PmAddSignatures(extension, layout);
        }

        ExFreePool(layout);
    }

    UnlockDriver (driverExtension);
}

VOID
PmBootDriverReinit(
    IN  PDRIVER_OBJECT  DriverObject,
    IN  PVOID           DriverExtension,
    IN  ULONG           Count
    )

{
    IoRegisterDriverReinitialization(DriverObject, PmDriverReinit,
                                     DriverExtension);    
}

NTSTATUS
PmCheckForUnclaimedPartitions(
    IN  PDEVICE_OBJECT  DeviceObject
    )

{
    PDEVICE_EXTENSION       extension = DeviceObject->DeviceExtension;
    PDO_EXTENSION           driverExtension = extension->DriverExtension;
    NTSTATUS                status, status2;
    PLIST_ENTRY             l, ll;
    PPARTITION_LIST_ENTRY   partition;
    PVOLMGR_LIST_ENTRY      volmgrEntry;

    LockDriver (driverExtension);

    if (extension->IsRedundantPath) {
        UnlockDriver (driverExtension);
        return STATUS_SUCCESS;
    }

    status = STATUS_SUCCESS;
    for (l = extension->PartitionList.Flink; l != &extension->PartitionList;
         l = l->Flink) {

        partition = CONTAINING_RECORD(l, PARTITION_LIST_ENTRY, ListEntry);
        if (partition->VolumeManagerEntry) {
            continue;
        }

        for (ll = driverExtension->VolumeManagerList.Flink;
             ll != &driverExtension->VolumeManagerList; ll = ll->Flink) {

            volmgrEntry = CONTAINING_RECORD(ll, VOLMGR_LIST_ENTRY, ListEntry);

            status2 = PmGivePartition(volmgrEntry,
                                      partition->TargetObject,
                                      partition->WholeDiskPdo);

            if (NT_SUCCESS(status2)) {
                partition->VolumeManagerEntry = volmgrEntry;
                break;
            }
        }

        if (ll == &driverExtension->VolumeManagerList) {
            status = STATUS_UNSUCCESSFUL;
        }
    }

    UnlockDriver (driverExtension);

    return status;
}

NTSTATUS
PmDiskGrowPartition(
    IN  PDEVICE_OBJECT  DeviceObject,
    IN  PIRP            Irp
    )

{
    PDEVICE_EXTENSION       extension = DeviceObject->DeviceExtension;
    PIO_STACK_LOCATION      irpSp = IoGetCurrentIrpStackLocation(Irp);
    PDISK_GROW_PARTITION    input;
    NTSTATUS                status;
    PPARTITION_LIST_ENTRY   partition;
    KEVENT                  event;

    if (irpSp->Parameters.DeviceIoControl.InputBufferLength <
        sizeof(DISK_GROW_PARTITION)) {

        return STATUS_INVALID_PARAMETER;
    }

    LockDriver (extension->DriverExtension);

    input = (PDISK_GROW_PARTITION) Irp->AssociatedIrp.SystemBuffer;

    status = PmFindPartition(extension, input->PartitionNumber, &partition);
    if (!NT_SUCCESS(status)) {
        UnlockDriver (extension->DriverExtension);
        return status;
    }

    status = PmChangePartitionIoctl(extension, partition,
             IOCTL_INTERNAL_VOLMGR_QUERY_CHANGE_PARTITION);
    if (!NT_SUCCESS(status)) {
        UnlockDriver (extension->DriverExtension);
        return status;
    }

    KeInitializeEvent(&event, NotificationEvent, FALSE);
    IoCopyCurrentIrpStackLocationToNext(Irp);
    IoSetCompletionRoutine(Irp, PmSignalCompletion, &event, TRUE, TRUE, TRUE);
    IoCallDriver(extension->TargetObject, Irp);
    KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
    status = Irp->IoStatus.Status;

    if (NT_SUCCESS(status)) {
        PmChangePartitionIoctl(extension, partition,
                               IOCTL_INTERNAL_VOLMGR_PARTITION_CHANGED);
    } else {
        PmChangePartitionIoctl(extension, partition,
                               IOCTL_INTERNAL_VOLMGR_CANCEL_CHANGE_PARTITION);
    }

    UnlockDriver (extension->DriverExtension);

    return status;
}

NTSTATUS
PmEjectVolumeManagers(
    IN PDEVICE_OBJECT DeviceObject
    )

/*++

Routine Description:

    This routine goes through the list of partitions for the given disk
    and takes the partition away from the owning volume managers.  It then
    goes through initial arbitration for each partition on the volume.

    This has the effect that each volume manager forgets any cached disk
    information and then start fresh on the disk as it may have been changed
    by another cluster member.

Arguments:

    DeviceObject    - Supplies the device object.

Return Value:

    NTSTATUS

--*/

{
    PDEVICE_EXTENSION       extension = DeviceObject->DeviceExtension;
    PDO_EXTENSION           driverExtension = extension->DriverExtension;
    PPARTITION_LIST_ENTRY   partition;
    PLIST_ENTRY             l;
    PVOLMGR_LIST_ENTRY      volmgrEntry;

    LockDriver (driverExtension);

    for (l = extension->PartitionList.Flink; l != &extension->PartitionList;
         l = l->Flink) {

        partition = CONTAINING_RECORD(l, PARTITION_LIST_ENTRY, ListEntry);
        if (!partition->VolumeManagerEntry) {
            continue;
        }

        PmTakePartition(partition->VolumeManagerEntry,
                        partition->TargetObject, NULL);

        partition->VolumeManagerEntry = NULL;
    }

    for (l = driverExtension->VolumeManagerList.Flink;
         l != &driverExtension->VolumeManagerList; l = l->Flink) {

        volmgrEntry = CONTAINING_RECORD(l, VOLMGR_LIST_ENTRY, ListEntry);
        PmTakeWholeDisk(volmgrEntry, extension->Pdo);
    }

    UnlockDriver (driverExtension);

    return STATUS_SUCCESS;
}

NTSTATUS
PmQueryDiskSignature(
    IN  PDEVICE_OBJECT  DeviceObject,
    IN  PIRP            Irp
    )

/*++

Routine Description:

    This routine returns the disk signature for the disk.  If the
    volume is not an MBR disk then this call will fail.

Arguments:

    DeviceObject    - Supplies the device object.

    Irp             - Supplies the IO request packet.

Return Value:

    NTSTATUS

--*/

{
    PDEVICE_EXTENSION               extension = DeviceObject->DeviceExtension;
    PIO_STACK_LOCATION              irpSp = IoGetCurrentIrpStackLocation(Irp);
    PPARTMGR_DISK_SIGNATURE         partSig = Irp->AssociatedIrp.SystemBuffer;
    NTSTATUS                        status;
    PDRIVE_LAYOUT_INFORMATION_EX    layout;

    if (irpSp->Parameters.DeviceIoControl.OutputBufferLength <
        sizeof(PARTMGR_DISK_SIGNATURE)) {

        return STATUS_INVALID_PARAMETER;
    }

    Irp->IoStatus.Information = sizeof(PARTMGR_DISK_SIGNATURE);

    if (extension->DiskSignature) {
        partSig->Signature = extension->DiskSignature;
        return STATUS_SUCCESS;
    }

    status = PmReadPartitionTableEx(extension->TargetObject, &layout);
    if (!NT_SUCCESS(status)) {
        Irp->IoStatus.Information = 0;
        return status;
    }

    if (layout->PartitionStyle != PARTITION_STYLE_MBR) {
        ExFreePool(layout);
        Irp->IoStatus.Information = 0;
        return STATUS_INVALID_PARAMETER;
    }

    partSig->Signature = layout->Mbr.Signature;

    ExFreePool(layout);

    return status;
}

NTSTATUS
PmDeviceControl(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp
    )

/*++

Routine Description:

    This routine is the dispatch for IRP_MJ_PNP.

Arguments:

    DeviceObject    - Supplies the device object.

    Irp             - Supplies the IO request packet.

Return Value:

    NTSTATUS

--*/

{
    PDEVICE_EXTENSION               extension = DeviceObject->DeviceExtension;
    PIO_STACK_LOCATION              irpSp = IoGetCurrentIrpStackLocation(Irp);
    KEVENT                          event;
    NTSTATUS                        status;
    PDRIVE_LAYOUT_INFORMATION       layout;
    PDRIVE_LAYOUT_INFORMATION_EX    newLayout;
    BOOLEAN                         issueSigCheckNotification;
    LIST_ENTRY                      completionList;

    if (extension->TargetObject->Characteristics&FILE_REMOVABLE_MEDIA) {
        IoSkipCurrentIrpStackLocation(Irp);
        return IoCallDriver(extension->TargetObject, Irp);
    }


    
    switch (irpSp->Parameters.DeviceIoControl.IoControlCode) {
        case IOCTL_DISK_SET_DRIVE_LAYOUT:
        case IOCTL_DISK_SET_DRIVE_LAYOUT_EX:
        case IOCTL_DISK_CREATE_DISK:
        case IOCTL_DISK_DELETE_DRIVE_LAYOUT:
        case IOCTL_DISK_UPDATE_PROPERTIES:


            LockDriver (extension->DriverExtension);

            issueSigCheckNotification = !extension->SignaturesNotChecked || 
                                        (IOCTL_DISK_UPDATE_PROPERTIES == 
                                         irpSp->Parameters.DeviceIoControl.IoControlCode);

            extension->SignaturesNotChecked = TRUE;

            UnlockDriver (extension->DriverExtension);


            KeInitializeEvent(&event, NotificationEvent, FALSE);
            IoCopyCurrentIrpStackLocationToNext(Irp);
            IoSetCompletionRoutine(Irp, PmSignalCompletion, &event, TRUE,
                                   TRUE, TRUE);
            IoCallDriver(extension->TargetObject, Irp);
            KeWaitForSingleObject(&event, Executive, KernelMode, FALSE,
                                  NULL);

            status = Irp->IoStatus.Status;

            if (NT_SUCCESS(status)) {
                status = PmCheckAndUpdateSignature (extension, 
                                                    issueSigCheckNotification, 
                                                    TRUE);
            }

            break;


        case IOCTL_PARTMGR_CHECK_UNCLAIMED_PARTITIONS:
            status = PmCheckForUnclaimedPartitions(DeviceObject);
            Irp->IoStatus.Information = 0;
            break;

        case IOCTL_DISK_GROW_PARTITION:
            status = PmDiskGrowPartition(DeviceObject, Irp);
            break;

        case IOCTL_PARTMGR_EJECT_VOLUME_MANAGERS:
            status = PmEjectVolumeManagers(DeviceObject);
            break;

        case IOCTL_PARTMGR_NOTIFY_SIGNATURE_CHECK:
            status = PmSigCheckNotificationInsert (extension, Irp);

            if (STATUS_PENDING == status) {
                return (STATUS_PENDING);                    
	    }

            break;

        case IOCTL_DISK_PERFORMANCE:
            //
            // Verify user buffer is large enough for the performance data.
            //

            status = STATUS_SUCCESS;
            if (irpSp->Parameters.DeviceIoControl.OutputBufferLength <
                    sizeof(DISK_PERFORMANCE)) {

                //
                // Indicate unsuccessful status and no data transferred.
                //

                status = STATUS_BUFFER_TOO_SMALL;
                Irp->IoStatus.Information = 0;
            }
            else if (!(extension->CountersEnabled)) {
                if (!PmQueryEnableAlways(DeviceObject)) {
                    status = STATUS_UNSUCCESSFUL;
                    Irp->IoStatus.Information = 0;
                }
            }
            if (status == STATUS_SUCCESS) {
                PmWmiCounterQuery(extension->PmWmiCounterContext,
                                  (PDISK_PERFORMANCE) Irp->AssociatedIrp.SystemBuffer,
                                  L"Partmgr ",
                                  extension->DiskNumber);
                Irp->IoStatus.Information = sizeof(DISK_PERFORMANCE);
            }
            break;

        case IOCTL_DISK_PERFORMANCE_OFF:
            //
            // Turns off counting
            //
            if (extension->CountersEnabled) {
                if (InterlockedCompareExchange(&extension->EnableAlways, 0, 1) == 1) {
                    if (!PmWmiCounterDisable(&extension->PmWmiCounterContext, FALSE, FALSE)) {
                        extension->CountersEnabled = FALSE;
                    }
                }
            }
            Irp->IoStatus.Information = 0;
            status = STATUS_SUCCESS;
            break;

        case IOCTL_PARTMGR_QUERY_DISK_SIGNATURE:
        case IOCTL_DISK_GET_DRIVE_LAYOUT:
        case IOCTL_DISK_GET_DRIVE_LAYOUT_EX:

            status = PmCheckAndUpdateSignature (extension, TRUE, FALSE);

            if (NT_SUCCESS (status) && 
                (irpSp->Parameters.DeviceIoControl.IoControlCode ==
                IOCTL_PARTMGR_QUERY_DISK_SIGNATURE)) {

                status = PmQueryDiskSignature(DeviceObject, Irp);
                break;
            }

            // Fall through.

        default:
            IoSkipCurrentIrpStackLocation(Irp);
            return IoCallDriver(extension->TargetObject, Irp);
    }

    Irp->IoStatus.Status = status;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
    return status;
}

RTL_GENERIC_COMPARE_RESULTS
PmTableSignatureCompareRoutine(
    IN  PRTL_GENERIC_TABLE  Table,
    IN  PVOID               First,
    IN  PVOID               Second
    )

{
    PSIGNATURE_TABLE_ENTRY  f = First;
    PSIGNATURE_TABLE_ENTRY  s = Second;

    if (f->Signature < s->Signature) {
        return GenericLessThan;
    }

    if (f->Signature > s->Signature) {
        return GenericGreaterThan;
    }

    return GenericEqual;
}

RTL_GENERIC_COMPARE_RESULTS
PmTableGuidCompareRoutine(
    IN  PRTL_GENERIC_TABLE  Table,
    IN  PVOID               First,
    IN  PVOID               Second
    )

{
    PGUID_TABLE_ENTRY   f = First;
    PGUID_TABLE_ENTRY   s = Second;
    PULONGLONG          p1, p2;

    p1 = (PULONGLONG) &f->Guid;
    p2 = (PULONGLONG) &s->Guid;

    if (p1[0] < p2[0]) {
        return GenericLessThan;
    }

    if (p1[0] > p2[0]) {
        return GenericGreaterThan;
    }

    if (p1[1] < p2[1]) {
        return GenericLessThan;
    }

    if (p1[1] > p2[1]) {
        return GenericGreaterThan;
    }

    return GenericEqual;
}

PVOID
PmTableAllocateRoutine(
    IN  PRTL_GENERIC_TABLE  Table,
    IN  CLONG               Size
    )

{
    return ExAllocatePoolWithTag(PagedPool, Size, PARTMGR_TAG_TABLE_ENTRY);
}

VOID
PmTableFreeRoutine(
    IN  PRTL_GENERIC_TABLE  Table,
    IN  PVOID               Buffer
    )

{
    ExFreePool(Buffer);
}

NTSTATUS
DriverEntry(
    IN PDRIVER_OBJECT DriverObject,
    IN PUNICODE_STRING RegistryPath
    )

/*++

Routine Description:

    This routine is the entry point for the driver.

Arguments:

    DriverObject    - Supplies the driver object.

    RegistryPath    - Supplies the registry path for this driver.

Return Value:

    NTSTATUS

--*/

{
    ULONG           i;
    NTSTATUS        status;
    PDO_EXTENSION   driverExtension;
    PDEVICE_OBJECT  deviceObject;

    for (i = 0; i <= IRP_MJ_MAXIMUM_FUNCTION; i++) {
        DriverObject->MajorFunction[i] = PmPassThrough;
    }

    DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = PmDeviceControl;
    DriverObject->MajorFunction[IRP_MJ_PNP] = PmPnp;
    DriverObject->MajorFunction[IRP_MJ_POWER] = PmPower;
    DriverObject->MajorFunction[IRP_MJ_SYSTEM_CONTROL] = PmWmi;
    DriverObject->MajorFunction[IRP_MJ_READ] = PmReadWrite;
    DriverObject->MajorFunction[IRP_MJ_WRITE] = PmReadWrite;

    DriverObject->DriverExtension->AddDevice = PmAddDevice;
    DriverObject->DriverUnload = PmUnload;

    status = IoAllocateDriverObjectExtension(DriverObject, PmAddDevice,
                                             sizeof(DO_EXTENSION),
                                             &driverExtension);
    if (!NT_SUCCESS(status)) {
        return status;
    }

    driverExtension->DiskPerfRegistryPath.MaximumLength =
        RegistryPath->Length + sizeof(UNICODE_NULL);
    driverExtension->DiskPerfRegistryPath.Buffer =
        ExAllocatePoolWithTag(
            PagedPool,
            driverExtension->DiskPerfRegistryPath.MaximumLength,
            PARTMGR_TAG_PARTITION_ENTRY);
    if (driverExtension->DiskPerfRegistryPath.Buffer != NULL)
    {
        RtlCopyUnicodeString(&driverExtension->DiskPerfRegistryPath,
                             RegistryPath);
    } else {
        driverExtension->DiskPerfRegistryPath.Length = 0;
        driverExtension->DiskPerfRegistryPath.MaximumLength = 0;
    }

    driverExtension->DriverObject = DriverObject;
    driverExtension->CurrentEpochNumber = 0;
    InitializeListHead(&driverExtension->VolumeManagerList);
    InitializeListHead(&driverExtension->DeviceExtensionList);
    InitializeListHead(&driverExtension->SignatureCheckNotificationIrpQueue);  

    KeInitializeMutex(&driverExtension->Mutex, 0);
    driverExtension->PastReinit = FALSE;

    RtlInitializeGenericTable(&driverExtension->SignatureTable,
                              PmTableSignatureCompareRoutine,
                              PmTableAllocateRoutine,
                              PmTableFreeRoutine, driverExtension);

    RtlInitializeGenericTable(&driverExtension->GuidTable,
                              PmTableGuidCompareRoutine,
                              PmTableAllocateRoutine,
                              PmTableFreeRoutine, driverExtension);    

    IoRegisterBootDriverReinitialization(DriverObject, PmBootDriverReinit,
                                         driverExtension);    

    status = IoRegisterPlugPlayNotification(
             EventCategoryDeviceInterfaceChange,
             PNPNOTIFY_DEVICE_INTERFACE_INCLUDE_EXISTING_INTERFACES,
             (PVOID) &VOLMGR_VOLUME_MANAGER_GUID, DriverObject,
             PmVolumeManagerNotification, driverExtension,
             &driverExtension->NotificationEntry);

    if (!NT_SUCCESS(status)) {
        return status;
    }

    driverExtension->BootDiskSig = PmQueryRegistrySignature();
    PmQueryRegistryGuid(driverExtension);

    return STATUS_SUCCESS;
}

NTSTATUS
PmBuildDependantVolumeRelations(
    IN  PDEVICE_EXTENSION Extension,
    OUT PDEVICE_RELATIONS *Relations
    )
/*++

Routine Description:

    This routine builds a list of volumes which are dependant on a given
    physical disk.  This list can be used for reporting removal relations
    to the pnp system.

Arguments:

    Extension   - Supplies the device extension for the pm filter.

    Relations   - Supplies a location to store the relations list.

Return Value:

    NTSTATUS

--*/

{
    ULONG                   partitionCount;
    PIRP                    irp;
    PDEVICE_RELATIONS       relationsList;
    PDEVICE_RELATIONS       combinedList;

    ULONG                   dependantVolumeCount = 0;

    PLIST_ENTRY             l;
    PPARTITION_LIST_ENTRY   partition;
    NTSTATUS                status = STATUS_SUCCESS;
    ULONG i;

    KEVENT event;

    PAGED_CODE();

    LockDriver (Extension->DriverExtension);

    //
    // Count the number of partitions we know about.  If there aren't any then
    // there aren't any relations either.
    //

    for(l = Extension->PartitionList.Flink, partitionCount = 0;
        l != &(Extension->PartitionList);
        l = l->Flink, partitionCount++);

    //
    // Allocate the relations list.
    //

    relationsList = ExAllocatePoolWithTag(
                        PagedPool,
                        (sizeof(DEVICE_RELATIONS) +
                        (sizeof(PDEVICE_RELATIONS) * partitionCount)),
                        PARTMGR_TAG_DEPENDANT_VOLUME_LIST);

    if(relationsList== NULL) {
        UnlockDriver (Extension->DriverExtension);
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    RtlZeroMemory(relationsList, (sizeof(DEVICE_RELATIONS) +
                                  sizeof(PDEVICE_OBJECT) * partitionCount));

    if(partitionCount == 0) {
        *Relations = relationsList;
        UnlockDriver (Extension->DriverExtension);
        return STATUS_SUCCESS;
    }

    KeInitializeEvent(&event, SynchronizationEvent, FALSE);

    for(l = Extension->PartitionList.Flink, i = 0, dependantVolumeCount = 0;
        l != &(Extension->PartitionList);
        l = l->Flink, i++) {

        PDEVICE_RELATIONS dependantVolumes;

        partition = CONTAINING_RECORD(l, PARTITION_LIST_ENTRY, ListEntry);

        //
        // Check to make sure the volume has a volume manager.  If it doesn't
        // then just skip to the next one.
        //

        if(partition->VolumeManagerEntry == NULL) {
            continue;
        }

        status = PmQueryDependantVolumeList(
                    partition->VolumeManagerEntry->VolumeManager,
                    partition->TargetObject,
                    partition->WholeDiskPdo,
                    &dependantVolumes);

        if(!NT_SUCCESS(status)) {

            //
            // Error getting this list.  We'll need to release the lists from
            // the other partitions.
            //

            break;
        }

        dependantVolumeCount += dependantVolumes->Count;
        relationsList->Objects[i] = (PDEVICE_OBJECT) dependantVolumes;
    }

    UnlockDriver (Extension->DriverExtension);

    relationsList->Count = i;

    if(NT_SUCCESS(status)) {

        //
        // Allocate a new device relations list which can hold all the dependant
        // volumes for all the partitions.
        //

        combinedList = ExAllocatePoolWithTag(
                            PagedPool,
                            (sizeof(DEVICE_RELATIONS) +
                            (sizeof(PDEVICE_OBJECT) * dependantVolumeCount)),
                            PARTMGR_TAG_DEPENDANT_VOLUME_LIST);
    } else {
        combinedList = NULL;
    }

    if(combinedList != NULL) {

        RtlZeroMemory(combinedList,
                      (sizeof(DEVICE_RELATIONS) +
                       (sizeof(PDEVICE_OBJECT) * dependantVolumeCount)));

        //
        // For each partition list ...
        //

        for(i = 0; i < relationsList->Count; i++) {

            PDEVICE_RELATIONS volumeList;
            ULONG j;

            volumeList = (PDEVICE_RELATIONS) relationsList->Objects[i];

            //
            // We might have skipped this volume above.  If we did the object
            // list should be NULL;
            //

            if(volumeList == NULL) {
                continue;
            }

            //
            // For each dependant volume in that list ...
            //

            for(j = 0; j < volumeList->Count; j++) {

                PDEVICE_OBJECT volume;
                ULONG k;

                volume = volumeList->Objects[j];

                //
                // Check to see if there's a duplicate in our combined list.
                //

                for(k = 0; k < combinedList->Count; k++) {
                    if(combinedList->Objects[k] == volume) {
                        break;
                    }
                }

                if(k == combinedList->Count) {

                    //
                    // We found no match - shove this object onto the end of
                    // the set.
                    //

                    combinedList->Objects[k] = volume;
                    combinedList->Count++;

                } else {

                    //
                    // We've got a spare reference to this device object.
                    // release it.
                    //

                    ObDereferenceObject(volume);
                }

            }

            //
            // Free the list.
            //

            ExFreePool(volumeList);
            relationsList->Objects[i] = NULL;
        }

        status = STATUS_SUCCESS;

    } else {


        //
        // For each partition list ...
        //

        for(i = 0; i < relationsList->Count; i++) {

            PDEVICE_RELATIONS volumeList;
            ULONG j;

            volumeList = (PDEVICE_RELATIONS) relationsList->Objects[i];

            //
            // For each dependant volume in that list ...
            //

            for(j = 0; j < volumeList->Count; j++) {

                PDEVICE_OBJECT volume;

                volume = volumeList->Objects[j];

                //
                // Dereference the volume.
                //

                ObDereferenceObject(volume);
            }

            //
            // Free the list.
            //

            ExFreePool(volumeList);
            relationsList->Objects[i] = NULL;
        }

        status = STATUS_INSUFFICIENT_RESOURCES;
    }

    //
    // Free the list of lists.
    //

    ExFreePool(relationsList);

    *Relations = combinedList;

    return status;
}

NTSTATUS
PmQueryDependantVolumeList(
    IN  PDEVICE_OBJECT VolumeManager,
    IN  PDEVICE_OBJECT Partition,
    IN  PDEVICE_OBJECT WholeDiskPdo,
    OUT PDEVICE_RELATIONS *DependantVolumes
    )
{
    KEVENT                                  event;
    PIRP                                    irp;

    IO_STATUS_BLOCK                         ioStatus;
    NTSTATUS                                status;
    VOLMGR_PARTITION_INFORMATION            input;
    VOLMGR_DEPENDANT_VOLUMES_INFORMATION    output;

    PAGED_CODE();

    ASSERT(DependantVolumes != NULL);

    if (!VolumeManager) {
        *DependantVolumes = ExAllocatePoolWithTag(PagedPool,
                            sizeof(DEVICE_RELATIONS),
                            PARTMGR_TAG_DEPENDANT_VOLUME_LIST);
        if (*DependantVolumes == NULL) {
            return STATUS_INSUFFICIENT_RESOURCES;
        }

        (*DependantVolumes)->Count = 0;

        return STATUS_SUCCESS;
    }

    KeInitializeEvent(&event, NotificationEvent, FALSE);

    input.PartitionDeviceObject = Partition;
    input.WholeDiskPdo = WholeDiskPdo;

    irp = IoBuildDeviceIoControlRequest(
            IOCTL_INTERNAL_VOLMGR_REFERENCE_DEPENDANT_VOLUMES, VolumeManager,
            &input, sizeof(input), &output, sizeof(output), TRUE, &event,
            &ioStatus);

    if (!irp) {
        *DependantVolumes = NULL;
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    status = IoCallDriver(VolumeManager, irp);
    if (status == STATUS_PENDING) {
        KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
        status = ioStatus.Status;
    }

    if (NT_SUCCESS(status)) {
        *DependantVolumes = output.DependantVolumeReferences;
    }

    return status;
}


NTSTATUS
PmRemovePartition(
    IN PPARTITION_LIST_ENTRY Partition
    )
{
    PIRP irp;
    KEVENT event;

    PIO_STACK_LOCATION nextStack;

    NTSTATUS status;

    PAGED_CODE();

    irp = IoAllocateIrp(Partition->TargetObject->StackSize, FALSE);

    if(irp == NULL) {
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    KeInitializeEvent(&event, SynchronizationEvent, FALSE);

    nextStack = IoGetNextIrpStackLocation(irp);

    nextStack->MajorFunction = IRP_MJ_PNP;
    nextStack->MinorFunction = IRP_MN_REMOVE_DEVICE;

    irp->IoStatus.Status = STATUS_NOT_SUPPORTED;

    IoSetCompletionRoutine(irp,
                           PmSignalCompletion,
                           &event,
                           TRUE,
                           TRUE,
                           TRUE);

    IoCallDriver(Partition->TargetObject, irp);

    KeWaitForSingleObject(&event,
                          KernelMode,
                          Executive,
                          FALSE,
                          NULL);

    status = irp->IoStatus.Status;

    IoFreeIrp(irp);

    return status;
}


NTSTATUS
PmReadWrite(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp
    )

/*++

Routine Description:

    This routine is the dispatch for IRP_MJ_READ & _WRITE.

Arguments:

    DeviceObject    - Supplies the device object.

    Irp             - Supplies the IO request packet.

Return Value:

    NTSTATUS

--*/

{
    PDEVICE_EXTENSION   extension =
        (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;

    if (extension->CountersEnabled || extension->PhysicalDiskIoNotifyRoutine) {
        PIO_STACK_LOCATION currentIrpStack = IoGetCurrentIrpStackLocation(Irp);
        PIO_STACK_LOCATION nextIrpStack = IoGetNextIrpStackLocation(Irp);

        *nextIrpStack = *currentIrpStack;

        if (extension->CountersEnabled) {
            PmWmiCounterIoStart(extension->PmWmiCounterContext,
                (PLARGE_INTEGER) &currentIrpStack->Parameters.Read);
        }
        else {      // need to calculate response time for tracing
            PmWmiGetClock(
                *((PLARGE_INTEGER)&currentIrpStack->Parameters.Read), NULL);
        }

        IoMarkIrpPending(Irp);
        IoSetCompletionRoutine(Irp, PmIoCompletion, DeviceObject,
                               TRUE, TRUE, TRUE);
        IoCallDriver(extension->TargetObject, Irp);
        return STATUS_PENDING;
    }

    IoSkipCurrentIrpStackLocation(Irp);
    return IoCallDriver(extension->TargetObject, Irp);
}



NTSTATUS
PmIoCompletion(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP           Irp,
    IN PVOID          Context
    )

/*++

Routine Description:

    This routine will get control from the system at the completion of an IRP.

Arguments:

    DeviceObject - for the IRP.

    Irp          - The I/O request that just completed.

    Context      - Not used.

Return Value:

    The IRP status.

--*/

{
    PDEVICE_EXTENSION  deviceExtension   = DeviceObject->DeviceExtension;
    PIO_STACK_LOCATION irpStack          = IoGetCurrentIrpStackLocation(Irp);
    PPHYSICAL_DISK_IO_NOTIFY_ROUTINE notifyRoutine;

    UNREFERENCED_PARAMETER(Context);

    if (deviceExtension->CountersEnabled) {
        PmWmiCounterIoComplete(deviceExtension->PmWmiCounterContext, Irp,
                             (PLARGE_INTEGER) &irpStack->Parameters.Read);
    }

    notifyRoutine = deviceExtension->PhysicalDiskIoNotifyRoutine;
    if (notifyRoutine) {
#ifdef NTPERF
        //
        // For now, only NTPERF needs this for tracing. Remove ifdef if it
        // is required for tracing in retail build
        //
        if (deviceExtension->CountersEnabled) {
            DISK_PERFORMANCE   PerfCounters;
            PmWmiCounterQuery(deviceExtension->PmWmiCounterContext,
                              &PerfCounters,
                              L"Partmgr ",
                              deviceExtension->DiskNumber);
            (*notifyRoutine) (deviceExtension->DiskNumber, Irp, &PerfCounters);
        } else {
            (*notifyRoutine) (deviceExtension->DiskNumber, Irp, NULL);
        }
#else
        if (!deviceExtension->CountersEnabled) {
            LARGE_INTEGER completeTime;
            PLARGE_INTEGER response;
            response = (PLARGE_INTEGER) &irpStack->Parameters.Read;
            PmWmiGetClock(completeTime, NULL);
            response->QuadPart = completeTime.QuadPart - response->QuadPart;
        }
        (*notifyRoutine) (deviceExtension->DiskNumber, Irp, NULL);
#endif
    }

    return STATUS_SUCCESS;

}



NTSTATUS
PmWmi(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp
    )

/*++

Routine Description:

    This routine handles any WMI requests for information.

Arguments:

    DeviceObject - Context for the activity.

    Irp          - The device control argument block.

Return Value:

    Status is returned.

--*/

{
    PIO_STACK_LOCATION      irpSp;
    NTSTATUS status;
    SYSCTL_IRP_DISPOSITION disposition;
    PDEVICE_EXTENSION  deviceExtension = DeviceObject->DeviceExtension;

    PAGED_CODE();

    irpSp = IoGetCurrentIrpStackLocation(Irp);

    if (irpSp->MinorFunction == IRP_MN_SET_TRACE_NOTIFY)
    {
        PVOID buffer = irpSp->Parameters.WMI.Buffer;
        ULONG bufferSize = irpSp->Parameters.WMI.BufferSize;

        if (bufferSize < sizeof(PPHYSICAL_DISK_IO_NOTIFY_ROUTINE))
        {
            status = STATUS_BUFFER_TOO_SMALL;
        } else {
#ifdef NTPERF
        //
        // For NTPERF Build, automatically turn on counters for tracing
        //
        if ((deviceExtension->PhysicalDiskIoNotifyRoutine == NULL) &&
            (*((PVOID *)buffer) != NULL)) {
            PmWmiCounterEnable(&deviceExtension->PmWmiCounterContext);
            deviceExtension->CountersEnabled = TRUE;
        } else
        if ((deviceExtension->PhysicalDiskIoNotifyRoutine != NULL) &&
            (*((PVOID *)buffer) == NULL)) {
            deviceExtension->CountersEnabled =
                PmWmiCounterDisable(&deviceExtension->PmWmiCounterContext,
                                    FALSE, FALSE);
        }
#endif
            deviceExtension->PhysicalDiskIoNotifyRoutine
                = (PPHYSICAL_DISK_IO_NOTIFY_ROUTINE)
                    *((PVOID *)buffer);

            status = STATUS_SUCCESS;
        }

        Irp->IoStatus.Status = status;
        Irp->IoStatus.Information = 0;
        IoCompleteRequest( Irp, IO_NO_INCREMENT );
    } else {
        if (deviceExtension->WmilibContext == NULL) {
            disposition = IrpForward;
            status = STATUS_SUCCESS;
        }
        else {
            status = WmiSystemControl(deviceExtension->WmilibContext,
                                      DeviceObject,
                                      Irp,
                                      &disposition);
        }
        switch (disposition)
        {
            case IrpProcessed:
            {
                break;
            }

            case IrpNotCompleted:
            {
                IoCompleteRequest(Irp, IO_NO_INCREMENT);
                break;
            }

            default:
            {
                IoSkipCurrentIrpStackLocation(Irp);

                status = IoCallDriver(deviceExtension->TargetObject, Irp);
                break;
            }
        }
    }
    return(status);

}

NTSTATUS
PmWmiFunctionControl(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp,
    IN ULONG GuidIndex,
    IN WMIENABLEDISABLECONTROL Function,
    IN BOOLEAN Enable
    )
/*++

Routine Description:

    This routine is a callback into the driver to query for enabling or
    disabling events and data collection.  When the driver has finished it
    must call WmiCompleteRequest to complete the irp. The driver can return
    STATUS_PENDING if the irp cannot be completed immediately.

Arguments:

    DeviceObject is the device whose events or data collection are being
        enabled or disabled

    Irp is the Irp that makes this request

    GuidIndex is the index into the list of guids provided when the
        device registered

    Function differentiates between event and data collection operations

    Enable indicates whether to enable or disable


Return Value:

    status

--*/
{
    NTSTATUS status;
    PDEVICE_EXTENSION deviceExtension;

    PAGED_CODE();

    deviceExtension = DeviceObject->DeviceExtension;

    if (GuidIndex == 0)
    {
        status = STATUS_SUCCESS;
        if (Function == WmiDataBlockControl) {
            if (!Enable) {
                deviceExtension->CountersEnabled =
                    PmWmiCounterDisable(&deviceExtension->PmWmiCounterContext,
                                        FALSE, FALSE);
            } else
            if (NT_SUCCESS(status =
                PmWmiCounterEnable(&deviceExtension->PmWmiCounterContext))) {
                deviceExtension->CountersEnabled = TRUE;
            }
        }
    } else {
        status = STATUS_WMI_GUID_NOT_FOUND;
    }

    status = WmiCompleteRequest(
                                 DeviceObject,
                                 Irp,
                                 status,
                                 0,
                                 IO_NO_INCREMENT);
    return(status);
}

NTSTATUS
PmReadPartitionTableEx(
    IN PDEVICE_OBJECT DeviceObject,
    IN PDRIVE_LAYOUT_INFORMATION_EX* DriveLayout
    )

/*++

Routine Description:

    This routine reads the partition table for the disk.

    The partition list is built in nonpaged pool that is allocated by this
    routine. It is the caller's responsability to free this memory when it
    is finished with the data.

Arguments:

    DeviceObject - Pointer for device object for this disk.

    DriveLayout - Pointer to the pointer that will return the patition list.
            This buffer is allocated in nonpaged pool by this routine. It is
            the responsability of the caller to free this memory if this
            routine is successful.

Return Values:

    Status.

--*/

{
    NTSTATUS Status;
    IO_STATUS_BLOCK IoStatus;
    PIRP Irp;
    KEVENT Event;
    PVOID IoCtlBuffer;
    ULONG IoCtlBufferSize;
    ULONG NewAllocationSize;
    ULONG NumTries;

    //
    // Initialize locals.
    //

    NumTries = 0;
    IoCtlBuffer = NULL;
    IoCtlBufferSize = 0;
    KeInitializeEvent(&Event, NotificationEvent, FALSE);

    //
    // Initialize the IOCTL buffer.
    //

    IoCtlBuffer = ExAllocatePoolWithTag(NonPagedPool, 
                                        PAGE_SIZE,
                                        PARTMGR_TAG_IOCTL_BUFFER);
    
    if (!IoCtlBuffer) {
        Status = STATUS_INSUFFICIENT_RESOURCES;
        goto cleanup;
    }
    
    IoCtlBufferSize = PAGE_SIZE;

    //
    // First try to get the partition table by issuing an IOCTL.
    //
    
    do {

        //
        // Make sure the event is reset.
        //

        KeClearEvent(&Event);

        //
        // Build an IOCTL Irp.
        //

        Irp = IoBuildDeviceIoControlRequest(IOCTL_DISK_GET_DRIVE_LAYOUT_EX,
                                            DeviceObject,
                                            NULL, 
                                            0, 
                                            IoCtlBuffer, 
                                            IoCtlBufferSize, 
                                            FALSE,
                                            &Event, 
                                            &IoStatus);
        if (!Irp) {
            Status = STATUS_INSUFFICIENT_RESOURCES;
            goto cleanup;
        }

        //
        // Call the driver.
        //

        Status = IoCallDriver(DeviceObject, Irp);

        if (Status == STATUS_PENDING) {
            KeWaitForSingleObject(&Event, 
                                  Executive, 
                                  KernelMode, 
                                  FALSE, 
                                  NULL);

            //
            // Update status.
            //
            
            Status = IoStatus.Status;
        }
    
        if (NT_SUCCESS(Status)) {
            
            //
            // We got it!
            //

            break;
        }

        if (Status != STATUS_BUFFER_TOO_SMALL) {
            
            //
            // It is a real error.
            //

            goto cleanup;
        }

        //
        // Resize IOCTL buffer. We should not enter the loop with a
        // NULL buffer.
        //

        ASSERT(IoCtlBuffer && IoCtlBufferSize);

        NewAllocationSize = IoCtlBufferSize * 2;

        ExFreePool(IoCtlBuffer);
        IoCtlBufferSize = 0;
        
        IoCtlBuffer = ExAllocatePoolWithTag(NonPagedPool,
                                            NewAllocationSize,
                                            PARTMGR_TAG_IOCTL_BUFFER);
        
        if (!IoCtlBuffer) {
            Status = STATUS_INSUFFICIENT_RESOURCES;
            goto cleanup;
        }
        
        IoCtlBufferSize = NewAllocationSize;

        //
        // Try again with the new buffer but do not loop forever.
        //

        NumTries++;

        if (NumTries > 32) {
            Status = STATUS_UNSUCCESSFUL;
            goto cleanup;
        }

    } while (TRUE);

    //
    // If we came here we should have acquired the partition tables in
    // IoCtlBuffer.
    //
    
    ASSERT(NT_SUCCESS(Status));
    ASSERT(IoCtlBuffer && IoCtlBufferSize);
    
    //
    // Set the output parameter and clear IoCtlBuffer so we don't free
    // it when we are cleaning up.
    //

    (*DriveLayout) = (PDRIVE_LAYOUT_INFORMATION_EX) IoCtlBuffer;

    IoCtlBuffer = NULL;
    IoCtlBufferSize = 0;

    Status = STATUS_SUCCESS;

 cleanup:
    
    if (IoCtlBuffer) {
        ASSERT(IoCtlBufferSize);
        ExFreePool(IoCtlBuffer);
    }

    //
    // If we were not successful with the IOCTL, pass the request off
    // to IoReadPartitionTableEx.
    //

    if (!NT_SUCCESS(Status)) {
        
        Status = IoReadPartitionTableEx(DeviceObject,
                                        DriveLayout);

    }
    
    return Status;
}

NTSTATUS
PmWritePartitionTableEx(
    IN  PDEVICE_OBJECT                  DeviceObject,
    IN  PDRIVE_LAYOUT_INFORMATION_EX    DriveLayout
    )

{
    ULONG           layoutSize;
    KEVENT          event;
    PIRP            irp;
    IO_STATUS_BLOCK ioStatus;
    NTSTATUS        status;

    layoutSize = FIELD_OFFSET(DRIVE_LAYOUT_INFORMATION_EX, PartitionEntry) +
                 DriveLayout->PartitionCount*sizeof(PARTITION_INFORMATION_EX);

    KeInitializeEvent(&event, NotificationEvent, FALSE);
    irp = IoBuildDeviceIoControlRequest(IOCTL_DISK_SET_DRIVE_LAYOUT_EX,
                                        DeviceObject, DriveLayout,
                                        layoutSize, NULL, 0, FALSE, &event,
                                        &ioStatus);
    if (!irp) {
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    status = IoCallDriver(DeviceObject, irp);
    if (status == STATUS_PENDING) {
        KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
        status = ioStatus.Status;
    }

    return status;
}


VOID
PmSigCheckUpdateEpoch (
    IN PDEVICE_EXTENSION DeviceExtension,
    IN PLIST_ENTRY       CompletionList
    )
    {
    NTSTATUS                       status;
    PIRP                           irp;
    PIO_STACK_LOCATION             irpSp;
    KIRQL                          oldIrql;
    PLIST_ENTRY                    listElement;


    //
    // Update the epoch for this disk and move it to the head of the queue
    //
    DeviceExtension->EpochNumber = ++DeviceExtension->DriverExtension->CurrentEpochNumber;

    RemoveEntryList (&DeviceExtension->ListEntry);

    InsertHeadList (&DeviceExtension->DriverExtension->DeviceExtensionList,
                    &DeviceExtension->ListEntry);


    //
    // Now scan the list of outstanding notification irps and for those that
    // are not yet cancelled move them to the completion list and fill in the
    // buffers with the appropriate contents. Separating out the completion
    // of the irps from their preparation means that we can avoid all the
    // mucking around with the mutex and opening shynchronisation holes.
    //
    InitializeListHead (CompletionList);

    listElement = DeviceExtension->DriverExtension->SignatureCheckNotificationIrpQueue.Flink;


    while (listElement != &DeviceExtension->DriverExtension->SignatureCheckNotificationIrpQueue) {

        irp = CONTAINING_RECORD (listElement, IRP, Tail.Overlay.ListEntry); 

        listElement = listElement->Flink;


        IoAcquireCancelSpinLock (&oldIrql);

        //
        // Check if the cancel routine has been called. If so
        // don't complete this irp.
        //
        status = (NULL == IoSetCancelRoutine (irp, NULL))
                    ? STATUS_CANCELLED
                    : STATUS_SUCCESS;

        if (NT_SUCCESS (status)) {
            RemoveEntryList (&irp->Tail.Overlay.ListEntry);
        }

        IoReleaseCancelSpinLock (oldIrql);


        if (NT_SUCCESS (status)) {
            InsertTailList (CompletionList, &irp->Tail.Overlay.ListEntry);

            status = PmSigCheckFillInNotificationIrp (DeviceExtension->DriverExtension, irp);

            irp->IoStatus.Status = status;
        }
    }


    return;
}



VOID
PmSigCheckCompleteNotificationIrps(
    IN PLIST_ENTRY CompletionList
    )
{
    PIRP        irp;
    PLIST_ENTRY listElement;


    PAGED_CODE();


    while (!IsListEmpty (CompletionList)) {
        //
        // There's an Irp waiting on the completion queue.
        // The notification buffer is already filled in so 
        // we just need to send it back to the caller.
        //
        listElement = RemoveHeadList (CompletionList);

        irp = CONTAINING_RECORD (listElement, IRP, Tail.Overlay.ListEntry); 

        IoCompleteRequest (irp, IO_NO_INCREMENT);
    }

    return;
}



NTSTATUS
PmSigCheckFillInNotificationIrp (
    IN PDO_EXTENSION DriverExtension,
    IN PIRP          Irp
    )
{
    PDEVICE_EXTENSION              deviceExtension;
    NTSTATUS                       status                 = STATUS_SUCCESS;
    PIO_STACK_LOCATION             irpSp                  = IoGetCurrentIrpStackLocation (Irp);
    PPARTMGR_SIGNATURE_CHECK_EPOCH sigCheckEpoch          = Irp->AssociatedIrp.SystemBuffer;
    PPARTMGR_SIGNATURE_CHECK_DISKS sigCheckDisks          = Irp->AssociatedIrp.SystemBuffer;
    ULONG                          highestDiskEpochNumber = 0;
    ULONG                          disksInBuffer          = 0;
    ULONG                          maxDisksInBuffer;
    PLIST_ENTRY                    listElement;


    PAGED_CODE();


    maxDisksInBuffer = ((irpSp->Parameters.DeviceIoControl.OutputBufferLength - 
                         FIELD_OFFSET (PARTMGR_SIGNATURE_CHECK_DISKS, DiskNumber)) 
                       / sizeof (sigCheckDisks->DiskNumber[0])) ;

    ASSERT (maxDisksInBuffer >= 1);


    //
    // Walk down the list of disks until either we run out of disks with 
    // an epoch higher than the request or we reach the head. Then we 
    // turn around and start filling in the buffer until we either 
    // run out of disks or run out of buffer.
    //
    listElement = DriverExtension->DeviceExtensionList.Flink;

    while (listElement != &DriverExtension->DeviceExtensionList) {

        deviceExtension = CONTAINING_RECORD (listElement, DEVICE_EXTENSION, ListEntry); 

        if (deviceExtension->EpochNumber <= sigCheckEpoch->RequestEpoch) {
            //
            // We have stepped past the device of interest so
            // back up one place. Note that for single entries
            // this will in fact take us back to the queue head
            // so make sure we can handle that case in the
            // following loop.
            //
            listElement = listElement->Blink;
            break;
        } else {
            listElement = listElement->Flink;
        }
    }


    //
    // Now move back towards the head of the list recording entries
    // in the buffer as we go
    //
    while ((listElement != &DriverExtension->DeviceExtensionList) &&
           (disksInBuffer < maxDisksInBuffer))  {

        deviceExtension = CONTAINING_RECORD (listElement, DEVICE_EXTENSION, ListEntry); 

        listElement = listElement->Blink;

        sigCheckDisks->DiskNumber [disksInBuffer++] = deviceExtension->DiskNumber;

        highestDiskEpochNumber = UMAX (highestDiskEpochNumber, deviceExtension->EpochNumber);
    }


    if ((listElement != &DriverExtension->DeviceExtensionList) &&
        (disksInBuffer == maxDisksInBuffer)) {
        //
        // We ran out of buffer before we ran out of disks. 
        // Return STATUS_BUFFER_OVERFLOW
        //
        status = STATUS_BUFFER_OVERFLOW;

    } else {

        status = STATUS_SUCCESS;
    }



    sigCheckDisks->CurrentEpoch             = DriverExtension->CurrentEpochNumber;
    sigCheckDisks->HighestDiskEpochReturned = highestDiskEpochNumber;
    sigCheckDisks->DiskNumbersReturned      = disksInBuffer;

    Irp->IoStatus.Information = UMAX (sizeof (PARTMGR_SIGNATURE_CHECK_DISKS),
                                      FIELD_OFFSET (PARTMGR_SIGNATURE_CHECK_DISKS, DiskNumber) +
                                      (sizeof (sigCheckDisks->DiskNumber[0]) * disksInBuffer));

    return (status);
}


NTSTATUS
PmSigCheckNotificationInsert (
    IN PDEVICE_EXTENSION DeviceExtension, 
    IN PIRP              Irp) 

{
    NTSTATUS                       status = STATUS_CANCELLED;
    PIO_STACK_LOCATION             irpSp  = IoGetCurrentIrpStackLocation (Irp);
    PPARTMGR_SIGNATURE_CHECK_EPOCH sigCheckEpoch;
    PPARTMGR_SIGNATURE_CHECK_DISKS sigCheckDisks;


    if ((irpSp->Parameters.DeviceIoControl.InputBufferLength  < sizeof (PARTMGR_SIGNATURE_CHECK_EPOCH)) ||
        (irpSp->Parameters.DeviceIoControl.OutputBufferLength < sizeof (PARTMGR_SIGNATURE_CHECK_DISKS))) {

        Irp->IoStatus.Information = 0;
        status = STATUS_BUFFER_TOO_SMALL;

    } else {

        sigCheckEpoch = Irp->AssociatedIrp.SystemBuffer;
        sigCheckDisks = Irp->AssociatedIrp.SystemBuffer;

        LockDriver (DeviceExtension->DriverExtension);

        if (PARTMGR_REQUEST_CURRENT_DISK_EPOCH == sigCheckEpoch->RequestEpoch) {

            //
            // Caller requesting the current epoch number. Return the epoch 
            // number but no disks
            //

            sigCheckDisks->CurrentEpoch             = DeviceExtension->DriverExtension->CurrentEpochNumber;
            sigCheckDisks->HighestDiskEpochReturned = 0;
            sigCheckDisks->DiskNumbersReturned      = 0;
            sigCheckDisks->DiskNumber [0]           = 0;


            Irp->IoStatus.Information = sizeof (PARTMGR_SIGNATURE_CHECK_DISKS);
            status = STATUS_SUCCESS;

        } else if (sigCheckEpoch->RequestEpoch > DeviceExtension->DriverExtension->CurrentEpochNumber) {

            //
            // Something wrong here. Caller asking about an epoch which hasn't 
            // happened yet.
            //

            Irp->IoStatus.Information = 0;
            status = STATUS_NOT_FOUND;

        } else if (sigCheckEpoch->RequestEpoch < DeviceExtension->DriverExtension->CurrentEpochNumber) {

            //
            // Caller asking about an epoch which ended a while back. Fill in the 
            // request now with as much information as we can.
            //
            status = PmSigCheckFillInNotificationIrp (DeviceExtension->DriverExtension, Irp);

        } else {
            KIRQL    oldIrql;

            //
            // The only thing left is that the request epoch is the same as the current 
            // epoch. Queue this Irp which will be completed when the epoch changes.
            //

            IoAcquireCancelSpinLock (&oldIrql);

            InsertTailList (&DeviceExtension->DriverExtension->SignatureCheckNotificationIrpQueue, 
                            &Irp->Tail.Overlay.ListEntry);

            if (!Irp->Cancel) {
                IoSetCancelRoutine (Irp, PmSigCheckNotificationCancel);
                IoMarkIrpPending (Irp);
                status = STATUS_PENDING;
            } else {
                RemoveEntryList (&Irp->Tail.Overlay.ListEntry);
                Irp->IoStatus.Information = 0;
                status = STATUS_CANCELLED;
            }

            IoReleaseCancelSpinLock (oldIrql);

        }
	    

        UnlockDriver (DeviceExtension->DriverExtension);
    }


    return (status);
}


NTSTATUS
PmSigCheckNotificationCancel (
    IN PDEVICE_OBJECT DeviceObject, 
    IN PIRP           Irp) 

/*++

Routine Description

    This function filters cancels an outstanding IOCTL IRP


Arguments:

    DeviceObject - Pointer to the target device object of the create/open.
    Irp          - Pointer to the I/O Request Packet that represents the operation.

Return Value:

    The function value is the status of the call to the file system's entry
    point.
--*/

{
    PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
    NTSTATUS          status          = STATUS_CANCELLED;
    KIRQL             oldIrql;


    RemoveEntryList (&Irp->Tail.Overlay.ListEntry);

    IoReleaseCancelSpinLock (Irp->CancelIrql);

    Irp->IoStatus.Status      = STATUS_CANCELLED;
    Irp->IoStatus.Information = 0;

    IoCompleteRequest (Irp, IO_NO_INCREMENT);

    return (STATUS_SUCCESS);
}


NTSTATUS
PmCheckAndUpdateSignature (
    IN PDEVICE_EXTENSION DeviceExtension,
    IN BOOLEAN           IssueSigCheckNotifications,
    IN BOOLEAN           ForceSignatureCheck) 

/*++

Routine Description

    This function ...


Arguments:

    DeviceExtension


Return Value:

    The function value is the status of the call to the file system's entry
    point.
--*/

{
    NTSTATUS                        status                = STATUS_SUCCESS;
    BOOLEAN                         processCompletionList = FALSE;
    PDRIVE_LAYOUT_INFORMATION_EX    newLayout;
    LIST_ENTRY                      completionList;


    if (ForceSignatureCheck || DeviceExtension->SignaturesNotChecked) {

        status = PmReadPartitionTableEx (DeviceExtension->TargetObject, &newLayout);


        /*
        ** If by the time we complete the read of the partition table
        ** the SignaturesNotChecked flag has been cleared there is no
        ** need to proceed further. 
        **
        ** Alternatively if we failed to read the partition table (eg
        ** due to a timeout from the disk) and the
        ** SignaturesNotChecked flag is already set then bail and
        ** leave a future pass to fix up the signatures.
        */
        if (!(ForceSignatureCheck || DeviceExtension->SignaturesNotChecked)) {

            if (NT_SUCCESS (status)) {
                ExFreePool (newLayout);
            }

            return (STATUS_SUCCESS);

        } else if (!NT_SUCCESS(status) && DeviceExtension->SignaturesNotChecked) {

            return status;

        }



        /*
        ** If we can't get the lock avoid the deadlock and just
        ** leave. Shouldn't happen with FtDisk and basic disks
        ** (recursive acquire) and dmio with dynamic disks doesn't
        ** really care about the (potentially bad) signature anyway.
        */
        if (!LockDriverWithTimeout (DeviceExtension->DriverExtension)) {

            if (NT_SUCCESS (status)) {
                ExFreePool (newLayout);
            }

            return status;
        }


        if (NT_SUCCESS (status)) {
    
            if (IssueSigCheckNotifications) {
                PmSigCheckUpdateEpoch (DeviceExtension, &completionList);
                processCompletionList = TRUE;
            }

            PmAddSignatures (DeviceExtension, newLayout);

            ExFreePool(newLayout);
        }

        DeviceExtension->SignaturesNotChecked = NT_SUCCESS (status) ? FALSE : TRUE;

        UnlockDriver (DeviceExtension->DriverExtension);


        if (processCompletionList) {
            PmSigCheckCompleteNotificationIrps (&completionList);
        }
    }



    return (status);
}