/*++

Copyright (C) 1991-5  Microsoft Corporation

Module Name:

    ftdisk.c

Abstract:

    This driver provides fault tolerance through disk mirroring and striping.
    This module contains routines that support calls from the NT I/O system.

Author:

    Bob Rinne   (bobri)  2-Feb-1992
    Mike Glass  (mglass)
    Norbert Kusters      2-Feb-1995

Environment:

    kernel mode only

Notes:

Revision History:

--*/

extern "C" {
    #include <ntosp.h>
    #include <ntddscsi.h>
    #include <initguid.h>
    #include <mountmgr.h>
    #include <ioevent.h>
    #include <partmgrp.h>
    #include <zwapi.h>
    #include <ntioapi.h>

}

#include <ftdisk.h>

extern "C" {

#include "wmiguid.h"
#include "ntdddisk.h"
#include "ftwmireg.h"

}

//
// Global Sequence number for error log.
//

ULONG FtErrorLogSequence = 0;

extern "C" {

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

NTSTATUS
FtDiskAddDevice(
    IN  PDRIVER_OBJECT  DriverObject,
    IN  PDEVICE_OBJECT  PhysicalDeviceObject,
    IN  PUNICODE_STRING RegistryPath
    );

}

NTSTATUS
FtpCreateLogicalDiskHelper(
    IN OUT  PROOT_EXTENSION         RootExtension,
    IN      FT_LOGICAL_DISK_TYPE    LogicalDiskType,
    IN      USHORT                  NumberOfMembers,
    IN      PFT_LOGICAL_DISK_ID     ArrayOfMembers,
    IN      USHORT                  ConfigurationInformationSize,
    IN      PVOID                   ConfigurationInformation,
    IN      USHORT                  StateInformationSize,
    IN      PVOID                   StateInformation,
    OUT     PFT_LOGICAL_DISK_ID     NewLogicalDiskId
    );

NTSTATUS
FtpBreakLogicalDiskHelper(
    IN OUT  PROOT_EXTENSION     RootExtension,
    IN      FT_LOGICAL_DISK_ID  RootLogicalDiskId
    );

NTSTATUS
FtpCreatePartitionLogicalDiskHelper(
    IN OUT  PVOLUME_EXTENSION   Extension,
    IN      LONGLONG            PartitionSize,
    OUT     PFT_LOGICAL_DISK_ID NewLogicalDiskId
    );

NTSTATUS
FtpAddPartition(
    IN  PVOLUME_EXTENSION   Extension,
    IN  PDEVICE_OBJECT      Partition,
    IN  PDEVICE_OBJECT      WholeDiskPdo
    );

NTSTATUS
FtpPartitionRemovedHelper(
    IN OUT  PROOT_EXTENSION RootExtension,
    IN      PDEVICE_OBJECT  Partition,
    IN      PDEVICE_OBJECT  WholeDiskPdo
    );

NTSTATUS
FtpSignalCompletion(
    IN  PDEVICE_OBJECT  DeviceObject,
    IN  PIRP            Irp,
    IN  PVOID           Event
    );

VOID
FtpRefCountCompletion(
    IN  PVOID       Extension,
    IN  NTSTATUS    Status
    );

VOID
FtpDecrementRefCount(
    IN OUT  PVOLUME_EXTENSION   Extension
    );

NTSTATUS
FtpAllSystemsGo(
    IN  PVOLUME_EXTENSION   Extension,
    IN  PIRP                Irp,
    IN  BOOLEAN             MustBeComplete,
    IN  BOOLEAN             MustHaveVolume,
    IN  BOOLEAN             MustBeOnline
    );

NTSTATUS
FtpSetGptAttributesOnDisk(
    IN  PDEVICE_OBJECT  Partition,
    IN  ULONGLONG       GptAttributes
    );

typedef struct _SET_TARGET_CONTEXT {
    KEVENT          Event;
    PDEVICE_OBJECT  TargetObject;
    PFT_VOLUME      FtVolume;
    PDEVICE_OBJECT  WholeDiskPdo;
} SET_TARGET_CONTEXT, *PSET_TARGET_CONTEXT;

VOID
FtpSetTargetCallback(
    IN  PVOLUME_EXTENSION   Extension
    );

VOID
FtpVolumeReadOnlyCallback(
    IN  PVOLUME_EXTENSION   Extension
    );

VOID
FtpZeroRefCallback(
    IN  PVOLUME_EXTENSION   Extension,
    IN  ZERO_REF_CALLBACK   ZeroRefCallback,
    IN  PVOID               ZeroRefContext,
    IN  BOOLEAN             AcquireSemaphore
    );

NTSTATUS
FtpRefCountCompletionRoutine(
    IN  PDEVICE_OBJECT  DeviceObject,
    IN  PIRP            Irp,
    IN  PVOID           Extension
    );

VOID
FtDiskShutdownFlushCompletionRoutine(
    IN  PVOID       Irp,
    IN  NTSTATUS    Status
    );

typedef struct _FT_PARTITION_OFFLINE_CONTEXT {

    PFT_VOLUME      Root;
    PFT_VOLUME      Parent;
    PFT_VOLUME      Child;
    PKEVENT         Event;

} FT_PARTITION_OFFLINE_CONTEXT, *PFT_PARTITION_OFFLINE_CONTEXT;

VOID
FtpMemberOfflineCallback(
    IN  PVOLUME_EXTENSION   Extension
    );

NTSTATUS
FtpChangeNotify(
    IN OUT  PROOT_EXTENSION RootExtension,
    IN OUT  PIRP            Irp
    );

VOID
FtpReadWriteCompletionRoutine(
    IN  PTRANSFER_PACKET    TransferPacket
    );

typedef struct _INSERT_MEMBER_CONTEXT {
    KEVENT      Event;
    PFT_VOLUME  Parent;
    USHORT      MemberNumber;
    PFT_VOLUME  Member;
} INSERT_MEMBER_CONTEXT, *PINSERT_MEMBER_CONTEXT;

VOID
FtpInsertMemberCallback(
    IN  PVOLUME_EXTENSION   Extension
    );

VOID
FtpVolumeOnlineCallback(
    IN  PVOLUME_EXTENSION   Extension
    );

VOID
FtpVolumeOfflineCallback(
    IN  PVOLUME_EXTENSION   Extension
    );

VOID
FtpPropogateRegistryState(
    IN  PVOLUME_EXTENSION   Extension,
    IN  PFT_VOLUME          Volume
    );

VOID
FtpQueryRemoveCallback(
    IN  PVOLUME_EXTENSION   Extension
    );

VOID
FtDiskShutdownCompletionRoutine(
    IN  PVOID       Context,
    IN  NTSTATUS    Status
    );

NTSTATUS
FtpCheckForQueryRemove(
    IN OUT  PVOLUME_EXTENSION   Extension
    );

BOOLEAN
FtpCheckForCancelRemove(
    IN OUT  PVOLUME_EXTENSION   Extension
    );

VOID
FtpRemoveHelper(
    IN OUT  PVOLUME_EXTENSION   Extension
    );

VOID
FtpStartCallback(
    IN  PVOLUME_EXTENSION   Extension
    );

VOID
FtpWorkerThread(
    IN  PVOID   RootExtension
    );

VOID
FtpEventSignalCompletion(
    IN  PVOID       Event,
    IN  NTSTATUS    Status
    );

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

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

NTSTATUS
FtpPmWmiCounterLibContext(
    IN OUT PROOT_EXTENSION RootExtension,
    IN     PIRP            Irp
    );

NTSTATUS
FtpCheckForCompleteVolume(
    IN  PVOLUME_EXTENSION   Extension,
    IN  PFT_VOLUME          FtVolume
    );

VOID
FtpCancelChangeNotify(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp
    );

PVOLUME_EXTENSION
FtpFindExtensionCoveringPartition(
    IN  PROOT_EXTENSION RootExtension,
    IN  PDEVICE_OBJECT  Partition
    );

VOID
FtpCleanupVolumeExtension(
    IN OUT  PVOLUME_EXTENSION   Extension
    );

#ifdef ALLOC_PRAGMA
#pragma alloc_text(INIT, DriverEntry)
#pragma alloc_text(INIT, FtDiskAddDevice)
#endif

#define IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS_ADMIN  CTL_CODE(IOCTL_VOLUME_BASE, 0, METHOD_BUFFERED, FILE_READ_ACCESS)

#define UNIQUE_ID_MAX_BUFFER_SIZE           50
#define REVERT_GPT_ATTRIBUTES_REGISTRY_NAME (L"GptAttributeRevertEntries")


#ifdef ALLOC_PRAGMA
#pragma code_seg("PAGE")
#endif

NTSTATUS
FtpAcquireWithTimeout(
    IN OUT  PROOT_EXTENSION RootExtension
    )

/*++

Routine Description:

    This routine grabs the root semaphore.  This routine will timeout
    after 10 seconds.

Arguments:

    RootExtension   - Supplies the root extension.

Return Value:

    None.

--*/

{
    LARGE_INTEGER   timeout;
    NTSTATUS        status;

    timeout.QuadPart = -10*(10*1000*1000);
    status = KeWaitForSingleObject(&RootExtension->Mutex, Executive,
                                   KernelMode, FALSE, &timeout);
    if (status == STATUS_TIMEOUT) {
        status = STATUS_UNSUCCESSFUL;
    }

    return status;
}

VOID
FtpDeleteVolume(
    IN  PFT_VOLUME  Volume
    )

{
    USHORT      n, i;
    PFT_VOLUME  vol;

    n = Volume->QueryNumberOfMembers();
    for (i = 0; i < n; i++) {
        vol = Volume->GetMember(i);
        if (vol) {
            FtpDeleteVolume(vol);
        }
    }

    if (!InterlockedDecrement(&Volume->_refCount)) {
        delete Volume;
    }
}

PFT_VOLUME
FtpBuildFtVolume(
    IN OUT  PROOT_EXTENSION     RootExtension,
    IN      FT_LOGICAL_DISK_ID  LogicalDiskId,
    IN OUT  PDEVICE_OBJECT      Partition,
    IN OUT  PDEVICE_OBJECT      WholeDiskPdo
    )

/*++

Routine Description:

    This routine builds up an FT volume object for the given logical
    disk id.

Arguments:

    RootExtension   - Supplies the root device extension.

    LogicalDiskId   - Supplies the logical disk id.

    Partition       - Supplies the first partition for this volume.

    WholeDiskPdo    - Supplies the whole disk PDO.

Return Value:

    A new FT volume object or NULL.

--*/

{
    PFT_LOGICAL_DISK_INFORMATION_SET    diskInfoSet = RootExtension->DiskInfoSet;
    FT_LOGICAL_DISK_TYPE                diskType;
    LONGLONG                            offset;
    ULONG                               sectorSize;
    PPARTITION                          partition;
    NTSTATUS                            status;
    USHORT                              numMembers, i;
    PFT_VOLUME*                         volArray;
    PCOMPOSITE_FT_VOLUME                comp;

    if (!LogicalDiskId) {
        return NULL;
    }

    diskType = diskInfoSet->QueryLogicalDiskType(LogicalDiskId);
    if (diskType == FtPartition) {

        partition = new PARTITION;
        if (!partition) {
            return NULL;
        }

        status = partition->Initialize(RootExtension, LogicalDiskId,
                                       Partition, WholeDiskPdo);
        if (!NT_SUCCESS(status)) {
            delete partition;
            return NULL;
        }

        return partition;
    }

    switch (diskType) {

        case FtVolumeSet:
            comp = new VOLUME_SET;
            break;

        case FtStripeSet:
            comp = new STRIPE;
            break;

        case FtMirrorSet:
            comp = new MIRROR;
            break;

        case FtStripeSetWithParity:
            comp = new STRIPE_WP;
            break;

        case FtRedistribution:
            comp = new REDISTRIBUTION;
            break;

        default:
            comp = NULL;
            break;

    }

    if (!comp) {
        return comp;
    }

    numMembers = diskInfoSet->QueryNumberOfMembersInLogicalDisk(LogicalDiskId);
    ASSERT(numMembers);

    volArray = (PFT_VOLUME*)
               ExAllocatePool(NonPagedPool, numMembers*sizeof(PFT_VOLUME));
    if (!volArray) {
        delete comp;
        return NULL;
    }

    for (i = 0; i < numMembers; i++) {
        volArray[i] = FtpBuildFtVolume(RootExtension,
                      diskInfoSet->QueryMemberLogicalDiskId(LogicalDiskId, i),
                      Partition, WholeDiskPdo);
    }

    status = comp->Initialize(RootExtension, LogicalDiskId, volArray,
                              numMembers, diskInfoSet->
                              GetConfigurationInformation(LogicalDiskId),
                              diskInfoSet->GetStateInformation(LogicalDiskId));

    if (!NT_SUCCESS(status)) {
        for (i = 0; i < numMembers; i++) {
            if (volArray[i]) {
                FtpDeleteVolume(volArray[i]);
            }
        }
        delete comp;
        return NULL;
    }

    return comp;
}

VOID
FtpCheckForRevertGptAttributes(
    IN  PROOT_EXTENSION                 RootExtension,
    IN  PDEVICE_OBJECT                  Partition,
    IN  ULONG                           MbrSignature,
    IN  GUID*                           GptPartitionGuid,
    IN  PFT_LOGICAL_DISK_INFORMATION    DiskInfo
    )

{
    ULONG                           i, n;
    PFTP_GPT_ATTRIBUTE_REVERT_ENTRY p;

    n = RootExtension->NumberOfAttributeRevertEntries;
    p = RootExtension->GptAttributeRevertEntries;
    for (i = 0; i < n; i++) {

        if (MbrSignature) {
            if (MbrSignature == p[i].MbrSignature) {
                break;
            }
        } else {
            if (IsEqualGUID(p[i].PartitionUniqueId, *GptPartitionGuid)) {
                break;
            }
        }
    }

    if (i == n) {
        return;
    }

    if (MbrSignature) {
        DiskInfo->SetGptAttributes(p[i].GptAttributes);
    } else {
        FtpSetGptAttributesOnDisk(Partition, p[i].GptAttributes);
    }

    RootExtension->NumberOfAttributeRevertEntries--;

    if (i + 1 == n) {
        if (!RootExtension->NumberOfAttributeRevertEntries) {
            ExFreePool(RootExtension->GptAttributeRevertEntries);
            RootExtension->GptAttributeRevertEntries = NULL;
        }
        return;
    }

    RtlMoveMemory(&p[i], &p[i + 1],
                  (n - i - 1)*sizeof(FTP_GPT_ATTRIBUTE_REVERT_ENTRY));
}

NTSTATUS
FtpQueryPartitionInformation(
    IN  PROOT_EXTENSION RootExtension,
    IN  PDEVICE_OBJECT  Partition,
    OUT PULONG          DiskNumber,
    OUT PLONGLONG       Offset,
    OUT PULONG          PartitionNumber,
    OUT PUCHAR          PartitionType,
    OUT PLONGLONG       PartitionLength,
    OUT GUID*           PartitionTypeGuid,
    OUT GUID*           PartitionUniqueIdGuid,
    OUT PBOOLEAN        IsGpt,
    OUT PULONGLONG      GptAttributes
    )

/*++

Routine Description:

    This routine returns the disk number and offset for the given partition.

Arguments:

    Partition       - Supplies the partition.

    DiskNumber      - Returns the disk number.

    Offset          - Returns the offset.

    PartitionNumber - Returns the partition number.

    PartitionType   - Returns the partition type.

    PartitionLength - Returns the partition length.

Return Value:

    NTSTATUS

--*/

{
    KEVENT                      event;
    PIRP                        irp;
    IO_STATUS_BLOCK             ioStatus;
    NTSTATUS                    status;
    STORAGE_DEVICE_NUMBER       number;
    PLIST_ENTRY                 l;
    PARTITION_INFORMATION_EX    partInfo;

    if (DiskNumber || PartitionNumber) {

        KeInitializeEvent(&event, NotificationEvent, FALSE);

        irp = IoBuildDeviceIoControlRequest(IOCTL_STORAGE_GET_DEVICE_NUMBER,
                                            Partition, NULL, 0, &number,
                                            sizeof(number), FALSE, &event,
                                            &ioStatus);
        if (!irp) {
            return STATUS_INSUFFICIENT_RESOURCES;
        }

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

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

        if (DiskNumber) {
            *DiskNumber = number.DeviceNumber;
        }

        if (PartitionNumber) {
            *PartitionNumber = number.PartitionNumber;
        }
    }

    if (Offset || PartitionType || PartitionLength || PartitionTypeGuid ||
        PartitionUniqueIdGuid || IsGpt || GptAttributes) {

        KeInitializeEvent(&event, NotificationEvent, FALSE);

        irp = IoBuildDeviceIoControlRequest(IOCTL_DISK_GET_PARTITION_INFO_EX,
                                            Partition, NULL, 0, &partInfo,
                                            sizeof(partInfo), FALSE, &event,
                                            &ioStatus);
        if (!irp) {
            return STATUS_INSUFFICIENT_RESOURCES;
        }

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

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

        if (Offset) {
            *Offset = partInfo.StartingOffset.QuadPart;
        }

        if (PartitionType) {
            if (partInfo.PartitionStyle == PARTITION_STYLE_MBR) {
                *PartitionType = partInfo.Mbr.PartitionType;
            } else {
                *PartitionType = 0;
            }
        }

        if (PartitionLength) {
            *PartitionLength = partInfo.PartitionLength.QuadPart;
        }

        if (PartitionTypeGuid) {
            if (partInfo.PartitionStyle == PARTITION_STYLE_GPT) {
                *PartitionTypeGuid = partInfo.Gpt.PartitionType;
            }
        }

        if (PartitionUniqueIdGuid) {
            if (partInfo.PartitionStyle == PARTITION_STYLE_GPT) {
                *PartitionUniqueIdGuid = partInfo.Gpt.PartitionId;
            }
        }

        if (IsGpt) {
            if (partInfo.PartitionStyle == PARTITION_STYLE_GPT) {
                *IsGpt = TRUE;
            } else {
                *IsGpt = FALSE;
            }
        }

        if (GptAttributes) {
            if (partInfo.PartitionStyle == PARTITION_STYLE_GPT) {
                *GptAttributes = partInfo.Gpt.Attributes;
            } else {
                *GptAttributes = 0;
            }
        }
    }

    return STATUS_SUCCESS;
}

PVOLUME_EXTENSION
FtpFindExtensionCoveringDiskId(
    IN  PROOT_EXTENSION     RootExtension,
    IN  FT_LOGICAL_DISK_ID  LogicalDiskId
    )

/*++

Routine Description:

    This routine finds the device extension for the given root logical
    disk id.

Arguments:

    RootExtension   - Supplies the root device extension.

    LogicalDiskId   - Supplies the logical disk id.

Return Value:

    A volume extension or NULL.

--*/

{
    PLIST_ENTRY         l;
    PVOLUME_EXTENSION   extension;

    for (l = RootExtension->VolumeList.Flink; l != &RootExtension->VolumeList;
         l = l->Flink) {

        extension = CONTAINING_RECORD(l, VOLUME_EXTENSION, ListEntry);
        if (extension->FtVolume &&
            extension->FtVolume->GetContainedLogicalDisk(LogicalDiskId)) {

            return extension;
        }
    }

    return NULL;
}

PVOLUME_EXTENSION
FtpFindExtension(
    IN  PROOT_EXTENSION     RootExtension,
    IN  FT_LOGICAL_DISK_ID  LogicalDiskId
    )

/*++

Routine Description:

    This routine finds the device extension for the given root logical
    disk id.

Arguments:

    RootExtension   - Supplies the root device extension.

    LogicalDiskId   - Supplies the logical disk id.

Return Value:

    A volume extension or NULL.

--*/

{
    PLIST_ENTRY         l;
    PVOLUME_EXTENSION   extension;

    for (l = RootExtension->VolumeList.Flink; l != &RootExtension->VolumeList;
         l = l->Flink) {

        extension = CONTAINING_RECORD(l, VOLUME_EXTENSION, ListEntry);
        if (extension->FtVolume &&
            extension->FtVolume->QueryLogicalDiskId() == LogicalDiskId) {

            return extension;
        }
    }

    return NULL;
}

class EMPTY_IRP_QUEUE_WORK_ITEM : public WORK_QUEUE_ITEM {

    public:

        LIST_ENTRY          IrpQueue;
        PVOLUME_EXTENSION   Extension;

};

typedef EMPTY_IRP_QUEUE_WORK_ITEM *PEMPTY_IRP_QUEUE_WORK_ITEM;

VOID
FtpEmptyQueueWorkerRoutine(
    IN  PVOID   WorkItem
    )

/*++

Routine Description:

    This routine empties the given queue of irps by calling their respective
    dispatch routines.

Arguments:

    WorkItem    - Supplies the work item.

Return Value:

    None.

--*/

{
    PEMPTY_IRP_QUEUE_WORK_ITEM  workItem = (PEMPTY_IRP_QUEUE_WORK_ITEM) WorkItem;
    PLIST_ENTRY                 q, l;
    PDRIVER_OBJECT              driverObject;
    PDEVICE_OBJECT              deviceObject;
    PIRP                        irp;
    PIO_STACK_LOCATION          irpSp;

    q = &workItem->IrpQueue;
    driverObject = workItem->Extension->Root->DriverObject;
    deviceObject = workItem->Extension->DeviceObject;

    while (!IsListEmpty(q)) {
        l = RemoveHeadList(q);
        irp = CONTAINING_RECORD(l, IRP, Tail.Overlay.ListEntry);
        irpSp = IoGetCurrentIrpStackLocation(irp);
        driverObject->MajorFunction[irpSp->MajorFunction](deviceObject, irp);
    }

    ExFreePool(WorkItem);
}

ULONG
FtpQueryDiskSignature(
    IN  PDEVICE_OBJECT  WholeDiskPdo
    )

/*++

Routine Description:

    This routine queries the disk signature for the given disk.

Arguments:

    WholeDisk   - Supplies the whole disk.

Return Value:

    The disk signature.

--*/

{
    PDEVICE_OBJECT              wholeDisk;
    KEVENT                      event;
    PIRP                        irp;
    PARTMGR_DISK_SIGNATURE      partSig;
    IO_STATUS_BLOCK             ioStatus;
    NTSTATUS                    status;

    wholeDisk = IoGetAttachedDeviceReference(WholeDiskPdo);
    if (!wholeDisk) {
        return 0;
    }

    KeInitializeEvent(&event, NotificationEvent, FALSE);
    irp = IoBuildDeviceIoControlRequest(IOCTL_PARTMGR_QUERY_DISK_SIGNATURE,
                                        wholeDisk, NULL, 0, &partSig,
                                        sizeof(partSig), FALSE, &event,
                                        &ioStatus);
    if (!irp) {
        ObDereferenceObject(wholeDisk);
        return 0;
    }

    status = IoCallDriver(wholeDisk, irp);
    if (status == STATUS_PENDING) {
        KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
        status = ioStatus.Status;
    }
    if (!NT_SUCCESS(status)) {
        ObDereferenceObject(wholeDisk);
        return 0;
    }

    ObDereferenceObject(wholeDisk);

    return partSig.Signature;
}

ULONG
FtpQueryDiskSignatureCache(
    IN  PVOLUME_EXTENSION   Extension
    )

{
    if (!Extension->Signature) {
        Extension->Signature = FtpQueryDiskSignature(Extension->WholeDiskPdo);
    }

    return Extension->Signature;

}

BOOLEAN
FtpQueryUniqueIdBuffer(
    IN  PVOLUME_EXTENSION   Extension,
    OUT PUCHAR              UniqueId,
    OUT PUSHORT             UniqueIdLength
    )

{
    GUID                uniqueGuid;
    ULONG               signature;
    NTSTATUS            status;
    LONGLONG            offset;
    FT_LOGICAL_DISK_ID  diskId;

    if (Extension->IsGpt) {
        *UniqueIdLength = sizeof(GUID) + 8;
    } else if (Extension->TargetObject) {
        *UniqueIdLength = sizeof(ULONG) + sizeof(LONGLONG);
    } else if (Extension->FtVolume) {
        *UniqueIdLength = sizeof(FT_LOGICAL_DISK_ID);
    } else {
        return FALSE;
    }

    if (!UniqueId) {
        return TRUE;
    }

    if (Extension->IsGpt) {

        RtlCopyMemory(UniqueId, "DMIO:ID:", 8);
        RtlCopyMemory(UniqueId + 8, &Extension->UniqueIdGuid, sizeof(GUID));

    } else if (Extension->TargetObject) {

        ASSERT(Extension->WholeDiskPdo);

        signature = FtpQueryDiskSignatureCache(Extension);
        if (!signature) {
            return FALSE;
        }

        status = FtpQueryPartitionInformation(Extension->Root,
                                              Extension->TargetObject,
                                              NULL, &offset, NULL, NULL, NULL,
                                              NULL, NULL, NULL, NULL);

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

        RtlCopyMemory(UniqueId, &signature, sizeof(signature));
        RtlCopyMemory(UniqueId + sizeof(signature), &offset, sizeof(offset));

    } else {
        diskId = Extension->FtVolume->QueryLogicalDiskId();
        RtlCopyMemory(UniqueId, &diskId, sizeof(diskId));
    }

    return TRUE;
}

UCHAR
FtpQueryMountLetter(
    IN  PVOLUME_EXTENSION   Extension
    )

/*++

Routine Description:

    This routine queries the drive letter from the mount point manager.

Arguments:

    Extension   - Supplies the volume extension.

    Delete      - Supplies whether or not to delete the drive letter.

Return Value:

    A mount point drive letter or 0.

--*/

{
    USHORT                  uniqueIdLength;
    ULONG                   mountPointSize;
    PMOUNTMGR_MOUNT_POINT   mountPoint;
    UNICODE_STRING          name;
    NTSTATUS                status;
    PFILE_OBJECT            fileObject;
    PDEVICE_OBJECT          deviceObject;
    KEVENT                  event;
    PIRP                    irp;
    MOUNTMGR_MOUNT_POINTS   points;
    IO_STATUS_BLOCK         ioStatus;
    ULONG                   mountPointsSize;
    PMOUNTMGR_MOUNT_POINTS  mountPoints;
    BOOLEAN                 freeMountPoints;
    UNICODE_STRING          dosDevices;
    UCHAR                   driveLetter;
    ULONG                   i;
    UNICODE_STRING          subString;
    WCHAR                   c;

    if (!FtpQueryUniqueIdBuffer(Extension, NULL, &uniqueIdLength)) {
        return 0;
    }

    mountPointSize = sizeof(MOUNTMGR_MOUNT_POINT) + uniqueIdLength;
    mountPoint = (PMOUNTMGR_MOUNT_POINT)
                 ExAllocatePool(PagedPool, mountPointSize);
    if (!mountPoint) {
        return 0;
    }

    if (!FtpQueryUniqueIdBuffer(Extension, (PUCHAR) (mountPoint + 1),
                                &uniqueIdLength)) {

        ExFreePool(mountPoint);
        return 0;
    }

    RtlZeroMemory(mountPoint, sizeof(MOUNTMGR_MOUNT_POINT));
    mountPoint->UniqueIdOffset = (USHORT) sizeof(MOUNTMGR_MOUNT_POINT);
    mountPoint->UniqueIdLength = uniqueIdLength;

    RtlInitUnicodeString(&name, MOUNTMGR_DEVICE_NAME);
    status = IoGetDeviceObjectPointer(&name, FILE_READ_ATTRIBUTES, &fileObject,
                                      &deviceObject);
    if (!NT_SUCCESS(status)) {
        ExFreePool(mountPoint);
        return 0;
    }

    KeInitializeEvent(&event, NotificationEvent, FALSE);
    irp = IoBuildDeviceIoControlRequest(IOCTL_MOUNTMGR_QUERY_POINTS,
                                        deviceObject, mountPoint,
                                        mountPointSize, &points,
                                        sizeof(points), FALSE, &event,
                                        &ioStatus);
    if (!irp) {
        ObDereferenceObject(fileObject);
        ExFreePool(mountPoint);
        return 0;
    }

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

    if (status == STATUS_BUFFER_OVERFLOW) {

        mountPointsSize = points.Size;
        mountPoints = (PMOUNTMGR_MOUNT_POINTS)
                      ExAllocatePool(PagedPool, mountPointsSize);
        if (!mountPoints) {
            ObDereferenceObject(fileObject);
            ExFreePool(mountPoint);
            return 0;
        }

        KeInitializeEvent(&event, NotificationEvent, FALSE);
        irp = IoBuildDeviceIoControlRequest(IOCTL_MOUNTMGR_QUERY_POINTS,
                                            deviceObject, mountPoint,
                                            mountPointSize, mountPoints,
                                            mountPointsSize, FALSE, &event,
                                            &ioStatus);
        if (!irp) {
            ExFreePool(mountPoints);
            ObDereferenceObject(fileObject);
            ExFreePool(mountPoint);
            return 0;
        }

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

        freeMountPoints = TRUE;

    } else {
        mountPoints = &points;
        freeMountPoints = FALSE;
    }

    ExFreePool(mountPoint);
    ObDereferenceObject(fileObject);

    if (!NT_SUCCESS(status)) {
        if (freeMountPoints) {
            ExFreePool(mountPoints);
        }
        return 0;
    }

    RtlInitUnicodeString(&dosDevices, L"\\DosDevices\\");

    driveLetter = 0;
    for (i = 0; i < mountPoints->NumberOfMountPoints; i++) {

        if (mountPoints->MountPoints[i].SymbolicLinkNameLength !=
            dosDevices.Length + 2*sizeof(WCHAR)) {

            continue;
        }

        subString.Length = subString.MaximumLength = dosDevices.Length;
        subString.Buffer = (PWSTR) ((PCHAR) mountPoints +
                mountPoints->MountPoints[i].SymbolicLinkNameOffset);

        if (RtlCompareUnicodeString(&dosDevices, &subString, TRUE)) {
            continue;
        }

        c = subString.Buffer[subString.Length/sizeof(WCHAR) + 1];

        if (c != ':') {
            continue;
        }

        c = subString.Buffer[subString.Length/sizeof(WCHAR)];

        if (c < FirstDriveLetter || c > LastDriveLetter) {
            continue;
        }

        driveLetter = (UCHAR) c;
        break;
    }

    if (freeMountPoints) {
        ExFreePool(mountPoints);
    }

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

/*++

Routine Description:

    This routine is a query routine for the disk registry entry.  It allocates
    space for the disk registry and copies it to the given context.

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         - Returns the disk registry entry.

    EntryContext    - Returns the disk registry size.

Return Value:

    NTSTATUS

--*/

{
    PVOID                   p;
    PDISK_CONFIG_HEADER*    reg;
    PULONG                  size;

    p = ExAllocatePool(PagedPool, ValueLength);
    if (!p) {
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    RtlCopyMemory(p, ValueData, ValueLength);

    reg = (PDISK_CONFIG_HEADER*) Context;
    *reg = (PDISK_CONFIG_HEADER) p;

    size = (PULONG) EntryContext;
    if (size) {
        *size = ValueLength;
    }

    return STATUS_SUCCESS;
}

PDISK_PARTITION
FtpFindDiskPartition(
    IN  PDISK_REGISTRY  DiskRegistry,
    IN  ULONG           Signature,
    IN  LONGLONG        Offset
    )

{
    PDISK_DESCRIPTION   diskDescription;
    USHORT              i, j;
    PDISK_PARTITION     diskPartition;
    LONGLONG            tmp;

    diskDescription = &DiskRegistry->Disks[0];
    for (i = 0; i < DiskRegistry->NumberOfDisks; i++) {
        if (diskDescription->Signature == Signature) {
            for (j = 0; j < diskDescription->NumberOfPartitions; j++) {
                diskPartition = &diskDescription->Partitions[j];
                tmp = *((LONGLONG UNALIGNED*)
                        &diskPartition->StartingOffset.QuadPart);
                if (tmp == Offset) {
                    return diskPartition;
                }
            }
        }

        diskDescription = (PDISK_DESCRIPTION) &diskDescription->
                          Partitions[diskDescription->NumberOfPartitions];
    }

    return NULL;
}

UCHAR
FtpQueryDriveLetterFromRegistry(
    IN  PROOT_EXTENSION     RootExtension,
    IN  PVOLUME_EXTENSION   Extension,
    IN  PDEVICE_OBJECT      TargetObject,
    IN  PDEVICE_OBJECT      WholeDiskPdo,
    IN  BOOLEAN             DeleteLetter
    )

/*++

Routine Description:

    This routine queries the sticky drive letter from the old registry.

Arguments:

    RootExtension   - Supplies the root extension.

    TargetObject    - Supplies the device object for the partition.

    WholeDiskPdo    - Supplies the whole disk PDO.

    DeleteLetter    - Supplies whether or not to delete the drive letter.

Return Value:

    A sticky drive letter.
    0 to represent no drive letter.

--*/

{
    RTL_QUERY_REGISTRY_TABLE    queryTable[2];
    ULONG                       registrySize;
    NTSTATUS                    status;
    PDISK_CONFIG_HEADER         registry;
    PDISK_REGISTRY              diskRegistry;
    ULONG                       signature;
    LONGLONG                    offset;
    PDISK_PARTITION             diskPartition;
    UCHAR                       driveLetter;

    RtlZeroMemory(queryTable, 2*sizeof(RTL_QUERY_REGISTRY_TABLE));
    queryTable[0].QueryRoutine = FtpDiskRegistryQueryRoutine;
    queryTable[0].Flags = RTL_QUERY_REGISTRY_REQUIRED;
    queryTable[0].Name = L"Information";
    queryTable[0].EntryContext = &registrySize;

    status = RtlQueryRegistryValues(RTL_REGISTRY_ABSOLUTE, DISK_REGISTRY_KEY_W,
                                    queryTable, &registry, NULL);
    if (!NT_SUCCESS(status)) {
        return 0;
    }

    ObReferenceObject(TargetObject);
    ObReferenceObject(WholeDiskPdo);

    FtpRelease(RootExtension);

    diskRegistry = (PDISK_REGISTRY)
                   ((PUCHAR) registry + registry->DiskInformationOffset);

    signature = FtpQueryDiskSignatureCache(Extension);
    if (signature) {
        status = FtpQueryPartitionInformation(RootExtension, TargetObject,
                                              NULL, &offset, NULL, NULL, NULL,
                                              NULL, NULL, NULL, NULL);
    } else {
        status = STATUS_UNSUCCESSFUL;
    }

    FtpAcquire(RootExtension);
    ObDereferenceObject(WholeDiskPdo);
    ObDereferenceObject(TargetObject);
    ExFreePool(registry);

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

    RtlZeroMemory(queryTable, 2*sizeof(RTL_QUERY_REGISTRY_TABLE));
    queryTable[0].QueryRoutine = FtpDiskRegistryQueryRoutine;
    queryTable[0].Flags = RTL_QUERY_REGISTRY_REQUIRED;
    queryTable[0].Name = L"Information";
    queryTable[0].EntryContext = &registrySize;

    status = RtlQueryRegistryValues(RTL_REGISTRY_ABSOLUTE, DISK_REGISTRY_KEY_W,
                                    queryTable, &registry, NULL);
    if (!NT_SUCCESS(status)) {
        return 0;
    }

    diskRegistry = (PDISK_REGISTRY)
                   ((PUCHAR) registry + registry->DiskInformationOffset);

    diskPartition = FtpFindDiskPartition(diskRegistry, signature, offset);
    if (!diskPartition) {
        ExFreePool(registry);
        return 0;
    }

    if (diskPartition->AssignDriveLetter) {
        driveLetter = diskPartition->DriveLetter;
    } else {
        driveLetter = 0xFF;
    }

    if (DeleteLetter) {
        diskPartition->DriveLetter = 0;
        diskPartition->AssignDriveLetter = TRUE;
        RtlWriteRegistryValue(RTL_REGISTRY_ABSOLUTE, DISK_REGISTRY_KEY_W,
                              L"Information", REG_BINARY, registry,
                              registrySize);
    }

    ExFreePool(registry);

    return driveLetter;
}

UCHAR
FtpQueryDriveLetterFromRegistry(
    IN  PVOLUME_EXTENSION   Extension,
    IN  BOOLEAN             DeleteLetter
    )

/*++

Routine Description:

    This routine queries the sticky drive letter from the old registry.

Arguments:

    Extension   - Supplies the volume extension.

Return Value:

    A sticky drive letter.
    0 to represent no drive letter.

--*/

{
    if (Extension->TargetObject) {
        return FtpQueryDriveLetterFromRegistry(Extension->Root,
                                               Extension,
                                               Extension->TargetObject,
                                               Extension->WholeDiskPdo,
                                               DeleteLetter);
    }

    return 0;
}

BOOLEAN
FtpSetMountLetter(
    IN  PVOLUME_EXTENSION   Extension,
    IN  UCHAR               DriveLetter
    )

/*++

Routine Description:

    This routine sets a drive letter to the given device in the mount table.

Arguments:

    Extension   - Supplies the volume extension.

    DriveLetter - Supplies the drive letter.

Return Value:

    FALSE   - Failure.

    TRUE    - Success.

--*/

{
    WCHAR                           dosBuffer[30];
    UNICODE_STRING                  dosName;
    WCHAR                           ntBuffer[40];
    UNICODE_STRING                  ntName;
    ULONG                           createPointSize;
    PMOUNTMGR_CREATE_POINT_INPUT    createPoint;
    UNICODE_STRING                  name;
    NTSTATUS                        status;
    PFILE_OBJECT                    fileObject;
    PDEVICE_OBJECT                  deviceObject;
    KEVENT                          event;
    PIRP                            irp;
    IO_STATUS_BLOCK                 ioStatus;

    swprintf(dosBuffer, L"\\DosDevices\\%c:", DriveLetter);
    RtlInitUnicodeString(&dosName, dosBuffer);

    swprintf(ntBuffer, L"\\Device\\HarddiskVolume%d", Extension->VolumeNumber);
    RtlInitUnicodeString(&ntName, ntBuffer);

    createPointSize = sizeof(MOUNTMGR_CREATE_POINT_INPUT) +
                      dosName.Length + ntName.Length;

    createPoint = (PMOUNTMGR_CREATE_POINT_INPUT)
                  ExAllocatePool(PagedPool, createPointSize);
    if (!createPoint) {
        return FALSE;
    }

    createPoint->SymbolicLinkNameOffset = sizeof(MOUNTMGR_CREATE_POINT_INPUT);
    createPoint->SymbolicLinkNameLength = dosName.Length;
    createPoint->DeviceNameOffset = createPoint->SymbolicLinkNameOffset +
                                    createPoint->SymbolicLinkNameLength;
    createPoint->DeviceNameLength = ntName.Length;

    RtlCopyMemory((PCHAR) createPoint + createPoint->SymbolicLinkNameOffset,
                  dosName.Buffer, dosName.Length);
    RtlCopyMemory((PCHAR) createPoint + createPoint->DeviceNameOffset,
                  ntName.Buffer, ntName.Length);

    RtlInitUnicodeString(&name, MOUNTMGR_DEVICE_NAME);
    status = IoGetDeviceObjectPointer(&name, FILE_READ_ATTRIBUTES, &fileObject,
                                      &deviceObject);
    if (!NT_SUCCESS(status)) {
        ExFreePool(createPoint);
        return 0;
    }

    KeInitializeEvent(&event, NotificationEvent, FALSE);
    irp = IoBuildDeviceIoControlRequest(IOCTL_MOUNTMGR_CREATE_POINT,
                                        deviceObject, createPoint,
                                        createPointSize, NULL, 0, FALSE,
                                        &event, &ioStatus);
    if (!irp) {
        ObDereferenceObject(fileObject);
        ExFreePool(createPoint);
        return FALSE;
    }

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

    ObDereferenceObject(fileObject);
    ExFreePool(createPoint);

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

    return TRUE;
}

VOID
FtpCreateOldNameLinks(
    IN  PVOLUME_EXTENSION   Extension
    )

/*++

Routine Description:

    This routine creates a \Device\Harddisk%d\Partition%d name for the
    given target device for legacy devices.  If successful, it stores the
    name in the device extension.

Arguments:

    Extension   - Supplies the volume extension.

Return Value:

    None.

--*/

{
    WCHAR           deviceNameBuffer[64];
    UNICODE_STRING  deviceName;
    NTSTATUS        status;
    ULONG           diskNumber, partitionNumber, i;
    WCHAR           oldNameBuffer[80];
    UNICODE_STRING  oldName;

    swprintf(deviceNameBuffer, L"\\Device\\HarddiskVolume%d", Extension->VolumeNumber);
    RtlInitUnicodeString(&deviceName, deviceNameBuffer);

    if (Extension->TargetObject) {

        status = FtpQueryPartitionInformation(Extension->Root,
                                              Extension->TargetObject,
                                              &diskNumber, NULL,
                                              &partitionNumber, NULL, NULL,
                                              NULL, NULL, NULL, NULL);
        if (!NT_SUCCESS(status)) {
            return;
        }

        swprintf(oldNameBuffer, L"\\Device\\Harddisk%d\\Partition%d",
                 diskNumber, partitionNumber);
        RtlInitUnicodeString(&oldName, oldNameBuffer);

        IoDeleteSymbolicLink(&oldName);
        for (i = 0; i < 1000; i++) {
            status = IoCreateSymbolicLink(&oldName, &deviceName);
            if (NT_SUCCESS(status)) {
                break;
            }
        }

    } else {
        Extension->FtVolume->CreateLegacyNameLinks(&deviceName);
    }
}

NTSTATUS
FtpQuerySuperFloppyDevnodeName(
    IN  PVOLUME_EXTENSION   Extension,
    OUT PWCHAR*             DevnodeName
    )

{
    NTSTATUS        status;
    UNICODE_STRING  string;
    PWCHAR          result;
    ULONG           n, i;
    WCHAR           c;

    status = IoRegisterDeviceInterface(Extension->WholeDiskPdo, &DiskClassGuid,
                                       NULL, &string);
    if (!NT_SUCCESS(status)) {
        return status;
    }

    result = (PWCHAR) ExAllocatePool(PagedPool, string.Length + sizeof(WCHAR));
    if (!result) {
        ExFreePool(string.Buffer);
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    n = string.Length/sizeof(WCHAR);
    for (i = 0; i < n; i++) {
        c = string.Buffer[i];
        if (c <= ' ' || c >= 0x80 || c == ',' || c == '\\') {
            c = '_';
        }
        result[i] = c;
    }
    result[n] = 0;
    ExFreePool(string.Buffer);

    *DevnodeName = result;

    return STATUS_SUCCESS;
}

BOOLEAN
FtpCreateNewDevice(
    IN  PROOT_EXTENSION     RootExtension,
    IN  PDEVICE_OBJECT      TargetObject,
    IN  PFT_VOLUME          FtVolume,
    IN  PDEVICE_OBJECT      WholeDiskPdo,
    IN  ULONG               AlignmentRequirement,
    IN  BOOLEAN             IsPreExposure,
    IN  BOOLEAN             IsHidden,
    IN  BOOLEAN             IsReadOnly,
    IN  BOOLEAN             IsEspType,
    IN  ULONGLONG           MbrGptAttributes
    )

/*++

Routine Description:

    This routine creates a new device object with the next available
    device name using the given target object of ft volume.

Arguments:

    RootExtension   - Supplies the root extension.

    TargetObject    - Supplies the partition.

    FtVolume        - Supplies the FT volume.

    WholeDiskPdo    - Supplies the whole disk PDO.

Return Value:

    FALSE   - Failure.

    TRUE    - Success.

--*/

{
    WCHAR               volumeName[30];
    UNICODE_STRING      volumeString;
    NTSTATUS            status;
    PDEVICE_OBJECT      deviceObject;
    PVOLUME_EXTENSION   extension, e;
    PWCHAR              buf;
    ULONG               signature;
    LONGLONG            offset, size;
    PLIST_ENTRY         l;
    LONG                r;
    GUID                uniqueGuid;
    UNICODE_STRING      guidString;
    BOOLEAN             IsGpt;

    ASSERT(TargetObject || FtVolume);
    ASSERT(!(TargetObject && FtVolume));
    ASSERT(!TargetObject || WholeDiskPdo);

    swprintf(volumeName, L"\\Device\\HarddiskVolume%d",
             RootExtension->NextVolumeNumber);
    RtlInitUnicodeString(&volumeString, volumeName);

    status = IoCreateDevice(RootExtension->DriverObject,
                            sizeof(VOLUME_EXTENSION),
                            &volumeString, FILE_DEVICE_DISK, 0,
                            FALSE, &deviceObject);
    if (!NT_SUCCESS(status)) {
        return FALSE;
    }

    extension = (PVOLUME_EXTENSION) deviceObject->DeviceExtension;
    RtlZeroMemory(extension, sizeof(VOLUME_EXTENSION));
    extension->DeviceObject = deviceObject;
    extension->Root = RootExtension;
    extension->DeviceExtensionType = DEVICE_EXTENSION_VOLUME;
    KeInitializeSpinLock(&extension->SpinLock);
    extension->TargetObject = TargetObject;
    extension->FtVolume = FtVolume;
    extension->RefCount = 1;
    InitializeListHead(&extension->ZeroRefHoldQueue);
    extension->IsStarted = FALSE;
    extension->IsOffline = TRUE;
    extension->IsHidden = IsHidden;
    extension->IsReadOnly = IsReadOnly;
    extension->IsEspType = IsEspType;
    extension->VolumeNumber = RootExtension->NextVolumeNumber++;
    extension->EmergencyTransferPacket = new DISPATCH_TP;
    InitializeListHead(&extension->EmergencyTransferPacketQueue);
    extension->MbrGptAttributes = MbrGptAttributes;

    if (!extension->EmergencyTransferPacket) {
        IoDeleteDevice(deviceObject);
        return FALSE;
    }

    InitializeListHead(&extension->ChangeNotifyIrps);

    buf = (PWCHAR) ExAllocatePool(PagedPool, 80*sizeof(WCHAR));
    if (!buf) {
        delete extension->EmergencyTransferPacket;
        IoDeleteDevice(deviceObject);
        return FALSE;
    }

    if (TargetObject) {

        extension->WholeDiskPdo = WholeDiskPdo;
        extension->WholeDisk = IoGetAttachedDeviceReference(WholeDiskPdo);
        ObDereferenceObject(extension->WholeDisk);

        status = FtpQueryPartitionInformation(RootExtension, TargetObject,
                                              NULL, &offset, NULL, NULL,
                                              &size, NULL, &uniqueGuid,
                                              &IsGpt, NULL);
        if (!NT_SUCCESS(status)) {
            delete extension->EmergencyTransferPacket;
            IoDeleteDevice(deviceObject);
            return FALSE;
        }

        extension->PartitionOffset = offset;
        extension->PartitionLength = size;

        if (IsGpt) {
            extension->IsGpt = TRUE;
            extension->UniqueIdGuid = uniqueGuid;

            if (IsEspType &&
                IsEqualGUID(uniqueGuid,
                            RootExtension->ESPUniquePartitionGUID)) {

                IoSetSystemPartition(&volumeString);
            }

            status = RtlStringFromGUID(uniqueGuid, &guidString);
            if (!NT_SUCCESS(status)) {
                delete extension->EmergencyTransferPacket;
                IoDeleteDevice(deviceObject);
                return FALSE;
            }

            swprintf(buf, L"GptPartition%s", guidString.Buffer);
            ExFreePool(guidString.Buffer);

        } else if (offset == 0) {

            extension->IsSuperFloppy = TRUE;
            ExFreePool(buf);

            status = FtpQuerySuperFloppyDevnodeName(extension, &buf);
            if (!NT_SUCCESS(status)) {
                delete extension->EmergencyTransferPacket;
                IoDeleteDevice(deviceObject);
                return FALSE;
            }

        } else {

            signature = FtpQueryDiskSignatureCache(extension);
            if (!signature) {
                delete extension->EmergencyTransferPacket;
                IoDeleteDevice(deviceObject);
                return FALSE;
            }

            swprintf(buf, L"Signature%XOffset%I64XLength%I64X", signature,
                     offset, size);
        }

    } else {
        swprintf(buf, L"Ft%I64X", FtVolume->QueryLogicalDiskId());
    }

    RtlInitUnicodeString(&extension->DeviceNodeName, buf);
    KeInitializeSemaphore(&extension->Semaphore, 1, 1);
    InsertTailList(&RootExtension->VolumeList, &extension->ListEntry);

    deviceObject->Flags |= DO_DIRECT_IO;
    deviceObject->AlignmentRequirement = AlignmentRequirement;
    if (FtVolume) {
        deviceObject->StackSize = FtVolume->QueryStackSize() + 1;
    } else {
        deviceObject->StackSize = TargetObject->StackSize + 1;
    }

    if (IsPreExposure) {
        extension->TargetObject = NULL;
        extension->FtVolume = NULL;
        extension->IsPreExposure = TRUE;
        extension->WholeDiskPdo = NULL;
        extension->WholeDisk = NULL;
        extension->PartitionOffset = 0;
        extension->PartitionLength = 0;

        r = 1;
        for (l = RootExtension->VolumeList.Flink;
             l != &RootExtension->VolumeList; l = l->Flink) {

            e = CONTAINING_RECORD(l, VOLUME_EXTENSION, ListEntry);
            if (e == extension) {
                continue;
            }
            r = RtlCompareUnicodeString(&e->DeviceNodeName,
                                        &extension->DeviceNodeName, TRUE);
            if (!r) {
                break;
            }
        }

        if (!r) {
            RemoveEntryList(&extension->ListEntry);
            ExFreePool(extension->DeviceNodeName.Buffer);
            delete extension->EmergencyTransferPacket;
            IoDeleteDevice(deviceObject);
            return FALSE;
        }

        RootExtension->PreExposureCount++;

    } else {
        FtpCreateOldNameLinks(extension);
    }

    if (!IsPreExposure && RootExtension->PreExposureCount) {
        r = 1;
        for (l = RootExtension->VolumeList.Flink;
             l != &RootExtension->VolumeList; l = l->Flink) {

            e = CONTAINING_RECORD(l, VOLUME_EXTENSION, ListEntry);
            if (e == extension) {
                continue;
            }
            if (!e->IsPreExposure) {
                continue;
            }

            r = RtlCompareUnicodeString(&e->DeviceNodeName,
                                        &extension->DeviceNodeName, TRUE);
            if (!r) {
                break;
            }
        }

        if (!r) {
            RootExtension->PreExposureCount--;
            RemoveEntryList(&e->ListEntry);
            InsertTailList(&RootExtension->DeadVolumeList, &e->ListEntry);
            FtpCleanupVolumeExtension(e);
        }
    }

    // Allocate WMI library context

    extension->WmilibContext = (PWMILIB_CONTEXT)
        ExAllocatePool(PagedPool, sizeof(WMILIB_CONTEXT));
    if (extension->WmilibContext != NULL) {
        RtlZeroMemory(extension->WmilibContext, sizeof(WMILIB_CONTEXT));
        extension->WmilibContext->GuidCount          = DiskperfGuidCount;
        extension->WmilibContext->GuidList           = DiskperfGuidList;
        extension->WmilibContext->QueryWmiRegInfo    = FtQueryWmiRegInfo;
        extension->WmilibContext->QueryWmiDataBlock  = FtQueryWmiDataBlock;
        extension->WmilibContext->WmiFunctionControl = FtWmiFunctionControl;
    }

    deviceObject->Flags &= ~DO_DEVICE_INITIALIZING;

    return TRUE;
}

PVOLUME_EXTENSION
FtpFindExtension(
    IN  PROOT_EXTENSION     RootExtension,
    IN  ULONG               Signature,
    IN  LONGLONG            Offset
    )

/*++

Routine Description:

    This routine finds the device extension for the given partition.

Arguments:

    RootExtension   - Supplies the root device extension.

    Signature       - Supplies the partition's disk signature.

    Offset          - Supplies the partition's offset.

Return Value:

    A volume extension or NULL.

--*/

{
    PLIST_ENTRY         l;
    PVOLUME_EXTENSION   extension;
    ULONG               signature;
    NTSTATUS            status;
    LONGLONG            offset;

    for (l = RootExtension->VolumeList.Flink; l != &RootExtension->VolumeList;
         l = l->Flink) {

        extension = CONTAINING_RECORD(l, VOLUME_EXTENSION, ListEntry);
        if (!extension->TargetObject) {
            continue;
        }

        signature = FtpQueryDiskSignatureCache(extension);
        if (Signature != signature) {
            continue;
        }

        status = FtpQueryPartitionInformation(RootExtension,
                                              extension->TargetObject,
                                              NULL, &offset, NULL, NULL, NULL,
                                              NULL, NULL, NULL, NULL);
        if (!NT_SUCCESS(status)) {
            continue;
        }

        if (offset != Offset) {
            continue;
        }

        return extension;
    }

    return NULL;
}

BOOLEAN
FtpQueryNtDeviceNameString(
    IN  PROOT_EXTENSION     RootExtension,
    IN  ULONG               Signature,
    IN  LONGLONG            Offset,
    OUT PUNICODE_STRING     String
    )

{
    PVOLUME_EXTENSION   extension;
    PWSTR               stringBuffer;

    extension = FtpFindExtension(RootExtension, Signature, Offset);
    if (!extension) {
        return FALSE;
    }

    stringBuffer = (PWSTR) ExAllocatePool(PagedPool, 128);
    if (!stringBuffer) {
        return FALSE;
    }

    swprintf(stringBuffer, L"\\Device\\HarddiskVolume%d", extension->VolumeNumber);
    RtlInitUnicodeString(String, stringBuffer);

    return TRUE;
}

BOOLEAN
FtpQueryNtDeviceNameString(
    IN  PROOT_EXTENSION     RootExtension,
    IN  FT_LOGICAL_DISK_ID  RootLogicalDiskId,
    OUT PUNICODE_STRING     String
    )

{
    PVOLUME_EXTENSION   extension;
    PWSTR               stringBuffer;

    extension = FtpFindExtension(RootExtension, RootLogicalDiskId);
    if (!extension) {
        return FALSE;
    }

    stringBuffer = (PWSTR) ExAllocatePool(PagedPool, 128);
    if (!stringBuffer) {
        return FALSE;
    }

    swprintf(stringBuffer, L"\\Device\\HarddiskVolume%d", extension->VolumeNumber);
    RtlInitUnicodeString(String, stringBuffer);

    return TRUE;
}

BOOLEAN
FtpLockLogicalDisk(
    IN  PROOT_EXTENSION     RootExtension,
    IN  FT_LOGICAL_DISK_ID  LogicalDiskId,
    OUT PHANDLE             Handle
    )

/*++

Routine Description:

    This routine attempts to lock the given logical disk id by going through
    the file system.  If it is successful then it returns the handle to the
    locked volume.

Arguments:

    RootExtension   - Supplies the root extension.

    LogicalDiskId   - Supplies the logical disk id.

    Handle          - Returns a handle to the locked volume.

Return Value:

    FALSE   - Failure.

    TRUE    - Success.

--*/

{
    UNICODE_STRING      string;
    OBJECT_ATTRIBUTES   oa;
    NTSTATUS            status;
    IO_STATUS_BLOCK     ioStatus;

    if (!FtpQueryNtDeviceNameString(RootExtension, LogicalDiskId, &string)) {
        return FALSE;
    }

    FtpRelease(RootExtension);

    InitializeObjectAttributes(&oa, &string, OBJ_CASE_INSENSITIVE |
                               OBJ_KERNEL_HANDLE, 0, 0);

    status = ZwOpenFile(Handle, SYNCHRONIZE | FILE_READ_DATA | FILE_WRITE_DATA,
                        &oa, &ioStatus, FILE_SHARE_READ | FILE_SHARE_WRITE,
                        FILE_SYNCHRONOUS_IO_ALERT);

    ExFreePool(string.Buffer);

    if (!NT_SUCCESS(status)) {
        FtpAcquire(RootExtension);
        return FALSE;
    }

    status = ZwFsControlFile(*Handle, 0, NULL, NULL, &ioStatus,
                             FSCTL_LOCK_VOLUME, NULL, 0, NULL, 0);

    if (!NT_SUCCESS(status)) {
        ZwClose(*Handle);
        FtpAcquire(RootExtension);
        return FALSE;
    }

    FtpAcquire(RootExtension);

    return TRUE;
}

VOID
FtpUniqueIdNotify(
    IN  PVOLUME_EXTENSION   Extension,
    IN  PMOUNTDEV_UNIQUE_ID NewUniqueId
    )

/*++

Routine Description:

    This routine goes through all of the mount manager clients that
    have registered to be aware of unique id changes to devices.

Arguments:

    Extension   - Supplies the volume extension.

    NewUniqueId - Supplies the new unique id.

Return Value:

    None.

--*/

{
    PMOUNTDEV_UNIQUE_ID                         oldUniqueId;
    UCHAR                                       oldUniqueIdBuffer[UNIQUE_ID_MAX_BUFFER_SIZE];
    PLIST_ENTRY                                 l;
    PIRP                                        irp;
    PIO_STACK_LOCATION                          irpSp;
    PMOUNTDEV_UNIQUE_ID                         input;
    ULONG                                       inputLength, outputLength;
    PMOUNTDEV_UNIQUE_ID_CHANGE_NOTIFY_OUTPUT    output;

    oldUniqueId = (PMOUNTDEV_UNIQUE_ID) oldUniqueIdBuffer;

    while (!IsListEmpty(&Extension->ChangeNotifyIrps)) {

        l = RemoveHeadList(&Extension->ChangeNotifyIrps);

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

        //
        // Remove cancel routine. If cancel is active let it complete this IRP.
        //
        if (IoSetCancelRoutine (irp, NULL) == NULL) {
            InitializeListHead (&irp->Tail.Overlay.ListEntry);
            continue;
        }

        irpSp = IoGetCurrentIrpStackLocation(irp);
        input = (PMOUNTDEV_UNIQUE_ID) irp->AssociatedIrp.SystemBuffer;

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

            irp->IoStatus.Status = STATUS_INVALID_PARAMETER;
            irp->IoStatus.Information = 0;
            IoCompleteRequest(irp, IO_NO_INCREMENT);
            continue;
        }

        inputLength = FIELD_OFFSET(MOUNTDEV_UNIQUE_ID, UniqueId) +
                      input->UniqueIdLength;

        if (inputLength >
            irpSp->Parameters.DeviceIoControl.InputBufferLength) {

            irp->IoStatus.Status = STATUS_INVALID_PARAMETER;
            irp->IoStatus.Information = 0;
            IoCompleteRequest(irp, IO_NO_INCREMENT);
            continue;
        }

        if (inputLength > 20) {
            irp->IoStatus.Status = STATUS_INVALID_PARAMETER;
            irp->IoStatus.Information = 0;
            IoCompleteRequest(irp, IO_NO_INCREMENT);
            continue;
        }

        RtlCopyMemory(oldUniqueId, input, inputLength);

        outputLength = sizeof(MOUNTDEV_UNIQUE_ID_CHANGE_NOTIFY_OUTPUT) +
                       oldUniqueId->UniqueIdLength +
                       NewUniqueId->UniqueIdLength;

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

            irp->IoStatus.Status = STATUS_INVALID_PARAMETER;
            irp->IoStatus.Information = 0;
            IoCompleteRequest(irp, IO_NO_INCREMENT);
            continue;
        }

        output = (PMOUNTDEV_UNIQUE_ID_CHANGE_NOTIFY_OUTPUT)
                 irp->AssociatedIrp.SystemBuffer;
        output->Size = outputLength;

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

            irp->IoStatus.Status = STATUS_BUFFER_OVERFLOW;
            irp->IoStatus.Information =
                    sizeof(MOUNTDEV_UNIQUE_ID_CHANGE_NOTIFY_OUTPUT);
            IoCompleteRequest(irp, IO_NO_INCREMENT);
            continue;
        }

        output->OldUniqueIdOffset =
                sizeof(MOUNTDEV_UNIQUE_ID_CHANGE_NOTIFY_OUTPUT);
        output->OldUniqueIdLength = oldUniqueId->UniqueIdLength;
        output->NewUniqueIdOffset = output->OldUniqueIdOffset +
                                    output->OldUniqueIdLength;
        output->NewUniqueIdLength = NewUniqueId->UniqueIdLength;

        RtlCopyMemory((PCHAR) output + output->OldUniqueIdOffset,
                      oldUniqueId->UniqueId, output->OldUniqueIdLength);
        RtlCopyMemory((PCHAR) output + output->NewUniqueIdOffset,
                      NewUniqueId->UniqueId, output->NewUniqueIdLength);

        irp->IoStatus.Status = STATUS_SUCCESS;
        irp->IoStatus.Information = output->Size;

        IoCompleteRequest(irp, IO_NO_INCREMENT);
    }

    // Perform a pre-exposure of the new devnode to avoid the PNP reboot
    // pop-up.

    if (FtpCreateNewDevice(Extension->Root, Extension->TargetObject,
                           Extension->FtVolume, Extension->WholeDiskPdo,
                           Extension->DeviceObject->AlignmentRequirement,
                           TRUE, TRUE, FALSE, FALSE, 0)) {

        IoInvalidateDeviceRelations(Extension->Root->Pdo, BusRelations);
    }
}

NTSTATUS
FtpDeleteMountPoints(
    IN  PVOLUME_EXTENSION   Extension
    )

/*++

Routine Description:

    This routine deletes the all of the entries in the mount table that
    are pointing to the given unique id.

Arguments:

    Extension   - Supplies the volume extension.

Return Value:

    NTSTATUS

--*/

{
    UNICODE_STRING          name;
    NTSTATUS                status;
    PFILE_OBJECT            fileObject;
    PDEVICE_OBJECT          deviceObject;
    WCHAR                   deviceNameBuffer[30];
    UNICODE_STRING          deviceName;
    PMOUNTMGR_MOUNT_POINT   point;
    UCHAR                   buffer[sizeof(MOUNTMGR_MOUNT_POINT) + 60];
    PVOID                   mountPoints;
    KEVENT                  event;
    PIRP                    irp;
    IO_STATUS_BLOCK         ioStatus;

    RtlInitUnicodeString(&name, MOUNTMGR_DEVICE_NAME);
    status = IoGetDeviceObjectPointer(&name, FILE_READ_ATTRIBUTES, &fileObject,
                                      &deviceObject);
    if (!NT_SUCCESS(status)) {
        return status;
    }

    swprintf(deviceNameBuffer, L"\\Device\\HarddiskVolume%d", Extension->VolumeNumber);
    RtlInitUnicodeString(&deviceName, deviceNameBuffer);

    point = (PMOUNTMGR_MOUNT_POINT) buffer;
    RtlZeroMemory(point, sizeof(MOUNTMGR_MOUNT_POINT));
    point->DeviceNameOffset = sizeof(MOUNTMGR_MOUNT_POINT);
    point->DeviceNameLength = deviceName.Length;
    RtlCopyMemory((PCHAR) point + point->DeviceNameOffset, deviceName.Buffer,
                  point->DeviceNameLength);

    mountPoints = ExAllocatePool(PagedPool, PAGE_SIZE);
    if (!mountPoints) {
        ObDereferenceObject(fileObject);
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    KeInitializeEvent(&event, NotificationEvent, FALSE);
    irp = IoBuildDeviceIoControlRequest(IOCTL_MOUNTMGR_DELETE_POINTS,
                                        deviceObject, point,
                                        sizeof(MOUNTMGR_MOUNT_POINT) +
                                        point->DeviceNameLength, mountPoints,
                                        PAGE_SIZE, FALSE, &event, &ioStatus);
    if (!irp) {
        ExFreePool(mountPoints);
        ObDereferenceObject(fileObject);
        return STATUS_INSUFFICIENT_RESOURCES;
    }

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

    ExFreePool(mountPoints);
    ObDereferenceObject(fileObject);

    return status;
}

VOID
FtpCleanupVolumeExtension(
    IN OUT  PVOLUME_EXTENSION   Extension
    )

{
    PLIST_ENTRY              l;
    PIRP                     irp;
    PPMWMICOUNTERLIB_CONTEXT counterLib;

    if (Extension->EmergencyTransferPacket) {
        delete Extension->EmergencyTransferPacket;
        Extension->EmergencyTransferPacket = NULL;
    }

    if (Extension->OfflineOwner) {
        ExFreePool(Extension->OfflineOwner);
        Extension->OfflineOwner = NULL;
    }

    while (!IsListEmpty(&Extension->ChangeNotifyIrps)) {

        l = RemoveHeadList(&Extension->ChangeNotifyIrps);
        irp = CONTAINING_RECORD(l, IRP, Tail.Overlay.ListEntry);

        //
        // Remove cancel routine. If cancel is active let it complete this IRP.
        //
        if (IoSetCancelRoutine (irp, NULL) == NULL) {
            InitializeListHead (&irp->Tail.Overlay.ListEntry);
            continue;
        }

        irp->IoStatus.Status = STATUS_INVALID_PARAMETER;
        irp->IoStatus.Information = 0;
        IoCompleteRequest(irp, IO_NO_INCREMENT);
    }

    if (Extension->WmilibContext != NULL) {
        IoWMIRegistrationControl(Extension->DeviceObject,
                                 WMIREG_ACTION_DEREGISTER);
        ExFreePool(Extension->WmilibContext);
        Extension->WmilibContext = NULL;

        counterLib = &Extension->Root->PmWmiCounterLibContext;
        counterLib->PmWmiCounterDisable(&Extension->PmWmiCounterContext,
                                        TRUE, TRUE);
        Extension->CountersEnabled = FALSE;
    }
}


NTSTATUS
FtpStartSystemThread(
    IN  PROOT_EXTENSION RootExtension
    )

{
    OBJECT_ATTRIBUTES   oa;
    NTSTATUS            status;
    HANDLE              handle;

    if (!RootExtension->TerminateThread) {
        return STATUS_SUCCESS;
    }

    InterlockedExchange(&RootExtension->TerminateThread, FALSE);

    InitializeObjectAttributes(&oa, NULL, OBJ_KERNEL_HANDLE, NULL, NULL);

    status = PsCreateSystemThread(&handle, 0, &oa, 0, NULL, FtpWorkerThread,
                                  RootExtension);
    if (!NT_SUCCESS(status)) {
        return status;
    }

    status = ObReferenceObjectByHandle(handle, THREAD_ALL_ACCESS, NULL,
                                       KernelMode,
                                       &RootExtension->WorkerThread, NULL);
    ZwClose(handle);

    if (!NT_SUCCESS(status)) {
        InterlockedExchange(&RootExtension->TerminateThread, TRUE);
    }

    return status;
}

NTSTATUS
FtpCreateLogicalDisk(
    IN OUT  PROOT_EXTENSION RootExtension,
    IN OUT  PIRP            Irp
    )

/*++

Routine Description:

    This routine creates the given logical disk.

Arguments:

    RootExtension   - Supplies the root extension.

    Irp             - Supplies the I/O request packet.

Return Value:

    NTSTATUS

--*/

{
    PIO_STACK_LOCATION                  irpSp = IoGetCurrentIrpStackLocation(Irp);
    PFT_CREATE_LOGICAL_DISK_INPUT       createDisk;
    ULONG                               inputSize;
    PVOID                               configInfo;
    NTSTATUS                            status;
    FT_LOGICAL_DISK_ID                  newLogicalDiskId;
    PFT_CREATE_LOGICAL_DISK_OUTPUT      createDiskOutput;

    if (irpSp->Parameters.DeviceIoControl.InputBufferLength <
        sizeof(FT_CREATE_LOGICAL_DISK_INPUT) ||
        irpSp->Parameters.DeviceIoControl.OutputBufferLength <
        sizeof(FT_CREATE_LOGICAL_DISK_OUTPUT)) {

        return STATUS_INVALID_PARAMETER;
    }

    createDisk = (PFT_CREATE_LOGICAL_DISK_INPUT)
                 Irp->AssociatedIrp.SystemBuffer;

    inputSize = FIELD_OFFSET(FT_CREATE_LOGICAL_DISK_INPUT, MemberArray) +
                createDisk->NumberOfMembers*sizeof(FT_LOGICAL_DISK_ID) +
                createDisk->ConfigurationInformationSize;

    if (irpSp->Parameters.DeviceIoControl.InputBufferLength < inputSize) {
        return STATUS_INVALID_PARAMETER;
    }

    configInfo = &createDisk->MemberArray[createDisk->NumberOfMembers];

    if (!RootExtension->FtCodeLocked) {
        MmLockPagableCodeSection(FtpComputeParity);
        status = FtpStartSystemThread(RootExtension);
        if (!NT_SUCCESS(status)) {
            return status;
        }
        RootExtension->FtCodeLocked = TRUE;
    }

    status = FtpCreateLogicalDiskHelper(RootExtension,
                                        createDisk->LogicalDiskType,
                                        createDisk->NumberOfMembers,
                                        createDisk->MemberArray,
                                        createDisk->ConfigurationInformationSize,
                                        configInfo, 0, NULL, &newLogicalDiskId);
    if (!NT_SUCCESS(status)) {
        return status;
    }

    createDiskOutput = (PFT_CREATE_LOGICAL_DISK_OUTPUT)
                       Irp->AssociatedIrp.SystemBuffer;

    createDiskOutput->NewLogicalDiskId = newLogicalDiskId;
    Irp->IoStatus.Information = sizeof(FT_CREATE_LOGICAL_DISK_OUTPUT);

    return status;
}

VOID
FtpResetPartitionType(
    IN  PVOLUME_EXTENSION   Extension
    )

/*++

Routine Description:

    This routine resets the FT bit in the partition type.

Arguments:

    Extension   - Supplies the volume extension.

Return Value:

    None.

--*/

{
    PDEVICE_OBJECT              targetObject;
    KEVENT                      event;
    PIRP                        irp;
    PARTITION_INFORMATION       partInfo;
    IO_STATUS_BLOCK             ioStatus;
    NTSTATUS                    status;
    SET_PARTITION_INFORMATION   setPartInfo;

    targetObject = Extension->TargetObject;

    KeInitializeEvent(&event, NotificationEvent, FALSE);

    irp = IoBuildDeviceIoControlRequest(IOCTL_DISK_GET_PARTITION_INFO,
                                        targetObject, NULL, 0, &partInfo,
                                        sizeof(partInfo), FALSE, &event,
                                        &ioStatus);
    if (!irp) {
        return;
    }

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

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

    setPartInfo.PartitionType = (partInfo.PartitionType & ~(0x80));

    KeInitializeEvent(&event, NotificationEvent, FALSE);

    irp = IoBuildDeviceIoControlRequest(IOCTL_DISK_SET_PARTITION_INFO,
                                        targetObject, &setPartInfo,
                                        sizeof(setPartInfo), NULL, 0, FALSE,
                                        &event, &ioStatus);
    if (!irp) {
        return;
    }

    status = IoCallDriver(targetObject, irp);
    if (status == STATUS_PENDING) {
        KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
    }
}

NTSTATUS
FtpBreakLogicalDisk(
    IN OUT  PROOT_EXTENSION RootExtension,
    IN OUT  PIRP            Irp
    )

/*++

Routine Description:

    This routine breaks a given logical disk.

Arguments:

    RootExtension   - Supplies the root extension.

    Irp             - Supplies the I/O request packet.

Return Value:

    NTSTATUS

--*/

{
    PIO_STACK_LOCATION                      irpSp = IoGetCurrentIrpStackLocation(Irp);
    PFT_BREAK_LOGICAL_DISK_INPUT            input;
    FT_LOGICAL_DISK_ID                      diskId;
    NTSTATUS                                status;

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

        return STATUS_INVALID_PARAMETER;
    }

    input = (PFT_BREAK_LOGICAL_DISK_INPUT) Irp->AssociatedIrp.SystemBuffer;
    diskId = input->RootLogicalDiskId;

    status = FtpBreakLogicalDiskHelper(RootExtension, diskId);

    return status;
}

NTSTATUS
FtpEnumerateLogicalDisks(
    IN OUT  PROOT_EXTENSION RootExtension,
    IN OUT  PIRP            Irp
    )

/*++

Routine Description:

    This routine enumerates all of the logical disks in the system.

Arguments:

    RootExtension   - Supplies the root extension.

    Irp             - Supplies the I/O request packet.

Return Value:

    NTSTATUS

--*/

{
    PIO_STACK_LOCATION                  irpSp = IoGetCurrentIrpStackLocation(Irp);
    PFT_LOGICAL_DISK_INFORMATION_SET    diskInfoSet;
    PFT_ENUMERATE_LOGICAL_DISKS_OUTPUT  output;
    ULONG                               i;

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

        return STATUS_INVALID_PARAMETER;
    }

    diskInfoSet = RootExtension->DiskInfoSet;
    output = (PFT_ENUMERATE_LOGICAL_DISKS_OUTPUT)
             Irp->AssociatedIrp.SystemBuffer;

    output->NumberOfRootLogicalDisks =
            diskInfoSet->QueryNumberOfRootLogicalDiskIds();
    Irp->IoStatus.Information = FIELD_OFFSET(FT_ENUMERATE_LOGICAL_DISKS_OUTPUT,
                                             RootLogicalDiskIds) +
                                output->NumberOfRootLogicalDisks*
                                sizeof(FT_LOGICAL_DISK_ID);
    if (Irp->IoStatus.Information >
        irpSp->Parameters.DeviceIoControl.OutputBufferLength) {

        Irp->IoStatus.Information =
                FIELD_OFFSET(FT_ENUMERATE_LOGICAL_DISKS_OUTPUT,
                             RootLogicalDiskIds);
        return STATUS_BUFFER_OVERFLOW;
    }

    for (i = 0; i < output->NumberOfRootLogicalDisks; i++) {
        output->RootLogicalDiskIds[i] = diskInfoSet->QueryRootLogicalDiskId(i);
    }

    return STATUS_SUCCESS;
}

NTSTATUS
FtpQueryLogicalDiskInformation(
    IN OUT  PROOT_EXTENSION RootExtension,
    IN OUT  PIRP            Irp
    )

/*++

Routine Description:

    This routine returns the logical disk information.

Arguments:

    RootExtension   - Supplies the root extension.

    Irp             - Supplies the I/O request packet.

Return Value:

    NTSTATUS

--*/

{
    PIO_STACK_LOCATION                          irpSp = IoGetCurrentIrpStackLocation(Irp);
    PFT_QUERY_LOGICAL_DISK_INFORMATION_INPUT    input;
    PFT_QUERY_LOGICAL_DISK_INFORMATION_OUTPUT   output;
    FT_LOGICAL_DISK_ID                          diskId;
    PFT_LOGICAL_DISK_INFORMATION_SET            diskInfoSet;
    PVOLUME_EXTENSION                           extension;
    PFT_VOLUME                                  topVol, vol;
    PFT_LOGICAL_DISK_DESCRIPTION                diskDescription;
    PFT_PARTITION_CONFIGURATION_INFORMATION     partInfo;
    LONGLONG                                    offset;
    PDEVICE_OBJECT                              wholeDisk;
    ULONG                                       diskNumber, sectorSize;
    PDRIVE_LAYOUT_INFORMATION_EX                layout;
    NTSTATUS                                    status;
    USHORT                                      i;
    PCHAR                                       p, q;

    if (irpSp->Parameters.DeviceIoControl.InputBufferLength <
        sizeof(FT_QUERY_LOGICAL_DISK_INFORMATION_INPUT) ||
        irpSp->Parameters.DeviceIoControl.OutputBufferLength <
        sizeof(FT_QUERY_LOGICAL_DISK_INFORMATION_OUTPUT)) {

        return STATUS_INVALID_PARAMETER;
    }

    input = (PFT_QUERY_LOGICAL_DISK_INFORMATION_INPUT)
            Irp->AssociatedIrp.SystemBuffer;
    output = (PFT_QUERY_LOGICAL_DISK_INFORMATION_OUTPUT)
             Irp->AssociatedIrp.SystemBuffer;
    diskId = input->LogicalDiskId;

    diskInfoSet = RootExtension->DiskInfoSet;
    diskDescription = diskInfoSet->GetLogicalDiskDescription(diskId, 0);
    if (!diskDescription) {
        return STATUS_INVALID_PARAMETER;
    }

    output->LogicalDiskType = diskDescription->LogicalDiskType;
    output->VolumeSize = 0;

    extension = FtpFindExtensionCoveringDiskId(RootExtension, diskId);
    if (extension) {
        topVol = extension->FtVolume;
        vol = topVol->GetContainedLogicalDisk(diskId);
        output->VolumeSize = vol->QueryVolumeSize();
    }

    if (output->LogicalDiskType == FtPartition) {

        if (!diskInfoSet->QueryFtPartitionInformation(diskId, &offset,
                                                      &wholeDisk, &diskNumber,
                                                      &sectorSize, NULL)) {

            Irp->IoStatus.Information = 0;
            return STATUS_INVALID_PARAMETER;
        }

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

        output->NumberOfMembers = 0;
        output->ConfigurationInformationSize =
                sizeof(FT_PARTITION_CONFIGURATION_INFORMATION);
        output->StateInformationSize = 0;
        output->Reserved = 0;

        Irp->IoStatus.Information =
                FIELD_OFFSET(FT_QUERY_LOGICAL_DISK_INFORMATION_OUTPUT,
                             MemberArray) +
                output->ConfigurationInformationSize;

        if (irpSp->Parameters.DeviceIoControl.OutputBufferLength <
            Irp->IoStatus.Information) {

            Irp->IoStatus.Information =
                    FIELD_OFFSET(FT_QUERY_LOGICAL_DISK_INFORMATION_OUTPUT,
                                 MemberArray);
            ExFreePool(layout);
            return STATUS_BUFFER_OVERFLOW;
        }

        partInfo = (PFT_PARTITION_CONFIGURATION_INFORMATION)
                   ((PCHAR) output +
                    FIELD_OFFSET(FT_QUERY_LOGICAL_DISK_INFORMATION_OUTPUT,
                                 MemberArray));

        partInfo->Signature = layout->Mbr.Signature;
        partInfo->DiskNumber = diskNumber;
        partInfo->ByteOffset = offset;

        ExFreePool(layout);

    } else {

        output->NumberOfMembers = diskDescription->u.Other.NumberOfMembers;
        if (diskDescription->u.Other.ByteOffsetToConfigurationInformation) {
            if (diskDescription->u.Other.ByteOffsetToStateInformation) {
                output->ConfigurationInformationSize =
                        diskDescription->u.Other.ByteOffsetToStateInformation -
                        diskDescription->u.Other.ByteOffsetToConfigurationInformation;
            } else {
                output->ConfigurationInformationSize =
                        diskDescription->DiskDescriptionSize -
                        diskDescription->u.Other.ByteOffsetToConfigurationInformation;
            }
        } else {
            output->ConfigurationInformationSize = 0;
        }
        if (diskDescription->u.Other.ByteOffsetToStateInformation) {
            output->StateInformationSize =
                    diskDescription->DiskDescriptionSize -
                    diskDescription->u.Other.ByteOffsetToStateInformation;
        } else {
            output->StateInformationSize = 0;
        }
        diskDescription->Reserved = 0;

        Irp->IoStatus.Information =
                FIELD_OFFSET(FT_QUERY_LOGICAL_DISK_INFORMATION_OUTPUT,
                             MemberArray) +
                output->NumberOfMembers*sizeof(FT_LOGICAL_DISK_ID) +
                output->ConfigurationInformationSize +
                output->StateInformationSize;

        if (irpSp->Parameters.DeviceIoControl.OutputBufferLength <
            Irp->IoStatus.Information) {

            Irp->IoStatus.Information =
                    FIELD_OFFSET(FT_QUERY_LOGICAL_DISK_INFORMATION_OUTPUT,
                                 MemberArray);
            return STATUS_BUFFER_OVERFLOW;
        }

        for (i = 0; i < output->NumberOfMembers; i++) {
            output->MemberArray[i] =
                    diskInfoSet->QueryMemberLogicalDiskId(diskId, i);
        }

        if (output->ConfigurationInformationSize) {
            p = (PCHAR) &output->MemberArray[output->NumberOfMembers];
            q = (PCHAR) diskDescription +
                diskDescription->u.Other.ByteOffsetToConfigurationInformation;
            RtlCopyMemory(p, q, output->ConfigurationInformationSize);
        }

        if (output->StateInformationSize) {
            p = (PCHAR) &output->MemberArray[output->NumberOfMembers] +
                output->ConfigurationInformationSize;
            q = (PCHAR) diskDescription +
                diskDescription->u.Other.ByteOffsetToStateInformation;
            RtlCopyMemory(p, q, output->StateInformationSize);
            vol->ModifyStateForUser(p);
        }
    }

    return STATUS_SUCCESS;
}

NTSTATUS
FtpOrphanLogicalDiskMember(
    IN OUT  PROOT_EXTENSION RootExtension,
    IN OUT  PIRP            Irp
    )

/*++

Routine Description:

    This routine orphans the given logical disk member.

Arguments:

    RootExtension   - Supplies the root extension.

    Irp             - Supplies the I/O request packet.

Return Value:

    NTSTATUS

--*/

{
    PIO_STACK_LOCATION                      irpSp = IoGetCurrentIrpStackLocation(Irp);
    PFT_ORPHAN_LOGICAL_DISK_MEMBER_INPUT    input;
    FT_LOGICAL_DISK_ID                      diskId;
    USHORT                                  member;
    PVOLUME_EXTENSION                       extension;
    PFT_VOLUME                              vol;
    NTSTATUS                                status;
    KEVENT                                  event;

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

        return STATUS_INVALID_PARAMETER;
    }

    input = (PFT_ORPHAN_LOGICAL_DISK_MEMBER_INPUT)
            Irp->AssociatedIrp.SystemBuffer;
    diskId = input->LogicalDiskId;
    member = input->MemberNumberToOrphan;

    extension = FtpFindExtensionCoveringDiskId(RootExtension, diskId);
    if (!extension || !extension->FtVolume) {
        return STATUS_INVALID_PARAMETER;
    }

    vol = extension->FtVolume->GetContainedLogicalDisk(diskId);
    KeInitializeEvent(&event, NotificationEvent, FALSE);
    status = vol->OrphanMember(member, FtpEventSignalCompletion, &event);
    if (NT_SUCCESS(status)) {
        FtpRelease(RootExtension);
        KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
        FtpAcquire(RootExtension);
    }

    return status;
}

NTSTATUS
FtpQueryNtDeviceNameForLogicalDisk(
    IN OUT  PROOT_EXTENSION RootExtension,
    IN OUT  PIRP            Irp
    )

/*++

Routine Description:

    This routine returns the nt device name for the given logical partition.

Arguments:

    RootExtension   - Supplies the root extension.

    Irp             - Supplies the I/O request packet.

Return Value:

    NTSTATUS

--*/

{
    PIO_STACK_LOCATION                                  irpSp = IoGetCurrentIrpStackLocation(Irp);
    PFT_QUERY_NT_DEVICE_NAME_FOR_LOGICAL_DISK_INPUT     input;
    PFT_QUERY_NT_DEVICE_NAME_FOR_LOGICAL_DISK_OUTPUT    output;
    FT_LOGICAL_DISK_ID                                  diskId;
    UNICODE_STRING                                      targetName;

    if (irpSp->Parameters.DeviceIoControl.InputBufferLength <
        sizeof(FT_QUERY_NT_DEVICE_NAME_FOR_LOGICAL_DISK_INPUT) ||
        irpSp->Parameters.DeviceIoControl.OutputBufferLength <
        sizeof(FT_QUERY_NT_DEVICE_NAME_FOR_LOGICAL_DISK_OUTPUT)) {

        return STATUS_INVALID_PARAMETER;
    }

    input = (PFT_QUERY_NT_DEVICE_NAME_FOR_LOGICAL_DISK_INPUT)
            Irp->AssociatedIrp.SystemBuffer;
    output = (PFT_QUERY_NT_DEVICE_NAME_FOR_LOGICAL_DISK_OUTPUT)
             Irp->AssociatedIrp.SystemBuffer;

    diskId = input->RootLogicalDiskId;
    if (!FtpQueryNtDeviceNameString(RootExtension, diskId, &targetName)) {
        return STATUS_INVALID_PARAMETER;
    }

    output->NumberOfCharactersInNtDeviceName = targetName.Length/sizeof(WCHAR);

    Irp->IoStatus.Information =
            FIELD_OFFSET(FT_QUERY_NT_DEVICE_NAME_FOR_LOGICAL_DISK_OUTPUT,
                         NtDeviceName) +
            output->NumberOfCharactersInNtDeviceName*sizeof(WCHAR);

    if (Irp->IoStatus.Information >
        irpSp->Parameters.DeviceIoControl.OutputBufferLength) {

        Irp->IoStatus.Information =
            FIELD_OFFSET(FT_QUERY_NT_DEVICE_NAME_FOR_LOGICAL_DISK_OUTPUT,
                         NtDeviceName);

        ExFreePool(targetName.Buffer);
        return STATUS_BUFFER_OVERFLOW;
    }

    RtlCopyMemory(output->NtDeviceName, targetName.Buffer,
                  targetName.Length);

    ExFreePool(targetName.Buffer);

    return STATUS_SUCCESS;
}

NTSTATUS
FtpQueryDriveLetterForLogicalDisk(
    IN OUT  PROOT_EXTENSION RootExtension,
    IN OUT  PIRP            Irp
    )

/*++

Routine Description:

    This routine queries the drive letter for the given root logical disk.

Arguments:

    Extension   - Supplies the root extension.

    Irp         - Supplies the I/O request packet.

Return Value:

    NTSTATUS

--*/

{
    PIO_STACK_LOCATION                              irpSp = IoGetCurrentIrpStackLocation(Irp);
    PFT_QUERY_DRIVE_LETTER_FOR_LOGICAL_DISK_INPUT   input;
    PFT_QUERY_DRIVE_LETTER_FOR_LOGICAL_DISK_OUTPUT  output;
    PFT_LOGICAL_DISK_INFORMATION_SET                diskInfoSet;

    if (irpSp->Parameters.DeviceIoControl.InputBufferLength <
        sizeof(FT_QUERY_DRIVE_LETTER_FOR_LOGICAL_DISK_INPUT) ||
        irpSp->Parameters.DeviceIoControl.OutputBufferLength <
        sizeof(FT_QUERY_DRIVE_LETTER_FOR_LOGICAL_DISK_OUTPUT)) {

        return STATUS_INVALID_PARAMETER;
    }

    input = (PFT_QUERY_DRIVE_LETTER_FOR_LOGICAL_DISK_INPUT)
            Irp->AssociatedIrp.SystemBuffer;
    output = (PFT_QUERY_DRIVE_LETTER_FOR_LOGICAL_DISK_OUTPUT)
             Irp->AssociatedIrp.SystemBuffer;

    diskInfoSet = RootExtension->DiskInfoSet;

    output->DriveLetter = diskInfoSet->QueryDriveLetter(
                          input->RootLogicalDiskId);
    if (output->DriveLetter == 0xFF) {
        output->DriveLetter = 0;
    }

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

    return STATUS_SUCCESS;
}

NTSTATUS
FtpDeleteMountLetter(
    IN  UCHAR   DriveLetter
    )

/*++

Routine Description:

    This routine deletes the given drive letter from the mount point
    manager.

Arguments:

    DriveLetter - Supplies the drive letter.

Return Value:

    NTSTATUS

--*/

{
    UNICODE_STRING          name;
    NTSTATUS                status;
    PFILE_OBJECT            fileObject;
    PDEVICE_OBJECT          deviceObject;
    PMOUNTMGR_MOUNT_POINT   point;
    UCHAR                   buffer[sizeof(MOUNTMGR_MOUNT_POINT) + 50];
    PWSTR                   s;
    UNICODE_STRING          symName;
    PVOID                   mountPoints;
    KEVENT                  event;
    PIRP                    irp;
    IO_STATUS_BLOCK         ioStatus;

    RtlInitUnicodeString(&name, MOUNTMGR_DEVICE_NAME);
    status = IoGetDeviceObjectPointer(&name, FILE_READ_ATTRIBUTES, &fileObject,
                                      &deviceObject);
    if (!NT_SUCCESS(status)) {
        return status;
    }

    point = (PMOUNTMGR_MOUNT_POINT) buffer;
    RtlZeroMemory(point, sizeof(MOUNTMGR_MOUNT_POINT));
    s = (PWSTR) ((PCHAR) point + sizeof(MOUNTMGR_MOUNT_POINT));
    swprintf(s, L"\\DosDevices\\%c:", DriveLetter);
    RtlInitUnicodeString(&symName, s);
    point->SymbolicLinkNameOffset = sizeof(MOUNTMGR_MOUNT_POINT);
    point->SymbolicLinkNameLength = symName.Length;

    mountPoints = ExAllocatePool(PagedPool, PAGE_SIZE);
    if (!mountPoints) {
        ObDereferenceObject(fileObject);
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    KeInitializeEvent(&event, NotificationEvent, FALSE);
    irp = IoBuildDeviceIoControlRequest(IOCTL_MOUNTMGR_DELETE_POINTS,
                                        deviceObject, point,
                                        sizeof(MOUNTMGR_MOUNT_POINT) +
                                        symName.Length, mountPoints, PAGE_SIZE,
                                        FALSE, &event, &ioStatus);
    if (!irp) {
        ExFreePool(mountPoints);
        ObDereferenceObject(fileObject);
        return STATUS_INSUFFICIENT_RESOURCES;
    }

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

    ExFreePool(mountPoints);
    ObDereferenceObject(fileObject);

    return status;
}

NTSTATUS
FtpSetDriveLetterForLogicalDisk(
    IN OUT  PROOT_EXTENSION RootExtension,
    IN OUT  PIRP            Irp
    )

/*++

Routine Description:

    This routine sets the drive letter for the given root logical disk.

Arguments:

    Extension   - Supplies the root extension.

    Irp         - Supplies the I/O request packet.

Return Value:

    NTSTATUS

--*/

{
    PIO_STACK_LOCATION                          irpSp = IoGetCurrentIrpStackLocation(Irp);
    PFT_SET_DRIVE_LETTER_FOR_LOGICAL_DISK_INPUT input;
    FT_LOGICAL_DISK_ID                          diskId;
    UCHAR                                       driveLetter, currentLetter;
    PVOLUME_EXTENSION                           extension;
    PFT_LOGICAL_DISK_INFORMATION_SET            diskInfoSet;

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

        return STATUS_INVALID_PARAMETER;
    }

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

    diskId = input->RootLogicalDiskId;
    driveLetter = input->DriveLetter;
    if (driveLetter < FirstDriveLetter || driveLetter > LastDriveLetter) {
        if (driveLetter) {
            return STATUS_INVALID_PARAMETER;
        }
    }

    extension = FtpFindExtension(RootExtension, diskId);
    if (!extension) {
        return STATUS_INVALID_PARAMETER;
    }

    currentLetter = FtpQueryMountLetter(extension);
    if (currentLetter) {
        FtpDeleteMountLetter(currentLetter);
    }

    if (driveLetter && !FtpSetMountLetter(extension, driveLetter)) {
        return STATUS_INVALID_PARAMETER;
    }

    diskInfoSet = RootExtension->DiskInfoSet;
    diskInfoSet->SetDriveLetter(diskId, driveLetter);

    return STATUS_SUCCESS;
}

NTSTATUS
FtpQueryNtDeviceNameForPartition(
    IN OUT  PROOT_EXTENSION RootExtension,
    IN OUT  PIRP            Irp
    )

/*++

Routine Description:

    This routine returns the nt device name for the given partition.

Arguments:

    RootExtension   - Supplies the root extension.

    Irp             - Supplies the I/O request packet.

Return Value:

    NTSTATUS

--*/

{
    PIO_STACK_LOCATION                              irpSp = IoGetCurrentIrpStackLocation(Irp);
    PFT_QUERY_NT_DEVICE_NAME_FOR_PARTITION_INPUT    input;
    PFT_QUERY_NT_DEVICE_NAME_FOR_PARTITION_OUTPUT   output;
    UNICODE_STRING                                  targetName;

    if (irpSp->Parameters.DeviceIoControl.InputBufferLength <
        sizeof(FT_QUERY_NT_DEVICE_NAME_FOR_PARTITION_INPUT) ||
        irpSp->Parameters.DeviceIoControl.OutputBufferLength <
        sizeof(FT_QUERY_NT_DEVICE_NAME_FOR_PARTITION_OUTPUT)) {

        return STATUS_INVALID_PARAMETER;
    }

    input = (PFT_QUERY_NT_DEVICE_NAME_FOR_PARTITION_INPUT)
            Irp->AssociatedIrp.SystemBuffer;
    output = (PFT_QUERY_NT_DEVICE_NAME_FOR_PARTITION_OUTPUT)
             Irp->AssociatedIrp.SystemBuffer;

    if (!FtpQueryNtDeviceNameString(RootExtension, input->Signature,
                                    input->Offset, &targetName)) {
        return STATUS_INVALID_PARAMETER;
    }

    output->NumberOfCharactersInNtDeviceName = targetName.Length/sizeof(WCHAR);

    Irp->IoStatus.Information =
            FIELD_OFFSET(FT_QUERY_NT_DEVICE_NAME_FOR_PARTITION_OUTPUT,
                         NtDeviceName) +
            output->NumberOfCharactersInNtDeviceName*sizeof(WCHAR);

    if (Irp->IoStatus.Information >
        irpSp->Parameters.DeviceIoControl.OutputBufferLength) {

        Irp->IoStatus.Information =
            FIELD_OFFSET(FT_QUERY_NT_DEVICE_NAME_FOR_PARTITION_OUTPUT,
                         NtDeviceName);

        ExFreePool(targetName.Buffer);
        return STATUS_BUFFER_OVERFLOW;
    }

    RtlCopyMemory(output->NtDeviceName, targetName.Buffer,
                  targetName.Length);

    ExFreePool(targetName.Buffer);

    return STATUS_SUCCESS;
}

NTSTATUS
FtpStopSyncOperations(
    IN OUT  PROOT_EXTENSION RootExtension,
    IN OUT  PIRP            Irp
    )

/*++

Routine Description:

    This routine stops all sync operations on the given root logical disk.

Arguments:

    Extension   - Supplies the root extension.

    Irp         - Supplies the I/O request packet.

Return Value:

    NTSTATUS

--*/

{
    PIO_STACK_LOCATION              irpSp = IoGetCurrentIrpStackLocation(Irp);
    PFT_STOP_SYNC_OPERATIONS_INPUT  input;
    FT_LOGICAL_DISK_ID              diskId;
    PVOLUME_EXTENSION               extension;

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

        return STATUS_INVALID_PARAMETER;
    }

    input = (PFT_STOP_SYNC_OPERATIONS_INPUT) Irp->AssociatedIrp.SystemBuffer;
    diskId = input->RootLogicalDiskId;

    extension = FtpFindExtension(RootExtension, diskId);
    if (!extension || !extension->FtVolume) {
        return STATUS_INVALID_PARAMETER;
    }

    extension->FtVolume->StopSyncOperations();

    return STATUS_SUCCESS;
}

NTSTATUS
FtpQueryStableGuid(
    IN OUT  PVOLUME_EXTENSION   Extension,
    IN OUT  PIRP                Irp
    )

/*++

Routine Description:

    This routine is called to query the stable guid for this volume.

Arguments:

    Extension   - Supplies the volume extension.

    Irp         - Supplies the IO request packet.

Return Value:

    NTSTATUS

--*/

{
    PIO_STACK_LOCATION      irpSp = IoGetCurrentIrpStackLocation(Irp);
    PMOUNTDEV_STABLE_GUID   output;

    if (!Extension->IsGpt) {
        return STATUS_UNSUCCESSFUL;
    }

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

        return STATUS_INVALID_PARAMETER;
    }

    output = (PMOUNTDEV_STABLE_GUID) Irp->AssociatedIrp.SystemBuffer;
    output->StableGuid = Extension->UniqueIdGuid;
    Irp->IoStatus.Information = sizeof(MOUNTDEV_STABLE_GUID);

    return STATUS_SUCCESS;
}

NTSTATUS
FtpQueryUniqueId(
    IN OUT  PVOLUME_EXTENSION   Extension,
    IN OUT  PIRP                Irp
    )

/*++

Routine Description:

    This routine is called to query the unique id for this volume.

Arguments:

    Extension   - Supplies the volume extension.

    Irp         - Supplies the IO request packet.

Return Value:

    NTSTATUS

--*/

{
    PIO_STACK_LOCATION  irpSp = IoGetCurrentIrpStackLocation(Irp);
    PMOUNTDEV_UNIQUE_ID output;
    NTSTATUS            status;
    ULONG               diskNumber;
    LONGLONG            offset;
    FT_LOGICAL_DISK_ID  diskId;

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

        return STATUS_INVALID_PARAMETER;
    }

    output = (PMOUNTDEV_UNIQUE_ID) Irp->AssociatedIrp.SystemBuffer;

    if (Extension->IsSuperFloppy) {

        output->UniqueIdLength = Extension->DeviceNodeName.Length;

    } else {
        if (!FtpQueryUniqueIdBuffer(Extension, NULL,
                                    &output->UniqueIdLength)) {

            return STATUS_INVALID_PARAMETER;
        }
    }

    Irp->IoStatus.Information = sizeof(USHORT) + output->UniqueIdLength;

    if (Irp->IoStatus.Information >
        irpSp->Parameters.DeviceIoControl.OutputBufferLength) {

        Irp->IoStatus.Information = sizeof(MOUNTDEV_UNIQUE_ID);
        return STATUS_BUFFER_OVERFLOW;
    }

    if (Extension->IsSuperFloppy) {

        RtlCopyMemory(output->UniqueId, Extension->DeviceNodeName.Buffer,
                      output->UniqueIdLength);

    } else {
        if (!FtpQueryUniqueIdBuffer(Extension, output->UniqueId,
                                    &output->UniqueIdLength)) {

            Irp->IoStatus.Information = 0;
            return STATUS_INVALID_DEVICE_REQUEST;
        }
    }

    return STATUS_SUCCESS;
}

NTSTATUS
FtpUniqueIdChangeNotify(
    IN OUT  PVOLUME_EXTENSION   Extension,
    IN OUT  PIRP                Irp
    )

/*++

Routine Description:

    This routine is to give a notify callback routine.

Arguments:

    Extension   - Supplies the volume extension.

    Irp         - Supplies the IO request packet.

Return Value:

    NTSTATUS

--*/

{
    PIO_STACK_LOCATION  irpSp = IoGetCurrentIrpStackLocation(Irp);
    PMOUNTDEV_UNIQUE_ID input;
    ULONG               len;
    PMOUNTDEV_UNIQUE_ID currentId;
    UCHAR               idBuffer[UNIQUE_ID_MAX_BUFFER_SIZE];

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

        return STATUS_INVALID_PARAMETER;
    }

    if (!Extension->TargetObject && !Extension->FtVolume) {
        return STATUS_INVALID_PARAMETER;
    }

    if (Extension->IsSuperFloppy) {
        return STATUS_INVALID_PARAMETER;
    }

    input = (PMOUNTDEV_UNIQUE_ID) Irp->AssociatedIrp.SystemBuffer;
    len = FIELD_OFFSET(MOUNTDEV_UNIQUE_ID, UniqueId) +
          input->UniqueIdLength;

    if (irpSp->Parameters.DeviceIoControl.InputBufferLength < len) {
        return STATUS_INVALID_PARAMETER;
    }

    if (!IsListEmpty(&Extension->ChangeNotifyIrps)) {
        return STATUS_INVALID_PARAMETER;
    }

    currentId = (PMOUNTDEV_UNIQUE_ID) idBuffer;
    if (!FtpQueryUniqueIdBuffer(Extension, currentId->UniqueId,
                                &currentId->UniqueIdLength)) {

        return STATUS_INVALID_PARAMETER;
    }

    Irp->Tail.Overlay.DriverContext[0] = Extension;

    IoSetCancelRoutine (Irp, FtpCancelChangeNotify);

    if (Irp->Cancel && IoSetCancelRoutine (Irp, NULL) == NULL) {
        return STATUS_CANCELLED;
    }

    IoMarkIrpPending(Irp);

    InsertTailList(&Extension->ChangeNotifyIrps, &Irp->Tail.Overlay.ListEntry);

    if (input->UniqueIdLength != currentId->UniqueIdLength ||
        RtlCompareMemory(input->UniqueId, currentId->UniqueId,
                         input->UniqueIdLength) != input->UniqueIdLength) {

        FtpUniqueIdNotify(Extension, currentId);
    }

    return STATUS_PENDING;
}

NTSTATUS
FtpCreatePartitionLogicalDisk(
    IN OUT  PVOLUME_EXTENSION   Extension,
    IN OUT  PIRP                Irp
    )

/*++

Routine Description:

    This routine creates assigns a logical disk id to a partition.

Arguments:

    Extension   - Supplies the partition extension.

    Irp         - Supplies the I/O request packet.

Return Value:

    NTSTATUS

--*/

{
    PIO_STACK_LOCATION                          irpSp = IoGetCurrentIrpStackLocation(Irp);
    LONGLONG                                    partitionSize;
    NTSTATUS                                    status;
    FT_LOGICAL_DISK_ID                          diskId;
    PFT_CREATE_PARTITION_LOGICAL_DISK_OUTPUT    output;

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

        return STATUS_INVALID_PARAMETER;
    }

    if (irpSp->Parameters.DeviceIoControl.InputBufferLength >=
        sizeof(LONGLONG)) {

        partitionSize = *((PLONGLONG) Irp->AssociatedIrp.SystemBuffer);
    } else {
        partitionSize = 0;
    }

    status = FtpCreatePartitionLogicalDiskHelper(Extension, partitionSize,
                                                 &diskId);
    if (!NT_SUCCESS(status)) {
        return status;
    }

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

    output = (PFT_CREATE_PARTITION_LOGICAL_DISK_OUTPUT)
             Irp->AssociatedIrp.SystemBuffer;

    output->NewLogicalDiskId = diskId;

    return status;
}

NTSTATUS
FtpQueryDeviceName(
    IN OUT  PVOLUME_EXTENSION   Extension,
    IN OUT  PIRP                Irp
    )

/*++

Routine Description:

    This routine returns the device name for the given device.

Arguments:

    Extension   - Supplies the volume extension.

    Irp         - Supplies the IO request packet.

Return Value:

    NTSTATUS

--*/

{
    PIO_STACK_LOCATION  irpSp = IoGetCurrentIrpStackLocation(Irp);
    WCHAR               nameBuffer[100];
    UNICODE_STRING      nameString;
    PMOUNTDEV_NAME      name;

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

        return STATUS_INVALID_PARAMETER;
    }

    swprintf(nameBuffer, L"\\Device\\HarddiskVolume%d", Extension->VolumeNumber);
    RtlInitUnicodeString(&nameString, nameBuffer);

    name = (PMOUNTDEV_NAME) Irp->AssociatedIrp.SystemBuffer;
    name->NameLength = nameString.Length;
    Irp->IoStatus.Information = name->NameLength + sizeof(USHORT);

    if (irpSp->Parameters.DeviceIoControl.OutputBufferLength <
        Irp->IoStatus.Information) {

        Irp->IoStatus.Information = sizeof(MOUNTDEV_NAME);
        return STATUS_BUFFER_OVERFLOW;
    }

    RtlCopyMemory(name->Name, nameString.Buffer, name->NameLength);

    return STATUS_SUCCESS;
}

NTSTATUS
FtpQuerySuggestedLinkName(
    IN OUT  PVOLUME_EXTENSION   Extension,
    IN OUT  PIRP                Irp
    )

/*++

Routine Description:

    This routine returns the suggested link name for the given device.

Arguments:

    Extension   - Supplies the volume extension.

    Irp         - Supplies the IO request packet.

Return Value:

    NTSTATUS

--*/

{
    PIO_STACK_LOCATION              irpSp = IoGetCurrentIrpStackLocation(Irp);
    BOOLEAN                         deleteLetter;
    UCHAR                           driveLetter;
    PFT_VOLUME                      vol;
    FT_LOGICAL_DISK_ID              diskId;
    WCHAR                           nameBuffer[30];
    UNICODE_STRING                  nameString;
    PMOUNTDEV_SUGGESTED_LINK_NAME   name;

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

        return STATUS_INVALID_PARAMETER;
    }

    if (irpSp->Parameters.DeviceIoControl.OutputBufferLength >=
        FIELD_OFFSET(MOUNTDEV_SUGGESTED_LINK_NAME, Name) + 28) {

        deleteLetter = TRUE;
    } else {
        deleteLetter = FALSE;
    }

    driveLetter = FtpQueryDriveLetterFromRegistry(Extension, deleteLetter);
    vol = Extension->FtVolume;
    if (vol) {
        diskId = vol->QueryLogicalDiskId();
        driveLetter = Extension->Root->DiskInfoSet->QueryDriveLetter(diskId);
    }

    if (!driveLetter) {
        return STATUS_NOT_FOUND;
    }

    swprintf(nameBuffer, L"\\DosDevices\\%c:", driveLetter);
    RtlInitUnicodeString(&nameString, nameBuffer);

    name = (PMOUNTDEV_SUGGESTED_LINK_NAME) Irp->AssociatedIrp.SystemBuffer;
    name->UseOnlyIfThereAreNoOtherLinks = TRUE;
    name->NameLength = nameString.Length;
    Irp->IoStatus.Information =
            name->NameLength + FIELD_OFFSET(MOUNTDEV_SUGGESTED_LINK_NAME, Name);

    if (irpSp->Parameters.DeviceIoControl.OutputBufferLength <
        Irp->IoStatus.Information) {

        Irp->IoStatus.Information = sizeof(MOUNTDEV_SUGGESTED_LINK_NAME);
        return STATUS_BUFFER_OVERFLOW;
    }

    RtlCopyMemory(name->Name, nameString.Buffer, name->NameLength);

    return STATUS_SUCCESS;
}

class CHANGE_DRIVE_LETTER_WORK_ITEM : public WORK_QUEUE_ITEM {

    public:

        PROOT_EXTENSION     RootExtension;
        FT_LOGICAL_DISK_ID  LogicalDiskId;
        UCHAR               OldDriveLetter;
        UCHAR               NewDriveLetter;

};

typedef CHANGE_DRIVE_LETTER_WORK_ITEM *PCHANGE_DRIVE_LETTER_WORK_ITEM;

VOID
FtpChangeDriveLetterWorkerRoutine(
    IN  PVOID   WorkItem
    )

/*++

Routine Description:

    This routine changes the drive letter.

Arguments:

    WorkItem    - Supplies the work item.

Return Value:

    None.

--*/

{
    PCHANGE_DRIVE_LETTER_WORK_ITEM      workItem = (PCHANGE_DRIVE_LETTER_WORK_ITEM) WorkItem;
    PROOT_EXTENSION                     rootExtension = workItem->RootExtension;
    PFT_LOGICAL_DISK_INFORMATION_SET    diskInfoSet = rootExtension->DiskInfoSet;

    FtpAcquire(rootExtension);
    if (workItem->OldDriveLetter &&
        diskInfoSet->QueryDriveLetter(workItem->LogicalDiskId) !=
        workItem->OldDriveLetter) {

        FtpRelease(rootExtension);
        ExFreePool(WorkItem);
        return;
    }
    diskInfoSet->SetDriveLetter(workItem->LogicalDiskId,
                                workItem->NewDriveLetter);
    FtpRelease(rootExtension);

    ExFreePool(WorkItem);
}

NTSTATUS
FtpLinkCreated(
    IN OUT  PVOLUME_EXTENSION   Extension,
    IN OUT  PIRP                Irp
    )

/*++

Routine Description:

    This routine is called when the mount manager changes the link.

Arguments:

    Extension   - Supplies the volume extension.

    Irp         - Supplies the IO request packet.

Return Value:

    NTSTATUS

--*/

{
    PIO_STACK_LOCATION              irpSp = IoGetCurrentIrpStackLocation(Irp);
    PFT_VOLUME                      vol;
    PMOUNTDEV_NAME                  name;
    ULONG                           nameLen;
    UNICODE_STRING                  nameString;
    UNICODE_STRING                  dosDevices;
    UCHAR                           driveLetter;
    PCHANGE_DRIVE_LETTER_WORK_ITEM  workItem;

    vol = Extension->FtVolume;
    if (!vol) {
        return STATUS_SUCCESS;
    }

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

        return STATUS_INVALID_PARAMETER;
    }

    name = (PMOUNTDEV_NAME) Irp->AssociatedIrp.SystemBuffer;
    nameLen = name->NameLength + sizeof(USHORT);

    if (irpSp->Parameters.DeviceIoControl.InputBufferLength < nameLen) {
        return STATUS_INVALID_PARAMETER;
    }

    nameString.Buffer = name->Name;
    nameString.Length = nameString.MaximumLength = name->NameLength;

    if (nameString.Length != 28 || nameString.Buffer[13] != ':' ||
        nameString.Buffer[12] < FirstDriveLetter || nameString.Buffer[12] > LastDriveLetter) {
        return STATUS_SUCCESS;
    }

    nameString.Length -= 2*sizeof(WCHAR);

    RtlInitUnicodeString(&dosDevices, L"\\DosDevices\\");

    if (!RtlEqualUnicodeString(&dosDevices, &nameString, TRUE)) {
        return STATUS_SUCCESS;
    }

    driveLetter = (UCHAR) nameString.Buffer[12];

    workItem = (PCHANGE_DRIVE_LETTER_WORK_ITEM)
               ExAllocatePool(NonPagedPool, sizeof(CHANGE_DRIVE_LETTER_WORK_ITEM));
    if (!workItem) {
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    ExInitializeWorkItem(workItem, FtpChangeDriveLetterWorkerRoutine, workItem);
    workItem->RootExtension = Extension->Root;
    workItem->LogicalDiskId = vol->QueryLogicalDiskId();
    workItem->OldDriveLetter = 0;
    workItem->NewDriveLetter = driveLetter;

    ExQueueWorkItem(workItem, DelayedWorkQueue);

    return STATUS_SUCCESS;
}

NTSTATUS
FtpLinkDeleted(
    IN OUT  PVOLUME_EXTENSION   Extension,
    IN OUT  PIRP                Irp
    )

/*++

Routine Description:

    This routine is called when the mount manager deletes a link.

Arguments:

    Extension   - Supplies the volume extension.

    Irp         - Supplies the IO request packet.

Return Value:

    NTSTATUS

--*/

{
    PIO_STACK_LOCATION              irpSp = IoGetCurrentIrpStackLocation(Irp);
    PFT_VOLUME                      vol;
    PMOUNTDEV_NAME                  name;
    ULONG                           nameLen;
    UNICODE_STRING                  nameString;
    UNICODE_STRING                  dosDevices;
    UCHAR                           driveLetter;
    PCHANGE_DRIVE_LETTER_WORK_ITEM  workItem;

    vol = Extension->FtVolume;
    if (!vol) {
        return STATUS_SUCCESS;
    }

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

        return STATUS_INVALID_PARAMETER;
    }

    name = (PMOUNTDEV_NAME) Irp->AssociatedIrp.SystemBuffer;
    nameLen = name->NameLength + sizeof(USHORT);

    if (irpSp->Parameters.DeviceIoControl.InputBufferLength < nameLen) {
        return STATUS_INVALID_PARAMETER;
    }

    nameString.Buffer = name->Name;
    nameString.Length = nameString.MaximumLength = name->NameLength;

    if (nameString.Length != 28 || nameString.Buffer[13] != ':' ||
        nameString.Buffer[12] < FirstDriveLetter || nameString.Buffer[12] > LastDriveLetter) {
        return STATUS_SUCCESS;
    }

    nameString.Length -= 2*sizeof(WCHAR);

    RtlInitUnicodeString(&dosDevices, L"\\DosDevices\\");

    if (!RtlEqualUnicodeString(&dosDevices, &nameString, TRUE)) {
        return STATUS_SUCCESS;
    }

    driveLetter = (UCHAR) nameString.Buffer[12];

    workItem = (PCHANGE_DRIVE_LETTER_WORK_ITEM)
               ExAllocatePool(NonPagedPool, sizeof(CHANGE_DRIVE_LETTER_WORK_ITEM));
    if (!workItem) {
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    ExInitializeWorkItem(workItem, FtpChangeDriveLetterWorkerRoutine, workItem);
    workItem->RootExtension = Extension->Root;
    workItem->LogicalDiskId = vol->QueryLogicalDiskId();
    workItem->OldDriveLetter = driveLetter;
    workItem->NewDriveLetter = 0;

    ExQueueWorkItem(workItem, DelayedWorkQueue);

    return STATUS_SUCCESS;
}

VOID
FtpSyncLogicalDiskIds(
    IN      PFT_LOGICAL_DISK_INFORMATION_SET    DiskInfoSet,
    IN OUT  PFT_VOLUME                          RootVolume,
    IN OUT  PFT_VOLUME                          Volume
    )

/*++

Routine Description:

    This routine syncs up the logical disk ids in the given FT_VOLUME object
    with the on disk logical disk ids.

Arguments:

    DiskInfoSet - Supplies the disk info set.

    RootVolume  - Supplies the root volume.

    Volume      - Supplies the volume.

Return Value:

    None.

--*/

{
    FT_LOGICAL_DISK_ID              diskId;
    PFT_LOGICAL_DISK_DESCRIPTION    p;
    USHORT                          n, i;
    PFT_VOLUME                      vol;

    if (Volume->QueryLogicalDiskType() == FtPartition) {

        for (;;) {

            diskId = Volume->QueryLogicalDiskId();
            p = DiskInfoSet->GetParentLogicalDiskDescription(diskId);
            if (!p) {
                break;
            }

            Volume = RootVolume->GetParentLogicalDisk(Volume);
            if (!Volume) {
                break;
            }

            Volume->SetLogicalDiskId(p->LogicalDiskId);
        }
        return;
    }

    n = Volume->QueryNumberOfMembers();
    for (i = 0; i < n; i++) {
        vol = Volume->GetMember(i);
        if (vol) {
            FtpSyncLogicalDiskIds(DiskInfoSet, RootVolume, vol);
        }
    }
}

VOID
FtpSyncLogicalDiskIds(
    IN  PROOT_EXTENSION RootExtension
    )

/*++

Routine Description:

    This routine syncs up the logical disk ids in the FT_VOLUME objects
    with the on disk logical disk ids.

Arguments:

    RootExtension   - Supplies the root extension.

Return Value:

    None.

--*/

{
    PLIST_ENTRY                         l;
    PVOLUME_EXTENSION                   extension;
    PFT_VOLUME                          vol;

    for (l = RootExtension->VolumeList.Flink;
         l != &RootExtension->VolumeList; l = l->Flink) {

        extension = CONTAINING_RECORD(l, VOLUME_EXTENSION, ListEntry);
        vol = extension->FtVolume;
        if (!vol) {
            continue;
        }

        FtpSyncLogicalDiskIds(RootExtension->DiskInfoSet, vol, vol);
    }
}

NTSTATUS
FtpPartitionArrivedHelper(
    IN OUT  PROOT_EXTENSION     RootExtension,
    IN      PDEVICE_OBJECT      Partition,
    IN      PDEVICE_OBJECT      WholeDiskPdo
    )

{
    ULONG                               diskNumber;
    LONGLONG                            offset;
    UCHAR                               partitionType;
    PFT_LOGICAL_DISK_INFORMATION_SET    diskInfoSet;
    PFT_LOGICAL_DISK_INFORMATION        diskInfo;
    NTSTATUS                            status;
    BOOLEAN                             changedLogicalDiskIds;
    FT_LOGICAL_DISK_ID                  diskId, partitionDiskId;
    PVOLUME_EXTENSION                   extension;
    PFT_VOLUME                          vol, c;
    PFT_LOGICAL_DISK_DESCRIPTION        parentDesc;
    ULONG                               n;
    UCHAR                               registryState[100];
    USHORT                              registryStateSize;
    BOOLEAN                             IsGpt, isHidden, isReadOnly, isEspType;
    GUID                                partitionTypeGuid, partitionUniqueId;
    ULONGLONG                           gptAttributes;
    ULONG                               signature;

    status = FtpQueryPartitionInformation(RootExtension, Partition,
                                          &diskNumber, &offset, NULL,
                                          &partitionType, NULL,
                                          &partitionTypeGuid,
                                          &partitionUniqueId, &IsGpt,
                                          &gptAttributes);
    if (!NT_SUCCESS(status)) {
        return status;
    }

    isHidden = FALSE;
    isReadOnly = FALSE;
    isEspType = FALSE;

    if (IsGpt) {
        if (IsEqualGUID(partitionTypeGuid, PARTITION_LDM_DATA_GUID)) {
            return STATUS_INVALID_PARAMETER;
        }

        if (RootExtension->GptAttributeRevertEntries) {
            FtpCheckForRevertGptAttributes(RootExtension, Partition, 0,
                                           &partitionUniqueId, NULL);
            status = FtpQueryPartitionInformation(
                     RootExtension, Partition, NULL, NULL, NULL, NULL, NULL,
                     NULL, NULL, NULL, &gptAttributes);
            if (!NT_SUCCESS(status)) {
                return status;
            }
        }

        if (IsEqualGUID(partitionTypeGuid, PARTITION_BASIC_DATA_GUID)) {
            if (gptAttributes&GPT_BASIC_DATA_ATTRIBUTE_HIDDEN) {
                isHidden = TRUE;
            }
            if (gptAttributes&GPT_BASIC_DATA_ATTRIBUTE_READ_ONLY) {
                isReadOnly = TRUE;
            }
        } else {
            if (IsEqualGUID(partitionTypeGuid, PARTITION_SYSTEM_GUID)) {
                isEspType = TRUE;
            }
            isHidden = TRUE;
        }

        if (!FtpCreateNewDevice(RootExtension, Partition, NULL, WholeDiskPdo,
                                Partition->AlignmentRequirement, FALSE,
                                isHidden, isReadOnly, isEspType, 0)) {

            return STATUS_INSUFFICIENT_RESOURCES;
        }

        IoInvalidateDeviceRelations(RootExtension->Pdo, BusRelations);

        return STATUS_SUCCESS;
    }

    if (partitionType == PARTITION_LDM) {
        return STATUS_INVALID_PARAMETER;
    }
    if (!IsRecognizedPartition(partitionType)) {
        isHidden = TRUE;
    }

    diskInfoSet = RootExtension->DiskInfoSet;
    if (!diskInfoSet->IsDiskInSet(WholeDiskPdo)) {

        diskInfo = new FT_LOGICAL_DISK_INFORMATION;
        if (!diskInfo) {
            return STATUS_INSUFFICIENT_RESOURCES;
        }

        status = diskInfo->Initialize(RootExtension, WholeDiskPdo);
        if (!NT_SUCCESS(status)) {
            delete diskInfo;
            return status;
        }

        status = diskInfoSet->AddLogicalDiskInformation(diskInfo,
                                                        &changedLogicalDiskIds);
        if (!NT_SUCCESS(status)) {
            delete diskInfo;
            return status;
        }

        if (changedLogicalDiskIds) {
            FtpSyncLogicalDiskIds(RootExtension);
        }

        if (RootExtension->GptAttributeRevertEntries) {
            signature = FtpQueryDiskSignature(WholeDiskPdo);
            if (signature) {
                FtpCheckForRevertGptAttributes(RootExtension, Partition,
                                               signature, NULL, diskInfo);
            }
        }

    } else {
        diskInfo = diskInfoSet->FindLogicalDiskInformation(WholeDiskPdo);
    }

    if (diskInfo) {
        if (IsRecognizedPartition(partitionType)) {
            gptAttributes = diskInfo->GetGptAttributes();
            if (gptAttributes&GPT_BASIC_DATA_ATTRIBUTE_HIDDEN) {
                isHidden = TRUE;
            }
            if (gptAttributes&GPT_BASIC_DATA_ATTRIBUTE_READ_ONLY) {
                isReadOnly = TRUE;
            }
        } else {
            gptAttributes = 0;
        }
    }

    // Make sure that the on disk reflects the state of the registry.

    diskInfoSet->MigrateRegistryInformation(Partition, diskNumber, offset);

    diskId = diskInfoSet->QueryRootLogicalDiskIdForContainedPartition(
             diskNumber, offset);
    if (diskId) {

        if (!RootExtension->FtCodeLocked) {
            MmLockPagableCodeSection(FtpComputeParity);
            status = FtpStartSystemThread(RootExtension);
            if (!NT_SUCCESS(status)) {
                return status;
            }
            RootExtension->FtCodeLocked = TRUE;
        }

        extension = FtpFindExtension(RootExtension, diskId);
        if (extension) {
            status = FtpAddPartition(extension, Partition, WholeDiskPdo);
            if (!NT_SUCCESS(status)) {
                return status;
            }

            FtpNotify(RootExtension, extension);

        } else {

            vol = FtpBuildFtVolume(RootExtension, diskId, Partition,
                                   WholeDiskPdo);

            if (!vol) {
                return STATUS_INSUFFICIENT_RESOURCES;
            }

            partitionDiskId = diskInfoSet->QueryPartitionLogicalDiskId(
                              diskNumber, offset);
            parentDesc = diskInfoSet->GetParentLogicalDiskDescription(
                         partitionDiskId, &n);
            while (parentDesc) {

                if (parentDesc->u.Other.ByteOffsetToStateInformation &&
                    (c = vol->GetContainedLogicalDisk(
                         parentDesc->LogicalDiskId))) {

                    c->NewStateArrival((PCHAR) parentDesc +
                            parentDesc->u.Other.ByteOffsetToStateInformation);
                }

                parentDesc = diskInfoSet->GetParentLogicalDiskDescription(
                             parentDesc, n);
            }

            if (!FtpCreateNewDevice(RootExtension, NULL, vol, NULL,
                                    Partition->AlignmentRequirement, FALSE,
                                    isHidden, isReadOnly, FALSE, 0)) {

                FtpDeleteVolume(vol);
                return STATUS_INSUFFICIENT_RESOURCES;
            }

            IoInvalidateDeviceRelations(RootExtension->Pdo, BusRelations);
        }

    } else {

        if (!FtpCreateNewDevice(RootExtension, Partition, NULL, WholeDiskPdo,
                                Partition->AlignmentRequirement, FALSE,
                                isHidden, isReadOnly, FALSE, gptAttributes)) {

            return STATUS_INSUFFICIENT_RESOURCES;
        }

        IoInvalidateDeviceRelations(RootExtension->Pdo, BusRelations);
    }

    return STATUS_SUCCESS;
}

NTSTATUS
FtpPartitionArrived(
    IN OUT  PROOT_EXTENSION RootExtension,
    IN OUT  PIRP            Irp
    )

/*++

Routine Description:

    This routine is called when a new partition is introduced into the
    system.

Arguments:

    Extension   - Supplies the device extension.

    Irp         - Supplies the IO request packet.

Return Value:

    NTSTATUS

--*/

{
    PIO_STACK_LOCATION                  irpSp = IoGetCurrentIrpStackLocation(Irp);
    PVOLMGR_PARTITION_INFORMATION       input;
    PDEVICE_OBJECT                      partition, wholeDiskPdo;
    NTSTATUS                            status;
    ULONG                               diskNumber;
    LONGLONG                            offset;
    UCHAR                               partitionType;
    PVOLUME_EXTENSION                   extension;

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

        return STATUS_INVALID_PARAMETER;
    }

    input = (PVOLMGR_PARTITION_INFORMATION) Irp->AssociatedIrp.SystemBuffer;
    partition = input->PartitionDeviceObject;
    wholeDiskPdo = input->WholeDiskPdo;

    status = FtpPartitionArrivedHelper(RootExtension, partition, wholeDiskPdo);

    return status;
}

VOID
FtpTotalBreakUp(
    IN OUT  PROOT_EXTENSION     RootExtension,
    IN      FT_LOGICAL_DISK_ID  LogicalDiskId
    )

{
    PFT_LOGICAL_DISK_INFORMATION_SET    diskInfoSet = RootExtension->DiskInfoSet;
    USHORT                              numDiskIds, i;
    PFT_LOGICAL_DISK_ID                 diskIds;

    if (!LogicalDiskId) {
        return;
    }

    numDiskIds = diskInfoSet->QueryNumberOfMembersInLogicalDisk(LogicalDiskId);
    if (numDiskIds) {
        diskIds = (PFT_LOGICAL_DISK_ID)
                  ExAllocatePool(PagedPool, numDiskIds*sizeof(FT_LOGICAL_DISK_ID));
        if (!diskIds) {
            return;
        }

        for (i = 0; i < numDiskIds; i++) {
            diskIds[i] = diskInfoSet->QueryMemberLogicalDiskId(LogicalDiskId, i);
        }
    }

    diskInfoSet->BreakLogicalDisk(LogicalDiskId);

    if (numDiskIds) {
        for (i = 0; i < numDiskIds; i++) {
            FtpTotalBreakUp(RootExtension, diskIds[i]);
        }

        ExFreePool(diskIds);
    }
}

NTSTATUS
FtpWholeDiskRemoved(
    IN OUT  PROOT_EXTENSION RootExtension,
    IN OUT  PIRP            Irp
    )

/*++

Routine Description:

    This routine is called when a whole disk is removed from the system.

Arguments:

    Extension   - Supplies the device extension.

    Irp         - Supplies the IO request packet.

Return Value:

    NTSTATUS

--*/

{
    PIO_STACK_LOCATION              irpSp = IoGetCurrentIrpStackLocation(Irp);
    PVOLMGR_WHOLE_DISK_INFORMATION  input;
    PDEVICE_OBJECT                  pdo, wholeDisk;
    NTSTATUS                        status;

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

        return STATUS_INVALID_PARAMETER;
    }

    input = (PVOLMGR_WHOLE_DISK_INFORMATION) Irp->AssociatedIrp.SystemBuffer;
    pdo = input->WholeDiskPdo;

    status = RootExtension->DiskInfoSet->RemoveLogicalDiskInformation(pdo);

    return status;
}

NTSTATUS
FtpReferenceDependantVolume(
    IN OUT  PROOT_EXTENSION RootExtension,
    IN OUT  PIRP            Irp
    )

/*++

Routine Description:

    This routine references the volume dependant to the given partition.

Arguments:

    Extension   - Supplies the device extension.

    Irp         - Supplies the IO request packet.

Return Value:

    NTSTATUS

--*/

{
    PIO_STACK_LOCATION                      irpSp = IoGetCurrentIrpStackLocation(Irp);
    PVOLMGR_PARTITION_INFORMATION           input;
    PDEVICE_OBJECT                          partition;
    PVOLUME_EXTENSION                       extension;
    PVOLMGR_DEPENDANT_VOLUMES_INFORMATION   output;

    if (irpSp->Parameters.DeviceIoControl.InputBufferLength <
        sizeof(VOLMGR_PARTITION_INFORMATION) ||
        irpSp->Parameters.DeviceIoControl.OutputBufferLength <
        sizeof(VOLMGR_DEPENDANT_VOLUMES_INFORMATION)) {

        return STATUS_INVALID_PARAMETER;
    }

    input = (PVOLMGR_PARTITION_INFORMATION) Irp->AssociatedIrp.SystemBuffer;
    partition = input->PartitionDeviceObject;
    output = (PVOLMGR_DEPENDANT_VOLUMES_INFORMATION)
             Irp->AssociatedIrp.SystemBuffer;

    output->DependantVolumeReferences = (PDEVICE_RELATIONS)
                                        ExAllocatePool(PagedPool,
                                        sizeof(DEVICE_RELATIONS));
    if (!output->DependantVolumeReferences) {
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    extension = FtpFindExtensionCoveringPartition(RootExtension, partition);
    if (!extension) {
        ExFreePool(output->DependantVolumeReferences);
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    if (extension->IsStarted) {
        output->DependantVolumeReferences->Count = 1;
        output->DependantVolumeReferences->Objects[0] =
                extension->DeviceObject;
        ObReferenceObject(extension->DeviceObject);
    } else {
        output->DependantVolumeReferences->Count = 0;
    }

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

    return STATUS_SUCCESS;
}

NTSTATUS
FtpPartitionRemoved(
    IN OUT  PROOT_EXTENSION RootExtension,
    IN OUT  PIRP            Irp
    )

/*++

Routine Description:

    This routine is called when a partition is removed from the system.

Arguments:

    Extension   - Supplies the device extension.

    Irp         - Supplies the IO request packet.

Return Value:

    NTSTATUS

--*/

{
    PIO_STACK_LOCATION              irpSp = IoGetCurrentIrpStackLocation(Irp);
    PVOLMGR_PARTITION_INFORMATION   input;
    PDEVICE_OBJECT                  partition;
    PDEVICE_OBJECT                  wholeDiskPdo;
    NTSTATUS                        status;

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

        return STATUS_INVALID_PARAMETER;
    }

    input = (PVOLMGR_PARTITION_INFORMATION) Irp->AssociatedIrp.SystemBuffer;
    partition = input->PartitionDeviceObject;
    wholeDiskPdo = input->WholeDiskPdo;

    status = FtpPartitionRemovedHelper(RootExtension, partition, wholeDiskPdo);

    return status;
}

NTSTATUS
FtpQueryChangePartition(
    IN OUT  PROOT_EXTENSION RootExtension,
    IN OUT  PIRP            Irp
    )

/*++

Routine Description:

    This routine checks to see if the given partition can be grown.

Arguments:

    Extension   - Supplies the device extension.

    Irp         - Supplies the IO request packet.

Return Value:

    NTSTATUS

--*/

{
    PIO_STACK_LOCATION                      irpSp = IoGetCurrentIrpStackLocation(Irp);
    PVOLMGR_PARTITION_INFORMATION           input;
    PVOLUME_EXTENSION                       extension;
    NTSTATUS                                status;

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

        return STATUS_INVALID_PARAMETER;
    }

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

    extension = FtpFindExtensionCoveringPartition(
            RootExtension, input->PartitionDeviceObject);
    if (!extension) {
        return STATUS_INVALID_PARAMETER;
    }

    if (extension->TargetObject) {
        status = STATUS_SUCCESS;
    } else {
        status = STATUS_INVALID_DEVICE_REQUEST;
    }

    return status;
}

NTSTATUS
FtpPartitionChanged(
    IN OUT  PROOT_EXTENSION RootExtension,
    IN OUT  PIRP            Irp
    )

/*++

Routine Description:

    This routine does a notification because the given partition has
    changed.

Arguments:

    Extension   - Supplies the device extension.

    Irp         - Supplies the IO request packet.

Return Value:

    NTSTATUS

--*/

{
    PIO_STACK_LOCATION                      irpSp = IoGetCurrentIrpStackLocation(Irp);
    PVOLMGR_PARTITION_INFORMATION           input;
    PVOLUME_EXTENSION                       extension;

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

        return STATUS_INVALID_PARAMETER;
    }

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

    extension = FtpFindExtensionCoveringPartition(
            RootExtension, input->PartitionDeviceObject);
    if (!extension) {
        return STATUS_INVALID_PARAMETER;
    }

    extension->WholeDisk = NULL;
    extension->PartitionOffset = 0;
    extension->PartitionLength = 0;

    FtpNotify(RootExtension, extension);

    // Perform a pre-exposure of the new devnode to avoid the PNP reboot
    // pop-up.

    if (!extension->IsGpt &&
        FtpCreateNewDevice(extension->Root, extension->TargetObject,
                           extension->FtVolume, extension->WholeDiskPdo,
                           extension->DeviceObject->AlignmentRequirement,
                           TRUE, TRUE, FALSE, FALSE, 0)) {

        IoInvalidateDeviceRelations(RootExtension->Pdo, BusRelations);
    }

    return STATUS_SUCCESS;
}

NTSTATUS
FtpQueryRootId(
    IN  PROOT_EXTENSION Extension,
    IN  PIRP            Irp
    )

/*++

Routine Description:

    This routine queries the ID for the given PDO.

Arguments:

    Extension   - Supplies the root extension.

    Irp         - Supplies the IO request packet.

Return Value:

    NTSTATUS

--*/

{
    PIO_STACK_LOCATION  irpSp = IoGetCurrentIrpStackLocation(Irp);
    UNICODE_STRING      string;
    NTSTATUS            status;
    ULONG               diskNumber;
    LONGLONG            offset;
    WCHAR               buffer[100];
    FT_LOGICAL_DISK_ID  diskId;
    PWSTR               id;

    switch (irpSp->Parameters.QueryId.IdType) {

        case BusQueryDeviceID:
            RtlInitUnicodeString(&string, L"ROOT\\FTDISK");
            break;

        case BusQueryHardwareIDs:
            RtlInitUnicodeString(&string, L"ROOT\\FTDISK");
            break;

        case BusQueryInstanceID:
            RtlInitUnicodeString(&string, L"0000");
            break;

        default:
            return STATUS_NOT_SUPPORTED ;

    }

    id = (PWSTR) ExAllocatePool(PagedPool, string.Length + 2*sizeof(WCHAR));
    if (!id) {
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    RtlCopyMemory(id, string.Buffer, string.Length);
    id[string.Length/sizeof(WCHAR)] = 0;
    id[string.Length/sizeof(WCHAR) + 1] = 0;

    Irp->IoStatus.Information = (ULONG_PTR) id;

    return STATUS_SUCCESS;
}

NTSTATUS
FtpQueryId(
    IN  PVOLUME_EXTENSION   Extension,
    IN  PIRP                Irp
    )

/*++

Routine Description:

    This routine queries the ID for the given PDO.

Arguments:

    Extension   - Supplies the volume extension.

    Irp         - Supplies the IO request packet.

Return Value:

    NTSTATUS

--*/

{
    PIO_STACK_LOCATION  irpSp = IoGetCurrentIrpStackLocation(Irp);
    UNICODE_STRING      string;
    NTSTATUS            status;
    PWSTR               id;

    switch (irpSp->Parameters.QueryId.IdType) {

        case BusQueryDeviceID:
            RtlInitUnicodeString(&string, L"STORAGE\\Volume");
            break;

        case BusQueryHardwareIDs:
            RtlInitUnicodeString(&string, L"STORAGE\\Volume");
            break;

        case BusQueryInstanceID:
            string = Extension->DeviceNodeName;
            break;

        default:
            return STATUS_NOT_SUPPORTED ;

    }

    id = (PWSTR) ExAllocatePool(PagedPool, string.Length + 2*sizeof(WCHAR));
    if (!id) {
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    RtlCopyMemory(id, string.Buffer, string.Length);
    id[string.Length/sizeof(WCHAR)] = 0;
    id[string.Length/sizeof(WCHAR) + 1] = 0;

    Irp->IoStatus.Information = (ULONG_PTR) id;

    return STATUS_SUCCESS;
}

class FTP_LOG_ERROR_CONTEXT : public WORK_QUEUE_ITEM {

    public:

        PDEVICE_EXTENSION   Extension;
        FT_LOGICAL_DISK_ID  LogicalDiskId;
        NTSTATUS            SpecificIoStatus;
        NTSTATUS            FinalStatus;
        ULONG               UniqueErrorValue;

};

typedef FTP_LOG_ERROR_CONTEXT *PFTP_LOG_ERROR_CONTEXT;

VOID
FtpLogErrorWorker(
    IN  PVOID   Context
    )

{
    PFTP_LOG_ERROR_CONTEXT  context = (PFTP_LOG_ERROR_CONTEXT) Context;
    PDEVICE_EXTENSION       Extension;
    PDEVICE_OBJECT          deviceObject;
    ULONG                   volumeNumber;
    FT_LOGICAL_DISK_ID      LogicalDiskId;
    NTSTATUS                SpecificIoStatus;
    NTSTATUS                FinalStatus;
    ULONG                   UniqueErrorValue;
    PDEVICE_EXTENSION       extension;
    NTSTATUS                status;
    UNICODE_STRING          dosName;
    ULONG                   extraSpace;
    PIO_ERROR_LOG_PACKET    errorLogPacket;
    PWCHAR                  p;

    Extension = context->Extension;
    LogicalDiskId = context->LogicalDiskId;
    SpecificIoStatus = context->SpecificIoStatus;
    FinalStatus = context->FinalStatus;
    UniqueErrorValue = context->UniqueErrorValue;

    if (LogicalDiskId) {
        FtpAcquire(Extension->Root);
        extension = FtpFindExtensionCoveringDiskId(Extension->Root,
                                                   LogicalDiskId);
        if (extension) {
            deviceObject = extension->DeviceObject;
            volumeNumber = ((PVOLUME_EXTENSION) extension)->VolumeNumber;
            ObReferenceObject(deviceObject);
        } else {
            deviceObject = NULL;
        }
        FtpRelease(Extension->Root);

        if (!extension) {
            extension = Extension->Root;
        }
    } else {
        extension = Extension;
        deviceObject = NULL;
    }

    if (deviceObject) {
        status = RtlVolumeDeviceToDosName(deviceObject, &dosName);
        ObDereferenceObject(deviceObject);
        if (!NT_SUCCESS(status)) {
            dosName.Buffer = (PWCHAR) ExAllocatePool(PagedPool, 100*sizeof(WCHAR));
            if (dosName.Buffer) {
                swprintf(dosName.Buffer, L"\\Device\\HarddiskVolume%d",
                         volumeNumber);
                RtlInitUnicodeString(&dosName, dosName.Buffer);
            }
        }
    } else {
        dosName.Buffer = NULL;
    }

    if (dosName.Buffer) {
        extraSpace = dosName.Length + sizeof(WCHAR);
    } else {
        extraSpace = 34;
    }

    errorLogPacket = (PIO_ERROR_LOG_PACKET)
                     IoAllocateErrorLogEntry(extension->DeviceObject,
                                             sizeof(IO_ERROR_LOG_PACKET) +
                                             (UCHAR)extraSpace);
    if (!errorLogPacket) {
        if (dosName.Buffer) {
            ExFreePool(dosName.Buffer);
        }
        return;
    }

    errorLogPacket->ErrorCode = SpecificIoStatus;
    errorLogPacket->SequenceNumber = FtErrorLogSequence++;
    errorLogPacket->FinalStatus = FinalStatus;
    errorLogPacket->UniqueErrorValue = UniqueErrorValue;
    errorLogPacket->DumpDataSize = 0;
    errorLogPacket->RetryCount = 0;

    errorLogPacket->NumberOfStrings = 1;
    errorLogPacket->StringOffset = sizeof(IO_ERROR_LOG_PACKET);
    p = (PWCHAR) ((PCHAR) errorLogPacket + sizeof(IO_ERROR_LOG_PACKET));
    if (dosName.Buffer) {
        RtlCopyMemory(p, dosName.Buffer, dosName.Length);
        p[dosName.Length/sizeof(WCHAR)] = 0;
        ExFreePool(dosName.Buffer);
    } else if (LogicalDiskId <= 0xFFFF && LogicalDiskId >= 0) {
        swprintf(p, L"%d", LogicalDiskId);
    } else {
        swprintf(p, L"%I64X", LogicalDiskId);
    }

    IoWriteErrorLogEntry(errorLogPacket);

    ExFreePool(Context);
}

VOID
FtpSendPagingNotification(
    IN  PDEVICE_OBJECT  Partition
    )

/*++

Routine Description:

    This routine sends a paging path IRP to the given partition.

Arguments:

    Partition   - Supplies the partition.

Return Value:

    None.

--*/

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

    KeInitializeEvent(&event, NotificationEvent, FALSE);
    irp = IoBuildDeviceIoControlRequest(0, Partition, NULL, 0, NULL, 0,
                                        FALSE, &event, &ioStatus);
    if (!irp) {
        return;
    }

    irpSp = IoGetNextIrpStackLocation(irp);
    irpSp->MajorFunction = IRP_MJ_PNP;
    irpSp->MinorFunction = IRP_MN_DEVICE_USAGE_NOTIFICATION;
    irp->IoStatus.Status = STATUS_NOT_SUPPORTED ;
    irpSp->Parameters.UsageNotification.InPath = TRUE;
    irpSp->Parameters.UsageNotification.Type = DeviceUsageTypePaging;

    status = IoCallDriver(Partition, irp);
    if (status == STATUS_PENDING) {
        KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
        status = ioStatus.Status;
    }
}

NTSTATUS
FtpInitializeLogicalDisk(
    IN OUT  PROOT_EXTENSION RootExtension,
    IN OUT  PIRP            Irp
    )

/*++

Routine Description:

    This routine initializes a given logical disk.

Arguments:

    RootExtension   - Supplies the root extension.

    Irp             - Supplies the I/O request packet.

Return Value:

    NTSTATUS

--*/

{
    PIO_STACK_LOCATION                  irpSp = IoGetCurrentIrpStackLocation(Irp);
    PFT_INITIALIZE_LOGICAL_DISK_INPUT   input;
    FT_LOGICAL_DISK_ID                  diskId;
    PVOLUME_EXTENSION                   extension;
    PFT_VOLUME                          vol;
    NTSTATUS                            status;

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

        return STATUS_INVALID_PARAMETER;
    }

    input = (PFT_INITIALIZE_LOGICAL_DISK_INPUT) Irp->AssociatedIrp.SystemBuffer;
    diskId = input->RootLogicalDiskId;

    extension = FtpFindExtension(RootExtension, diskId);
    if (!extension || !extension->FtVolume) {
        return STATUS_INVALID_PARAMETER;
    }

    vol = extension->FtVolume;
    ASSERT(vol);

    KeWaitForSingleObject(&extension->Semaphore, Executive, KernelMode, FALSE,
                          NULL);
    status = FtpAllSystemsGo(extension, NULL, TRUE, TRUE, TRUE);
    KeReleaseSemaphore(&extension->Semaphore, IO_NO_INCREMENT, 1, FALSE);

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

    vol->StartSyncOperations(input->RegenerateOrphans,
                             FtpRefCountCompletion, extension);

    return STATUS_SUCCESS;
}

NTSTATUS
FtpCheckIo(
    IN OUT  PROOT_EXTENSION RootExtension,
    IN OUT  PIRP            Irp
    )

/*++

Routine Description:

    This routine checks the io path for the given logical disk.

Arguments:

    Extension   - Supplies the root extension.

    Irp         - Supplies the I/O request packet.

Return Value:

    NTSTATUS

--*/

{
    PIO_STACK_LOCATION  irpSp = IoGetCurrentIrpStackLocation(Irp);
    PFT_CHECK_IO_INPUT  input;
    PFT_CHECK_IO_OUTPUT output;
    FT_LOGICAL_DISK_ID  diskId;
    PVOLUME_EXTENSION   extension;
    PFT_VOLUME          vol;
    NTSTATUS            status;
    BOOLEAN             ok;

    if (irpSp->Parameters.DeviceIoControl.InputBufferLength <
        sizeof(FT_CHECK_IO_INPUT) ||
        irpSp->Parameters.DeviceIoControl.OutputBufferLength <
        sizeof(FT_CHECK_IO_OUTPUT)) {

        return STATUS_INVALID_PARAMETER;
    }

    input = (PFT_CHECK_IO_INPUT) Irp->AssociatedIrp.SystemBuffer;
    output = (PFT_CHECK_IO_OUTPUT) Irp->AssociatedIrp.SystemBuffer;
    diskId = input->LogicalDiskId;

    extension = FtpFindExtensionCoveringDiskId(RootExtension, diskId);
    if (!extension || !extension->FtVolume) {
        return STATUS_INVALID_PARAMETER;
    }

    KeWaitForSingleObject(&extension->Semaphore, Executive, KernelMode, FALSE,
                          NULL);
    status = FtpAllSystemsGo(extension, NULL, FALSE, TRUE, TRUE);
    KeReleaseSemaphore(&extension->Semaphore, IO_NO_INCREMENT, 1, FALSE);

    if (!NT_SUCCESS(status)) {
        output->IsIoOk = FALSE;
        Irp->IoStatus.Information = sizeof(FT_CHECK_IO_OUTPUT);
        return STATUS_SUCCESS;
    }

    vol = extension->FtVolume->GetContainedLogicalDisk(diskId);
    status = vol->CheckIo(&ok);

    FtpDecrementRefCount(extension);

    if (NT_SUCCESS(status)) {
        output->IsIoOk = ok;
        Irp->IoStatus.Information = sizeof(FT_CHECK_IO_OUTPUT);
    }

    return status;
}

NTSTATUS
FtpBreakLogicalDiskHelper(
    IN OUT  PROOT_EXTENSION     RootExtension,
    IN      FT_LOGICAL_DISK_ID  RootLogicalDiskId
    )

/*++

Routine Description:

    This routine breaks a given logical disk.

Arguments:

    RootExtension       - Supplies the root extension.

    RootLogicalDiskId   - Supplies the root logical disk id.

Return Value:

    NTSTATUS

--*/

{
    FT_LOGICAL_DISK_ID                      diskId;
    PFT_LOGICAL_DISK_INFORMATION_SET        diskInfoSet;
    PVOLUME_EXTENSION                       extension;
    FT_LOGICAL_DISK_TYPE                    diskType;
    UCHAR                                   newUniqueIdBuffer[UNIQUE_ID_MAX_BUFFER_SIZE];
    PMOUNTDEV_UNIQUE_ID                     newUniqueId;
    PPARTITION                              partition;
    BOOLEAN                                 closeHandle;
    PFT_VOLUME                              vol, member, m;
    HANDLE                                  handle;
    PFT_MIRROR_AND_SWP_STATE_INFORMATION    state;
    USHORT                                  n, i;
    NTSTATUS                                status;
    KEVENT                                  event;
    SET_TARGET_CONTEXT                      context;
    ULONG                                   alignment;

    diskId = RootLogicalDiskId;
    diskInfoSet = RootExtension->DiskInfoSet;

    extension = FtpFindExtension(RootExtension, diskId);
    if (!extension) {
        return STATUS_INVALID_PARAMETER;
    }
    alignment = extension->DeviceObject->AlignmentRequirement;

    diskType = diskInfoSet->QueryLogicalDiskType(diskId);
    newUniqueId = (PMOUNTDEV_UNIQUE_ID) newUniqueIdBuffer;

    vol = extension->FtVolume;

    if (diskType == FtPartition) {

        partition = (PPARTITION) vol;
        KeInitializeEvent(&context.Event, NotificationEvent, FALSE);
        context.TargetObject = partition->GetTargetObject();
        context.FtVolume = NULL;
        context.WholeDiskPdo = partition->GetWholeDiskPdo();
        FtpZeroRefCallback(extension, FtpSetTargetCallback, &context, TRUE);
        KeWaitForSingleObject(&context.Event, Executive, KernelMode, FALSE,
                              NULL);

        member = NULL;
        closeHandle = FALSE;
        FtpResetPartitionType(extension);

        FtpQueryUniqueIdBuffer(extension, newUniqueId->UniqueId,
                               &newUniqueId->UniqueIdLength);
        FtpUniqueIdNotify(extension, newUniqueId);

    } else if (diskType == FtMirrorSet) {

        state = (PFT_MIRROR_AND_SWP_STATE_INFORMATION)
                diskInfoSet->GetStateInformation(diskId);
        if (!state) {
            return STATUS_INVALID_PARAMETER;
        }

        if (state->UnhealthyMemberState == FtMemberHealthy ||
            state->UnhealthyMemberNumber != 0) {

            member = vol->GetMember(0);
            if (!member) {
                member = vol->GetMember(1);
            }

        } else {
            member = vol->GetMember(1);
            if (!member) {
                member = vol->GetMember(0);
            }
        }

        KeInitializeEvent(&context.Event, NotificationEvent, FALSE);
        context.TargetObject = NULL;
        context.FtVolume = member;
        context.WholeDiskPdo = NULL;
        FtpZeroRefCallback(extension, FtpSetTargetCallback, &context, TRUE);
        KeWaitForSingleObject(&context.Event, Executive, KernelMode, FALSE,
                              NULL);

        closeHandle = FALSE;

        FtpQueryUniqueIdBuffer(extension, newUniqueId->UniqueId,
                               &newUniqueId->UniqueIdLength);
        FtpUniqueIdNotify(extension, newUniqueId);

    } else {
        if (!FtpLockLogicalDisk(RootExtension, diskId, &handle)) {
            return STATUS_ACCESS_DENIED;
        }
        closeHandle = TRUE;
        member = NULL;
    }

    status = diskInfoSet->BreakLogicalDisk(diskId);
    if (!NT_SUCCESS(status)) {
        KeInitializeEvent(&context.Event, NotificationEvent, FALSE);
        context.TargetObject = NULL;
        context.FtVolume = vol;
        context.WholeDiskPdo = NULL;
        FtpZeroRefCallback(extension, FtpSetTargetCallback, &context, TRUE);
        KeWaitForSingleObject(&context.Event, Executive, KernelMode, FALSE,
                              NULL);

        if (closeHandle) {
            ZwClose(handle);
        }
        return status;
    }

    if (closeHandle) {

        KeInitializeEvent(&context.Event, NotificationEvent, FALSE);
        context.TargetObject = NULL;
        context.FtVolume = NULL;
        context.WholeDiskPdo = NULL;
        FtpZeroRefCallback(extension, FtpSetTargetCallback, &context, TRUE);
        KeWaitForSingleObject(&context.Event, Executive, KernelMode, FALSE,
                              NULL);

        RemoveEntryList(&extension->ListEntry);
        InsertTailList(&RootExtension->DeadVolumeList, &extension->ListEntry);
        FtpDeleteMountPoints(extension);
        FtpCleanupVolumeExtension(extension);
    }

    n = vol->QueryNumberOfMembers();
    for (i = 0; i < n; i++) {
        m = vol->GetMember(i);
        if (!m || m == member) {
            continue;
        }
        FtpCreateNewDevice(RootExtension, NULL, m, NULL, alignment, FALSE,
                           FALSE, FALSE, FALSE, 0);
    }
    if (!InterlockedDecrement(&vol->_refCount)) {
        delete vol;
    }

    if (member) {
        FtpNotify(RootExtension, extension);
    } else if (!closeHandle) {
        FtpNotify(RootExtension, extension);
    }

    if (closeHandle) {
        ZwClose(handle);
    }

    if (diskType != FtPartition) {
        IoInvalidateDeviceRelations(RootExtension->Pdo, BusRelations);
    }

    return STATUS_SUCCESS;
}

NTSTATUS
FtpReplaceLogicalDiskMember(
    IN OUT  PROOT_EXTENSION RootExtension,
    IN OUT  PIRP            Irp
    )

/*++

Routine Description:

    This routine replaces the given logical disk member.

Arguments:

    RootExtension   - Supplies the root extension.

    Irp             - Supplies the I/O request packet.

Return Value:

    NTSTATUS

--*/

{
    PIO_STACK_LOCATION                      irpSp = IoGetCurrentIrpStackLocation(Irp);
    PFT_REPLACE_LOGICAL_DISK_MEMBER_INPUT   input;
    PFT_REPLACE_LOGICAL_DISK_MEMBER_OUTPUT  output;
    FT_LOGICAL_DISK_ID                      diskId, newMemberDiskId, newDiskId;
    USHORT                                  member;
    HANDLE                                  handle;
    PVOLUME_EXTENSION                       replacementExtension, extension;
    PFT_VOLUME                              replacementVolume, vol, oldVol, root;
    NTSTATUS                                status;
    PFT_LOGICAL_DISK_INFORMATION_SET        diskInfoSet;
    PVOLUME_EXTENSION                       oldVolExtension;
    PFT_LOGICAL_DISK_DESCRIPTION            p;
    WCHAR                                   deviceNameBuffer[64];
    UNICODE_STRING                          deviceName;
    UCHAR                                   newUniqueIdBuffer[UNIQUE_ID_MAX_BUFFER_SIZE];
    PMOUNTDEV_UNIQUE_ID                     newUniqueId;
    KEVENT                                  event;
    SET_TARGET_CONTEXT                      context;
    ULONG                                   alignment;

    if (irpSp->Parameters.DeviceIoControl.InputBufferLength <
        sizeof(FT_REPLACE_LOGICAL_DISK_MEMBER_INPUT) ||
        irpSp->Parameters.DeviceIoControl.OutputBufferLength <
        sizeof(FT_REPLACE_LOGICAL_DISK_MEMBER_OUTPUT)) {

        return STATUS_INVALID_PARAMETER;
    }

    input = (PFT_REPLACE_LOGICAL_DISK_MEMBER_INPUT)
            Irp->AssociatedIrp.SystemBuffer;
    output = (PFT_REPLACE_LOGICAL_DISK_MEMBER_OUTPUT)
             Irp->AssociatedIrp.SystemBuffer;

    diskId = input->LogicalDiskId;
    member = input->MemberNumberToReplace;
    newMemberDiskId = input->NewMemberLogicalDiskId;

    if (!FtpLockLogicalDisk(RootExtension, newMemberDiskId, &handle)) {
        return STATUS_ACCESS_DENIED;
    }

    replacementExtension = FtpFindExtension(RootExtension, newMemberDiskId);
    extension = FtpFindExtensionCoveringDiskId(RootExtension, diskId);
    if (!extension || !extension->FtVolume || !replacementExtension ||
        !replacementExtension->FtVolume) {

        ZwClose(handle);
        return STATUS_INVALID_PARAMETER;
    }

    alignment = extension->DeviceObject->AlignmentRequirement;
    extension->DeviceObject->AlignmentRequirement |=
            replacementExtension->DeviceObject->AlignmentRequirement;

    newUniqueId = (PMOUNTDEV_UNIQUE_ID) newUniqueIdBuffer;

    replacementVolume = replacementExtension->FtVolume;
    root = extension->FtVolume;
    vol = root->GetContainedLogicalDisk(diskId);

    // Flush the QUEUE so that no IRPs in transit have incorrect alignment.
    KeInitializeEvent(&event, NotificationEvent, FALSE);
    FtpZeroRefCallback(extension, FtpQueryRemoveCallback, &event,
                       TRUE);
    KeWaitForSingleObject(&event, Executive, KernelMode, FALSE,
                          NULL);

    KeWaitForSingleObject(&extension->Semaphore, Executive, KernelMode, FALSE,
                          NULL);
    status = FtpAllSystemsGo(extension, NULL, FALSE, TRUE, TRUE);
    KeReleaseSemaphore(&extension->Semaphore, IO_NO_INCREMENT, 1, FALSE);

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

    status = FtpCheckForCompleteVolume(extension, vol);
    if (!NT_SUCCESS(status)) {
        FtpDecrementRefCount(extension);
        ZwClose(handle);
        return status;
    }

    status = FtpAllSystemsGo(replacementExtension, NULL, TRUE, TRUE, TRUE);
    if (!NT_SUCCESS(status)) {
        FtpDecrementRefCount(extension);
        ZwClose(handle);
        return status;
    }

    FtpDecrementRefCount(replacementExtension);

    KeInitializeEvent(&context.Event, NotificationEvent, FALSE);
    context.TargetObject = NULL;
    context.FtVolume = NULL;
    context.WholeDiskPdo = NULL;
    FtpZeroRefCallback(replacementExtension, FtpSetTargetCallback, &context,
                       TRUE);
    KeWaitForSingleObject(&context.Event, Executive, KernelMode, FALSE, NULL);

    oldVol = vol->GetMember(member);

    if (!vol->IsVolumeSuitableForRegenerate(member, replacementVolume)) {
        FtpDecrementRefCount(extension);

        KeInitializeEvent(&context.Event, NotificationEvent, FALSE);
        context.TargetObject = NULL;
        context.FtVolume = replacementVolume;
        context.WholeDiskPdo = NULL;
        FtpZeroRefCallback(replacementExtension, FtpSetTargetCallback,
                           &context, TRUE);
        KeWaitForSingleObject(&context.Event, Executive, KernelMode, FALSE,
                              NULL);

        ZwClose(handle);
        return STATUS_INVALID_PARAMETER;
    }

    diskInfoSet = RootExtension->DiskInfoSet;
    status = diskInfoSet->ReplaceLogicalDiskMember(diskId, member,
                                                   newMemberDiskId,
                                                   &newDiskId);
    if (!NT_SUCCESS(status)) {
        FtpDecrementRefCount(extension);

        KeInitializeEvent(&context.Event, NotificationEvent, FALSE);
        context.TargetObject = NULL;
        context.FtVolume = replacementVolume;
        context.WholeDiskPdo = NULL;
        FtpZeroRefCallback(replacementExtension, FtpSetTargetCallback,
                           &context, TRUE);
        KeWaitForSingleObject(&context.Event, Executive, KernelMode, FALSE,
                              NULL);

        ZwClose(handle);
        return status;
    }

    InterlockedIncrement(&extension->RefCount);
    vol->RegenerateMember(member, replacementVolume,
                          FtpRefCountCompletion, extension);
    vol->StartSyncOperations(FALSE, FtpRefCountCompletion, extension);

    RemoveEntryList(&replacementExtension->ListEntry);
    InsertTailList(&RootExtension->DeadVolumeList,
                   &replacementExtension->ListEntry);
    FtpDeleteMountPoints(replacementExtension);
    FtpCleanupVolumeExtension(replacementExtension);

    Irp->IoStatus.Information =
            sizeof(FT_REPLACE_LOGICAL_DISK_MEMBER_OUTPUT);
    output->NewLogicalDiskId = newDiskId;

    vol->SetLogicalDiskId(newDiskId);

    while (p = diskInfoSet->GetParentLogicalDiskDescription(
           vol->QueryLogicalDiskId())) {

        if (vol = root->GetParentLogicalDisk(vol)) {
            vol->SetLogicalDiskId(p->LogicalDiskId);
        }
    }

    if (oldVol) {
        FtpCreateNewDevice(RootExtension, NULL, oldVol, NULL, alignment, FALSE,
                           FALSE, FALSE, FALSE, 0);
    }

    swprintf(deviceNameBuffer, L"\\Device\\HarddiskVolume%d", extension->VolumeNumber);
    RtlInitUnicodeString(&deviceName, deviceNameBuffer);
    replacementVolume->CreateLegacyNameLinks(&deviceName);

    FtpQueryUniqueIdBuffer(extension, newUniqueId->UniqueId,
                           &newUniqueId->UniqueIdLength);
    FtpUniqueIdNotify(extension, newUniqueId);

    IoInvalidateDeviceRelations(RootExtension->Pdo, BusRelations);

    ZwClose(handle);

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

/*++

Routine Description:

    This routine handles the PnP paging notification IRP.

Arguments:

    DeviceObject    - Supplies the device object.

    Irp             - Supplies the IO request packet.

Return Value:

    NTSTATUS

--*/

{
    PVOLUME_EXTENSION                   extension = (PVOLUME_EXTENSION) DeviceObject->DeviceExtension;
    PIO_STACK_LOCATION                  irpSp = IoGetCurrentIrpStackLocation(Irp);
    NTSTATUS                            status;
    PFT_VOLUME                          vol;

    ASSERT(extension->DeviceExtensionType != DEVICE_EXTENSION_ROOT);

    status = FtpAllSystemsGo(extension, Irp, FALSE, TRUE, FALSE);
    if (status == STATUS_PENDING) {
        return status;
    }
    if (!NT_SUCCESS(status)) {
        Irp->IoStatus.Information = 0;
        Irp->IoStatus.Status = status;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
        return status;
    }

    if (irpSp->Parameters.UsageNotification.Type == DeviceUsageTypePaging) {
        extension->InPagingPath = irpSp->Parameters.UsageNotification.InPath;
        IoInvalidateDeviceState(extension->DeviceObject);
    }

    if (extension->TargetObject) {
        IoCopyCurrentIrpStackLocationToNext(Irp);
        IoSetCompletionRoutine(Irp, FtpRefCountCompletionRoutine,
                               extension, TRUE, TRUE, TRUE);
        IoMarkIrpPending(Irp);

        IoCallDriver(extension->TargetObject, Irp);

        return STATUS_PENDING;
    }

    vol = extension->FtVolume;
    ASSERT(vol);

    IoMarkIrpPending(Irp);
    irpSp->DeviceObject = DeviceObject;

    vol->BroadcastIrp(Irp, FtDiskShutdownFlushCompletionRoutine, Irp);

    return STATUS_PENDING;
}

VOID
FtpDereferenceMbrGptAttributes(
    IN  PVOLUME_EXTENSION   Extension,
    IN  PDEVICE_OBJECT      WholeDiskPdo
    )

{
    PLIST_ENTRY                     l;
    PVOLUME_EXTENSION               extension;
    PFT_LOGICAL_DISK_INFORMATION    diskInfo;

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

        extension = CONTAINING_RECORD(l, VOLUME_EXTENSION, ListEntry);
        if (extension == Extension ||
            extension->WholeDiskPdo != WholeDiskPdo ||
            !extension->MbrGptAttributes) {

            continue;
        }

        return;
    }

    diskInfo = Extension->Root->DiskInfoSet->FindLogicalDiskInformation(
               WholeDiskPdo);
    if (diskInfo) {
        diskInfo->SetGptAttributes(0);
    }
}

NTSTATUS
FtpPartitionRemovedHelper(
    IN OUT  PROOT_EXTENSION RootExtension,
    IN      PDEVICE_OBJECT  Partition,
    IN      PDEVICE_OBJECT  WholeDiskPdo
    )

{
    PVOLUME_EXTENSION               extension;
    KEVENT                          event;
    PFT_VOLUME                      vol, part, parent;
    FT_PARTITION_OFFLINE_CONTEXT    offlineContext;
    USHORT                          n, i;
    SET_TARGET_CONTEXT              context;

    extension = FtpFindExtensionCoveringPartition(RootExtension, Partition);
    if (!extension) {
        return STATUS_INVALID_PARAMETER;
    }

    if (extension->TargetObject) {
        ASSERT(extension->TargetObject == Partition);

        KeInitializeEvent(&context.Event, NotificationEvent, FALSE);
        context.TargetObject = NULL;
        context.FtVolume = NULL;
        context.WholeDiskPdo = NULL;
        FtpZeroRefCallback(extension, FtpSetTargetCallback, &context, TRUE);
        KeWaitForSingleObject(&context.Event, Executive, KernelMode, FALSE,
                              NULL);

        if (WholeDiskPdo) {
            FtpDeleteMountPoints(extension);
            if (!extension->IsGpt && extension->MbrGptAttributes) {
                FtpDereferenceMbrGptAttributes(extension, WholeDiskPdo);
            }
        }

        RemoveEntryList(&extension->ListEntry);
        InsertTailList(&RootExtension->DeadVolumeList, &extension->ListEntry);
        FtpCleanupVolumeExtension(extension);

        IoInvalidateDeviceRelations(RootExtension->Pdo, BusRelations);

    } else {

        vol = extension->FtVolume;
        ASSERT(vol);
        part = vol->GetContainedLogicalDisk(Partition);
        parent = vol->GetParentLogicalDisk(part);
        KeInitializeEvent(&event, NotificationEvent, FALSE);
        offlineContext.Root = vol;
        offlineContext.Parent = parent;
        offlineContext.Child = part;
        offlineContext.Event = &event;
        FtpZeroRefCallback(extension, FtpMemberOfflineCallback,
                           &offlineContext, TRUE);
        KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);

        if (extension->FtVolume) {
            FtpNotify(RootExtension, extension);
        } else {
            if (WholeDiskPdo) {
                FtpDeleteMountPoints(extension);
                FtpTotalBreakUp(RootExtension, vol->QueryLogicalDiskId());
            }
            FtpDeleteVolume(vol);
            RemoveEntryList(&extension->ListEntry);
            InsertTailList(&RootExtension->DeadVolumeList, &extension->ListEntry);
            FtpCleanupVolumeExtension(extension);
            IoInvalidateDeviceRelations(RootExtension->Pdo, BusRelations);
        }

        if (parent) {
            if (!InterlockedDecrement(&part->_refCount)) {
                delete part;
            }
        }
    }

    return STATUS_SUCCESS;
}

NTSTATUS
FtpGetVolumeDiskExtents(
    IN  PVOLUME_EXTENSION   Extension,
    IN  PIRP                Irp
    )

/*++

Routine Description:

    This routine returns the disk extents for the given volume.

Arguments:

    Extension   - Supplies the volume extension.

    Irp         - Supplies the IO request packet.

Return Value:

    NTSTATUS

--*/

{
    PIO_STACK_LOCATION      irpSp = IoGetCurrentIrpStackLocation(Irp);
    PVOLUME_DISK_EXTENTS    output = (PVOLUME_DISK_EXTENTS) Irp->AssociatedIrp.SystemBuffer;
    NTSTATUS                status;
    ULONG                   diskNumber, numExtents;
    LONGLONG                offset, length;
    PDISK_EXTENT            extents;

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

        return STATUS_INVALID_PARAMETER;
    }

    if (Extension->TargetObject) {
        status = FtpQueryPartitionInformation(Extension->Root,
                                              Extension->TargetObject,
                                              &diskNumber, &offset, NULL,
                                              NULL, &length, NULL, NULL, NULL,
                                              NULL);
        if (!NT_SUCCESS(status)) {
            return status;
        }

        Irp->IoStatus.Information = sizeof(VOLUME_DISK_EXTENTS);
        output->NumberOfDiskExtents = 1;
        output->Extents[0].DiskNumber = diskNumber;
        output->Extents[0].StartingOffset.QuadPart = offset;
        output->Extents[0].ExtentLength.QuadPart = length;

        return STATUS_SUCCESS;
    }

    status = Extension->FtVolume->QueryDiskExtents(&extents, &numExtents);
    if (!NT_SUCCESS(status)) {
        return status;
    }

    output->NumberOfDiskExtents = numExtents;
    Irp->IoStatus.Information = FIELD_OFFSET(VOLUME_DISK_EXTENTS, Extents) +
                                numExtents*sizeof(DISK_EXTENT);
    if (irpSp->Parameters.DeviceIoControl.OutputBufferLength <
        Irp->IoStatus.Information) {

        Irp->IoStatus.Information = FIELD_OFFSET(VOLUME_DISK_EXTENTS, Extents);
        ExFreePool(extents);
        return STATUS_BUFFER_OVERFLOW;
    }

    RtlCopyMemory(output->Extents, extents, numExtents*sizeof(DISK_EXTENT));
    ExFreePool(extents);

    return status;
}

NTSTATUS
FtpDisksFromFtVolume(
    IN  PFT_VOLUME          FtVolume,
    OUT PDEVICE_OBJECT**    DiskPdos,
    OUT PULONG              NumDiskPdos
    )

{
    PDEVICE_OBJECT* diskPdos;
    ULONG           numDisks, nd, j, k;
    USHORT          n, i;
    PFT_VOLUME      vol;
    PDEVICE_OBJECT* dp;
    NTSTATUS        status;
    PDEVICE_OBJECT* diskPdos2;

    if (FtVolume->QueryLogicalDiskType() == FtPartition) {
        numDisks = 1;
        diskPdos = (PDEVICE_OBJECT*)
                   ExAllocatePool(PagedPool, numDisks*sizeof(PDEVICE_OBJECT));
        if (!diskPdos) {
            return STATUS_INSUFFICIENT_RESOURCES;
        }
        diskPdos[0] = ((PPARTITION) FtVolume)->GetWholeDiskPdo();
        *DiskPdos = diskPdos;
        *NumDiskPdos = numDisks;
        return STATUS_SUCCESS;
    }

    diskPdos = NULL;
    numDisks = 0;

    n = FtVolume->QueryNumberOfMembers();
    for (i = 0; i < n; i++) {
        vol = FtVolume->GetMember(i);
        if (!vol) {
            continue;
        }

        status = FtpDisksFromFtVolume(vol, &dp, &nd);
        if (!NT_SUCCESS(status)) {
            if (diskPdos) {
                ExFreePool(diskPdos);
            }
            return status;
        }

        diskPdos2 = diskPdos;
        diskPdos = (PDEVICE_OBJECT*) ExAllocatePool(PagedPool,
                   (numDisks + nd)*sizeof(PDEVICE_OBJECT));
        if (!diskPdos) {
            ExFreePool(dp);
            if (diskPdos2) {
                ExFreePool(diskPdos2);
            }
            return STATUS_INSUFFICIENT_RESOURCES;
        }
        if (diskPdos2) {
            RtlCopyMemory(diskPdos, diskPdos2,
                          numDisks*sizeof(PDEVICE_OBJECT));
            ExFreePool(diskPdos2);
        }

        for (j = 0; j < nd; j++) {
            for (k = 0; k < numDisks; k++) {
                if (dp[j] == diskPdos[k]) {
                    break;
                }
            }
            if (k == numDisks) {
                diskPdos[numDisks++] = dp[j];
            }
        }

        ExFreePool(dp);
    }

    *DiskPdos = diskPdos;
    *NumDiskPdos = numDisks;

    return STATUS_SUCCESS;
}

NTSTATUS
FtpDisksFromVolumes(
    IN  PVOLUME_EXTENSION*  Extensions,
    IN  ULONG               NumVolumes,
    OUT PDEVICE_OBJECT**    WholeDiskPdos,
    OUT PULONG              NumDisks
    )

/*++

Routine Description:

    This routine computes the disks that are used by the given volumes
    and returns the list of whole disk pdos.

Arguments:

    Extensions      - Supplies the list of volumes.

    NumVolumes      - Supplies the number of volumes.

    WholeDiskPdos   - Returns the list of disks.

    NumDisks        - Returns the number of disks.

Return Value:

    NTSTATUS

--*/

{
    ULONG           numDisks, i, j, k;
    PDEVICE_OBJECT* diskPdos;
    PDEVICE_OBJECT* diskPdos2;
    NTSTATUS        status;
    PDEVICE_OBJECT* volumeDiskPdos;
    ULONG           numVolumeDisks;

    numDisks = 0;
    diskPdos = NULL;

    for (i = 0; i < NumVolumes; i++) {

        if (Extensions[i]->TargetObject) {
            for (j = 0; j < numDisks; j++) {
                if (Extensions[i]->WholeDiskPdo == diskPdos[j]) {
                    break;
                }
            }
            if (j == numDisks) {
                diskPdos2 = diskPdos;
                numDisks++;
                diskPdos = (PDEVICE_OBJECT*)
                           ExAllocatePool(PagedPool,
                                          numDisks*sizeof(PDEVICE_OBJECT));
                if (!diskPdos) {
                    if (diskPdos2) {
                        ExFreePool(diskPdos2);
                    }
                    return STATUS_INSUFFICIENT_RESOURCES;
                }
                if (diskPdos2) {
                    RtlCopyMemory(diskPdos, diskPdos2,
                                  (numDisks - 1)*sizeof(PDEVICE_OBJECT));
                    ExFreePool(diskPdos2);
                }
                diskPdos[numDisks - 1] = Extensions[i]->WholeDiskPdo;
            }

        } else if (Extensions[i]->FtVolume) {

            status = FtpDisksFromFtVolume(Extensions[i]->FtVolume,
                                          &volumeDiskPdos, &numVolumeDisks);
            if (!NT_SUCCESS(status)) {
                if (diskPdos) {
                    ExFreePool(diskPdos);
                }
                return status;
            }

            diskPdos2 = diskPdos;
            diskPdos = (PDEVICE_OBJECT*) ExAllocatePool(PagedPool,
                       (numDisks + numVolumeDisks)*sizeof(PDEVICE_OBJECT));
            if (!diskPdos) {
                ExFreePool(volumeDiskPdos);
                if (diskPdos2) {
                    ExFreePool(diskPdos2);
                }
                return STATUS_INSUFFICIENT_RESOURCES;
            }
            if (diskPdos2) {
                RtlCopyMemory(diskPdos, diskPdos2,
                              numDisks*sizeof(PDEVICE_OBJECT));
                ExFreePool(diskPdos2);
            }

            for (j = 0; j < numVolumeDisks; j++) {
                for (k = 0; k < numDisks; k++) {
                    if (volumeDiskPdos[j] == diskPdos[k]) {
                        break;
                    }
                }
                if (k == numDisks) {
                    diskPdos[numDisks++] = volumeDiskPdos[j];
                }
            }

            ExFreePool(volumeDiskPdos);
        }
    }

    *WholeDiskPdos = diskPdos;
    *NumDisks = numDisks;

    return STATUS_SUCCESS;
}

BOOLEAN
FtpVolumeContainsDisks(
    IN  PFT_VOLUME          FtVolume,
    IN  PDEVICE_OBJECT*     WholeDiskPdos,
    IN  ULONG               NumDisks
    )

/*++

Routine Description:

    This routine determines whether or not the given volume contains
    any of the given disks.

Arguments:

    FtVolume    - Supplies the FT volumes.

    WholeDiskPdos   - Supplies the list of disks.

    NumDisks        - Supplies the number of disks.

Return Value:

    FALSE   - The given volume does not contain any of the given disks.

    TRUE    - The given volume contains at least one of the given disks.

--*/

{
    PDEVICE_OBJECT  wholeDiskPdo;
    ULONG           i;
    USHORT          n, j;
    PFT_VOLUME      vol;

    if (FtVolume->QueryLogicalDiskType() == FtPartition) {
        wholeDiskPdo = ((PPARTITION) FtVolume)->GetWholeDiskPdo();
        for (i = 0; i < NumDisks; i++) {
            if (wholeDiskPdo == WholeDiskPdos[i]) {
                return TRUE;
            }
        }

        return FALSE;
    }

    n = FtVolume->QueryNumberOfMembers();
    for (j = 0; j < n; j++) {
        vol = FtVolume->GetMember(j);
        if (!vol) {
            continue;
        }

        if (FtpVolumeContainsDisks(vol, WholeDiskPdos, NumDisks)) {
            return TRUE;
        }
    }

    return FALSE;
}

NTSTATUS
FtpVolumesFromDisks(
    IN  PROOT_EXTENSION     RootExtension,
    IN  PDEVICE_OBJECT*     WholeDiskPdos,
    IN  ULONG               NumDisks,
    OUT PVOLUME_EXTENSION** Extensions,
    OUT PULONG              NumVolumes
    )

/*++

Routine Description:

    This routine computes the volumes that use the given set of disks
    and returns the list of volume device extensions.

Arguments:

    RootExtension   - Supplies the root extension.

    WholeDiskPdos   - Supplies the list of disks.

    NumDisks        - Supplies the number of disks.

    Extensions      - Returns the list of volumes.

    NumVolumes      - Returns the number of volumes.

Return Value:

    NTSTATUS

--*/

{
    PVOLUME_EXTENSION*  extensions;
    ULONG               numVolumes;
    PLIST_ENTRY         l;
    PVOLUME_EXTENSION   extension;
    ULONG               i;

    extensions = (PVOLUME_EXTENSION*)
                 ExAllocatePool(PagedPool, RootExtension->NextVolumeNumber*
                                sizeof(PVOLUME_EXTENSION));
    if (!extensions) {
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    numVolumes = 0;
    for (l = RootExtension->VolumeList.Flink;
         l != &RootExtension->VolumeList; l = l->Flink) {

        extension = CONTAINING_RECORD(l, VOLUME_EXTENSION, ListEntry);
        if (extension->TargetObject) {
            for (i = 0; i < NumDisks; i++) {
                if (WholeDiskPdos[i] == extension->WholeDiskPdo) {
                    break;
                }
            }
            if (i == NumDisks) {
                continue;
            }
        } else if (extension->FtVolume) {
            if (!FtpVolumeContainsDisks(extension->FtVolume, WholeDiskPdos,
                                        NumDisks)) {

                continue;
            }
        } else {
            continue;
        }

        extensions[numVolumes++] = extension;
    }

    *Extensions = extensions;
    *NumVolumes = numVolumes;

    return STATUS_SUCCESS;
}

NTSTATUS
FtpQueryFailoverSet(
    IN  PVOLUME_EXTENSION   Extension,
    IN  PIRP                Irp
    )

/*++

Routine Description:

    This routine returns the list of disks which include the given volume
    and which make up a failover set.

Arguments:

    Extension   - Supplies the volume extension.

    Irp         - Supplies the IO request packet.

Return Value:

    NTSTATUS

--*/

{
    PIO_STACK_LOCATION      irpSp = IoGetCurrentIrpStackLocation(Irp);
    ULONG                   numVolumes, numVolumes2, numDisks, numDisks2;
    PVOLUME_EXTENSION*      extensions;
    PDEVICE_OBJECT*         diskPdos;
    NTSTATUS                status;
    PVOLUME_FAILOVER_SET    output;
    ULONG                   i;
    PDEVICE_OBJECT          deviceObject;

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

        return STATUS_INVALID_PARAMETER;
    }

    numVolumes = 1;
    extensions = (PVOLUME_EXTENSION*)
                 ExAllocatePool(PagedPool,
                                numVolumes*sizeof(PVOLUME_EXTENSION));
    if (!extensions) {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
    extensions[0] = Extension;

    diskPdos = NULL;
    numDisks = 0;

    for (;;) {

        numDisks2 = numDisks;
        if (diskPdos) {
            ExFreePool(diskPdos);
            diskPdos = NULL;
        }

        status = FtpDisksFromVolumes(extensions, numVolumes, &diskPdos,
                                     &numDisks);
        if (!NT_SUCCESS(status)) {
            break;
        }

        if (numDisks == numDisks2) {
            status = STATUS_SUCCESS;
            break;
        }

        numVolumes2 = numVolumes;
        if (extensions) {
            ExFreePool(extensions);
            extensions = NULL;
        }

        status = FtpVolumesFromDisks(Extension->Root, diskPdos, numDisks,
                                     &extensions, &numVolumes);
        if (!NT_SUCCESS(status)) {
            break;
        }

        if (numVolumes == numVolumes2) {
            status = STATUS_SUCCESS;
            break;
        }
    }

    if (extensions) {
        ExFreePool(extensions);
    }

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

    output = (PVOLUME_FAILOVER_SET) Irp->AssociatedIrp.SystemBuffer;
    output->NumberOfDisks = numDisks;
    Irp->IoStatus.Information =
            FIELD_OFFSET(VOLUME_FAILOVER_SET, DiskNumbers) +
            numDisks*sizeof(ULONG);
    if (Irp->IoStatus.Information >
        irpSp->Parameters.DeviceIoControl.OutputBufferLength) {

        Irp->IoStatus.Information = sizeof(VOLUME_FAILOVER_SET);
        if (diskPdos) {
            ExFreePool(diskPdos);
        }
        return STATUS_BUFFER_OVERFLOW;
    }

    for (i = 0; i < numDisks; i++) {
        deviceObject = IoGetAttachedDeviceReference(diskPdos[i]);
        status = FtpQueryPartitionInformation(Extension->Root, deviceObject,
                                              &output->DiskNumbers[i],
                                              NULL, NULL, NULL, NULL, NULL,
                                              NULL, NULL, NULL);
        ObDereferenceObject(deviceObject);
        if (!NT_SUCCESS(status)) {
            Irp->IoStatus.Information = 0;
            if (diskPdos) {
                ExFreePool(diskPdos);
            }
            return status;
        }
    }

    if (diskPdos) {
        ExFreePool(diskPdos);
    }

    return STATUS_SUCCESS;
}

NTSTATUS
FtpQueryVolumeNumber(
    IN  PVOLUME_EXTENSION   Extension,
    IN  PIRP                Irp
    )

/*++

Routine Description:

    This routine returns the volume number for the given volume.

Arguments:

    Extension   - Supplies the volume extension.

    Irp         - Supplies the IO request packet.

Return Value:

    NTSTATUS

--*/

{
    PIO_STACK_LOCATION  irpSp = IoGetCurrentIrpStackLocation(Irp);
    PVOLUME_NUMBER      output;

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

        return STATUS_INVALID_PARAMETER;
    }

    output = (PVOLUME_NUMBER) Irp->AssociatedIrp.SystemBuffer;
    output->VolumeNumber = Extension->VolumeNumber;
    RtlCopyMemory(output->VolumeManagerName, L"FTDISK  ", 16);

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

    return STATUS_SUCCESS;
}

NTSTATUS
FtpLogicalToPhysical(
    IN  PVOLUME_EXTENSION   Extension,
    IN  PIRP                Irp
    )

/*++

Routine Description:

    This routine returns physical disk and offset for a given volume
    logical offset.

Arguments:

    Extension   - Supplies the volume extension.

    Irp         - Supplies the IO request packet.

Return Value:

    NTSTATUS

--*/

{
    PIO_STACK_LOCATION          irpSp = IoGetCurrentIrpStackLocation(Irp);
    PVOLUME_LOGICAL_OFFSET      input;
    LONGLONG                    logicalOffset;
    PVOLUME_PHYSICAL_OFFSETS    output;
    NTSTATUS                    status;
    ULONG                       diskNumber;
    LONGLONG                    partitionOffset, partitionLength;
    PFT_VOLUME                  vol;
    PVOLUME_PHYSICAL_OFFSET     physicalOffsets;
    ULONG                       numPhysicalOffsets;
    ULONG                       i;

    if (irpSp->Parameters.DeviceIoControl.InputBufferLength <
        sizeof(VOLUME_LOGICAL_OFFSET) ||
        irpSp->Parameters.DeviceIoControl.OutputBufferLength <
        sizeof(VOLUME_PHYSICAL_OFFSETS)) {

        return STATUS_INVALID_PARAMETER;
    }

    input = (PVOLUME_LOGICAL_OFFSET) Irp->AssociatedIrp.SystemBuffer;
    logicalOffset = input->LogicalOffset;
    output = (PVOLUME_PHYSICAL_OFFSETS) Irp->AssociatedIrp.SystemBuffer;

    if (Extension->TargetObject) {
        status = FtpQueryPartitionInformation(Extension->Root,
                                              Extension->TargetObject,
                                              &diskNumber,
                                              &partitionOffset, NULL, NULL,
                                              &partitionLength, NULL, NULL,
                                              NULL, NULL);
        if (!NT_SUCCESS(status)) {
            return status;
        }

        if (logicalOffset < 0 ||
            partitionLength <= logicalOffset) {
            return STATUS_INVALID_PARAMETER;
        }

        output->NumberOfPhysicalOffsets = 1;
        output->PhysicalOffset[0].DiskNumber = diskNumber;
        output->PhysicalOffset[0].Offset = partitionOffset + logicalOffset;

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

        return status;
    }

    vol = Extension->FtVolume;
    ASSERT(vol);

    status = vol->QueryPhysicalOffsets(logicalOffset, &physicalOffsets,
                                       &numPhysicalOffsets);
    if (!NT_SUCCESS(status)) {
        return status;
    }

    Irp->IoStatus.Information = FIELD_OFFSET(VOLUME_PHYSICAL_OFFSETS,
                                             PhysicalOffset) +
                                numPhysicalOffsets*
                                sizeof(VOLUME_PHYSICAL_OFFSET);

    output->NumberOfPhysicalOffsets = numPhysicalOffsets;

    if (Irp->IoStatus.Information >
        irpSp->Parameters.DeviceIoControl.OutputBufferLength) {

        Irp->IoStatus.Information = FIELD_OFFSET(VOLUME_PHYSICAL_OFFSETS,
                                                 PhysicalOffset);
        ExFreePool(physicalOffsets);
        return STATUS_BUFFER_OVERFLOW;
    }

    for (i = 0; i < numPhysicalOffsets; i++) {
        output->PhysicalOffset[i] = physicalOffsets[i];
    }

    ExFreePool(physicalOffsets);

    return STATUS_SUCCESS;
}

NTSTATUS
FtpPhysicalToLogical(
    IN  PVOLUME_EXTENSION   Extension,
    IN  PIRP                Irp
    )

/*++

Routine Description:

    This routine returns the volume logical offset for a given disk number
    and physical offset.

Arguments:

    Extension   - Supplies the volume extension.

    Irp         - Supplies the IO request packet.

Return Value:

    NTSTATUS

--*/

{
    PIO_STACK_LOCATION          irpSp = IoGetCurrentIrpStackLocation(Irp);
    PVOLUME_PHYSICAL_OFFSET     input;
    ULONG                       diskNumber, otherDiskNumber;
    LONGLONG                    physicalOffset;
    PVOLUME_LOGICAL_OFFSET      output;
    NTSTATUS                    status;
    LONGLONG                    partitionOffset, partitionLength;
    PFT_VOLUME                  vol;
    LONGLONG                    logicalOffset;

    if (irpSp->Parameters.DeviceIoControl.InputBufferLength <
        sizeof(VOLUME_PHYSICAL_OFFSET) ||
        irpSp->Parameters.DeviceIoControl.OutputBufferLength <
        sizeof(VOLUME_LOGICAL_OFFSET)) {

        return STATUS_INVALID_PARAMETER;
    }

    input = (PVOLUME_PHYSICAL_OFFSET) Irp->AssociatedIrp.SystemBuffer;
    diskNumber = input->DiskNumber;
    physicalOffset = input->Offset;
    output = (PVOLUME_LOGICAL_OFFSET) Irp->AssociatedIrp.SystemBuffer;

    if (Extension->TargetObject) {
        status = FtpQueryPartitionInformation(Extension->Root,
                                              Extension->TargetObject,
                                              &otherDiskNumber,
                                              &partitionOffset, NULL, NULL,
                                              &partitionLength, NULL, NULL,
                                              NULL, NULL);
        if (!NT_SUCCESS(status)) {
            return status;
        }

        if (diskNumber != otherDiskNumber ||
            physicalOffset < partitionOffset ||
            partitionOffset + partitionLength <= physicalOffset) {

            return STATUS_INVALID_PARAMETER;
        }

        output->LogicalOffset = physicalOffset - partitionOffset;

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

        return status;
    }

    vol = Extension->FtVolume;
    ASSERT(vol);

    status = vol->QueryLogicalOffset(input, &logicalOffset);
    if (!NT_SUCCESS(status)) {
        return status;
    }

    output->LogicalOffset = logicalOffset;
    Irp->IoStatus.Information = sizeof(VOLUME_LOGICAL_OFFSET);

    return status;
}

BOOLEAN
FtpIsReplicatedPartition(
    IN  PFT_VOLUME  FtVolume
    )

{
    PFT_VOLUME  m0, m1;

    if (FtVolume->QueryLogicalDiskType() == FtPartition) {
        return TRUE;
    }

    if (FtVolume->QueryLogicalDiskType() != FtMirrorSet) {
        return FALSE;
    }

    m0 = FtVolume->GetMember(0);
    m1 = FtVolume->GetMember(1);

    if (m0 && !FtpIsReplicatedPartition(m0)) {
        return FALSE;
    }

    if (m1 && !FtpIsReplicatedPartition(m1)) {
        return FALSE;
    }

    if (!m0 && !m1) {
        return FALSE;
    }

    return TRUE;
}

NTSTATUS
FtpIsPartition(
    IN  PVOLUME_EXTENSION   Extension,
    IN  PIRP                Irp
    )

/*++

Routine Description:

    This routine determines whether the given volume is installable. 
    To be an installable volume on Whistler, the volume must be a basic 
    partition. 

    We will disallow installing to Ft mirrors on Whistler, because we will
    offline Ft volumes after a Whistler install\upgrade.
    
    This call will return STATUS_UNSUCCESSFUL for all volumes that are
    not a simple basic partition, e.g., mirrors, RAID5, stripe sets
    and volume sets.

Arguments:

    Extension   - Supplies the volume extension.

    Irp         - Supplies the IO request packet.

Return Value:

    NTSTATUS

--*/

{
    NTSTATUS    status;

    if (Extension->TargetObject) {
        status = STATUS_SUCCESS;
    } 
    else if (Extension->FtVolume && FtpIsReplicatedPartition(Extension->FtVolume)) {
        status = STATUS_SUCCESS;
    } 
    else {
        status = STATUS_UNSUCCESSFUL;
    }

    return status;
}

NTSTATUS
FtpSetGptAttributesOnDisk(
    IN  PDEVICE_OBJECT  Partition,
    IN  ULONGLONG       GptAttributes
    )

{
    KEVENT                          event;
    PIRP                            irp;
    PARTITION_INFORMATION_EX        partInfo;
    IO_STATUS_BLOCK                 ioStatus;
    NTSTATUS                        status;
    SET_PARTITION_INFORMATION_EX    setPartInfo;

    KeInitializeEvent(&event, NotificationEvent, FALSE);

    irp = IoBuildDeviceIoControlRequest(IOCTL_DISK_GET_PARTITION_INFO_EX,
                                        Partition, NULL, 0, &partInfo,
                                        sizeof(partInfo), FALSE, &event,
                                        &ioStatus);
    if (!irp) {
        return STATUS_INSUFFICIENT_RESOURCES;
    }

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

    ASSERT(partInfo.PartitionStyle == PARTITION_STYLE_GPT);

    setPartInfo.PartitionStyle = partInfo.PartitionStyle;
    setPartInfo.Gpt = partInfo.Gpt;
    setPartInfo.Gpt.Attributes = GptAttributes;

    irp = IoBuildDeviceIoControlRequest(IOCTL_DISK_SET_PARTITION_INFO_EX,
                                        Partition, &setPartInfo,
                                        sizeof(setPartInfo), NULL, 0, FALSE,
                                        &event, &ioStatus);
    if (!irp) {
        return STATUS_INSUFFICIENT_RESOURCES;
    }

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

    return STATUS_SUCCESS;
}

NTSTATUS
FtpCheckSecurity(
    IN  PVOLUME_EXTENSION   Extension,
    IN  PIRP                Irp
    )

{
    SECURITY_SUBJECT_CONTEXT    securityContext;
    BOOLEAN                     accessGranted;
    NTSTATUS                    status;
    ACCESS_MASK                 grantedAccess;

    SeCaptureSubjectContext(&securityContext);
    SeLockSubjectContext(&securityContext);

    accessGranted = FALSE;
    status = STATUS_ACCESS_DENIED;

    _try {

        accessGranted = SeAccessCheck(
                        Extension->DeviceObject->SecurityDescriptor,
                        &securityContext, TRUE, FILE_READ_DATA, 0, NULL,
                        IoGetFileObjectGenericMapping(), Irp->RequestorMode,
                        &grantedAccess, &status);

    } _finally {
        SeUnlockSubjectContext(&securityContext);
        SeReleaseSubjectContext(&securityContext);
    }

    if (!accessGranted) {
        return status;
    }

    return STATUS_SUCCESS;
}

NTSTATUS
FtpQueryRegistryRevertEntriesCallback(
    IN  PWSTR   ValueName,
    IN  ULONG   ValueType,
    IN  PVOID   ValueData,
    IN  ULONG   ValueLength,
    IN  PVOID   RevertEntries,
    IN  PVOID   NumberOfRevertEntries
    )

{
    PFTP_GPT_ATTRIBUTE_REVERT_ENTRY*    revertEntries = (PFTP_GPT_ATTRIBUTE_REVERT_ENTRY*) RevertEntries;
    PULONG                              pn = (PULONG) NumberOfRevertEntries;

    if (ValueType != REG_BINARY) {
        return STATUS_SUCCESS;
    }

    (*revertEntries) = (PFTP_GPT_ATTRIBUTE_REVERT_ENTRY)
                       ExAllocatePool(PagedPool, ValueLength);
    if (!(*revertEntries)) {
        return STATUS_SUCCESS;
    }

    RtlCopyMemory((*revertEntries), ValueData, ValueLength);
    *pn = ValueLength/sizeof(FTP_GPT_ATTRIBUTE_REVERT_ENTRY);

    return STATUS_SUCCESS;
}

NTSTATUS
FtpQueryRegistryRevertEntries(
    IN  PROOT_EXTENSION                     RootExtension,
    OUT PFTP_GPT_ATTRIBUTE_REVERT_ENTRY*    RevertEntries,
    OUT PULONG                              NumberOfRevertEntries
    )

{
    RTL_QUERY_REGISTRY_TABLE        queryTable[2];
    PFTP_GPT_ATTRIBUTE_REVERT_ENTRY revertEntries;
    ULONG                           n;

    revertEntries = NULL;
    n = 0;

    RtlZeroMemory(queryTable, 2*sizeof(RTL_QUERY_REGISTRY_TABLE));
    queryTable[0].QueryRoutine = FtpQueryRegistryRevertEntriesCallback;
    queryTable[0].Flags = RTL_QUERY_REGISTRY_REQUIRED;
    queryTable[0].Name = REVERT_GPT_ATTRIBUTES_REGISTRY_NAME;
    queryTable[0].EntryContext = &n;

    RtlQueryRegistryValues(RTL_REGISTRY_ABSOLUTE,
                           RootExtension->DiskPerfRegistryPath.Buffer,
                           queryTable, &revertEntries, NULL);

    if (!revertEntries) {
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    *RevertEntries = revertEntries;
    *NumberOfRevertEntries = n;

    return STATUS_SUCCESS;
}

NTSTATUS
FtpStoreGptAttributeRevertRecord(
    IN  PROOT_EXTENSION RootExtension,
    IN  ULONG           MbrSignature,
    IN  GUID*           GptPartitionGuid,
    IN  ULONGLONG       GptAttributes
    )

{
    NTSTATUS                        status;
    PFTP_GPT_ATTRIBUTE_REVERT_ENTRY p, q;
    ULONG                           n, i;

    status = FtpQueryRegistryRevertEntries(RootExtension, &p, &n);
    if (!NT_SUCCESS(status)) {
        p = NULL;
        n = 0;
    }

    for (i = 0; i < n; i++) {
        if (MbrSignature) {
            if (MbrSignature == p[i].MbrSignature) {
                break;
            }
        } else {
            if (IsEqualGUID(*GptPartitionGuid, p[i].PartitionUniqueId)) {
                break;
            }
        }
    }

    if (i == n) {
        q = (PFTP_GPT_ATTRIBUTE_REVERT_ENTRY)
            ExAllocatePool(PagedPool,
                           (n + 1)*sizeof(FTP_GPT_ATTRIBUTE_REVERT_ENTRY));
        if (!q) {
            if (p) {
                ExFreePool(p);
            }
            return STATUS_INSUFFICIENT_RESOURCES;
        }

        if (n && p) {
            RtlCopyMemory(q, p, n*sizeof(FTP_GPT_ATTRIBUTE_REVERT_ENTRY));
        }
        if (p) {
            ExFreePool(p);
        }

        p = q;
        n++;
    }

    RtlZeroMemory(&p[i], sizeof(FTP_GPT_ATTRIBUTE_REVERT_ENTRY));
    if (GptPartitionGuid) {
        p[i].PartitionUniqueId = *GptPartitionGuid;
    }
    p[i].GptAttributes = GptAttributes;
    p[i].MbrSignature = MbrSignature;

    status = RtlWriteRegistryValue(RTL_REGISTRY_ABSOLUTE,
                                   RootExtension->DiskPerfRegistryPath.Buffer,
                                   REVERT_GPT_ATTRIBUTES_REGISTRY_NAME,
                                   REG_BINARY, p,
                                   n*sizeof(FTP_GPT_ATTRIBUTE_REVERT_ENTRY));

    ExFreePool(p);

    return status;
}

VOID
FtpDeleteGptAttributeRevertRecord(
    IN  PROOT_EXTENSION RootExtension,
    IN  ULONG           MbrSignature,
    IN  GUID*           GptPartitionGuid
    )

{
    NTSTATUS                        status;
    PFTP_GPT_ATTRIBUTE_REVERT_ENTRY p, q;
    ULONG                           n, i;

    status = FtpQueryRegistryRevertEntries(RootExtension, &p, &n);
    if (!NT_SUCCESS(status)) {
        return;
    }

    for (i = 0; i < n; i++) {
        if (MbrSignature) {
            if (MbrSignature == p[i].MbrSignature) {
                break;
            }
        } else {
            if (IsEqualGUID(*GptPartitionGuid, p[i].PartitionUniqueId)) {
                break;
            }
        }
    }

    if (i == n) {
        return;
    }

    if (i + 1 < n) {
        RtlMoveMemory(&p[i], &p[i + 1],
                      (n - i - 1)*sizeof(FTP_GPT_ATTRIBUTE_REVERT_ENTRY));
    }

    n--;

    if (n) {
        RtlWriteRegistryValue(RTL_REGISTRY_ABSOLUTE,
                              RootExtension->DiskPerfRegistryPath.Buffer,
                              REVERT_GPT_ATTRIBUTES_REGISTRY_NAME,
                              REG_BINARY, p,
                              n*sizeof(FTP_GPT_ATTRIBUTE_REVERT_ENTRY));
    } else {
        RtlDeleteRegistryValue(RTL_REGISTRY_ABSOLUTE,
                               RootExtension->DiskPerfRegistryPath.Buffer,
                               REVERT_GPT_ATTRIBUTES_REGISTRY_NAME);
    }

    ExFreePool(p);

    return;
}

VOID
FtpApplyGptAttributes(
    IN  PVOLUME_EXTENSION   Extension,
    IN  ULONGLONG           GptAttributes
    )

{
    NTSTATUS    status;

    if (GptAttributes&GPT_BASIC_DATA_ATTRIBUTE_READ_ONLY) {
        if (!Extension->IsReadOnly) {
            FtpZeroRefCallback(Extension, FtpVolumeReadOnlyCallback,
                               (PVOID) TRUE, TRUE);
        }
    } else {
        if (Extension->IsReadOnly) {
            FtpZeroRefCallback(Extension, FtpVolumeReadOnlyCallback,
                               (PVOID) FALSE, TRUE);
        }
    }

    if (GptAttributes&GPT_BASIC_DATA_ATTRIBUTE_HIDDEN) {
        if (!Extension->IsHidden) {
            Extension->IsHidden = TRUE;
            if (Extension->MountedDeviceInterfaceName.Buffer) {
                IoSetDeviceInterfaceState(
                        &Extension->MountedDeviceInterfaceName, FALSE);
            }
        }
    } else {
        if (Extension->IsHidden) {
            Extension->IsHidden = FALSE;

            if (!Extension->MountedDeviceInterfaceName.Buffer) {
                if (!Extension->IsStarted) {
                    return;
                }
                status = IoRegisterDeviceInterface(
                         Extension->DeviceObject,
                         &MOUNTDEV_MOUNTED_DEVICE_GUID, NULL,
                         &Extension->MountedDeviceInterfaceName);
                if (!NT_SUCCESS(status)) {
                    return;
                }
            }

            IoSetDeviceInterfaceState(
                    &Extension->MountedDeviceInterfaceName, TRUE);
        }
    }
}

VOID
FtpRevertGptAttributes(
    IN  PVOLUME_EXTENSION   Extension
    )

{
    PFT_LOGICAL_DISK_INFORMATION    diskInfo;
    ULONG                           signature;
    PLIST_ENTRY                     l;
    PVOLUME_EXTENSION               extension;

    Extension->RevertOnCloseFileObject = NULL;

    if (!Extension->IsGpt) {

        diskInfo = Extension->Root->DiskInfoSet->FindLogicalDiskInformation(
                   Extension->WholeDiskPdo);
        if (diskInfo) {
            diskInfo->SetGptAttributes(Extension->GptAttributesToRevertTo);
        }

        signature = FtpQueryDiskSignatureCache(Extension);
        if (signature) {
            FtpDeleteGptAttributeRevertRecord(Extension->Root, signature,
                                              NULL);
        }

        return;
    }

    l = &Extension->Root->VolumeList;
    extension = Extension;

    for (;;) {

        FtpSetGptAttributesOnDisk(extension->TargetObject,
                                  Extension->GptAttributesToRevertTo);

        FtpDeleteGptAttributeRevertRecord(Extension->Root, 0,
                                          &extension->UniqueIdGuid);

        if (!Extension->ApplyToAllConnectedVolumes) {
            break;
        }

        for (l = l->Flink; l != &Extension->Root->VolumeList; l = l->Flink) {

            extension = CONTAINING_RECORD(l, VOLUME_EXTENSION, ListEntry);
            if (extension == Extension ||
                extension->WholeDiskPdo != Extension->WholeDiskPdo) {

                continue;
            }
        }

        if (l == &Extension->Root->VolumeList) {
            break;
        }
    }
}

NTSTATUS
FtpSetGptAttributes(
    IN  PVOLUME_EXTENSION   Extension,
    IN  PIRP                Irp
    )

/*++

Routine Description:

    This routine sets the given GPT attributes on the given volume.  If the
    'RevertOnClose' bit is set then the GPT attributes will go back to
    their original state when the handle that this IOCTL was sent using
    gets an IRP_MJ_CLEANUP.  In order for this driver to get the CLEANUP, the
    handle must not be opened with read or write access but just
    read_attributes.  If the 'RevertOnClose' bit is set then the effect of
    the bit changes will not be applied to this volume and every effort will
    be made so that if the system crashes, the bits will be properly reverted.

    If the 'RevertOnClose' bit is clear then the effect of the bit changes will
    be immediate.  If READ_ONLY is set, for example, the volume will instantly
    become read only and all writes will fail.  The caller should normally
    only issue READ_ONLY request after issueing an
    IOCTL_VOLSNAP_FLUSH_AND_HOLD_WRITES and before issueing the corresponding
    IOCTL_VOLSNAP_RELEASE_WRITES.  If HIDDEN is set, then the volume will
    take itself out of the list of volumes used by the MOUNTMGR.  Similarly,
    if the HIDDEN bit is cleared then the volume will put itself back in
    the list of volumes used by the MOUNTMGR.

    If the 'ApplyToAllConnectedVolumes' bit is set then the GPT attributes
    will be set for all volumes that are joined by a disk relation.  In
    the basic disk case, this means all partitions on the disk.  In the
    dynamic disk case, this means all volumes in the group.  This IOCTL will
    fail on MBR basic disks unless this is set because MBR basic disks do
    not support the GPT attributes per partition but per disk.

Arguments:

    Extension   - Supplies the volume extension.

    Irp         - Supplies the I/O request packet.

Return Value:

    NTSTATUS

--*/

{
    PIO_STACK_LOCATION                      irpSp = IoGetCurrentIrpStackLocation(Irp);
    PVOLUME_SET_GPT_ATTRIBUTES_INFORMATION  input = (PVOLUME_SET_GPT_ATTRIBUTES_INFORMATION) Irp->AssociatedIrp.SystemBuffer;
    NTSTATUS                                status;
    UCHAR                                   partitionType;
    PFT_LOGICAL_DISK_INFORMATION            diskInfo;
    ULONGLONG                               gptAttributes;
    ULONG                                   signature;
    PLIST_ENTRY                             l;
    PVOLUME_EXTENSION                       extension;
    GUID                                    partitionTypeGuid;

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

        return STATUS_INVALID_PARAMETER;
    }

    if (input->Reserved1 || input->Reserved2 || !Extension->TargetObject) {
        return STATUS_INVALID_PARAMETER;
    }

    if (!Extension->IsGpt) {
        if (!input->ApplyToAllConnectedVolumes) {
            return STATUS_INVALID_PARAMETER;
        }

        status = FtpQueryPartitionInformation(Extension->Root,
                                              Extension->TargetObject,
                                              NULL, NULL, NULL, &partitionType,
                                              NULL, NULL, NULL, NULL, NULL);
        if (!NT_SUCCESS(status)) {
            return status;
        }

        if (!IsRecognizedPartition(partitionType)) {
            return STATUS_INVALID_PARAMETER;
        }

        diskInfo = Extension->Root->DiskInfoSet->
                   FindLogicalDiskInformation(Extension->WholeDiskPdo);
        if (!diskInfo) {
            return STATUS_INVALID_PARAMETER;
        }

        if (input->RevertOnClose) {
            gptAttributes = diskInfo->GetGptAttributes();
            Extension->GptAttributesToRevertTo = gptAttributes;
            Extension->RevertOnCloseFileObject = irpSp->FileObject;
            Extension->ApplyToAllConnectedVolumes =
                    input->ApplyToAllConnectedVolumes;
            signature = FtpQueryDiskSignatureCache(Extension);
            if (!signature) {
                Extension->RevertOnCloseFileObject = NULL;
                return STATUS_INSUFFICIENT_RESOURCES;
            }
            status = FtpStoreGptAttributeRevertRecord(Extension->Root,
                                                      signature, NULL,
                                                      gptAttributes);
            if (!NT_SUCCESS(status)) {
                Extension->RevertOnCloseFileObject = NULL;
                return status;
            }
        }

        status = diskInfo->SetGptAttributes(input->GptAttributes);
        if (!NT_SUCCESS(status)) {
            if (input->RevertOnClose) {
                Extension->RevertOnCloseFileObject = NULL;
                FtpDeleteGptAttributeRevertRecord(Extension->Root, signature,
                                                  NULL);
            }
            return status;
        }

        if (!input->RevertOnClose) {

            FtpApplyGptAttributes(Extension, input->GptAttributes);
            Extension->MbrGptAttributes = input->GptAttributes;

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

                extension = CONTAINING_RECORD(l, VOLUME_EXTENSION, ListEntry);
                if (extension == Extension ||
                    extension->WholeDiskPdo != Extension->WholeDiskPdo) {

                    continue;
                }

                status = FtpQueryPartitionInformation(extension->Root,
                                                      extension->TargetObject,
                                                      NULL, NULL, NULL,
                                                      &partitionType, NULL,
                                                      NULL, NULL, NULL, NULL);
                if (!NT_SUCCESS(status) ||
                    !IsRecognizedPartition(partitionType)) {

                    continue;
                }

                FtpApplyGptAttributes(extension, input->GptAttributes);
                extension->MbrGptAttributes = input->GptAttributes;
            }
        }

        return STATUS_SUCCESS;
    }

    l = &Extension->Root->VolumeList;
    extension = Extension;

    for (;;) {

        status = FtpQueryPartitionInformation(Extension->Root,
                                              extension->TargetObject,
                                              NULL, NULL, NULL, NULL, NULL,
                                              &partitionTypeGuid, NULL,
                                              NULL, &gptAttributes);
        if (!NT_SUCCESS(status)) {
            return status;
        }
        if (!IsEqualGUID(partitionTypeGuid, PARTITION_BASIC_DATA_GUID)) {
            if (extension == Extension) {
                return STATUS_INVALID_PARAMETER;
            }
            goto NextVolume;
        }

        if (input->RevertOnClose) {

            if (extension == Extension) {
                Extension->RevertOnCloseFileObject = irpSp->FileObject;
                Extension->GptAttributesToRevertTo = gptAttributes;
                Extension->ApplyToAllConnectedVolumes =
                        input->ApplyToAllConnectedVolumes;
            }

            status = FtpStoreGptAttributeRevertRecord(
                        Extension->Root, 0, &extension->UniqueIdGuid,
                        gptAttributes);
            if (!NT_SUCCESS(status)) {
                if (input->RevertOnClose) {
                    FtpRevertGptAttributes(Extension);
                }
                return status;
            }
        }

        status = FtpSetGptAttributesOnDisk(extension->TargetObject,
                                           input->GptAttributes);
        if (!NT_SUCCESS(status)) {
            if (input->RevertOnClose) {
                FtpRevertGptAttributes(Extension);
            }
            return status;
        }

        if (!input->RevertOnClose) {
            FtpApplyGptAttributes(extension, input->GptAttributes);
        }

NextVolume:
        if (!input->ApplyToAllConnectedVolumes) {
            break;
        }

        for (l = l->Flink; l != &Extension->Root->VolumeList; l = l->Flink) {

            extension = CONTAINING_RECORD(l, VOLUME_EXTENSION, ListEntry);
            if (extension == Extension ||
                extension->WholeDiskPdo != Extension->WholeDiskPdo) {

                continue;
            }
        }

        if (l == &Extension->Root->VolumeList) {
            break;
        }
    }

    return STATUS_SUCCESS;
}

NTSTATUS
FtpGetGptAttributes(
    IN  PVOLUME_EXTENSION   Extension,
    IN  PIRP                Irp
    )

/*++

Routine Description:

    This routine returns the current GPT attributes definitions for the volume.

Arguments:

    Extension   - Supplies the volume extension.

    Irp         - Supplies the I/O request packet.

Return Value:

    NTSTATUS

--*/

{
    PIO_STACK_LOCATION                      irpSp = IoGetCurrentIrpStackLocation(Irp);
    PVOLUME_GET_GPT_ATTRIBUTES_INFORMATION  output = (PVOLUME_GET_GPT_ATTRIBUTES_INFORMATION) Irp->AssociatedIrp.SystemBuffer;
    NTSTATUS                                status;
    UCHAR                                   partitionType;
    GUID                                    gptPartitionType;
    ULONGLONG                               gptAttributes;
    PFT_LOGICAL_DISK_INFORMATION            diskInfo;

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

    if (irpSp->Parameters.DeviceIoControl.OutputBufferLength <
        Irp->IoStatus.Information) {

        Irp->IoStatus.Information = 0;
        return STATUS_INVALID_PARAMETER;
    }


    if (!Extension->TargetObject) {
        Irp->IoStatus.Information = 0;
        return STATUS_INVALID_PARAMETER;
    }

    status = FtpQueryPartitionInformation(Extension->Root,
                                          Extension->TargetObject, NULL, NULL,
                                          NULL, &partitionType, NULL,
                                          &gptPartitionType, NULL, NULL,
                                          &gptAttributes);
    if (!NT_SUCCESS(status)) {
        Irp->IoStatus.Information = 0;
        return status;
    }

    if (Extension->IsGpt) {
        if (!IsEqualGUID(gptPartitionType, PARTITION_BASIC_DATA_GUID)) {
            Irp->IoStatus.Information = 0;
            return STATUS_INVALID_PARAMETER;
        }
        output->GptAttributes = gptAttributes;
        return STATUS_SUCCESS;
    }

    if (!IsRecognizedPartition(partitionType)) {
        Irp->IoStatus.Information = 0;
        return STATUS_INVALID_PARAMETER;
    }

    diskInfo = Extension->Root->DiskInfoSet->
               FindLogicalDiskInformation(Extension->WholeDiskPdo);
    if (!diskInfo) {
        Irp->IoStatus.Information = 0;
        return STATUS_INVALID_PARAMETER;
    }

    gptAttributes = diskInfo->GetGptAttributes();
    output->GptAttributes = gptAttributes;

    return STATUS_SUCCESS;
}

NTSTATUS
FtpQueryHiddenVolumes(
    IN  PROOT_EXTENSION RootExtension,
    IN  PIRP            Irp
    )

/*++

Routine Description:

    This routine returns a list of hidden volumes.  Hidden volumes are those
    that do not give PNP VolumeClassGuid notification.

Arguments:

    RootExtension   - Supplies the root extension.

    Irp             - Supplies the IO request packet.

Return Value:

    NTSTATUS

-*/

{
    PIO_STACK_LOCATION      irpSp = IoGetCurrentIrpStackLocation(Irp);
    PVOLMGR_HIDDEN_VOLUMES  output;
    PLIST_ENTRY             l;
    PVOLUME_EXTENSION       extension;
    WCHAR                   buffer[100];
    UNICODE_STRING          name;
    PWCHAR                  buf;

    Irp->IoStatus.Information = FIELD_OFFSET(VOLMGR_HIDDEN_VOLUMES, MultiSz);

    if (irpSp->Parameters.DeviceIoControl.OutputBufferLength <
        Irp->IoStatus.Information) {

        Irp->IoStatus.Information = 0;
        return STATUS_INVALID_PARAMETER;
    }

    output = (PVOLMGR_HIDDEN_VOLUMES) Irp->AssociatedIrp.SystemBuffer;

    output->MultiSzLength = sizeof(WCHAR);

    for (l = RootExtension->VolumeList.Flink; l != &RootExtension->VolumeList;
         l = l->Flink) {

        extension = CONTAINING_RECORD(l, VOLUME_EXTENSION, ListEntry);
        if (!extension->IsHidden || !extension->IsInstalled) {
            continue;
        }

        swprintf(buffer, L"\\Device\\HarddiskVolume%d",
                 extension->VolumeNumber);
        RtlInitUnicodeString(&name, buffer);

        output->MultiSzLength += name.Length + sizeof(WCHAR);
    }

    if (irpSp->Parameters.DeviceIoControl.OutputBufferLength <
        Irp->IoStatus.Information + output->MultiSzLength) {

        return STATUS_BUFFER_OVERFLOW;
    }

    Irp->IoStatus.Information += output->MultiSzLength;
    buf = output->MultiSz;

    for (l = RootExtension->VolumeList.Flink; l != &RootExtension->VolumeList;
         l = l->Flink) {

        extension = CONTAINING_RECORD(l, VOLUME_EXTENSION, ListEntry);
        if (!extension->IsHidden || !extension->IsInstalled) {
            continue;
        }

        swprintf(buf, L"\\Device\\HarddiskVolume%d", extension->VolumeNumber);
        RtlInitUnicodeString(&name, buf);

        buf += name.Length/sizeof(WCHAR) + 1;
    }

    *buf = 0;

    return STATUS_SUCCESS;
}

NTSTATUS
FtpCheckOfflineOwner(
    IN  PVOLUME_EXTENSION   Extension,
    IN  PIRP                Irp
    )

{
    PIO_STACK_LOCATION  irpSp = IoGetCurrentIrpStackLocation(Irp);
    GUID*               guid = (GUID*) Irp->AssociatedIrp.SystemBuffer;

    if (!Extension->OfflineOwner) {
        return STATUS_SUCCESS;
    }

    if (irpSp->Parameters.DeviceIoControl.InputBufferLength < sizeof(GUID)) {
        return STATUS_FILE_LOCK_CONFLICT;
    }

    if (!IsEqualGUID(*guid, *(Extension->OfflineOwner))) {
        return STATUS_FILE_LOCK_CONFLICT;
    }

    return STATUS_SUCCESS;
}

NTSTATUS
FtpAddOfflineOwner(
    IN  PVOLUME_EXTENSION   Extension,
    IN  PIRP                Irp
    )

{
    PIO_STACK_LOCATION  irpSp = IoGetCurrentIrpStackLocation(Irp);
    GUID*               guid = (GUID*) Irp->AssociatedIrp.SystemBuffer;

    if (irpSp->Parameters.DeviceIoControl.InputBufferLength < sizeof(GUID)) {
        if (Extension->OfflineOwner) {
            ExFreePool(Extension->OfflineOwner);
            Extension->OfflineOwner = NULL;
        }
        return STATUS_SUCCESS;
    }

    if (!Extension->OfflineOwner) {
        Extension->OfflineOwner = (GUID*)
                                  ExAllocatePool(NonPagedPool, sizeof(GUID));
        if (!Extension->OfflineOwner) {
            return STATUS_INSUFFICIENT_RESOURCES;
        }
    }

    *(Extension->OfflineOwner) = *guid;

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

/*++

Routine Description:

    This routine is the dispatch for IRP_MJ_DEVICE_CONTROL.

Arguments:

    DeviceObject    - Supplies the device object.

    Irp             - Supplies the IO request packet.

Return Value:

    NTSTATUS

--*/

{
    PVOLUME_EXTENSION                       extension = (PVOLUME_EXTENSION) DeviceObject->DeviceExtension;
    PROOT_EXTENSION                         rootExtension = extension->Root;
    PIO_STACK_LOCATION                      irpSp = IoGetCurrentIrpStackLocation(Irp);
    NTSTATUS                                status;
    PFT_VOLUME                              vol;
    PDISPATCH_TP                            packet;
    PVERIFY_INFORMATION                     verifyInfo;
    PSET_PARTITION_INFORMATION              setPartitionInfo;
    PSET_PARTITION_INFORMATION_EX           setPartitionInfoEx;
    PDEVICE_OBJECT                          targetObject;
    KEVENT                                  event;
    PPARTITION_INFORMATION                  partInfo;
    PPARTITION_INFORMATION_EX               partInfoEx;
    PDISK_GEOMETRY                          diskGeometry;
    PFT_LOGICAL_DISK_INFORMATION_SET        diskInfoSet;
    PFT_SET_INFORMATION                     setInfo;
    FT_LOGICAL_DISK_ID                      diskId;
    PFT_MIRROR_AND_SWP_STATE_INFORMATION    stateInfo;
    PFT_SPECIAL_READ                        specialRead;
    PFT_QUERY_LOGICAL_DISK_ID_OUTPUT        queryLogicalDiskIdOutput;
    PGET_LENGTH_INFORMATION                 lengthInfo;
    ULONG                                   cylinderSize;

    Irp->IoStatus.Information = 0;

    if (extension->DeviceExtensionType == DEVICE_EXTENSION_ROOT) {

        switch (irpSp->Parameters.DeviceIoControl.IoControlCode) {

            case FT_CONFIGURE:
                status = STATUS_INVALID_PARAMETER;
                break;

            case FT_CREATE_LOGICAL_DISK:
                FtpAcquire(rootExtension);
                status = FtpCreateLogicalDisk(rootExtension, Irp);
                FtpRelease(rootExtension);
                break;

            case FT_BREAK_LOGICAL_DISK:
                FtpAcquire(rootExtension);
                status = FtpBreakLogicalDisk(rootExtension, Irp);
                FtpRelease(rootExtension);
                break;

            case FT_ENUMERATE_LOGICAL_DISKS:
                FtpAcquire(rootExtension);
                status = FtpEnumerateLogicalDisks(rootExtension, Irp);
                FtpRelease(rootExtension);
                break;

            case FT_QUERY_LOGICAL_DISK_INFORMATION:
                FtpAcquire(rootExtension);
                status = FtpQueryLogicalDiskInformation(rootExtension, Irp);
                FtpRelease(rootExtension);
                break;

            case FT_ORPHAN_LOGICAL_DISK_MEMBER:
                FtpAcquire(rootExtension);
                status = FtpOrphanLogicalDiskMember(rootExtension, Irp);
                FtpRelease(rootExtension);
                break;

            case FT_REPLACE_LOGICAL_DISK_MEMBER:
                FtpAcquire(rootExtension);
                status = FtpReplaceLogicalDiskMember(rootExtension, Irp);
                FtpRelease(rootExtension);
                break;

            case FT_QUERY_NT_DEVICE_NAME_FOR_LOGICAL_DISK:
                FtpAcquire(rootExtension);
                status = FtpQueryNtDeviceNameForLogicalDisk(rootExtension, Irp);
                FtpRelease(rootExtension);
                break;

            case FT_INITIALIZE_LOGICAL_DISK:
                FtpAcquire(rootExtension);
                status = FtpInitializeLogicalDisk(rootExtension, Irp);
                FtpRelease(rootExtension);
                break;

            case FT_QUERY_DRIVE_LETTER_FOR_LOGICAL_DISK:
                FtpAcquire(rootExtension);
                status = FtpQueryDriveLetterForLogicalDisk(rootExtension, Irp);
                FtpRelease(rootExtension);
                break;

            case FT_CHECK_IO:
                FtpAcquire(rootExtension);
                status = FtpCheckIo(rootExtension, Irp);
                FtpRelease(rootExtension);
                break;

            case FT_SET_DRIVE_LETTER_FOR_LOGICAL_DISK:
                FtpAcquire(rootExtension);
                status = FtpSetDriveLetterForLogicalDisk(rootExtension, Irp);
                FtpRelease(rootExtension);
                break;

            case FT_QUERY_NT_DEVICE_NAME_FOR_PARTITION:
                FtpAcquire(rootExtension);
                status = FtpQueryNtDeviceNameForPartition(rootExtension, Irp);
                FtpRelease(rootExtension);
                break;

            case FT_CHANGE_NOTIFY:
                FtpAcquire(rootExtension);
                status = FtpChangeNotify(rootExtension, Irp);
                FtpRelease(rootExtension);
                break;

            case FT_STOP_SYNC_OPERATIONS:
                FtpAcquire(rootExtension);
                status = FtpStopSyncOperations(rootExtension, Irp);
                FtpRelease(rootExtension);
                break;

            case IOCTL_VOLMGR_QUERY_HIDDEN_VOLUMES:
                KeEnterCriticalRegion();
                FtpAcquire(rootExtension);
                status = FtpQueryHiddenVolumes(rootExtension, Irp);
                FtpRelease(rootExtension);
                KeLeaveCriticalRegion();
                break;

            default:
                status = STATUS_INVALID_PARAMETER;
                break;

        }

        if (status != STATUS_PENDING) {
            Irp->IoStatus.Status = status;
            IoCompleteRequest(Irp, IO_NO_INCREMENT);
        }

        return status;
    }

    switch (irpSp->Parameters.DeviceIoControl.IoControlCode) {

        case IOCTL_MOUNTDEV_QUERY_UNIQUE_ID:
            status = FtpAllSystemsGo(extension, Irp, FALSE, TRUE, FALSE);
            if (status == STATUS_PENDING) {
                return status;
            }
            if (NT_SUCCESS(status)) {
                status = FtpQueryUniqueId(extension, Irp);
                FtpDecrementRefCount(extension);
            }
            Irp->IoStatus.Status = status;
            IoCompleteRequest(Irp, IO_NO_INCREMENT);
            return status;

        case IOCTL_MOUNTDEV_QUERY_STABLE_GUID:
            status = FtpAllSystemsGo(extension, Irp, FALSE, TRUE, FALSE);
            if (status == STATUS_PENDING) {
                return status;
            }
            if (NT_SUCCESS(status)) {
                status = FtpQueryStableGuid(extension, Irp);
                FtpDecrementRefCount(extension);
            }
            Irp->IoStatus.Status = status;
            IoCompleteRequest(Irp, IO_NO_INCREMENT);
            return status;

        case IOCTL_MOUNTDEV_UNIQUE_ID_CHANGE_NOTIFY:
            FtpAcquire(extension->Root);
            status = FtpUniqueIdChangeNotify(extension, Irp);
            FtpRelease(extension->Root);
            if (status != STATUS_PENDING) {
                Irp->IoStatus.Status = status;
                IoCompleteRequest(Irp, IO_NO_INCREMENT);
            }
            return status;

        case IOCTL_MOUNTDEV_QUERY_DEVICE_NAME:
            status = FtpAllSystemsGo(extension, Irp, FALSE, FALSE, FALSE);
            if (status == STATUS_PENDING) {
                return status;
            }
            if (NT_SUCCESS(status)) {
                status = FtpQueryDeviceName(extension, Irp);
                FtpDecrementRefCount(extension);
            }
            Irp->IoStatus.Status = status;
            IoCompleteRequest(Irp, IO_NO_INCREMENT);
            return status;

        case IOCTL_MOUNTDEV_QUERY_SUGGESTED_LINK_NAME:
            FtpAcquire(extension->Root);
            status = FtpQuerySuggestedLinkName(extension, Irp);
            FtpRelease(extension->Root);
            Irp->IoStatus.Status = status;
            IoCompleteRequest(Irp, IO_NO_INCREMENT);
            return status;

        case IOCTL_MOUNTDEV_LINK_CREATED:
            status = FtpAllSystemsGo(extension, Irp, FALSE, TRUE, TRUE);
            if (status == STATUS_PENDING) {
                return status;
            }
            if (NT_SUCCESS(status)) {
                status = FtpLinkCreated(extension, Irp);
                FtpDecrementRefCount(extension);
            }
            Irp->IoStatus.Status = status;
            IoCompleteRequest(Irp, IO_NO_INCREMENT);
            return status;

        case IOCTL_MOUNTDEV_LINK_DELETED:
            status = FtpAllSystemsGo(extension, Irp, FALSE, TRUE, TRUE);
            if (status == STATUS_PENDING) {
                return status;
            }
            if (NT_SUCCESS(status)) {
                status = FtpLinkDeleted(extension, Irp);
                FtpDecrementRefCount(extension);
            }
            Irp->IoStatus.Status = status;
            IoCompleteRequest(Irp, IO_NO_INCREMENT);
            return status;

        case IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS:
        case IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS_ADMIN:
            status = FtpAllSystemsGo(extension, Irp, FALSE, TRUE, FALSE);
            if (status == STATUS_PENDING) {
                return status;
            }
            if (NT_SUCCESS(status)) {
                status = FtpGetVolumeDiskExtents(extension, Irp);
                FtpDecrementRefCount(extension);
            }
            Irp->IoStatus.Status = status;
            IoCompleteRequest(Irp, IO_NO_INCREMENT);
            return status;

        case IOCTL_VOLUME_SUPPORTS_ONLINE_OFFLINE:
            Irp->IoStatus.Status = STATUS_SUCCESS;
            IoCompleteRequest(Irp, IO_NO_INCREMENT);
            return STATUS_SUCCESS;

        case IOCTL_VOLUME_ONLINE:
            FtpAcquire(extension->Root);

            status = FtpAllSystemsGo(extension, Irp, FALSE, TRUE, FALSE);
            if (status == STATUS_PENDING) {
                FtpRelease(extension->Root);
                return status;
            }
            if (!NT_SUCCESS(status)) {
                FtpRelease(extension->Root);
                Irp->IoStatus.Status = status;
                IoCompleteRequest(Irp, IO_NO_INCREMENT);
                return status;
            }

            status = FtpCheckOfflineOwner(extension, Irp);
            if (!NT_SUCCESS(status)) {
                FtpDecrementRefCount(extension);
                FtpRelease(extension->Root);
                Irp->IoStatus.Status = status;
                IoCompleteRequest(Irp, IO_NO_INCREMENT);
                return status;
            }

            if (extension->FtVolume) {
                FtpPropogateRegistryState(extension, extension->FtVolume);
            }

            KeInitializeEvent(&event, NotificationEvent, FALSE);
            FtpZeroRefCallback(extension, FtpVolumeOnlineCallback, &event,
                               TRUE);
            FtpDecrementRefCount(extension);
            KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);

            FtpRelease(extension->Root);

            Irp->IoStatus.Status = STATUS_SUCCESS;
            IoCompleteRequest(Irp, IO_NO_INCREMENT);
            return STATUS_SUCCESS;

        case IOCTL_VOLUME_OFFLINE:
            FtpAcquire(extension->Root);

            status = FtpAddOfflineOwner(extension, Irp);
            if (!NT_SUCCESS(status)) {
                FtpRelease(extension->Root);
                Irp->IoStatus.Status = status;
                IoCompleteRequest(Irp, IO_NO_INCREMENT);
                return status;
            }

            KeInitializeEvent(&event, NotificationEvent, FALSE);
            FtpZeroRefCallback(extension, FtpVolumeOfflineCallback, &event,
                               TRUE);
            KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);

            FtpRelease(extension->Root);

            Irp->IoStatus.Status = STATUS_SUCCESS;
            IoCompleteRequest(Irp, IO_NO_INCREMENT);
            return STATUS_SUCCESS;

        case IOCTL_VOLUME_IS_OFFLINE:
            status = FtpAllSystemsGo(extension, Irp, FALSE, TRUE, FALSE);
            if (status == STATUS_PENDING) {
                return status;
            }
            if (NT_SUCCESS(status)) {
                if (!extension->IsOffline) {
                    status = STATUS_UNSUCCESSFUL;
                }
                FtpDecrementRefCount(extension);
            }
            Irp->IoStatus.Status = status;
            IoCompleteRequest(Irp, IO_NO_INCREMENT);
            return status;

        case IOCTL_VOLUME_IS_IO_CAPABLE:
            status = FtpAllSystemsGo(extension, Irp, FALSE, TRUE, FALSE);
            if (status == STATUS_PENDING) {
                return status;
            }
            if (NT_SUCCESS(status)) {
                if (!extension->TargetObject &&
                    !extension->FtVolume->IsComplete(TRUE)) {

                    status = STATUS_UNSUCCESSFUL;
                }
                FtpDecrementRefCount(extension);
            }
            Irp->IoStatus.Status = status;
            IoCompleteRequest(Irp, IO_NO_INCREMENT);
            return status;

        case IOCTL_VOLUME_QUERY_FAILOVER_SET:
            KeEnterCriticalRegion();
            FtpAcquire(extension->Root);
            status = FtpQueryFailoverSet(extension, Irp);
            FtpRelease(extension->Root);
            KeLeaveCriticalRegion();
            Irp->IoStatus.Status = status;
            IoCompleteRequest(Irp, IO_NO_INCREMENT);
            return status;

        case IOCTL_VOLUME_QUERY_VOLUME_NUMBER:
            status = FtpAllSystemsGo(extension, Irp, FALSE, TRUE, FALSE);
            if (status == STATUS_PENDING) {
                return status;
            }
            if (NT_SUCCESS(status)) {
                status = FtpQueryVolumeNumber(extension, Irp);
                FtpDecrementRefCount(extension);
            }
            Irp->IoStatus.Status = status;
            IoCompleteRequest(Irp, IO_NO_INCREMENT);
            return status;

        case IOCTL_VOLUME_LOGICAL_TO_PHYSICAL:
            status = FtpAllSystemsGo(extension, Irp, FALSE, TRUE, FALSE);
            if (status == STATUS_PENDING) {
                return status;
            }
            if (NT_SUCCESS(status)) {
                status = FtpLogicalToPhysical(extension, Irp);
                FtpDecrementRefCount(extension);
            }
            Irp->IoStatus.Status = status;
            IoCompleteRequest(Irp, IO_NO_INCREMENT);
            return status;

        case IOCTL_VOLUME_PHYSICAL_TO_LOGICAL:
            status = FtpAllSystemsGo(extension, Irp, FALSE, TRUE, FALSE);
            if (status == STATUS_PENDING) {
                return status;
            }
            if (NT_SUCCESS(status)) {
                status = FtpPhysicalToLogical(extension, Irp);
                FtpDecrementRefCount(extension);
            }
            Irp->IoStatus.Status = status;
            IoCompleteRequest(Irp, IO_NO_INCREMENT);
            return status;

        case IOCTL_VOLUME_IS_PARTITION:
            status = FtpAllSystemsGo(extension, Irp, TRUE, TRUE, TRUE);
            if (status == STATUS_PENDING) {
                return status;
            }
            if (NT_SUCCESS(status)) {
                status = FtpIsPartition(extension, Irp);
                FtpDecrementRefCount(extension);
            }
            Irp->IoStatus.Status = status;
            IoCompleteRequest(Irp, IO_NO_INCREMENT);
            return status;

        case IOCTL_VOLUME_SET_GPT_ATTRIBUTES:
            status = FtpCheckSecurity(extension, Irp);
            if (!NT_SUCCESS(status)) {
                break;
            }
            FtpAcquire(extension->Root);
            status = FtpSetGptAttributes(extension, Irp);
            FtpRelease(extension->Root);
            Irp->IoStatus.Status = status;
            IoCompleteRequest(Irp, IO_NO_INCREMENT);
            return status;

        case IOCTL_VOLUME_GET_GPT_ATTRIBUTES:
            KeEnterCriticalRegion();
            FtpAcquire(extension->Root);
            status = FtpGetGptAttributes(extension, Irp);
            FtpRelease(extension->Root);
            KeLeaveCriticalRegion();
            Irp->IoStatus.Status = status;
            IoCompleteRequest(Irp, IO_NO_INCREMENT);
            return status;

        case IOCTL_PARTMGR_EJECT_VOLUME_MANAGERS:
        case IOCTL_DISK_COPY_DATA:
            status = STATUS_INVALID_DEVICE_REQUEST;
            break;

        case IOCTL_DISK_GET_PARTITION_INFO:
        case IOCTL_DISK_GET_PARTITION_INFO_EX:
        case IOCTL_STORAGE_GET_DEVICE_NUMBER:
            status = FtpAllSystemsGo(extension, Irp, FALSE, TRUE, FALSE);
            break;

        case IOCTL_DISK_IS_WRITABLE:
            if (extension->IsReadOnly) {
                status = STATUS_MEDIA_WRITE_PROTECTED;
            } else {
                status = FtpAllSystemsGo(extension, Irp, TRUE, TRUE, TRUE);
            }
            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 (!FtQueryEnableAlways(DeviceObject)) {
                    status = STATUS_UNSUCCESSFUL;
                    Irp->IoStatus.Information = 0;
                }
            }
            if (status == STATUS_SUCCESS) {
                extension->Root->PmWmiCounterLibContext.
                PmWmiCounterQuery(extension->PmWmiCounterContext,
                                  (PDISK_PERFORMANCE) Irp->AssociatedIrp.SystemBuffer,
                                  L"FTDISK  ",
                                  extension->VolumeNumber);
                Irp->IoStatus.Information = sizeof(DISK_PERFORMANCE);
            }

            Irp->IoStatus.Status = status;
            IoCompleteRequest(Irp, IO_NO_INCREMENT);
            return status;

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

        default:
            status = FtpAllSystemsGo(extension, Irp, TRUE, TRUE, TRUE);
            break;

    }

    if (status == STATUS_PENDING) {
        return status;
    }
    if (!NT_SUCCESS(status)) {
        Irp->IoStatus.Status = status;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
        return status;
    }

    if (extension->TargetObject) {
        if (irpSp->Parameters.DeviceIoControl.IoControlCode ==
            FT_CREATE_PARTITION_LOGICAL_DISK) {

            FtpDecrementRefCount(extension);

            Irp->IoStatus.Information = 0;

            FtpAcquire(extension->Root);

            if (!extension->Root->FtCodeLocked) {
                MmLockPagableCodeSection(FtpComputeParity);
                status = FtpStartSystemThread(extension->Root);
                if (!NT_SUCCESS(status)) {
                    FtpRelease(extension->Root);
                    Irp->IoStatus.Status = status;
                    IoCompleteRequest(Irp, IO_NO_INCREMENT);
                    return status;
                }
                extension->Root->FtCodeLocked = TRUE;
            }
            status = FtpCreatePartitionLogicalDisk(extension, Irp);

            FtpRelease(extension->Root);

            Irp->IoStatus.Status = status;
            IoCompleteRequest(Irp, IO_NO_INCREMENT);
            return status;
        }

        if (irpSp->Parameters.DeviceIoControl.IoControlCode ==
            IOCTL_DISK_UPDATE_PROPERTIES) {

            targetObject = extension->TargetObject;
            ObReferenceObject(targetObject);

            FtpDecrementRefCount(extension);

            IoSkipCurrentIrpStackLocation(Irp);
            status = IoCallDriver(targetObject, Irp);

            ObDereferenceObject(targetObject);

            return status;
        }

        IoCopyCurrentIrpStackLocationToNext(Irp);
        IoSetCompletionRoutine(Irp, FtpRefCountCompletionRoutine,
                               extension, TRUE, TRUE, TRUE);
        IoMarkIrpPending(Irp);

        IoCallDriver(extension->TargetObject, Irp);

        return STATUS_PENDING;
    }

    vol = extension->FtVolume;
    ASSERT(vol);

    switch (irpSp->Parameters.DeviceIoControl.IoControlCode) {

        case IOCTL_DISK_GET_DRIVE_LAYOUT:
        case IOCTL_DISK_GET_DRIVE_LAYOUT_EX:
        case IOCTL_SCSI_GET_ADDRESS:
        case IOCTL_SCSI_GET_DUMP_POINTERS:
        case IOCTL_SCSI_FREE_DUMP_POINTERS:
            if (FtpIsReplicatedPartition(vol)) {
                targetObject = vol->GetLeftmostPartitionObject();
                ASSERT(targetObject);

                KeInitializeEvent(&event, NotificationEvent, FALSE);
                IoCopyCurrentIrpStackLocationToNext(Irp);
                IoSetCompletionRoutine(Irp, FtpSignalCompletion, &event, TRUE,
                                       TRUE, TRUE);
                IoCallDriver(targetObject, Irp);
                KeWaitForSingleObject(&event, Executive, KernelMode, FALSE,
                                      NULL);

                status = Irp->IoStatus.Status;

            } else {
                status = STATUS_INVALID_DEVICE_REQUEST;
            }
            break;

        case IOCTL_DISK_VERIFY:

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

                status = STATUS_INVALID_PARAMETER;
                break;
            }

            packet = new DISPATCH_TP;
            if (!packet) {
                status = STATUS_INSUFFICIENT_RESOURCES;
                break;
            }

            verifyInfo = (PVERIFY_INFORMATION) Irp->AssociatedIrp.SystemBuffer;

            if (verifyInfo->StartingOffset.QuadPart < 0) {
                delete packet;
                status = STATUS_INVALID_PARAMETER;
                break;
            }

            packet->Mdl = NULL;
            packet->Offset = verifyInfo->StartingOffset.QuadPart;
            packet->Length = verifyInfo->Length;
            packet->CompletionRoutine = FtpReadWriteCompletionRoutine;
            packet->TargetVolume = vol;
            packet->Thread = Irp->Tail.Overlay.Thread;
            packet->IrpFlags = irpSp->Flags;
            packet->ReadPacket = TRUE;
            packet->Irp = Irp;
            packet->Extension = extension;

            IoMarkIrpPending(Irp);

            TRANSFER(packet);

            return STATUS_PENDING;

        case IOCTL_DISK_SET_PARTITION_INFO:

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

                status = STATUS_INVALID_PARAMETER;
                break;
            }

            setPartitionInfo = (PSET_PARTITION_INFORMATION)
                               Irp->AssociatedIrp.SystemBuffer;

            status = vol->SetPartitionType(setPartitionInfo->PartitionType);
            break;

        case IOCTL_DISK_SET_PARTITION_INFO_EX:

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

                status = STATUS_INVALID_PARAMETER;
                break;
            }

            setPartitionInfoEx = (PSET_PARTITION_INFORMATION_EX)
                                 Irp->AssociatedIrp.SystemBuffer;
            if (setPartitionInfoEx->PartitionStyle != PARTITION_STYLE_MBR) {
                status = STATUS_INVALID_PARAMETER;
                break;
            }

            status = vol->SetPartitionType(
                     setPartitionInfoEx->Mbr.PartitionType);
            break;

        case IOCTL_DISK_GET_PARTITION_INFO_EX:

            if (extension->IsGpt) {
                status = STATUS_INVALID_PARAMETER;
                break;
            }

            //
            // Fall through.
            //

        case IOCTL_DISK_GET_PARTITION_INFO:

            targetObject = vol->GetLeftmostPartitionObject();
            if (!targetObject) {
                status = STATUS_NO_SUCH_DEVICE;
                break;
            }

            KeInitializeEvent(&event, NotificationEvent, FALSE);
            IoCopyCurrentIrpStackLocationToNext(Irp);
            IoSetCompletionRoutine(Irp, FtpSignalCompletion, &event, TRUE,
                                   TRUE, TRUE);
            IoCallDriver(targetObject, Irp);
            KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);

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

            if (irpSp->Parameters.DeviceIoControl.IoControlCode ==
                IOCTL_DISK_GET_PARTITION_INFO) {

                partInfo = (PPARTITION_INFORMATION)
                           Irp->AssociatedIrp.SystemBuffer;
                partInfo->PartitionLength.QuadPart = vol->QueryVolumeSize();
                break;
            }

            partInfoEx = (PPARTITION_INFORMATION_EX)
                         Irp->AssociatedIrp.SystemBuffer;
            if (partInfoEx->PartitionStyle != PARTITION_STYLE_MBR) {
                ASSERT(FALSE);
                status = STATUS_INVALID_PARAMETER;
                break;
            }
            partInfoEx->PartitionLength.QuadPart = vol->QueryVolumeSize();
            break;

        case IOCTL_DISK_GET_LENGTH_INFO:

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

            if (irpSp->Parameters.DeviceIoControl.OutputBufferLength <
                Irp->IoStatus.Information) {

                Irp->IoStatus.Information = 0;
                status = STATUS_INVALID_PARAMETER;
                break;
            }

            lengthInfo = (PGET_LENGTH_INFORMATION)
                         Irp->AssociatedIrp.SystemBuffer;

            lengthInfo->Length.QuadPart = vol->QueryVolumeSize();
            status = STATUS_SUCCESS;
            break;

        case IOCTL_DISK_GET_DRIVE_GEOMETRY:

            targetObject = vol->GetLeftmostPartitionObject();
            if (!targetObject) {
                status = STATUS_NO_SUCH_DEVICE;
                break;
            }

            KeInitializeEvent(&event, NotificationEvent, FALSE);
            IoCopyCurrentIrpStackLocationToNext(Irp);
            IoSetCompletionRoutine(Irp, FtpSignalCompletion, &event, TRUE,
                                   TRUE, TRUE);
            IoCallDriver(targetObject, Irp);
            KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);

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

            diskGeometry = (PDISK_GEOMETRY) Irp->AssociatedIrp.SystemBuffer;
            diskGeometry->BytesPerSector = vol->QuerySectorSize();
            cylinderSize = diskGeometry->TracksPerCylinder*
                           diskGeometry->SectorsPerTrack*
                           diskGeometry->BytesPerSector;
            if (cylinderSize) {
                diskGeometry->Cylinders.QuadPart =
                        vol->QueryVolumeSize()/cylinderSize;
            }
            break;

        case IOCTL_DISK_CHECK_VERIFY:
            status = STATUS_SUCCESS;
            break;

        case FT_QUERY_SET_STATE:

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

                status = STATUS_INVALID_PARAMETER;
                break;
            }

            KeEnterCriticalRegion();
            FtpAcquire(rootExtension);
            diskInfoSet = rootExtension->DiskInfoSet;
            setInfo = (PFT_SET_INFORMATION) Irp->AssociatedIrp.SystemBuffer;
            diskId = vol->QueryLogicalDiskId();
            setInfo->NumberOfMembers =
                    diskInfoSet->QueryNumberOfMembersInLogicalDisk(diskId);
            switch (diskInfoSet->QueryLogicalDiskType(diskId)) {
                case FtVolumeSet:
                    setInfo->Type = VolumeSet;
                    break;

                case FtStripeSet:
                    setInfo->Type = Stripe;
                    break;

                case FtMirrorSet:
                    setInfo->Type = Mirror;
                    break;

                case FtStripeSetWithParity:
                    setInfo->Type = StripeWithParity;
                    break;

                default:
                    setInfo->Type = NotAnFtMember;
                    break;

            }

            stateInfo = (PFT_MIRROR_AND_SWP_STATE_INFORMATION)
                        diskInfoSet->GetStateInformation(diskId);
            if (stateInfo) {
                if (stateInfo->IsInitializing) {
                    setInfo->SetState = FtInitializing;
                } else {
                    switch (stateInfo->UnhealthyMemberState) {
                        case FtMemberHealthy:
                            setInfo->SetState = FtStateOk;
                            break;

                        case FtMemberRegenerating:
                            setInfo->SetState = FtRegenerating;
                            break;

                        case FtMemberOrphaned:
                            setInfo->SetState = FtHasOrphan;
                            break;

                    }
                }
            } else {
                setInfo->SetState = FtStateOk;
            }
            FtpRelease(rootExtension);
            KeLeaveCriticalRegion();

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

        case FT_SECONDARY_READ:
        case FT_PRIMARY_READ:

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

                status = STATUS_INVALID_PARAMETER;
                break;
            }

            specialRead = (PFT_SPECIAL_READ) Irp->AssociatedIrp.SystemBuffer;
            if (specialRead->ByteOffset.QuadPart <= 0) {
                status = STATUS_INVALID_PARAMETER;
                break;
            }

            if (specialRead->Length >
                irpSp->Parameters.DeviceIoControl.OutputBufferLength) {

                status = STATUS_INVALID_PARAMETER;
                break;
            }

            packet = new DISPATCH_TP;
            if (!packet) {
                status = STATUS_INSUFFICIENT_RESOURCES;
                break;
            }

            packet->Mdl = Irp->MdlAddress;
            packet->Offset = specialRead->ByteOffset.QuadPart;
            packet->Length = specialRead->Length;
            packet->CompletionRoutine = FtpReadWriteCompletionRoutine;
            packet->TargetVolume = vol;
            packet->Thread = Irp->Tail.Overlay.Thread;
            packet->IrpFlags = irpSp->Flags;
            packet->ReadPacket = TRUE;
            if (irpSp->Parameters.DeviceIoControl.IoControlCode ==
                FT_SECONDARY_READ) {

                packet->SpecialRead = TP_SPECIAL_READ_SECONDARY;
            } else {
                packet->SpecialRead = TP_SPECIAL_READ_PRIMARY;
            }
            packet->Irp = Irp;
            packet->Extension = extension;

            IoMarkIrpPending(Irp);

            TRANSFER(packet);

            return STATUS_PENDING;

        case FT_BALANCED_READ_MODE:
        case FT_SEQUENTIAL_WRITE_MODE:
        case FT_PARALLEL_WRITE_MODE:

            status = STATUS_SUCCESS;
            break;

        case FT_QUERY_LOGICAL_DISK_ID:

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

                status = STATUS_INVALID_PARAMETER;
                break;
            }

            queryLogicalDiskIdOutput = (PFT_QUERY_LOGICAL_DISK_ID_OUTPUT)
                                       Irp->AssociatedIrp.SystemBuffer;

            queryLogicalDiskIdOutput->RootLogicalDiskId =
                    vol->QueryLogicalDiskId();

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

        default:
            status = STATUS_INVALID_DEVICE_REQUEST;
            break;

    }

    FtpDecrementRefCount(extension);

    Irp->IoStatus.Status = status;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
    return status;
}

NTSTATUS
FtpCreatePartitionLogicalDiskHelper(
    IN OUT  PVOLUME_EXTENSION   Extension,
    IN      LONGLONG            PartitionSize,
    OUT     PFT_LOGICAL_DISK_ID NewLogicalDiskId
    )

{
    PMOUNTDEV_UNIQUE_ID                 newUniqueId;
    UCHAR                               newUniqueIdBuffer[UNIQUE_ID_MAX_BUFFER_SIZE];
    NTSTATUS                            status;
    ULONG                               diskNumber;
    LONGLONG                            offset;
    PFT_LOGICAL_DISK_INFORMATION_SET    diskInfoSet;
    FT_LOGICAL_DISK_ID                  diskId;
    PPARTITION                          partition;
    UCHAR                               type;
    SET_TARGET_CONTEXT                  context;

    if (Extension->IsGpt) {
        return STATUS_INVALID_PARAMETER;
    }

    newUniqueId = (PMOUNTDEV_UNIQUE_ID) newUniqueIdBuffer;

    status = FtpQueryPartitionInformation(Extension->Root,
                                          Extension->TargetObject, &diskNumber,
                                          &offset, NULL, NULL, NULL, NULL,
                                          NULL, NULL, NULL);

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

    diskInfoSet = Extension->Root->DiskInfoSet;
    status = diskInfoSet->CreatePartitionLogicalDisk(diskNumber, offset,
                                                     PartitionSize, &diskId);
    if (!NT_SUCCESS(status)) {
        return status;
    }

    partition = new PARTITION;
    if (!partition) {
        diskInfoSet->BreakLogicalDisk(diskId);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
    status = partition->Initialize(Extension->Root, diskId,
                                   Extension->TargetObject,
                                   Extension->WholeDiskPdo);
    if (!NT_SUCCESS(status)) {
        if (!InterlockedDecrement(&partition->_refCount)) {
            delete partition;
        }
        diskInfoSet->BreakLogicalDisk(diskId);
        return status;
    }

    type = partition->QueryPartitionType();
    if (!type) {
        if (!InterlockedDecrement(&partition->_refCount)) {
            delete partition;
        }
        diskInfoSet->BreakLogicalDisk(diskId);
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    status = partition->SetPartitionType(type);
    if (!NT_SUCCESS(status)) {
        if (!InterlockedDecrement(&partition->_refCount)) {
            delete partition;
        }
        diskInfoSet->BreakLogicalDisk(diskId);
        return status;
    }

    KeInitializeEvent(&context.Event, NotificationEvent, FALSE);
    context.TargetObject = NULL;
    context.FtVolume = partition;
    context.WholeDiskPdo = NULL;
    FtpZeroRefCallback(Extension, FtpSetTargetCallback, &context, TRUE);
    KeWaitForSingleObject(&context.Event, Executive, KernelMode, FALSE,
                          NULL);

    FtpQueryUniqueIdBuffer(Extension, newUniqueId->UniqueId,
                           &newUniqueId->UniqueIdLength);
    FtpUniqueIdNotify(Extension, newUniqueId);

    *NewLogicalDiskId = diskId;

    FtpNotify(Extension->Root, Extension);

    return status;
}

NTSTATUS
FtpInsertMirror(
    IN OUT  PROOT_EXTENSION     RootExtension,
    IN      PFT_LOGICAL_DISK_ID ArrayOfMembers,
    OUT     PFT_LOGICAL_DISK_ID NewLogicalDiskId
    )

{
    PFT_LOGICAL_DISK_INFORMATION_SET        diskInfoSet;
    ULONG                                   i;
    NTSTATUS                                status;
    PVOLUME_EXTENSION                       extension, shadowExtension;
    PFT_VOLUME                              topVol, vol, shadowVol, parentVol;
    FT_LOGICAL_DISK_ID                      fakeDiskId, mirrorDiskId, parentDiskId;
    FT_LOGICAL_DISK_ID                      mirrorMembers[2];
    FT_MIRROR_SET_CONFIGURATION_INFORMATION config;
    FT_MIRROR_AND_SWP_STATE_INFORMATION     state;
    USHORT                                  n, j;
    PMIRROR                                 mirror;
    PFT_VOLUME*                             arrayOfVolumes;
    KEVENT                                  event;
    INSERT_MEMBER_CONTEXT                   context;
    UCHAR                                   newUniqueIdBuffer[UNIQUE_ID_MAX_BUFFER_SIZE];
    PMOUNTDEV_UNIQUE_ID                     newUniqueId;
    PFT_LOGICAL_DISK_DESCRIPTION            p;
    WCHAR                                   deviceNameBuffer[64];
    UNICODE_STRING                          deviceName;
    SET_TARGET_CONTEXT                      setContext;

    diskInfoSet = RootExtension->DiskInfoSet;
    for (i = 0; i < 100; i++) {
        status = diskInfoSet->CreatePartitionLogicalDisk(i, 0, 0, &fakeDiskId);
        if (NT_SUCCESS(status)) {
            break;
        }
    }

    if (i == 100) {
        return status;
    }

    extension = FtpFindExtensionCoveringDiskId(RootExtension,
                                               ArrayOfMembers[0]);
    ASSERT(extension);

    topVol = extension->FtVolume;
    vol = topVol->GetContainedLogicalDisk(ArrayOfMembers[0]);

    shadowExtension = FtpFindExtension(RootExtension, ArrayOfMembers[1]);
    ASSERT(shadowExtension);
    shadowVol = shadowExtension->FtVolume;

    if (shadowVol->QueryVolumeSize() < vol->QueryVolumeSize()) {
        return STATUS_INVALID_PARAMETER;
    }

    mirrorMembers[0] = fakeDiskId;
    mirrorMembers[1] = ArrayOfMembers[1];
    config.MemberSize = vol->QueryVolumeSize();
    state.IsInitializing = FALSE;
    state.IsDirty = TRUE;
    state.UnhealthyMemberNumber = 1;
    state.UnhealthyMemberState = FtMemberRegenerating;

    status = diskInfoSet->AddNewLogicalDisk(FtMirrorSet, 2, mirrorMembers,
                                            sizeof(config), &config,
                                            sizeof(state), &state,
                                            &mirrorDiskId);
    if (!NT_SUCCESS(status)) {
        diskInfoSet->BreakLogicalDisk(fakeDiskId);
        return status;
    }

    parentVol = topVol->GetParentLogicalDisk(vol);
    if (!parentVol) {
        diskInfoSet->BreakLogicalDisk(mirrorDiskId);
        diskInfoSet->BreakLogicalDisk(fakeDiskId);
        return STATUS_INVALID_PARAMETER;
    }

    n = parentVol->QueryNumberOfMembers();
    for (j = 0; j < n; j++) {
        if (parentVol->GetMember(j) == vol) {
            break;
        }
    }

    status = diskInfoSet->ReplaceLogicalDiskMember(
             parentVol->QueryLogicalDiskId(), j, mirrorDiskId, &parentDiskId);
    if (!NT_SUCCESS(status)) {
        diskInfoSet->BreakLogicalDisk(mirrorDiskId);
        diskInfoSet->BreakLogicalDisk(fakeDiskId);
        return status;
    }

    status = diskInfoSet->ReplaceLogicalDiskMember(
             mirrorDiskId, 0, ArrayOfMembers[0], &mirrorDiskId);
    if (!NT_SUCCESS(status)) {
        diskInfoSet->ReplaceLogicalDiskMember(
                 parentDiskId, j, ArrayOfMembers[0], &parentDiskId);
        diskInfoSet->BreakLogicalDisk(mirrorDiskId);
        diskInfoSet->BreakLogicalDisk(fakeDiskId);
        return status;
    }

    *NewLogicalDiskId = mirrorDiskId;
    diskInfoSet->BreakLogicalDisk(fakeDiskId);

    arrayOfVolumes = (PFT_VOLUME*) ExAllocatePool(NonPagedPool, 2*sizeof(PFT_VOLUME));
    if (!arrayOfVolumes) {
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    mirror = new MIRROR;
    if (!mirror) {
        ExFreePool(arrayOfVolumes);
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    arrayOfVolumes[0] = vol;
    arrayOfVolumes[1] = shadowVol;

    status = mirror->Initialize(RootExtension, mirrorDiskId, arrayOfVolumes, 2,
                                &config, &state);
    if (!NT_SUCCESS(status)) {
        if (!InterlockedDecrement(&mirror->_refCount)) {
            delete mirror;
        }
        return status;
    }

    KeInitializeEvent(&setContext.Event, NotificationEvent, FALSE);
    setContext.TargetObject = NULL;
    setContext.FtVolume = NULL;
    setContext.WholeDiskPdo = NULL;
    FtpZeroRefCallback(shadowExtension, FtpSetTargetCallback, &setContext,
                       TRUE);
    KeWaitForSingleObject(&setContext.Event, Executive, KernelMode, FALSE,
                          NULL);

    RemoveEntryList(&shadowExtension->ListEntry);
    InsertTailList(&RootExtension->DeadVolumeList,
                   &shadowExtension->ListEntry);
    FtpDeleteMountPoints(shadowExtension);
    FtpCleanupVolumeExtension(shadowExtension);

    KeInitializeEvent(&context.Event, NotificationEvent, FALSE);
    context.Parent = parentVol;
    context.MemberNumber = j;
    context.Member = mirror;
    FtpZeroRefCallback(extension, FtpInsertMemberCallback, &context, TRUE);
    KeWaitForSingleObject(&context.Event, Executive, KernelMode, FALSE, NULL);

    parentVol = mirror;
    while (p = diskInfoSet->GetParentLogicalDiskDescription(
           parentVol->QueryLogicalDiskId())) {

        if (parentVol = topVol->GetParentLogicalDisk(parentVol)) {
            parentVol->SetLogicalDiskId(p->LogicalDiskId);
        }
    }

    swprintf(deviceNameBuffer, L"\\Device\\HarddiskVolume%d", extension->VolumeNumber);
    RtlInitUnicodeString(&deviceName, deviceNameBuffer);
    mirror->CreateLegacyNameLinks(&deviceName);

    newUniqueId = (PMOUNTDEV_UNIQUE_ID) newUniqueIdBuffer;
    FtpQueryUniqueIdBuffer(extension, newUniqueId->UniqueId,
                           &newUniqueId->UniqueIdLength);

    FtpUniqueIdNotify(extension, newUniqueId);

    IoInvalidateDeviceRelations(RootExtension->Pdo, BusRelations);
    FtpNotify(RootExtension, extension);

    return STATUS_SUCCESS;
}

VOID
FtpBootDriverReinitialization(
    IN  PDRIVER_OBJECT  DriverObject,
    IN  PVOID           RootExtension,
    IN  ULONG           Count
    )

/*++

Routine Description:

    This routine is called after all of the boot drivers are loaded and it
    checks to make sure that we did not boot off of the stale half of a
    mirror.

Arguments:

    DriverObject    - Supplies the drive object.

    RootExtension   - Supplies the root extension.

    Count           - Supplies the count.

Return Value:

    None.

--*/

{
    PROOT_EXTENSION         rootExtension = (PROOT_EXTENSION) RootExtension;
    NTSTATUS                status;
    BOOTDISK_INFORMATION    bootInfo;
    BOOLEAN                 onlyOne, skipBoot, skipSystem;
    PLIST_ENTRY             l;
    PVOLUME_EXTENSION       extension;
    PFT_VOLUME              vol, partition;
    FT_MEMBER_STATE         state;

    status = IoGetBootDiskInformation(&bootInfo, sizeof(bootInfo));
    if (!NT_SUCCESS(status)) {
        return;
    }

    if (bootInfo.BootDeviceSignature == bootInfo.SystemDeviceSignature &&
        bootInfo.BootPartitionOffset == bootInfo.SystemPartitionOffset) {

        onlyOne = TRUE;
    } else {
        onlyOne = FALSE;
    }

    if (!bootInfo.BootDeviceSignature || !bootInfo.BootPartitionOffset) {
        skipBoot = TRUE;
    } else {
        skipBoot = FALSE;
    }

    if (!bootInfo.SystemDeviceSignature || !bootInfo.SystemPartitionOffset) {
        skipSystem = TRUE;
    } else {
        skipSystem = FALSE;
    }

    if (skipBoot && skipSystem) {
        return;
    }

    FtpAcquire(rootExtension);

    for (l = rootExtension->VolumeList.Flink;
         l != &rootExtension->VolumeList; l = l->Flink) {

        extension = CONTAINING_RECORD(l, VOLUME_EXTENSION, ListEntry);
        vol = extension->FtVolume;
        if (!vol) {
            continue;
        }

        if (!skipBoot) {
            partition = vol->GetContainedLogicalDisk(
                        bootInfo.BootDeviceSignature,
                        bootInfo.BootPartitionOffset);
            if (partition) {
                if (vol->QueryVolumeState(partition, &state) &&
                    state != FtMemberHealthy) {

                    KeBugCheckEx(FTDISK_INTERNAL_ERROR,
                                 (ULONG_PTR) extension,
                                 bootInfo.BootDeviceSignature,
                                 (ULONG_PTR) bootInfo.BootPartitionOffset,
                                 state);
                }
            }
        }

        if (onlyOne) {
            continue;
        }

        if (!skipSystem) {
            partition = vol->GetContainedLogicalDisk(
                        bootInfo.SystemDeviceSignature,
                        bootInfo.SystemPartitionOffset);
            if (partition) {
                if (vol->QueryVolumeState(partition, &state) &&
                    state != FtMemberHealthy) {

                    KeBugCheckEx(FTDISK_INTERNAL_ERROR,
                                 (ULONG_PTR) extension,
                                 bootInfo.BootDeviceSignature,
                                 (ULONG_PTR) bootInfo.BootPartitionOffset,
                                 state);
                }
            }
        }
    }

    rootExtension->PastBootReinitialize = TRUE;

    FtpRelease(rootExtension);
}

NTSTATUS
FtpQuerySystemVolumeNameQueryRoutine(
    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         - Returns the system volume name.

    EntryContext    - Not used.

Return Value:

    NTSTATUS

--*/

{
    PUNICODE_STRING systemVolumeName = (PUNICODE_STRING) Context;
    UNICODE_STRING  string;

    if (ValueType != REG_SZ) {
        return STATUS_SUCCESS;
    }

    RtlInitUnicodeString(&string, (PWSTR) ValueData);

    systemVolumeName->Length = string.Length;
    systemVolumeName->MaximumLength = systemVolumeName->Length + sizeof(WCHAR);
    systemVolumeName->Buffer = (PWSTR) ExAllocatePool(PagedPool,
                                              systemVolumeName->MaximumLength);
    if (!systemVolumeName->Buffer) {
        return STATUS_SUCCESS;
    }

    RtlCopyMemory(systemVolumeName->Buffer, ValueData,
                  systemVolumeName->Length);
    systemVolumeName->Buffer[systemVolumeName->Length/sizeof(WCHAR)] = 0;

    return STATUS_SUCCESS;
}

VOID
FtpDriverReinitialization(
    IN  PDRIVER_OBJECT  DriverObject,
    IN  PVOID           RootExtension,
    IN  ULONG           Count
    )

/*++

Routine Description:

    This routine is called after all of the disk drivers are loaded

Arguments:

    DriverObject    - Supplies the drive object.

    RootExtension   - Supplies the root extension.

    Count           - Supplies the count.

Return Value:

    None.

--*/

{
    PROOT_EXTENSION             rootExtension = (PROOT_EXTENSION) RootExtension;
    RTL_QUERY_REGISTRY_TABLE    queryTable[2];
    UNICODE_STRING              systemVolumeName, s;
    PLIST_ENTRY                 l;
    PVOLUME_EXTENSION           extension;
    WCHAR                       buffer[100];

    RtlZeroMemory(queryTable, 2*sizeof(RTL_QUERY_REGISTRY_TABLE));
    queryTable[0].QueryRoutine = FtpQuerySystemVolumeNameQueryRoutine;
    queryTable[0].Flags = RTL_QUERY_REGISTRY_REQUIRED;
    queryTable[0].Name = L"SystemPartition";

    systemVolumeName.Buffer = NULL;

    RtlQueryRegistryValues(RTL_REGISTRY_ABSOLUTE,
                           L"\\Registry\\Machine\\System\\Setup",
                           queryTable, &systemVolumeName, NULL);

    FtpAcquire(rootExtension);

    for (l = rootExtension->VolumeList.Flink;
         l != &rootExtension->VolumeList; l = l->Flink) {

        extension = CONTAINING_RECORD(l, VOLUME_EXTENSION, ListEntry);

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

        swprintf(buffer, L"\\Device\\HarddiskVolume%d", extension->VolumeNumber);
        RtlInitUnicodeString(&s, buffer);

        if (systemVolumeName.Buffer &&
            RtlEqualUnicodeString(&s, &systemVolumeName, TRUE)) {

            rootExtension->ESPUniquePartitionGUID = extension->UniqueIdGuid;
        }

        FtpApplyESPProtection(&s);
    }

    rootExtension->PastReinitialize = TRUE;

    FtpRelease(rootExtension);

    if (systemVolumeName.Buffer) {
        ExFreePool(systemVolumeName.Buffer);
    }
}

VOID
FtpCopyStateToRegistry(
    IN  FT_LOGICAL_DISK_ID  LogicalDiskId,
    IN  PVOID               LogicalDiskState,
    IN  USHORT              LogicalDiskStateSize
    )

/*++

Routine Description:

    This routine writes the given state to the registry so that it can
    be retrieved to solve some of the so called split brain problems.

Arguments:

    LogicalDiskId           - Supplies the logical disk id.

    LogicalDiskState        - Supplies the logical disk state.

    LogicalDiskStateSize    - Supplies the logical disk state size.

Return Value:

    None.

--*/

{
    WCHAR   registryName[50];

    RtlCreateRegistryKey(RTL_REGISTRY_ABSOLUTE, FT_STATE_REGISTRY_KEY);

    swprintf(registryName, L"%I64X", LogicalDiskId);

    RtlWriteRegistryValue(RTL_REGISTRY_ABSOLUTE, FT_STATE_REGISTRY_KEY,
                          registryName, REG_BINARY, LogicalDiskState,
                          LogicalDiskStateSize);
}

NTSTATUS
FtpQueryStateFromRegistryRoutine(
    IN  PWSTR   ValueName,
    IN  ULONG   ValueType,
    IN  PVOID   ValueData,
    IN  ULONG   ValueLength,
    IN  PVOID   Context,
    IN  PVOID   EntryContext
    )

/*++

Routine Description:

    This routine fetches the binary data for the given regitry entry.

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         - Returns the registry data.

    EntryContext    - Supplies the length of the registry data buffer.

Return Value:

    NTSTATUS

--*/

{
    if (ValueLength > *((PUSHORT) EntryContext)) {
        return STATUS_INVALID_PARAMETER;
    }

    *((PUSHORT) EntryContext) = (USHORT) ValueLength;
    RtlCopyMemory(Context, ValueData, ValueLength);

    return STATUS_SUCCESS;
}

BOOLEAN
FtpQueryStateFromRegistry(
    IN  FT_LOGICAL_DISK_ID  LogicalDiskId,
    IN  PVOID               LogicalDiskState,
    IN  USHORT              BufferSize,
    OUT PUSHORT             LogicalDiskStateSize
    )

/*++

Routine Description:

    This routine queries the given state from the registry so that it can
    be retrieved to solve some of the so called split brain problems.

Arguments:

    LogicalDiskId           - Supplies the logical disk id.

    LogicalDiskState        - Supplies the logical disk state.

    LogicalDiskStateSize    - Supplie the logical disk state size.

Return Value:

    None.

--*/

{
    WCHAR                       registryName[50];
    RTL_QUERY_REGISTRY_TABLE    queryTable[2];
    NTSTATUS                    status;

    *LogicalDiskStateSize = BufferSize;

    swprintf(registryName, L"%I64X", LogicalDiskId);

    RtlZeroMemory(queryTable, 2*sizeof(RTL_QUERY_REGISTRY_TABLE));
    queryTable[0].QueryRoutine = FtpQueryStateFromRegistryRoutine;
    queryTable[0].Flags = RTL_QUERY_REGISTRY_REQUIRED;
    queryTable[0].Name = registryName;
    queryTable[0].EntryContext = LogicalDiskStateSize;

    status = RtlQueryRegistryValues(RTL_REGISTRY_ABSOLUTE,
                                    FT_STATE_REGISTRY_KEY, queryTable,
                                    LogicalDiskState, NULL);

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

    return TRUE;
}

VOID
FtpDeleteStateInRegistry(
    IN  FT_LOGICAL_DISK_ID  LogicalDiskId
    )

/*++

Routine Description:

    This routine deletes the given registry state in the registry.

Arguments:

    LogicalDiskId           - Supplies the logical disk id.

Return Value:

    None.

--*/

{
    WCHAR                       registryName[50];

    swprintf(registryName, L"%I64X", LogicalDiskId);

    RtlDeleteRegistryValue(RTL_REGISTRY_ABSOLUTE, FT_STATE_REGISTRY_KEY,
                           registryName);
}


NTSTATUS
FtWmi(
    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.

--*/

{
    PVOLUME_EXTENSION       extension = (PVOLUME_EXTENSION) DeviceObject->DeviceExtension;
    PIO_STACK_LOCATION      irpSp = IoGetCurrentIrpStackLocation(Irp);
    NTSTATUS                status;
    SYSCTL_IRP_DISPOSITION  disposition;

    if (extension->DeviceExtensionType == DEVICE_EXTENSION_ROOT) {
        IoSkipCurrentIrpStackLocation(Irp);
        return IoCallDriver(extension->Root->TargetObject, Irp);
    }

    ASSERT(extension->DeviceExtensionType == DEVICE_EXTENSION_VOLUME);

    status = WmiSystemControl(extension->WmilibContext, DeviceObject,
                              Irp, &disposition);

    switch (disposition) {
        case IrpProcessed:
            break;

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

        default:
            status = Irp->IoStatus.Status;
            IoCompleteRequest(Irp, IO_NO_INCREMENT);
            break;
    }

    return status;
}


NTSTATUS
FtWmiFunctionControl(
    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;
    PVOLUME_EXTENSION extension;
    PPMWMICOUNTERLIB_CONTEXT counterLib;

    extension = (PVOLUME_EXTENSION) DeviceObject->DeviceExtension;
    counterLib = &extension->Root->PmWmiCounterLibContext;

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

    status = WmiCompleteRequest(
                                 DeviceObject,
                                 Irp,
                                 status,
                                 0,
                                 IO_NO_INCREMENT);
    return(status);
}



NTSTATUS
FtpPmWmiCounterLibContext(
    IN OUT PROOT_EXTENSION RootExtension,
    IN PIRP            Irp
    )

/*++

Routine Description:

    This routine is called from the partition manager to enable access to
    the performance counter maintenance routines.

Arguments:

    RootExtension   - Supplies the device extension.

    Irp             - Supplies the IO request packet.

Return Value:

    NTSTATUS

--*/

{
    PIO_STACK_LOCATION                  irpSp = IoGetCurrentIrpStackLocation(Irp);
    PPMWMICOUNTERLIB_CONTEXT            input;

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

        return STATUS_INVALID_PARAMETER;
    }

    input = (PPMWMICOUNTERLIB_CONTEXT) Irp->AssociatedIrp.SystemBuffer;
    RootExtension->PmWmiCounterLibContext = *input;

    return STATUS_SUCCESS;
}


VOID
FtDiskUnload(
    IN  PDRIVER_OBJECT  DriverObject
    )

/*++

Routine Description:

    This routine unloads.

Arguments:

    DriverObject    - Supplies the driver object.

Return Value:

    None.

--*/

{
    ObDereferenceObject(DriverObject);
}

VOID
FtpApplyESPSecurityWorker(
    IN  PDEVICE_OBJECT  DeviceObject,
    IN  PVOID           WorkItem
    )

{
    PVOLUME_EXTENSION   extension = (PVOLUME_EXTENSION) DeviceObject->DeviceExtension;
    PIO_WORKITEM        workItem = (PIO_WORKITEM) WorkItem;
    WCHAR               buffer[100];
    UNICODE_STRING      s;

    swprintf(buffer, L"\\Device\\HarddiskVolume%d", extension->VolumeNumber);
    RtlInitUnicodeString(&s, buffer);

    FtpApplyESPProtection(&s);

    IoFreeWorkItem(workItem);
}

VOID
FtpPostApplyESPSecurity(
    IN  PVOLUME_EXTENSION   Extension
    )

{
    PIO_WORKITEM    workItem;

    workItem = IoAllocateWorkItem(Extension->DeviceObject);
    if (!workItem) {
        return;
    }

    IoQueueWorkItem(workItem, FtpApplyESPSecurityWorker, DelayedWorkQueue,
                    workItem);
}

NTSTATUS
FtDiskPnp(
    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

--*/

{
    PVOLUME_EXTENSION       extension = (PVOLUME_EXTENSION) DeviceObject->DeviceExtension;
    PIO_STACK_LOCATION      irpSp = IoGetCurrentIrpStackLocation(Irp);
    PROOT_EXTENSION         rootExtension;
    PDEVICE_OBJECT          targetObject;
    NTSTATUS                status;
    UNICODE_STRING          interfaceName;
    PLIST_ENTRY             l;
    PVOLUME_EXTENSION       e;
    UNICODE_STRING          dosName;
    KEVENT                  event;
    ULONG                   n, size;
    PDEVICE_RELATIONS       deviceRelations;
    PDEVICE_CAPABILITIES    capabilities;
    DEVICE_INSTALL_STATE    deviceInstallState;
    ULONG                   bytes;
    BOOLEAN                 deletePdo;
    BOOLEAN                 dontAssertGuid;
    BOOLEAN                 removeInProgress;

    if (extension->DeviceExtensionType == DEVICE_EXTENSION_ROOT) {

        rootExtension = (PROOT_EXTENSION) extension;
        targetObject = rootExtension->TargetObject;

        switch (irpSp->MinorFunction) {

            case IRP_MN_START_DEVICE:
            case IRP_MN_CANCEL_REMOVE_DEVICE:
            case IRP_MN_CANCEL_STOP_DEVICE:
            case IRP_MN_QUERY_RESOURCES:
            case IRP_MN_QUERY_RESOURCE_REQUIREMENTS:
                Irp->IoStatus.Status = STATUS_SUCCESS ;
                IoSkipCurrentIrpStackLocation(Irp);
                return IoCallDriver(targetObject, Irp);

            case IRP_MN_QUERY_DEVICE_RELATIONS:
                if (irpSp->Parameters.QueryDeviceRelations.Type != BusRelations) {
                    IoSkipCurrentIrpStackLocation(Irp);
                    return IoCallDriver(targetObject, Irp);
                }

                FtpAcquire(rootExtension);

                n = 0;
                for (l = rootExtension->VolumeList.Flink;
                     l != &rootExtension->VolumeList; l = l->Flink) {

                    n++;
                }

                size = FIELD_OFFSET(DEVICE_RELATIONS, Objects) +
                       n*sizeof(PDEVICE_OBJECT);

                deviceRelations = (PDEVICE_RELATIONS)
                                  ExAllocatePool(PagedPool, size);
                if (!deviceRelations) {
                    FtpRelease(rootExtension);
                    status = STATUS_INSUFFICIENT_RESOURCES;
                    Irp->IoStatus.Information = 0;
                    break;
                }

                deviceRelations->Count = n;
                n = 0;
                for (l = rootExtension->VolumeList.Flink;
                     l != &rootExtension->VolumeList; l = l->Flink) {

                    e = CONTAINING_RECORD(l, VOLUME_EXTENSION, ListEntry);
                    deviceRelations->Objects[n++] = e->DeviceObject;
                    ObReferenceObject(e->DeviceObject);
                }

                while (!IsListEmpty(&rootExtension->DeadVolumeList)) {
                    l = RemoveHeadList(&rootExtension->DeadVolumeList);
                    e = CONTAINING_RECORD(l, VOLUME_EXTENSION, ListEntry);
                    e->DeadToPnp = TRUE;
                }

                FtpRelease(rootExtension);

                Irp->IoStatus.Status = STATUS_SUCCESS;
                Irp->IoStatus.Information = (ULONG_PTR) deviceRelations;

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

            case IRP_MN_QUERY_ID:
                status = FtpQueryRootId(rootExtension, Irp);

                if (NT_SUCCESS(status) || (status == STATUS_NOT_SUPPORTED)) {
                    if (NT_SUCCESS(status)) {
                        Irp->IoStatus.Status = status;
                    }

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

            case IRP_MN_REMOVE_DEVICE:
            case IRP_MN_SURPRISE_REMOVAL:

                FtpAcquire(rootExtension);

                if (rootExtension->VolumeManagerInterfaceName.Buffer) {
                    IoSetDeviceInterfaceState(
                            &rootExtension->VolumeManagerInterfaceName, FALSE);
                    ExFreePool(rootExtension->VolumeManagerInterfaceName.Buffer);
                    rootExtension->VolumeManagerInterfaceName.Buffer = NULL;
                }

                if (irpSp->MinorFunction == IRP_MN_REMOVE_DEVICE) {

                    ASSERT(IsListEmpty(&rootExtension->VolumeList));

                    while (!IsListEmpty(&rootExtension->VolumeList)) {

                        l = RemoveHeadList(&rootExtension->VolumeList);
                        e = CONTAINING_RECORD(l, VOLUME_EXTENSION, ListEntry);

                        FtpCleanupVolumeExtension(e);
                        ExFreePool(e->DeviceNodeName.Buffer);
                        IoDeleteDevice(e->DeviceObject);
                    }

                    delete rootExtension->DiskInfoSet;
                    rootExtension->DiskInfoSet = NULL;

                    FtpRelease(rootExtension);

                    InterlockedExchange(&rootExtension->TerminateThread, TRUE);

                    KeReleaseSemaphore(&rootExtension->WorkerSemaphore,
                                       IO_NO_INCREMENT, 1, FALSE);

                    KeWaitForSingleObject(rootExtension->WorkerThread, Executive,
                                          KernelMode, FALSE, NULL);

                    ObDereferenceObject(rootExtension->WorkerThread);

                    ASSERT(IsListEmpty(&rootExtension->ChangeNotifyIrpList));

                    IoDetachDevice(targetObject);
                    IoUnregisterShutdownNotification(rootExtension->DeviceObject);
                    IoDeleteDevice(rootExtension->DeviceObject);
                } else {
                    FtpRelease(rootExtension);
                }

                Irp->IoStatus.Status = STATUS_SUCCESS;
                IoSkipCurrentIrpStackLocation(Irp);
                return IoCallDriver(targetObject, Irp);

            case IRP_MN_QUERY_REMOVE_DEVICE:
            case IRP_MN_DEVICE_USAGE_NOTIFICATION:
                status = STATUS_INVALID_DEVICE_REQUEST;
                break;

            case IRP_MN_QUERY_CAPABILITIES:
                KeInitializeEvent(&event, NotificationEvent, FALSE);
                IoCopyCurrentIrpStackLocationToNext(Irp);
                IoSetCompletionRoutine(Irp, FtpSignalCompletion,
                                       &event, TRUE, TRUE, TRUE);
                IoCallDriver(targetObject, Irp);
                KeWaitForSingleObject(&event, Executive, KernelMode, FALSE,
                                      NULL);

                capabilities = irpSp->Parameters.DeviceCapabilities.Capabilities;
                capabilities->SilentInstall = 1;
                capabilities->RawDeviceOK = 1;
                status = Irp->IoStatus.Status;
                break;

            case IRP_MN_QUERY_PNP_DEVICE_STATE:
                KeInitializeEvent(&event, NotificationEvent, FALSE);
                IoCopyCurrentIrpStackLocationToNext(Irp);
                IoSetCompletionRoutine(Irp, FtpSignalCompletion,
                                       &event, TRUE, TRUE, TRUE);
                IoCallDriver(targetObject, Irp);
                KeWaitForSingleObject(&event, Executive, KernelMode, FALSE,
                                      NULL);

                status = Irp->IoStatus.Status;
                if (NT_SUCCESS(status)) {
                    Irp->IoStatus.Information |= PNP_DEVICE_NOT_DISABLEABLE |
                                                 PNP_DEVICE_DONT_DISPLAY_IN_UI;
                } else {
                    status = STATUS_SUCCESS;
                    Irp->IoStatus.Information = PNP_DEVICE_NOT_DISABLEABLE |
                                                PNP_DEVICE_DONT_DISPLAY_IN_UI;
                }
                break;

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

        }

    } else if (extension->DeviceExtensionType == DEVICE_EXTENSION_VOLUME) {

        switch (irpSp->MinorFunction) {

            case IRP_MN_START_DEVICE:
                FtpAcquire(extension->Root);

                KeInitializeEvent(&event, NotificationEvent, FALSE);
                FtpZeroRefCallback(extension, FtpStartCallback, &event, TRUE);
                KeWaitForSingleObject(&event, Executive, KernelMode, FALSE,
                                      NULL);

                dontAssertGuid = FALSE;
                if (extension->Root->PastBootReinitialize) {

                    status = IoGetDeviceProperty(extension->DeviceObject,
                                                 DevicePropertyInstallState,
                                                 sizeof(deviceInstallState),
                                                 &deviceInstallState, &bytes);
                    if (NT_SUCCESS(status)) {
                        if (deviceInstallState == InstallStateInstalled) {
                            extension->IsInstalled = TRUE;
                            if (extension->IsPreExposure) {
                                extension->Root->PreExposureCount--;
                                RemoveEntryList(&extension->ListEntry);
                                InsertTailList(
                                        &extension->Root->DeadVolumeList,
                                        &extension->ListEntry);
                                FtpCleanupVolumeExtension(extension);
                                status = STATUS_UNSUCCESSFUL;
                                dontAssertGuid = TRUE;
                            } else if (extension->IsHidden) {
                                status = STATUS_UNSUCCESSFUL;
                                dontAssertGuid = TRUE;
                                if (extension->IsEspType &&
                                    extension->Root->PastReinitialize) {

                                    FtpPostApplyESPSecurity(extension);
                                }
                            } else {
                                status = IoRegisterDeviceInterface(
                                         extension->DeviceObject,
                                         &MOUNTDEV_MOUNTED_DEVICE_GUID, NULL,
                                         &extension->MountedDeviceInterfaceName);
                            }
                        } else {
                            status = STATUS_UNSUCCESSFUL;
                            dontAssertGuid = TRUE;
                        }
                    } else {
                        dontAssertGuid = TRUE;
                    }
                } else {
                    extension->IsInstalled = TRUE;
                    if (extension->IsPreExposure || extension->IsHidden) {
                        status = STATUS_UNSUCCESSFUL;
                        dontAssertGuid = TRUE;
                    } else {
                        status = IoRegisterDeviceInterface(
                                 extension->DeviceObject,
                                 &MOUNTDEV_MOUNTED_DEVICE_GUID, NULL,
                                 &extension->MountedDeviceInterfaceName);
                    }
                }

                if (NT_SUCCESS(status)) {
                    status = IoSetDeviceInterfaceState(
                             &extension->MountedDeviceInterfaceName, TRUE);
                }

                if (!NT_SUCCESS(status)) {
                    if (extension->MountedDeviceInterfaceName.Buffer) {
                        ExFreePool(extension->MountedDeviceInterfaceName.Buffer);
                        extension->MountedDeviceInterfaceName.Buffer = NULL;
                    }
                    KeInitializeEvent(&event, NotificationEvent, FALSE);
                    FtpZeroRefCallback(extension, FtpVolumeOnlineCallback,
                                       &event, TRUE);
                    KeWaitForSingleObject(&event, Executive, KernelMode, FALSE,
                                          NULL);
                }

                if (!extension->IsHidden) {
                    FtRegisterDevice(DeviceObject);
                }

                FtpRelease(extension->Root);
                if (dontAssertGuid) {
                    status = STATUS_SUCCESS;
                }
                break;

            case IRP_MN_QUERY_REMOVE_DEVICE:
                if (extension->DeviceObject->Flags&DO_SYSTEM_BOOT_PARTITION) {
                    status = STATUS_INVALID_DEVICE_REQUEST;
                    break;
                }

                status = FtpCheckForQueryRemove(extension);
                break;

            case IRP_MN_CANCEL_REMOVE_DEVICE:
                removeInProgress = FtpCheckForCancelRemove(extension);

                if (removeInProgress) {
                    KeInitializeEvent(&event, NotificationEvent, FALSE);
                    FtpZeroRefCallback(extension, FtpQueryRemoveCallback,
                                       &event, TRUE);
                    KeWaitForSingleObject(&event, Executive, KernelMode, FALSE,
                                          NULL);
                }
                status = STATUS_SUCCESS;
                break;

            case IRP_MN_QUERY_STOP_DEVICE:
                status = STATUS_UNSUCCESSFUL;
                break;

            case IRP_MN_CANCEL_STOP_DEVICE:
            case IRP_MN_QUERY_RESOURCES:
            case IRP_MN_QUERY_RESOURCE_REQUIREMENTS:
                status = STATUS_SUCCESS;
                break;

            case IRP_MN_REMOVE_DEVICE:
            case IRP_MN_SURPRISE_REMOVAL:

                FtpAcquire(extension->Root);

                FtpRemoveHelper(extension);

                KeInitializeEvent(&event, NotificationEvent, FALSE);
                FtpZeroRefCallback(extension, FtpQueryRemoveCallback, &event,
                                   TRUE);
                KeWaitForSingleObject(&event, Executive, KernelMode, FALSE,
                                      NULL);

                if (extension->MountedDeviceInterfaceName.Buffer) {
                    IoSetDeviceInterfaceState(
                            &extension->MountedDeviceInterfaceName, FALSE);
                    ExFreePool(extension->MountedDeviceInterfaceName.Buffer);
                    extension->MountedDeviceInterfaceName.Buffer = NULL;
                }

                if (irpSp->MinorFunction == IRP_MN_REMOVE_DEVICE) {
                    if (extension->DeadToPnp && !extension->DeviceDeleted) {
                        extension->DeviceDeleted = TRUE;
                        ExFreePool(extension->DeviceNodeName.Buffer);
                        deletePdo = TRUE;
                    } else {
                        deletePdo = FALSE;
                    }
                } else {
                    deletePdo = FALSE;
                }

                FtpRelease(extension->Root);

                // If this device is still being enumerated then don't
                // delete it and wait for a start instead.  If it is not
                // being enumerated then blow it away.

                if (deletePdo) {
                    IoDeleteDevice(extension->DeviceObject);
                }
                status = STATUS_SUCCESS;
                break;

            case IRP_MN_QUERY_DEVICE_RELATIONS:
                if (irpSp->Parameters.QueryDeviceRelations.Type !=
                    TargetDeviceRelation) {

                    status = STATUS_NOT_SUPPORTED;
                    break;
                }

                deviceRelations = (PDEVICE_RELATIONS)
                                  ExAllocatePool(PagedPool,
                                                 sizeof(DEVICE_RELATIONS));
                if (!deviceRelations) {
                    status = STATUS_INSUFFICIENT_RESOURCES;
                    break;
                }

                ObReferenceObject(DeviceObject);
                deviceRelations->Count = 1;
                deviceRelations->Objects[0] = DeviceObject;
                Irp->IoStatus.Information = (ULONG_PTR) deviceRelations;
                status = STATUS_SUCCESS;
                break;

            case IRP_MN_QUERY_INTERFACE:
                status = STATUS_NOT_SUPPORTED ;
                break;

            case IRP_MN_QUERY_CAPABILITIES:
                capabilities = irpSp->Parameters.DeviceCapabilities.Capabilities;
                capabilities->SilentInstall = 1;
                capabilities->RawDeviceOK = 1;
                capabilities->SurpriseRemovalOK = 1;
                capabilities->Address = extension->VolumeNumber;
                status = STATUS_SUCCESS;
                break;

            case IRP_MN_QUERY_ID:
                status = FtpQueryId(extension, Irp);
                break;

            case IRP_MN_QUERY_PNP_DEVICE_STATE:
                Irp->IoStatus.Information = PNP_DEVICE_DONT_DISPLAY_IN_UI;
                if ((extension->DeviceObject->Flags&DO_SYSTEM_BOOT_PARTITION) ||
                    extension->InPagingPath) {

                    Irp->IoStatus.Information |= PNP_DEVICE_NOT_DISABLEABLE;
                }
                status = STATUS_SUCCESS;
                break;

            case IRP_MN_DEVICE_USAGE_NOTIFICATION:
                return FtDiskPagingNotification(DeviceObject, Irp);

            default:
                status = STATUS_NOT_SUPPORTED;
                break;

        }
    } else {
        Irp->IoStatus.Information = 0;
        status = STATUS_INVALID_DEVICE_REQUEST;
    }

    if (status != STATUS_NOT_SUPPORTED) {
        Irp->IoStatus.Status = status;
    } else {
        status = Irp->IoStatus.Status;
    }

    IoCompleteRequest(Irp, IO_NO_INCREMENT);
    return status;
}

class DELETE_FT_REGISTRY_WORK_ITEM : public WORK_QUEUE_ITEM {

    public:

        PROOT_EXTENSION     RootExtension;
        FT_LOGICAL_DISK_ID  LogicalDiskId;

};

typedef DELETE_FT_REGISTRY_WORK_ITEM *PDELETE_FT_REGISTRY_WORK_ITEM;

VOID
FtpDeleteFtRegistryWorker(
    IN  PVOID   WorkItem
    )

{
    PDELETE_FT_REGISTRY_WORK_ITEM       workItem = (PDELETE_FT_REGISTRY_WORK_ITEM) WorkItem;
    PROOT_EXTENSION                     rootExtension = workItem->RootExtension;
    PFT_LOGICAL_DISK_INFORMATION_SET    diskInfoSet = rootExtension->DiskInfoSet;

    FtpAcquire(rootExtension);
    diskInfoSet->DeleteFtRegistryInfo(workItem->LogicalDiskId);
    FtpRelease(rootExtension);
}

#ifdef ALLOC_PRAGMA
#pragma code_seg()
#endif

PVOLUME_EXTENSION
FtpFindExtensionCoveringPartition(
    IN  PROOT_EXTENSION RootExtension,
    IN  PDEVICE_OBJECT  Partition
    )

/*++

Routine Description:

    This routine finds the device extension covering the given partition.

Arguments:

    RootExtension   - Supplies the root extension.

    Partition       - Supplies the partition.

Return Value:

    The volume extension covering the given partition.

--*/

{
    PLIST_ENTRY         l;
    PVOLUME_EXTENSION   extension;
    PFT_VOLUME          vol;

    for (l = RootExtension->VolumeList.Flink; l != &RootExtension->VolumeList;
         l = l->Flink) {

        extension = CONTAINING_RECORD(l, VOLUME_EXTENSION, ListEntry);

        if (extension->TargetObject) {
            if (extension->TargetObject == Partition) {
                return extension;
            }
            continue;
        }

        vol = extension->FtVolume;
        if (vol && vol->GetContainedLogicalDisk(Partition)) {
            return extension;
        }
    }

    return NULL;
}

VOID
FtpAcquire(
    IN OUT  PROOT_EXTENSION RootExtension
    )

/*++

Routine Description:

    This routine grabs the root semaphore.

Arguments:

    RootExtension   - Supplies the root extension.

Return Value:

    None.

--*/

{
    KeWaitForSingleObject(&RootExtension->Mutex, Executive, KernelMode,
                          FALSE, NULL);
}

VOID
FtpRelease(
    IN OUT  PROOT_EXTENSION RootExtension
    )

/*++

Routine Description:

    This routine releases the root semaphore.

Arguments:

    RootExtension   - Supplies the root extension.

Return Value:

    None.

--*/

{
    KeReleaseSemaphore(&RootExtension->Mutex, IO_NO_INCREMENT, 1, FALSE);
}

VOID
FtpCancelChangeNotify(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp
    )
/*++

Routine Description:

    This is the cancel routine for notification IRPs.

Arguments:

    DeviceObject   - Supplies the device object.

    Irp            - Supplies the IO request packet.

Return Value:

    None

--*/
{
    PVOLUME_EXTENSION   Extension;

    IoReleaseCancelSpinLock (Irp->CancelIrql);

    Extension = (PVOLUME_EXTENSION) Irp->Tail.Overlay.DriverContext[0];

    FtpAcquire(Extension->Root);
    RemoveEntryList (&Irp->Tail.Overlay.ListEntry);
    FtpRelease(Extension->Root);

    Irp->IoStatus.Status = STATUS_CANCELLED;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
}


NTSTATUS
FtDiskCreate(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp
    )

/*++

Routine Description:

    This routine is the dispatch for IRP_MJ_CREATE.

Arguments:

    DeviceObject - Supplies the device object.

    Irp          - Supplies the IO request block.

Return Value:

    NTSTATUS

--*/

{
    Irp->IoStatus.Status = STATUS_SUCCESS;
    Irp->IoStatus.Information = 0;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
    return STATUS_SUCCESS;
}

VOID
FtpEventSignalCompletion(
    IN  PVOID       Event,
    IN  NTSTATUS    Status
    )

/*++

Routine Description:

    Completion routine of type FT_COMPLETION_ROUTINE that sets
    the status of the given event to Signaled

Arguments:

    Event       - Supplies the event

    Status      - Supplies the status of the operation.

Return Value:

    None.

--*/

{
    KeSetEvent( (PKEVENT) Event, IO_NO_INCREMENT, FALSE );
}

VOID
FtpVolumeOnlineCallback(
    IN  PVOLUME_EXTENSION   Extension
    )

{
    if (Extension->IsOffline) {
        Extension->IsOffline = FALSE;
        Extension->IsComplete = FALSE;
    }
    KeSetEvent((PKEVENT) Extension->ZeroRefContext, IO_NO_INCREMENT, FALSE);
}

VOID
FtpVolumeOfflineCallback(
    IN  PVOLUME_EXTENSION   Extension
    )

{
    if (!Extension->IsOffline) {
        Extension->IsOffline = TRUE;
        if (Extension->FtVolume) {
            Extension->FtVolume->SetDirtyBit(FALSE, NULL, NULL);
        }
    }
    KeSetEvent((PKEVENT) Extension->ZeroRefContext, IO_NO_INCREMENT, FALSE);
}

NTSTATUS
FtpAllSystemsGo(
    IN  PVOLUME_EXTENSION   Extension,
    IN  PIRP                Irp,
    IN  BOOLEAN             MustBeComplete,
    IN  BOOLEAN             MustHaveVolume,
    IN  BOOLEAN             MustBeOnline
    )

/*++

Routine Description:

    This routine checks the device extension states to make sure that the
    IRP can proceed.  If the IRP can proceed then the device extension ref
    count is incremented.  If the IRP is queued then STATUS_PENDING returned.

Arguments:

    Extension       - Supplies the device extension.

    Irp             - Supplies the I/O request packet.

    MustBeComplete  - Supplies whether or not the FT set must be complete.

    MustHaveVolume  - Supplies whether or not the PDO still refers to an
                        existing volume.

    MustBeOnline    - Supplies whether or not the volume must be online.

Return Value:

    STATUS_PENDING      - The IRP was put on the ZeroRef queue.

    STATUS_SUCCESS      - The IRP can proceed.  The ref count was incremented.

    !NT_SUCCESS(status) - The IRP must fail with the status returned.

--*/

{
    KIRQL                           irql;
    PFT_VOLUME                      vol;
    BOOLEAN                         deleteFtRegistryInfo;
    PDELETE_FT_REGISTRY_WORK_ITEM   workItem;

    if (MustBeComplete) {
        MustHaveVolume = TRUE;
        MustBeOnline = TRUE;
    }

    KeAcquireSpinLock(&Extension->SpinLock, &irql);
    if (MustHaveVolume && !Extension->TargetObject && !Extension->FtVolume) {
        KeReleaseSpinLock(&Extension->SpinLock, irql);
        return STATUS_NO_SUCH_DEVICE;
    }

    if (!Extension->IsStarted) {
        KeReleaseSpinLock(&Extension->SpinLock, irql);
        return STATUS_NO_SUCH_DEVICE;
    }

    if (MustBeOnline && Extension->IsOffline) {
        if (Extension->DeviceObject->Flags&DO_SYSTEM_BOOT_PARTITION) {
            Extension->IsOffline = FALSE;
        } else {
            KeReleaseSpinLock(&Extension->SpinLock, irql);
            if (Irp) {
                Irp->IoStatus.Information = 0;
            }
            return STATUS_DEVICE_OFF_LINE;
        }
    }

    if (Extension->ZeroRefCallback || Extension->RemoveInProgress) {
        ASSERT(Irp);
        IoMarkIrpPending(Irp);
        InsertTailList(&Extension->ZeroRefHoldQueue,
                       &Irp->Tail.Overlay.ListEntry);
        KeReleaseSpinLock(&Extension->SpinLock, irql);
        return STATUS_PENDING;
    }

    if (Extension->TargetObject) {
        InterlockedIncrement(&Extension->RefCount);
        if (!Extension->IsOffline) {
            InterlockedExchange(&Extension->AllSystemsGo, TRUE);
        }
        KeReleaseSpinLock(&Extension->SpinLock, irql);
        return STATUS_SUCCESS;
    }

    if (!MustBeComplete || Extension->IsComplete) {
        InterlockedIncrement(&Extension->RefCount);
        if (Extension->IsComplete && MustHaveVolume && !Extension->IsOffline) {
            InterlockedExchange(&Extension->AllSystemsGo, TRUE);
        }
        KeReleaseSpinLock(&Extension->SpinLock, irql);
        return STATUS_SUCCESS;
    }

    vol = Extension->FtVolume;
    ASSERT(vol);

    if (!vol->IsComplete(TRUE)) {
        KeReleaseSpinLock(&Extension->SpinLock, irql);
        return STATUS_NO_SUCH_DEVICE;
    }
    vol->CompleteNotification(TRUE);

    if (vol->IsComplete(FALSE)) {
        deleteFtRegistryInfo = FALSE;
    } else {
        deleteFtRegistryInfo = TRUE;
    }

    Extension->IsComplete = TRUE;
    InterlockedIncrement(&Extension->RefCount);
    InterlockedIncrement(&Extension->RefCount);
    InterlockedExchange(&Extension->AllSystemsGo, TRUE);
    KeReleaseSpinLock(&Extension->SpinLock, irql);

    vol->StartSyncOperations(FALSE, FtpRefCountCompletion, Extension);
    vol->SetDirtyBit(TRUE, NULL, NULL);

    if (deleteFtRegistryInfo) {

        workItem = (PDELETE_FT_REGISTRY_WORK_ITEM)
                   ExAllocatePool(NonPagedPool,
                                  sizeof(DELETE_FT_REGISTRY_WORK_ITEM));
        if (!workItem) {
            return STATUS_SUCCESS;
        }

        ExInitializeWorkItem(workItem, FtpDeleteFtRegistryWorker, workItem);
        workItem->RootExtension = Extension->Root;
        workItem->LogicalDiskId = vol->QueryLogicalDiskId();

        FtpQueueWorkItem(Extension->Root, workItem);
    }

    return STATUS_SUCCESS;
}

VOID
FtpZeroRefCallback(
    IN  PVOLUME_EXTENSION   Extension,
    IN  ZERO_REF_CALLBACK   ZeroRefCallback,
    IN  PVOID               ZeroRefContext,
    IN  BOOLEAN             AcquireSemaphore
    )

/*++

Routine Description:

    This routine sets up the given zero ref callback and state.

Arguments:

    Extension           - Supplies the device extension.

    ZeroRefCallback     - Supplies the zero ref callback.

    ZeroRefContext      - Supplies the zero ref context.

    AcquireSemaphore    - Supplies whether or not to acquire the semaphore.

Return Value:

    None.

--*/

{
    KIRQL   irql;

    if (AcquireSemaphore) {
        KeWaitForSingleObject(&Extension->Semaphore, Executive, KernelMode,
                              FALSE, NULL);
    }

    KeAcquireSpinLock(&Extension->SpinLock, &irql);
    InterlockedExchange(&Extension->AllSystemsGo, FALSE);
    ASSERT(!Extension->ZeroRefCallback);
    Extension->ZeroRefCallback = ZeroRefCallback;
    Extension->ZeroRefContext = ZeroRefContext;
    KeReleaseSpinLock(&Extension->SpinLock, irql);

    if (Extension->FtVolume) {
        Extension->FtVolume->StopSyncOperations();
    }

    FtpDecrementRefCount(Extension);
}

NTSTATUS
FtDiskPower(
    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

--*/

{
    PVOLUME_EXTENSION       extension = (PVOLUME_EXTENSION) DeviceObject->DeviceExtension;
    PROOT_EXTENSION         rootExtension = extension->Root;
    PIO_STACK_LOCATION      irpSp = IoGetCurrentIrpStackLocation(Irp);
    NTSTATUS                status;

    if (extension->DeviceExtensionType == DEVICE_EXTENSION_ROOT) {
        PoStartNextPowerIrp(Irp);
        IoSkipCurrentIrpStackLocation(Irp);
        return PoCallDriver(rootExtension->TargetObject, Irp);
    }

    switch (irpSp->MinorFunction) {
        case IRP_MN_WAIT_WAKE:
        case IRP_MN_POWER_SEQUENCE:
        case IRP_MN_SET_POWER:
        case IRP_MN_QUERY_POWER:
            status = STATUS_SUCCESS;
            break;

        default:
            status = Irp->IoStatus.Status;
            break;

    }

    Irp->IoStatus.Status = status;
    PoStartNextPowerIrp(Irp);
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
    return status;
}

VOID
FtpWorkerThread(
    IN  PVOID   RootExtension
    )

/*++

Routine Description:

    This is a worker thread to process work queue items.

Arguments:

    RootExtension   - Supplies the root device extension.

Return Value:

    None.

--*/

{
    PROOT_EXTENSION     extension = (PROOT_EXTENSION) RootExtension;
    KIRQL               irql;
    PLIST_ENTRY         l;
    PWORK_QUEUE_ITEM    queueItem;

    for (;;) {

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

        KeAcquireSpinLock(&extension->SpinLock, &irql);
        if (extension->TerminateThread) {
            KeReleaseSpinLock(&extension->SpinLock, irql);
            PsTerminateSystemThread(STATUS_SUCCESS);
            return;
        }

        ASSERT(!IsListEmpty(&extension->WorkerQueue));
        l = RemoveHeadList(&extension->WorkerQueue);
        KeReleaseSpinLock(&extension->SpinLock, irql);

        queueItem = CONTAINING_RECORD(l, WORK_QUEUE_ITEM, List);
        queueItem->WorkerRoutine(queueItem->Parameter);

        ExFreePool(queueItem);
    }
}

VOID
FtpEmptyQueueAtDispatchLevel(
    IN OUT  PVOLUME_EXTENSION   Extension,
    IN OUT  PLIST_ENTRY         IrpQueue
    )

/*++

Routine Description:

    This routine empties the given queue of irps that are callable at
    dispatch level by calling their respective dispatch routines.

Arguments:

    Extension   - Supplies the device extension.

    IrpQueue    - Supplies the queue of IRPs.

Return Value:

    None.

--*/

{
    PDRIVER_OBJECT      driverObject;
    PDEVICE_OBJECT      deviceObject;
    PLIST_ENTRY         l, tmp;
    PIRP                irp;
    PIO_STACK_LOCATION  irpSp;

    driverObject = Extension->Root->DriverObject;
    deviceObject = Extension->DeviceObject;

    for (l = IrpQueue->Flink; l != IrpQueue; l = l->Flink) {
        irp = CONTAINING_RECORD(l, IRP, Tail.Overlay.ListEntry);
        irpSp = IoGetCurrentIrpStackLocation(irp);
        switch (irpSp->MajorFunction) {
            case IRP_MJ_POWER:
            case IRP_MJ_READ:
            case IRP_MJ_WRITE:
                tmp = l->Blink;
                RemoveEntryList(l);
                l = tmp;
                driverObject->MajorFunction[irpSp->MajorFunction](
                        deviceObject, irp);
                break;

        }
    }
}

VOID
FtpDecrementRefCount(
    IN OUT  PVOLUME_EXTENSION   Extension
    )

/*++

Routine Description:

    This routine decrements the ref count and handles the case
    when the ref count goes to zero.

Arguments:

    Extension   - Supplies the volume extension.

Return Value:

    None.

--*/

{
    LONG                        count;
    KIRQL                       irql;
    BOOLEAN                     startSync, list;
    LIST_ENTRY                  q;
    PEMPTY_IRP_QUEUE_WORK_ITEM  workItem;
    PLIST_ENTRY                 l;
    PIRP                        irp;

    count = InterlockedDecrement(&Extension->RefCount);
    if (count) {
        return;
    }

    KeAcquireSpinLock(&Extension->SpinLock, &irql);
    if (!Extension->ZeroRefCallback) {
        KeReleaseSpinLock(&Extension->SpinLock, irql);
        return;
    }

    Extension->ZeroRefCallback(Extension);
    Extension->ZeroRefCallback = NULL;
    InterlockedIncrement(&Extension->RefCount);

    if (Extension->FtVolume && Extension->IsComplete && Extension->IsStarted &&
        !Extension->IsOffline) {

        startSync = TRUE;
        InterlockedIncrement(&Extension->RefCount);
    } else {
        startSync = FALSE;
    }

    if (IsListEmpty(&Extension->ZeroRefHoldQueue) ||
        Extension->RemoveInProgress) {

        list = FALSE;
    } else {
        list = TRUE;
        q = Extension->ZeroRefHoldQueue;
        InitializeListHead(&Extension->ZeroRefHoldQueue);
    }
    KeReleaseSpinLock(&Extension->SpinLock, irql);

    KeReleaseSemaphore(&Extension->Semaphore, IO_NO_INCREMENT, 1, FALSE);

    if (startSync) {
        Extension->FtVolume->StartSyncOperations(FALSE, FtpRefCountCompletion,
                                                 Extension);
    }

    if (!list) {
        return;
    }

    q.Flink->Blink = &q;
    q.Blink->Flink = &q;

    FtpEmptyQueueAtDispatchLevel(Extension, &q);

    if (IsListEmpty(&q)) {
        return;
    }

    workItem = (PEMPTY_IRP_QUEUE_WORK_ITEM)
               ExAllocatePool(NonPagedPool,
                              sizeof(EMPTY_IRP_QUEUE_WORK_ITEM));
    if (!workItem) {
        workItem = (PEMPTY_IRP_QUEUE_WORK_ITEM)
                   ExAllocatePool(NonPagedPool,
                                  sizeof(EMPTY_IRP_QUEUE_WORK_ITEM));
        if (!workItem) {
            while (!IsListEmpty(&q)) {
                l = RemoveHeadList(&q);
                irp = CONTAINING_RECORD(l, IRP, Tail.Overlay.ListEntry);
                irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
                irp->IoStatus.Information = 0;
                IoCompleteRequest(irp, IO_NO_INCREMENT);
            }
            return;
        }
    }

    ExInitializeWorkItem(workItem, FtpEmptyQueueWorkerRoutine, workItem);
    workItem->IrpQueue = q;
    workItem->IrpQueue.Flink->Blink = &workItem->IrpQueue;
    workItem->IrpQueue.Blink->Flink = &workItem->IrpQueue;
    workItem->Extension = Extension;

    ExQueueWorkItem(workItem, CriticalWorkQueue);
}

NTSTATUS
FtDiskAddDevice(
    IN  PDRIVER_OBJECT  DriverObject,
    IN  PDEVICE_OBJECT  PhysicalDeviceObject,
    IN  PUNICODE_STRING RegistryPath
    )

/*++

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

--*/

{
    UNICODE_STRING      deviceName, dosName;
    NTSTATUS            status;
    PDEVICE_OBJECT      deviceObject;
    PROOT_EXTENSION     rootExtension;
    HANDLE              handle;
    KIRQL               irql;

    RtlInitUnicodeString(&deviceName, DD_FT_CONTROL_DEVICE_NAME);

    status = IoCreateDevice(DriverObject, sizeof(ROOT_EXTENSION),
                            &deviceName, FILE_DEVICE_NETWORK,
                            FILE_DEVICE_SECURE_OPEN, FALSE,
                            &deviceObject);

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

    RtlInitUnicodeString(&dosName, L"\\DosDevices\\FtControl");
    IoCreateSymbolicLink(&dosName, &deviceName);

    rootExtension = (PROOT_EXTENSION) deviceObject->DeviceExtension;
    RtlZeroMemory(rootExtension, sizeof(ROOT_EXTENSION));
    rootExtension->DeviceObject = deviceObject;
    rootExtension->Root = rootExtension;
    rootExtension->DeviceExtensionType = DEVICE_EXTENSION_ROOT;
    KeInitializeSpinLock(&rootExtension->SpinLock);
    rootExtension->DriverObject = DriverObject;

    rootExtension->TargetObject =
            IoAttachDeviceToDeviceStack(deviceObject, PhysicalDeviceObject);
    if (!rootExtension->TargetObject) {
        IoDeleteSymbolicLink(&dosName);
        IoDeleteDevice(deviceObject);
        return STATUS_NO_SUCH_DEVICE;
    }

    rootExtension->Pdo = PhysicalDeviceObject;
    InitializeListHead(&rootExtension->VolumeList);
    InitializeListHead(&rootExtension->DeadVolumeList);
    rootExtension->NextVolumeNumber = 1;

    rootExtension->DiskInfoSet = new FT_LOGICAL_DISK_INFORMATION_SET;
    if (!rootExtension->DiskInfoSet) {
        IoDeleteSymbolicLink(&dosName);
        IoDetachDevice(rootExtension->TargetObject);
        IoDeleteDevice(deviceObject);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
    status = rootExtension->DiskInfoSet->Initialize();
    if (!NT_SUCCESS(status)) {
        delete rootExtension->DiskInfoSet;
        IoDeleteSymbolicLink(&dosName);
        IoDetachDevice(rootExtension->TargetObject);
        IoDeleteDevice(deviceObject);
        return status;
    }

    InitializeListHead(&rootExtension->WorkerQueue);
    KeInitializeSemaphore(&rootExtension->WorkerSemaphore, 0, MAXLONG);
    rootExtension->TerminateThread = TRUE;
    InitializeListHead(&rootExtension->ChangeNotifyIrpList);
    KeInitializeSemaphore(&rootExtension->Mutex, 1, 1);

    rootExtension->DiskPerfRegistryPath.MaximumLength =
            RegistryPath->Length + sizeof(UNICODE_NULL);
    rootExtension->DiskPerfRegistryPath.Buffer = (PWSTR)
            ExAllocatePool(PagedPool,
                           rootExtension->DiskPerfRegistryPath.MaximumLength);
    if (!rootExtension->DiskPerfRegistryPath.Buffer) {
        delete rootExtension->DiskInfoSet;
        IoDeleteSymbolicLink(&dosName);
        IoDetachDevice(rootExtension->TargetObject);
        IoDeleteDevice(deviceObject);
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    RtlCopyUnicodeString(&rootExtension->DiskPerfRegistryPath,
                         RegistryPath);

    status = IoRegisterShutdownNotification(deviceObject);
    if (!NT_SUCCESS(status)) {
        ExFreePool(rootExtension->DiskPerfRegistryPath.Buffer);
        delete rootExtension->DiskInfoSet;
        IoDeleteSymbolicLink(&dosName);
        IoDetachDevice(rootExtension->TargetObject);
        IoDeleteDevice(deviceObject);
        return status;
    }

    deviceObject->Flags &= ~DO_DEVICE_INITIALIZING;

    return STATUS_SUCCESS;
}

NTSTATUS
FtpRefCountCompletionRoutine(
    IN  PDEVICE_OBJECT  DeviceObject,
    IN  PIRP            Irp,
    IN  PVOID           Extension
    )

/*++

Routine Description:

    This routine decrements the ref count in the device extension.

Arguments:

    DeviceObject    - Supplies the device object.

    Irp             - Supplies the IO request packet.

    Extension       - Supplies the device extension.

Return Value:

    NTSTATUS

--*/

{
    PVOLUME_EXTENSION   extension = (PVOLUME_EXTENSION) Extension;

    if (extension->CountersEnabled) {
        PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
        if (irpStack->MajorFunction == IRP_MJ_READ ||
            irpStack->MajorFunction == IRP_MJ_WRITE) {
            PPMWMICOUNTERLIB_CONTEXT counterLib;
    
            counterLib = &extension->Root->PmWmiCounterLibContext;
            counterLib->PmWmiCounterIoComplete(
                extension->PmWmiCounterContext, Irp,
                (PLARGE_INTEGER) &irpStack->Parameters.Read);
        }
    }

    FtpDecrementRefCount(extension);
    return STATUS_SUCCESS;
}

NTSTATUS
FtDiskReadWrite(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp
    )

/*++

Routine Description:

    This routine is the dispatch for IRP_MJ_READ and IRP_MJ_WRITE.

Arguments:

    DeviceObject    - Supplies the device object.

    Irp             - Supplies the IO request packet.

Return Value:

    NTSTATUS

--*/

{
    PVOLUME_EXTENSION   extension;
    NTSTATUS            status;
    PFT_VOLUME          vol;
    PDISPATCH_TP        packet;
    KIRQL               irql;
    PIO_STACK_LOCATION  irpSp;
    LONGLONG            offset;
    ULONG               length;

    extension = (PVOLUME_EXTENSION) DeviceObject->DeviceExtension;

    if (extension->DeviceExtensionType != DEVICE_EXTENSION_VOLUME) {
        Irp->IoStatus.Information = 0;
        Irp->IoStatus.Status = STATUS_NO_SUCH_DEVICE;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
        return STATUS_NO_SUCH_DEVICE;
    }

    InterlockedIncrement(&extension->RefCount);
    if (!extension->AllSystemsGo) {
        FtpDecrementRefCount(extension);

        status = FtpAllSystemsGo(extension, Irp, TRUE, TRUE, TRUE);
        if (status == STATUS_PENDING) {
            return STATUS_PENDING;
        }

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

    if (extension->IsReadOnly) {
        irpSp = IoGetCurrentIrpStackLocation(Irp);
        if (irpSp->MajorFunction == IRP_MJ_WRITE) {
            Irp->IoStatus.Status = STATUS_INVALID_DEVICE_REQUEST;
            Irp->IoStatus.Information = 0;
            IoCompleteRequest(Irp, IO_NO_INCREMENT);
            return STATUS_INVALID_DEVICE_REQUEST;
        }
    }

    if (extension->TargetObject) {
        IoCopyCurrentIrpStackLocationToNext(Irp);

        if (extension->WholeDisk) {
            irpSp = IoGetNextIrpStackLocation(Irp);
            offset = irpSp->Parameters.Read.ByteOffset.QuadPart;
            length = irpSp->Parameters.Read.Length;
            if (offset < 0 || offset + length > extension->PartitionLength) {
                FtpDecrementRefCount(extension);
                Irp->IoStatus.Information = 0;
                Irp->IoStatus.Status = STATUS_INVALID_PARAMETER;
                IoCompleteRequest(Irp, IO_NO_INCREMENT);
                return STATUS_INVALID_PARAMETER;
            }

            if (extension->CountersEnabled) {
                PIO_STACK_LOCATION currentIrpStack =
                    IoGetCurrentIrpStackLocation(Irp);
                PPMWMICOUNTERLIB_CONTEXT counterLib;
    
                counterLib = &extension->Root->PmWmiCounterLibContext;
                counterLib->PmWmiCounterIoStart(
                    extension->PmWmiCounterContext,
                    (PLARGE_INTEGER) &currentIrpStack->Parameters.Read);
            }

            irpSp->Parameters.Read.ByteOffset.QuadPart +=
                    extension->PartitionOffset;

            IoSetCompletionRoutine(Irp, FtpRefCountCompletionRoutine,
                                   extension, TRUE, TRUE, TRUE);

            IoMarkIrpPending(Irp);

            IoCallDriver(extension->WholeDisk, Irp);

        } else {

            if (extension->CountersEnabled) {
                PIO_STACK_LOCATION currentIrpStack =
                    IoGetCurrentIrpStackLocation(Irp);
                PPMWMICOUNTERLIB_CONTEXT counterLib;
    
                counterLib = &extension->Root->PmWmiCounterLibContext;
                counterLib->PmWmiCounterIoStart(
                    extension->PmWmiCounterContext,
                    (PLARGE_INTEGER) &currentIrpStack->Parameters.Read);
            }

            IoSetCompletionRoutine(Irp, FtpRefCountCompletionRoutine,
                                   extension, TRUE, TRUE, TRUE);

            IoMarkIrpPending(Irp);

            IoCallDriver(extension->TargetObject, Irp);
        }

        return STATUS_PENDING;
    }

    vol = extension->FtVolume;
    ASSERT(vol);

    packet = new DISPATCH_TP;
    if (!packet) {
        KeAcquireSpinLock(&extension->SpinLock, &irql);
        if (extension->EmergencyTransferPacketInUse) {
            IoMarkIrpPending(Irp);
            InsertTailList(&extension->
                           EmergencyTransferPacketQueue,
                           &Irp->Tail.Overlay.ListEntry);
            KeReleaseSpinLock(&extension->SpinLock, irql);
            return STATUS_PENDING;
        }
        packet = extension->EmergencyTransferPacket;
        extension->EmergencyTransferPacketInUse = TRUE;
        KeReleaseSpinLock(&extension->SpinLock, irql);
    }

    irpSp = IoGetCurrentIrpStackLocation(Irp);

    packet->Mdl = Irp->MdlAddress;
    packet->OriginalIrp = Irp;
    packet->Offset = irpSp->Parameters.Read.ByteOffset.QuadPart;
    packet->Length = irpSp->Parameters.Read.Length;
    packet->CompletionRoutine = FtpReadWriteCompletionRoutine;
    packet->TargetVolume = vol;
    packet->Thread = Irp->Tail.Overlay.Thread;
    packet->IrpFlags = irpSp->Flags;
    if (irpSp->MajorFunction == IRP_MJ_READ) {
        packet->ReadPacket = TRUE;
    } else {
        packet->ReadPacket = FALSE;
    }
    packet->Irp = Irp;
    packet->Extension = extension;

    if (extension->CountersEnabled) {
        PPMWMICOUNTERLIB_CONTEXT counterLib;

        counterLib = &extension->Root->PmWmiCounterLibContext;
        counterLib->PmWmiCounterIoStart(
            extension->PmWmiCounterContext,
            (PLARGE_INTEGER) &irpSp->Parameters.Read);
    }

    IoMarkIrpPending(Irp);

    TRANSFER(packet);

    return STATUS_PENDING;
}

NTSTATUS
FtpSetPowerState(
    IN  PROOT_EXTENSION RootExtension,
    IN  PIRP            Irp
    )

/*++

Routine Description:

    This routine sets the power state for the volume from the power state
    given to it by the disk.

Arguments:

    RootExtension   - Supplies the root extension.

    Irp             - Supplies the I/O request packet.

Return Value:

    NTSTATUS

--*/

{
    PIO_STACK_LOCATION  irpSp = IoGetCurrentIrpStackLocation(Irp);
    PVOLMGR_POWER_STATE input = (PVOLMGR_POWER_STATE) Irp->AssociatedIrp.SystemBuffer;
    PVOLUME_EXTENSION   extension;
    KIRQL               irql;
    POWER_STATE         powerState;

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

        return STATUS_INVALID_PARAMETER;
    }

    extension = FtpFindExtensionCoveringPartition(
                RootExtension, input->PartitionDeviceObject);
    if (!extension) {
        return STATUS_INVALID_DEVICE_REQUEST;
    }

    KeAcquireSpinLock(&extension->SpinLock, &irql);
    if (extension->PowerState == input->PowerState) {
        KeReleaseSpinLock(&extension->SpinLock, irql);
        return STATUS_SUCCESS;
    }
    extension->PowerState = input->PowerState;
    KeReleaseSpinLock(&extension->SpinLock, irql);

    powerState.DeviceState = input->PowerState;
    PoSetPowerState(extension->DeviceObject, DevicePowerState, powerState);
    PoRequestPowerIrp(extension->DeviceObject, IRP_MN_SET_POWER,
                      powerState, NULL, NULL, NULL);

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

/*++

Routine Description:

    This routine is the dispatch for IRP_MJ_DEVICE_CONTROL.

Arguments:

    DeviceObject    - Supplies the device object.

    Irp             - Supplies the IO request packet.

Return Value:

    NTSTATUS

--*/

{
    PVOLUME_EXTENSION   extension = (PVOLUME_EXTENSION) DeviceObject->DeviceExtension;
    PIO_STACK_LOCATION  irpSp = IoGetCurrentIrpStackLocation(Irp);
    NTSTATUS            status;

    Irp->IoStatus.Information = 0;

    FtpAcquire(extension->Root);

    switch (irpSp->Parameters.DeviceIoControl.IoControlCode) {

        case IOCTL_INTERNAL_VOLMGR_PARTITION_ARRIVED:
            if (extension->DeviceExtensionType == DEVICE_EXTENSION_ROOT) {
                status = FtpPartitionArrived(extension->Root, Irp);
            } else {
                status = STATUS_INVALID_PARAMETER;
            }
            break;

        case IOCTL_INTERNAL_VOLMGR_PARTITION_REMOVED:
            if (extension->DeviceExtensionType == DEVICE_EXTENSION_ROOT) {
                status = FtpPartitionRemoved(extension->Root, Irp);
            } else {
                status = STATUS_INVALID_PARAMETER;
            }
            break;

        case IOCTL_INTERNAL_VOLMGR_WHOLE_DISK_REMOVED:
            if (extension->DeviceExtensionType == DEVICE_EXTENSION_ROOT) {
                status = FtpWholeDiskRemoved(extension->Root, Irp);
            } else {
                status = STATUS_INVALID_PARAMETER;
            }
            break;

        case IOCTL_INTERNAL_VOLMGR_REFERENCE_DEPENDANT_VOLUMES:
            if (extension->DeviceExtensionType == DEVICE_EXTENSION_ROOT) {
                status = FtpReferenceDependantVolume(extension->Root, Irp);
            } else {
                status = STATUS_INVALID_PARAMETER;
            }
            break;

        case IOCTL_INTERNAL_VOLMGR_QUERY_CHANGE_PARTITION:
            if (extension->DeviceExtensionType == DEVICE_EXTENSION_ROOT) {
                status = FtpQueryChangePartition(extension->Root, Irp);
            } else {
                status = STATUS_INVALID_PARAMETER;
            }
            break;

        case IOCTL_INTERNAL_VOLMGR_CANCEL_CHANGE_PARTITION:
            if (extension->DeviceExtensionType == DEVICE_EXTENSION_ROOT) {
                status = STATUS_SUCCESS;
            } else {
                status = STATUS_INVALID_PARAMETER;
            }
            break;

        case IOCTL_INTERNAL_VOLMGR_PARTITION_CHANGED:
            if (extension->DeviceExtensionType == DEVICE_EXTENSION_ROOT) {
                status = FtpPartitionChanged(extension->Root, Irp);
            } else {
                status = STATUS_INVALID_PARAMETER;
            }
            break;

        case IOCTL_INTERNAL_VOLMGR_PMWMICOUNTERLIB_CONTEXT:
            if (extension->DeviceExtensionType == DEVICE_EXTENSION_ROOT) {
                status = FtpPmWmiCounterLibContext(extension->Root, Irp);
            } else {
                status = STATUS_INVALID_PARAMETER;
            }
            break;

        case IOCTL_INTERNAL_VOLMGR_SET_POWER_STATE:
            if (extension->DeviceExtensionType == DEVICE_EXTENSION_ROOT) {
                status = FtpSetPowerState(extension->Root, Irp);
            } else {
                status = STATUS_INVALID_PARAMETER;
            }
            break;


        default:
            status = STATUS_INVALID_DEVICE_REQUEST;
            break;

    }

    FtpRelease(extension->Root);

    Irp->IoStatus.Status = status;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
    return status;
}
VOID
FtpVolumeReadOnlyCallback(
    IN  PVOLUME_EXTENSION   Extension
    )

{
    if (Extension->ZeroRefContext) {
        Extension->IsReadOnly = TRUE;
    } else {
        Extension->IsReadOnly = FALSE;
    }
}

VOID
FtpSetTargetCallback(
    IN  PVOLUME_EXTENSION   Extension
    )

/*++

Routine Description:

    This routine sets the given target object.

Arguments:

    Extension   - Supplies the volume extension.

Return Value:

    None.

--*/

{
    PSET_TARGET_CONTEXT context = (PSET_TARGET_CONTEXT) Extension->ZeroRefContext;

    Extension->OldWholeDiskPdo = Extension->WholeDiskPdo;
    Extension->TargetObject = context->TargetObject;
    Extension->FtVolume = context->FtVolume;
    Extension->WholeDiskPdo = context->WholeDiskPdo;
    Extension->WholeDisk = NULL;
    Extension->PartitionOffset = 0;
    Extension->PartitionLength = 0;
    KeSetEvent(&context->Event, IO_NO_INCREMENT, FALSE);
}

VOID
FtpCancelRoutine(
    IN OUT  PDEVICE_OBJECT  DeviceObject,
    IN OUT  PIRP            Irp
    )

/*++

Routine Description:

    This routine is called on when the given IRP is cancelled.  It
    will dequeue this IRP off the work queue and complete the
    request as CANCELLED.

Arguments:

    DeviceObject    - Supplies the device object.

    Irp             - Supplies the IRP.

Return Value:

    None.

--*/

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

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

    IoCompleteRequest(Irp, IO_NO_INCREMENT);
}

NTSTATUS
FtpChangeNotify(
    IN OUT  PROOT_EXTENSION RootExtension,
    IN OUT  PIRP            Irp
    )

/*++

Routine Description:

    This routine queues up a change notify IRP to be completed when
    a change occurs in the FT state.

Arguments:

    Extension   - Supplies the root extension.

    Irp         - Supplies the I/O request packet.

Return Value:

    NTSTATUS

--*/

{
    KIRQL       irql;
    NTSTATUS    status;

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

    IoAcquireCancelSpinLock(&irql);
    if (Irp->Cancel) {
        status = STATUS_CANCELLED;
    } else {
        InsertTailList(&RootExtension->ChangeNotifyIrpList,
                       &Irp->Tail.Overlay.ListEntry);
        status = STATUS_PENDING;
        IoMarkIrpPending(Irp);
        IoSetCancelRoutine(Irp, FtpCancelRoutine);
    }
    IoReleaseCancelSpinLock(irql);

    if (status != STATUS_PENDING) {
        Irp->IoStatus.Status = status;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
    }

    return status;
}

VOID
FtDiskShutdownFlushCompletionRoutine(
    IN  PVOID       Irp,
    IN  NTSTATUS    Status
    )

/*++

Routine Description:

    This is the completion routine for FtDiskShutdownFlush and
    FtDiskPagingNotification.

Arguments:

    Irp         - IRP involved.

    Status      - Status of operation.

Return Value:

    None.

--*/

{
    PIRP                irp = (PIRP) Irp;
    PIO_STACK_LOCATION  irpSp;
    PVOLUME_EXTENSION   extension;

    irpSp = IoGetCurrentIrpStackLocation(irp);
    extension = (PVOLUME_EXTENSION) irpSp->DeviceObject->DeviceExtension;

    FtpDecrementRefCount(extension);

    irp->IoStatus.Status = Status;
    irp->IoStatus.Information = 0;

    if (irpSp->MajorFunction == IRP_MJ_POWER) {
        PoStartNextPowerIrp(irp);
    }

    IoCompleteRequest(irp, IO_DISK_INCREMENT);
}

typedef struct _FTP_SHUTDOWN_CONTEXT {
    PIRP    Irp;
    LONG    RefCount;
} FTP_SHUTDOWN_CONTEXT, *PFTP_SHUTDOWN_CONTEXT;

NTSTATUS
FtDiskShutdownFlush(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp
    )

/*++

Routine Description:

    This routine is the dispatch for IRP_MJ_SHUTDOWN and IRP_MJ_FLUSH.

Arguments:

    DeviceObject    - Supplies the device object.

    Irp             - Supplies the IO request packet.

Return Value:

    NTSTATUS

--*/

{
    PVOLUME_EXTENSION                   extension = (PVOLUME_EXTENSION) DeviceObject->DeviceExtension;
    PROOT_EXTENSION                     rootExtension;
    ULONG                               numVolumes, i;
    PVOLUME_EXTENSION*                  arrayOfVolumes;
    PLIST_ENTRY                         l;
    NTSTATUS                            status;
    PFT_VOLUME                          vol;
    PFTP_SHUTDOWN_CONTEXT               context;
    PIO_STACK_LOCATION                  irpSp;

    if (extension->DeviceExtensionType == DEVICE_EXTENSION_ROOT) {

        rootExtension = (PROOT_EXTENSION) extension;
        FtpAcquire(rootExtension);

        numVolumes = rootExtension->NextVolumeNumber;
        arrayOfVolumes = (PVOLUME_EXTENSION*)
                         ExAllocatePool(PagedPool,
                                        numVolumes*sizeof(PVOLUME_EXTENSION));
        if (!arrayOfVolumes) {
            Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
            IoCompleteRequest(Irp, IO_NO_INCREMENT);
            return STATUS_INSUFFICIENT_RESOURCES;
        }

        numVolumes = 0;
        for (l = rootExtension->VolumeList.Flink;
             l != &rootExtension->VolumeList; l = l->Flink) {

            extension = CONTAINING_RECORD(l, VOLUME_EXTENSION, ListEntry);

            KeWaitForSingleObject(&extension->Semaphore, Executive, KernelMode,
                                  FALSE, NULL);
            status = FtpAllSystemsGo(extension, NULL, FALSE, TRUE, TRUE);
            KeReleaseSemaphore(&extension->Semaphore, IO_NO_INCREMENT, 1,
                               FALSE);

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

            vol = extension->FtVolume;
            if (vol) {
                arrayOfVolumes[numVolumes++] = extension;
            } else {
                FtpDecrementRefCount(extension);
            }
        }

        FtpRelease(rootExtension);

        if (numVolumes) {

            context = (PFTP_SHUTDOWN_CONTEXT)
                      ExAllocatePool(NonPagedPool,
                                     sizeof(FTP_SHUTDOWN_CONTEXT));
            if (!context) {
                for (i = 0; i < numVolumes; i++) {
                    FtpDecrementRefCount(extension);
                }
                Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
                IoCompleteRequest(Irp, IO_NO_INCREMENT);
                return STATUS_INSUFFICIENT_RESOURCES;
            }

            Irp->IoStatus.Status = STATUS_SUCCESS;

            context->Irp = Irp;
            context->RefCount = (LONG) numVolumes;

            IoMarkIrpPending(Irp);

            for (i = 0; i < numVolumes; i++) {
                vol = arrayOfVolumes[i]->FtVolume;
                vol->SetDirtyBit(FALSE, FtDiskShutdownCompletionRoutine,
                                 context);
            }

            ExFreePool(arrayOfVolumes);

            return STATUS_PENDING;
        }

        ExFreePool(arrayOfVolumes);

        //
        // Complete this request.
        //

        Irp->IoStatus.Status = STATUS_SUCCESS;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);

        return STATUS_SUCCESS;
    }

    status = FtpAllSystemsGo(extension, Irp, FALSE, TRUE, TRUE);
    if (status == STATUS_PENDING) {
        return status;
    }
    if (!NT_SUCCESS(status)) {
        Irp->IoStatus.Information = 0;
        Irp->IoStatus.Status = status;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
        return status;
    }

    if (extension->TargetObject) {
        IoCopyCurrentIrpStackLocationToNext(Irp);
        IoSetCompletionRoutine(Irp, FtpRefCountCompletionRoutine,
                               extension, TRUE, TRUE, TRUE);
        IoMarkIrpPending(Irp);

        IoCallDriver(extension->TargetObject, Irp);

        return STATUS_PENDING;
    }

    vol = extension->FtVolume;
    ASSERT(vol);

    IoMarkIrpPending(Irp);
    irpSp = IoGetCurrentIrpStackLocation(Irp);
    irpSp->DeviceObject = DeviceObject;

    vol->BroadcastIrp(Irp, FtDiskShutdownFlushCompletionRoutine, Irp);

    return STATUS_PENDING;
}

NTSTATUS
FtpSignalCompletion(
    IN  PDEVICE_OBJECT  DeviceObject,
    IN  PIRP            Irp,
    IN  PVOID           Event
    )

{
    KeSetEvent((PKEVENT) Event, IO_NO_INCREMENT, FALSE);
    return STATUS_MORE_PROCESSING_REQUIRED;
}

VOID
FtpQueryRemoveCallback(
    IN  PVOLUME_EXTENSION   Extension
    )

/*++

Routine Description:

    This routine sets the ZeroRef event.

Arguments:

    Extension   - Supplies the volume extension.

Return Value:

    None.

--*/

{
    KeSetEvent((PKEVENT) Extension->ZeroRefContext, IO_NO_INCREMENT, FALSE);
}

VOID
FtpStartCallback(
    IN  PVOLUME_EXTENSION   Extension
    )

/*++

Routine Description:

    This routine sets the ZeroRef event.

Arguments:

    Extension   - Supplies the volume extension.

Return Value:

    None.

--*/

{
    Extension->IsStarted = TRUE;
    KeSetEvent((PKEVENT) Extension->ZeroRefContext, IO_NO_INCREMENT, FALSE);
}

NTSTATUS
FtpCheckForQueryRemove(
    IN OUT  PVOLUME_EXTENSION   Extension
    )

{
    KIRQL       irql;
    NTSTATUS    status;

    KeAcquireSpinLock(&Extension->SpinLock, &irql);
    if (Extension->InPagingPath || Extension->RemoveInProgress) {
        KeReleaseSpinLock(&Extension->SpinLock, irql);
        status = STATUS_INVALID_DEVICE_REQUEST;
    } else {
        InterlockedExchange(&Extension->AllSystemsGo, FALSE);
        Extension->RemoveInProgress = TRUE;
        KeReleaseSpinLock(&Extension->SpinLock, irql);
        status = STATUS_SUCCESS;
    }

    return status;
}

BOOLEAN
FtpCheckForCancelRemove(
    IN OUT  PVOLUME_EXTENSION   Extension
    )

{
    KIRQL   irql;
    BOOLEAN removeInProgress;

    KeAcquireSpinLock(&Extension->SpinLock, &irql);
    removeInProgress = Extension->RemoveInProgress;
    Extension->RemoveInProgress = FALSE;
    KeReleaseSpinLock(&Extension->SpinLock, irql);

    return removeInProgress;
}

VOID
FtpRemoveHelper(
    IN OUT  PVOLUME_EXTENSION   Extension
    )

{
    KIRQL   irql;

    KeAcquireSpinLock(&Extension->SpinLock, &irql);
    InterlockedExchange(&Extension->AllSystemsGo, FALSE);
    Extension->IsStarted = FALSE;
    Extension->RemoveInProgress = FALSE;
    KeReleaseSpinLock(&Extension->SpinLock, irql);
}

NTSTATUS
FtDiskCleanup(
    IN  PDEVICE_OBJECT  DeviceObject,
    IN  PIRP            Irp
    )

/*++

Routine Description:

    This routine cancels all of the IRPs currently queued on
    the given device.

Arguments:

    DeviceObject    - Supplies the device object.

    Irp             - Supplies the cleanup IRP.

Return Value:

    STATUS_SUCCESS  - Success.

--*/

{
    PROOT_EXTENSION     rootExtension = (PROOT_EXTENSION) DeviceObject->DeviceExtension;
    PIO_STACK_LOCATION  irpSp = IoGetCurrentIrpStackLocation(Irp);
    PFILE_OBJECT        file = irpSp->FileObject;
    PVOLUME_EXTENSION   extension;
    KIRQL               irql;
    PLIST_ENTRY         l;
    PIRP                irp;

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

    if (rootExtension->DeviceExtensionType != DEVICE_EXTENSION_ROOT) {
        ASSERT(rootExtension->DeviceExtensionType == DEVICE_EXTENSION_VOLUME);
        extension = (PVOLUME_EXTENSION) rootExtension;
        if (extension->RevertOnCloseFileObject == file) {
            FtpAcquire(extension->Root);
            FtpRevertGptAttributes(extension);
            FtpRelease(extension->Root);
        }
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
        return STATUS_SUCCESS;
    }

    IoAcquireCancelSpinLock(&irql);

    for (;;) {

        for (l = rootExtension->ChangeNotifyIrpList.Flink;
             l != &rootExtension->ChangeNotifyIrpList; l = l->Flink) {

            irp = CONTAINING_RECORD(l, IRP, Tail.Overlay.ListEntry);
            if (IoGetCurrentIrpStackLocation(irp)->FileObject == file) {
                break;
            }
        }

        if (l == &rootExtension->ChangeNotifyIrpList) {
            break;
        }

        irp->Cancel = TRUE;
        irp->CancelIrql = irql;
        irp->CancelRoutine = NULL;
        FtpCancelRoutine(DeviceObject, irp);

        IoAcquireCancelSpinLock(&irql);
    }

    IoReleaseCancelSpinLock(irql);

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

    IoCompleteRequest(Irp, IO_NO_INCREMENT);

    return STATUS_SUCCESS;
}

NTSTATUS
DriverEntry(
    IN  PDRIVER_OBJECT  DriverObject,
    IN  PUNICODE_STRING RegistryPath
    )

/*++

Routine Description:

    This routine is called when the driver loads loads.

Arguments:

    DriverObject    - Supplies the driver object.

    RegistryPath    - Supplies the registry path.

Return Value:

    NTSTATUS

--*/

{
    NTSTATUS                    status;
    PDEVICE_OBJECT              pdo = 0, fdo;
    PROOT_EXTENSION             rootExtension;

    DriverObject->DriverUnload = FtDiskUnload;
    DriverObject->MajorFunction[IRP_MJ_CREATE] = FtDiskCreate;
    DriverObject->MajorFunction[IRP_MJ_READ] = FtDiskReadWrite;
    DriverObject->MajorFunction[IRP_MJ_WRITE] = FtDiskReadWrite;
    DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = FtDiskDeviceControl;
    DriverObject->MajorFunction[IRP_MJ_INTERNAL_DEVICE_CONTROL] = FtDiskInternalDeviceControl;
    DriverObject->MajorFunction[IRP_MJ_SHUTDOWN] = FtDiskShutdownFlush;
    DriverObject->MajorFunction[IRP_MJ_FLUSH_BUFFERS] = FtDiskShutdownFlush;
    DriverObject->MajorFunction[IRP_MJ_PNP] = FtDiskPnp;
    DriverObject->MajorFunction[IRP_MJ_POWER] = FtDiskPower;
    DriverObject->MajorFunction[IRP_MJ_CLEANUP] = FtDiskCleanup;
    DriverObject->MajorFunction[IRP_MJ_SYSTEM_CONTROL] = FtWmi;

    ObReferenceObject(DriverObject);

    status = IoReportDetectedDevice(
                 DriverObject,
                 InterfaceTypeUndefined,
                 -1,
                 -1,
                 NULL,
                 NULL,
                 TRUE,
                 &pdo
             );
    if (!NT_SUCCESS(status)) {
        return status;
    }

    status = FtDiskAddDevice(DriverObject, pdo, RegistryPath);
    if (!NT_SUCCESS(status)) {
        return status;
    }

    fdo = IoGetAttachedDeviceReference(pdo);
    ObDereferenceObject(fdo);

    rootExtension = (PROOT_EXTENSION) fdo->DeviceExtension;

    status = IoRegisterDeviceInterface(rootExtension->Pdo,
                                       &VOLMGR_VOLUME_MANAGER_GUID, NULL,
                                       &rootExtension->VolumeManagerInterfaceName);
    if (NT_SUCCESS(status)) {
        status = IoSetDeviceInterfaceState(
                 &rootExtension->VolumeManagerInterfaceName, TRUE);
    } else {
        rootExtension->VolumeManagerInterfaceName.Buffer = NULL;
    }

    IoRegisterBootDriverReinitialization(DriverObject,
                                         FtpBootDriverReinitialization,
                                         rootExtension);

    IoRegisterDriverReinitialization(DriverObject, FtpDriverReinitialization,
                                     rootExtension);

    FtpQueryRegistryRevertEntries(rootExtension,
                                  &rootExtension->GptAttributeRevertEntries,
                                  &rootExtension->NumberOfAttributeRevertEntries);

    RtlDeleteRegistryValue(RTL_REGISTRY_ABSOLUTE, RegistryPath->Buffer,
                           REVERT_GPT_ATTRIBUTES_REGISTRY_NAME);

    IoInvalidateDeviceState(rootExtension->Pdo);

    return STATUS_SUCCESS;
}

VOID
FtpLogError(
    IN  PDEVICE_EXTENSION   Extension,
    IN  FT_LOGICAL_DISK_ID  LogicalDiskId,
    IN  NTSTATUS            SpecificIoStatus,
    IN  NTSTATUS            FinalStatus,
    IN  ULONG               UniqueErrorValue
    )

/*++

Routine Description:

    This routine performs error logging for the FT driver.

Arguments:

    Extension        - Extension.
    LogicalDiskId    - Logical disk id representing failing device.
    SpecificIoStatus - IO error status value.
    FinalStatus      - Status returned for failure.
    UniqueErrorValue - Values defined to uniquely identify error location.

Return Value:

    None

--*/

{
    PFTP_LOG_ERROR_CONTEXT  context;

    context = (PFTP_LOG_ERROR_CONTEXT)
              ExAllocatePool(NonPagedPool, sizeof(FTP_LOG_ERROR_CONTEXT));
    if (!context) {
        return;
    }

    ExInitializeWorkItem(context, FtpLogErrorWorker, context);
    context->Extension = Extension;
    context->LogicalDiskId = LogicalDiskId;
    context->SpecificIoStatus = SpecificIoStatus;
    context->FinalStatus = FinalStatus;
    context->UniqueErrorValue = UniqueErrorValue;

    ExQueueWorkItem(context, CriticalWorkQueue);
}

VOID
FtpQueueWorkItem(
    IN  PROOT_EXTENSION     RootExtension,
    IN  PWORK_QUEUE_ITEM    WorkItem
    )

/*++

Routine Description:

    This routine queues a work item to a private worker thread.

Arguments:

    RootExtension       - Supplies the root device extension.

    WorkItem            - The work item to be queued.

Return Value:

    None.

--*/

{
    KIRQL   irql;

    KeAcquireSpinLock(&RootExtension->SpinLock, &irql);
    InsertTailList(&RootExtension->WorkerQueue, &WorkItem->List);
    KeReleaseSpinLock(&RootExtension->SpinLock, irql);

    KeReleaseSemaphore(&RootExtension->WorkerSemaphore, 0, 1, FALSE);
}

VOID
FtpNotify(
    IN OUT  PROOT_EXTENSION     RootExtension,
    IN      PVOLUME_EXTENSION   Extension
    )

/*++

Routine Description:

    This routine completes all of the change notify irps in the queue.

Arguments:

    RootExtension   - Supplies the root extension.

    Extension       - Supplies the specific extension being changed.

Return Value:

    None.

--*/

{
    LIST_ENTRY                          q;
    KIRQL                               irql;
    PLIST_ENTRY                         p;
    PIRP                                irp;
    TARGET_DEVICE_CUSTOM_NOTIFICATION   notification;

    InitializeListHead(&q);
    IoAcquireCancelSpinLock(&irql);
    while (!IsListEmpty(&RootExtension->ChangeNotifyIrpList)) {
        p = RemoveHeadList(&RootExtension->ChangeNotifyIrpList);
        irp = CONTAINING_RECORD(p, IRP, Tail.Overlay.ListEntry);
        IoSetCancelRoutine(irp, NULL);
        InsertTailList(&q, p);
    }
    IoReleaseCancelSpinLock(irql);

    while (!IsListEmpty(&q)) {
        p = RemoveHeadList(&q);
        irp = CONTAINING_RECORD(p, IRP, Tail.Overlay.ListEntry);
        IoCompleteRequest(irp, IO_NO_INCREMENT);
    }

    if (Extension->IsStarted) {
        notification.Version = 1;
        notification.Size = (USHORT)
                            FIELD_OFFSET(TARGET_DEVICE_CUSTOM_NOTIFICATION,
                                         CustomDataBuffer);
        RtlCopyMemory(&notification.Event,
                      &GUID_IO_VOLUME_PHYSICAL_CONFIGURATION_CHANGE,
                      sizeof(GUID_IO_VOLUME_PHYSICAL_CONFIGURATION_CHANGE));
        notification.FileObject = NULL;
        notification.NameBufferOffset = -1;

        IoReportTargetDeviceChangeAsynchronous(Extension->DeviceObject,
                                               &notification, NULL, NULL);
    }
}

#ifdef ALLOC_PRAGMA
#pragma code_seg("PAGELK")
#endif

NTSTATUS
FtpCheckForCompleteVolume(
    IN  PVOLUME_EXTENSION   Extension,
    IN  PFT_VOLUME          FtVolume
    )

{
    KIRQL   irql;

    KeAcquireSpinLock(&Extension->SpinLock, &irql);
    if (!FtVolume->IsComplete(TRUE)) {
        KeReleaseSpinLock(&Extension->SpinLock, irql);
        return STATUS_NO_SUCH_DEVICE;
    }
    FtVolume->CompleteNotification(TRUE);
    KeReleaseSpinLock(&Extension->SpinLock, irql);

    return STATUS_SUCCESS;
}

BOOLEAN
FsRtlIsTotalDeviceFailure(
    IN NTSTATUS Status
    )

/*++

Routine Description:

    This routine is given an NTSTATUS value and make a determination as to
    if this value indicates that the complete device has failed and therefore
    should no longer be used, or if the failure is one that indicates that
    continued use of the device is ok (i.e. a sector failure).

Arguments:

    Status - the NTSTATUS value to test.

Return Value:

    TRUE  - The status value given is believed to be a fatal device error.
    FALSE - The status value given is believed to be a sector failure, but not
            a complete device failure.
--*/

{
    if (NT_SUCCESS(Status)) {

        //
        // All warning and informational errors will be resolved here.
        //

        return FALSE;
    }

    switch (Status) {
    case STATUS_CRC_ERROR:
    case STATUS_DEVICE_DATA_ERROR:
        return FALSE;
    default:
        return TRUE;
    }
}

BOOLEAN
FtpIsWorseStatus(
    IN  NTSTATUS    Status1,
    IN  NTSTATUS    Status2
    )

/*++

Routine Description:

    This routine compares two NTSTATUS codes and decides if Status1 is
    worse than Status2.

Arguments:

    Status1 - Supplies the first status.

    Status2 - Supplies the second status.

Return Value:

    FALSE   - Status1 is not worse than Status2.

    TRUE    - Status1 is worse than Status2.


--*/

{
    if (NT_ERROR(Status2) && FsRtlIsTotalDeviceFailure(Status2)) {
        return FALSE;
    }

    if (NT_ERROR(Status1) && FsRtlIsTotalDeviceFailure(Status1)) {
        return TRUE;
    }

    if (NT_ERROR(Status2)) {
        return FALSE;
    }

    if (NT_ERROR(Status1)) {
        return TRUE;
    }

    if (NT_WARNING(Status2)) {
        return FALSE;
    }

    if (NT_WARNING(Status1)) {
        return TRUE;
    }

    if (NT_INFORMATION(Status2)) {
        return FALSE;
    }

    if (NT_INFORMATION(Status1)) {
        return TRUE;
    }

    return FALSE;
}

VOID
FtDiskShutdownCompletionRoutine(
    IN  PVOID       Context,
    IN  NTSTATUS    Status
    )

{
    PFTP_SHUTDOWN_CONTEXT   context = (PFTP_SHUTDOWN_CONTEXT) Context;

    if (InterlockedDecrement(&context->RefCount)) {
        return;
    }

    IoCompleteRequest(context->Irp, IO_NO_INCREMENT);
    ExFreePool(context);
}

NTSTATUS
FtpCreateLogicalDiskHelper(
    IN OUT  PROOT_EXTENSION         RootExtension,
    IN      FT_LOGICAL_DISK_TYPE    LogicalDiskType,
    IN      USHORT                  NumberOfMembers,
    IN      PFT_LOGICAL_DISK_ID     ArrayOfMembers,
    IN      USHORT                  ConfigurationInformationSize,
    IN      PVOID                   ConfigurationInformation,
    IN      USHORT                  StateInformationSize,
    IN      PVOID                   StateInformation,
    OUT     PFT_LOGICAL_DISK_ID     NewLogicalDiskId
    )

{
    BOOLEAN                                         lockZero;
    FT_MIRROR_AND_SWP_STATE_INFORMATION             actualStateInfo;
    FT_REDISTRIBUTION_STATE_INFORMATION             redistStateInfo;
    PHANDLE                                         handleArray;
    PFT_LOGICAL_DISK_INFORMATION_SET                diskInfoSet;
    NTSTATUS                                        status;
    FT_LOGICAL_DISK_ID                              newLogicalDiskId;
    PFT_VOLUME*                                     volArray;
    PVOLUME_EXTENSION*                              extArray;
    PVOLUME_EXTENSION                               extension;
    KIRQL                                           irql;
    USHORT                                          i, j;
    KEVENT                                          event;
    PCOMPOSITE_FT_VOLUME                            comp;
    WCHAR                                           deviceNameBuffer[64];
    UNICODE_STRING                                  deviceName;
    UCHAR                                           newUniqueIdBuffer[UNIQUE_ID_MAX_BUFFER_SIZE];
    PMOUNTDEV_UNIQUE_ID                             newUniqueId;
    SET_TARGET_CONTEXT                              context;
    ULONG                                           alignment;
    PFT_REDISTRIBUTION_CONFIGURATION_INFORMATION    redistConfig;
    PFT_REDISTRIBUTION_STATE_INFORMATION            redistState;
    PFT_MIRROR_AND_SWP_STATE_INFORMATION            mirrorState;

    switch (LogicalDiskType) {

        case FtVolumeSet:
            ConfigurationInformation = NULL;
            ConfigurationInformationSize = 0;
            StateInformation = NULL;
            StateInformationSize = 0;
            lockZero = FALSE;
            if (NumberOfMembers == 0) {
                return STATUS_INVALID_PARAMETER;
            }
            break;

        case FtStripeSet:
            if (ConfigurationInformationSize <
                sizeof(FT_STRIPE_SET_CONFIGURATION_INFORMATION)) {

                return STATUS_INVALID_PARAMETER;
            }
            ConfigurationInformationSize =
                    sizeof(FT_STRIPE_SET_CONFIGURATION_INFORMATION);
            StateInformation = NULL;
            StateInformationSize = 0;
            lockZero = TRUE;
            if (NumberOfMembers == 0) {
                return STATUS_INVALID_PARAMETER;
            }
            break;

        case FtMirrorSet:
            if (ConfigurationInformationSize <
                sizeof(FT_MIRROR_SET_CONFIGURATION_INFORMATION)) {

                return STATUS_INVALID_PARAMETER;
            }
            ConfigurationInformationSize =
                    sizeof(FT_MIRROR_SET_CONFIGURATION_INFORMATION);
            if (!StateInformation) {
                actualStateInfo.IsDirty = TRUE;
                actualStateInfo.IsInitializing = FALSE;
                actualStateInfo.UnhealthyMemberNumber = 1;
                actualStateInfo.UnhealthyMemberState = FtMemberRegenerating;
                StateInformation = &actualStateInfo;
                StateInformationSize = sizeof(actualStateInfo);
            }
            lockZero = FALSE;
            if (NumberOfMembers != 2) {
                return STATUS_INVALID_PARAMETER;
            }
            j = NumberOfMembers;
            for (i = 0; i < NumberOfMembers; i++) {
                if (!ArrayOfMembers[i]) {
                    if (j < NumberOfMembers) {
                        return STATUS_INVALID_PARAMETER;
                    }
                    j = i;
                    mirrorState = (PFT_MIRROR_AND_SWP_STATE_INFORMATION)
                                  StateInformation;
                    mirrorState->UnhealthyMemberNumber = i;
                    mirrorState->UnhealthyMemberState = FtMemberOrphaned;
                }
            }
            break;

        case FtStripeSetWithParity:
            if (ConfigurationInformationSize <
                sizeof(FT_STRIPE_SET_WITH_PARITY_CONFIGURATION_INFORMATION)) {

                return STATUS_INVALID_PARAMETER;
            }
            ConfigurationInformationSize =
                    sizeof(FT_STRIPE_SET_WITH_PARITY_CONFIGURATION_INFORMATION);
            if (!StateInformation) {
                actualStateInfo.IsDirty = TRUE;
                actualStateInfo.IsInitializing = TRUE;
                actualStateInfo.UnhealthyMemberNumber = 0;
                actualStateInfo.UnhealthyMemberState = FtMemberHealthy;
                StateInformation = &actualStateInfo;
                StateInformationSize = sizeof(actualStateInfo);
            }
            lockZero = TRUE;
            if (NumberOfMembers < 3) {
                return STATUS_INVALID_PARAMETER;
            }
            j = NumberOfMembers;
            for (i = 0; i < NumberOfMembers; i++) {
                if (!ArrayOfMembers[i]) {
                    if (j < NumberOfMembers) {
                        return STATUS_INVALID_PARAMETER;
                    }
                    j = i;
                    mirrorState = (PFT_MIRROR_AND_SWP_STATE_INFORMATION)
                                  StateInformation;
                    mirrorState->IsInitializing = FALSE;
                    mirrorState->UnhealthyMemberNumber = i;
                    mirrorState->UnhealthyMemberState = FtMemberOrphaned;
                }
            }
            break;

        case FtRedistribution:
            if (ConfigurationInformationSize <
                sizeof(FT_REDISTRIBUTION_CONFIGURATION_INFORMATION)) {

                return STATUS_INVALID_PARAMETER;
            }
            ConfigurationInformationSize =
                    sizeof(FT_REDISTRIBUTION_CONFIGURATION_INFORMATION);
            if (!StateInformation) {
                redistStateInfo.BytesRedistributed = 0;
                StateInformation = &redistStateInfo;
                StateInformationSize = sizeof(redistStateInfo);
            }
            redistConfig = (PFT_REDISTRIBUTION_CONFIGURATION_INFORMATION)
                           ConfigurationInformation;
            if (redistConfig->StripeSize&0x80000000) {
                lockZero = TRUE;
                redistConfig->StripeSize &= (~0x80000000);
                redistState = (PFT_REDISTRIBUTION_STATE_INFORMATION)
                              StateInformation;
                redistState->BytesRedistributed = 0x7FFFFFFFFFFFFFFF;
            } else {
                lockZero = FALSE;
            }
            if (NumberOfMembers != 2) {
                return STATUS_INVALID_PARAMETER;
            }
            break;

        default:
            return STATUS_INVALID_PARAMETER;

    }

    handleArray = (PHANDLE)
                  ExAllocatePool(NonPagedPool, NumberOfMembers*sizeof(HANDLE));
    if (!handleArray) {
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    for (i = lockZero ? 0 : 1; i < NumberOfMembers; i++) {
        if (!ArrayOfMembers[i]) {
            continue;
        }
        if (!FtpLockLogicalDisk(RootExtension, ArrayOfMembers[i],
                                &handleArray[i])) {
            break;
        }
    }

    if (i < NumberOfMembers) {
        for (j = lockZero ? 0 : 1; j < i; j++) {
            if (ArrayOfMembers[j]) {
                ZwClose(handleArray[j]);
            }
        }
        ExFreePool(handleArray);
        return STATUS_ACCESS_DENIED;
    }

    if (LogicalDiskType == FtMirrorSet &&
        ArrayOfMembers[0] &&
        !(extension = FtpFindExtension(RootExtension, ArrayOfMembers[0])) &&
        (extension = FtpFindExtensionCoveringDiskId(RootExtension,
                                                    ArrayOfMembers[0]))) {

        status = FtpInsertMirror(RootExtension, ArrayOfMembers,
                                 NewLogicalDiskId);

        if (ArrayOfMembers[1]) {
            ZwClose(handleArray[1]);
        }
        ExFreePool(handleArray);
        return status;
    }

    diskInfoSet = RootExtension->DiskInfoSet;
    status = diskInfoSet->AddNewLogicalDisk(LogicalDiskType,
                                            NumberOfMembers,
                                            ArrayOfMembers,
                                            ConfigurationInformationSize,
                                            ConfigurationInformation,
                                            StateInformationSize,
                                            StateInformation,
                                            &newLogicalDiskId);
    if (!NT_SUCCESS(status)) {
        for (i = lockZero ? 0 : 1; i < NumberOfMembers; i++) {
            if (ArrayOfMembers[i]) {
                ZwClose(handleArray[i]);
            }
        }
        ExFreePool(handleArray);
        return status;
    }

    volArray = (PFT_VOLUME*)
               ExAllocatePool(NonPagedPool, NumberOfMembers*sizeof(PFT_VOLUME));
    if (!volArray) {
        for (i = lockZero ? 0 : 1; i < NumberOfMembers; i++) {
            if (ArrayOfMembers[i]) {
                ZwClose(handleArray[i]);
            }
        }
        ExFreePool(handleArray);
        diskInfoSet->BreakLogicalDisk(newLogicalDiskId);
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    extArray = (PVOLUME_EXTENSION*)
               ExAllocatePool(NonPagedPool, NumberOfMembers*
                              sizeof(PVOLUME_EXTENSION));
    if (!extArray) {
        for (i = lockZero ? 0 : 1; i < NumberOfMembers; i++) {
            if (ArrayOfMembers[i]) {
                ZwClose(handleArray[i]);
            }
        }
        ExFreePool(handleArray);
        ExFreePool(volArray);
        diskInfoSet->BreakLogicalDisk(newLogicalDiskId);
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    alignment = 0;
    for (i = 0; i < NumberOfMembers; i++) {

        if (!ArrayOfMembers[i]) {
            extArray[i] = NULL;
            volArray[i] = NULL;
            continue;
        }

        extension = FtpFindExtension(RootExtension, ArrayOfMembers[i]);
        extArray[i] = extension;
        if (!extension || !extension->FtVolume) {
            break;
        }

        alignment |= extension->DeviceObject->AlignmentRequirement;

        volArray[i] = extension->FtVolume;
        if (!lockZero && i == 0) {
            continue;
        }

        KeInitializeEvent(&context.Event, NotificationEvent, FALSE);
        context.TargetObject = NULL;
        context.FtVolume = NULL;
        context.WholeDiskPdo = NULL;
        FtpZeroRefCallback(extension, FtpSetTargetCallback, &context, TRUE);
        KeWaitForSingleObject(&context.Event, Executive, KernelMode, FALSE,
                              NULL);
    }

    if (i < NumberOfMembers) {
        for (j = 0; j < i; j++) {
            if (ArrayOfMembers[j]) {
                KeAcquireSpinLock(&extArray[j]->SpinLock, &irql);
                extArray[j]->FtVolume = volArray[j];
                KeReleaseSpinLock(&extArray[j]->SpinLock, irql);
            }
        }
        for (i = lockZero ? 0 : 1; i < NumberOfMembers; i++) {
            if (ArrayOfMembers[i]) {
                ZwClose(handleArray[i]);
            }
        }
        ExFreePool(handleArray);
        ExFreePool(extArray);
        ExFreePool(volArray);
        diskInfoSet->BreakLogicalDisk(newLogicalDiskId);
        return STATUS_INVALID_PARAMETER;
    }

    switch (LogicalDiskType) {

        case FtVolumeSet:
            comp = new VOLUME_SET;
            break;

        case FtStripeSet:
            comp = new STRIPE;
            break;

        case FtMirrorSet:
            comp = new MIRROR;
            break;

        case FtStripeSetWithParity:
            comp = new STRIPE_WP;
            break;

        case FtRedistribution:
            comp = new REDISTRIBUTION;
            break;

        default:
            comp = NULL;
            break;

    }

    if (!comp) {
        for (j = 0; j < NumberOfMembers; j++) {
            if (ArrayOfMembers[j]) {
                KeAcquireSpinLock(&extArray[j]->SpinLock, &irql);
                extArray[j]->FtVolume = volArray[j];
                KeReleaseSpinLock(&extArray[j]->SpinLock, irql);
            }
        }
        for (i = lockZero ? 0 : 1; i < NumberOfMembers; i++) {
            if (ArrayOfMembers[i]) {
                ZwClose(handleArray[i]);
            }
        }
        ExFreePool(handleArray);
        ExFreePool(extArray);
        ExFreePool(volArray);
        diskInfoSet->BreakLogicalDisk(newLogicalDiskId);
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    status = comp->Initialize(RootExtension, newLogicalDiskId,
                              volArray, NumberOfMembers,
                              ConfigurationInformation, StateInformation);
    if (!NT_SUCCESS(status)) {
        for (j = 0; j < NumberOfMembers; j++) {
            if (ArrayOfMembers[j]) {
                KeAcquireSpinLock(&extArray[j]->SpinLock, &irql);
                extArray[j]->FtVolume = volArray[j];
                KeReleaseSpinLock(&extArray[j]->SpinLock, irql);
            }
        }
        for (i = lockZero ? 0 : 1; i < NumberOfMembers; i++) {
            if (ArrayOfMembers[i]) {
                ZwClose(handleArray[i]);
            }
        }
        delete comp;
        ExFreePool(handleArray);
        ExFreePool(extArray);
        diskInfoSet->BreakLogicalDisk(newLogicalDiskId);
        return status;
    }

    for (i = lockZero ? 0 : 1; i < NumberOfMembers; i++) {
        extension = extArray[i];
        if (!extension) {
            continue;
        }
        RemoveEntryList(&extension->ListEntry);
        InsertTailList(&RootExtension->DeadVolumeList, &extension->ListEntry);
        FtpDeleteMountPoints(extension);
        FtpCleanupVolumeExtension(extension);
        ZwClose(handleArray[i]);
    }
    ExFreePool(handleArray);

    extension = extArray[0];
    ExFreePool(extArray);

    if (lockZero || !extension) {

        if (!FtpCreateNewDevice(RootExtension, NULL, comp, NULL, alignment,
                                FALSE, FALSE, FALSE, FALSE, 0)) {

            return STATUS_INSUFFICIENT_RESOURCES;
        }

    } else {

        swprintf(deviceNameBuffer, L"\\Device\\HarddiskVolume%d", extension->VolumeNumber);
        RtlInitUnicodeString(&deviceName, deviceNameBuffer);
        comp->CreateLegacyNameLinks(&deviceName);

        extension->DeviceObject->AlignmentRequirement = alignment;

        KeInitializeEvent(&context.Event, NotificationEvent, FALSE);
        context.TargetObject = NULL;
        context.FtVolume = comp;
        context.WholeDiskPdo = NULL;
        FtpZeroRefCallback(extension, FtpSetTargetCallback, &context, TRUE);
        KeWaitForSingleObject(&context.Event, Executive, KernelMode, FALSE,
                              NULL);

        newUniqueId = (PMOUNTDEV_UNIQUE_ID) newUniqueIdBuffer;
        FtpQueryUniqueIdBuffer(extension, newUniqueId->UniqueId,
                               &newUniqueId->UniqueIdLength);

        FtpUniqueIdNotify(extension, newUniqueId);

        FtpNotify(RootExtension, extension);
    }

    *NewLogicalDiskId = newLogicalDiskId;

    IoInvalidateDeviceRelations(RootExtension->Pdo, BusRelations);

    return STATUS_SUCCESS;
}

VOID
FtpMemberOfflineCallback(
    IN  PVOLUME_EXTENSION   Extension
    )

/*++

Routine Description:

    This routine is called to offline a partition after disk activity
    has stopped.

Arguments:

    Extension   - Supplies the volume extension.

Return Value:

    None.

--*/

{
    PFT_PARTITION_OFFLINE_CONTEXT   offline = (PFT_PARTITION_OFFLINE_CONTEXT) Extension->ZeroRefContext;
    USHORT                          n, i;

    if (offline->Parent) {
        Extension->IsComplete = FALSE;
        n = offline->Parent->QueryNumberOfMembers();
        for (i = 0; i < n; i++) {
            if (offline->Parent->GetMember(i) == offline->Child) {
                offline->Parent->SetMember(i, NULL);
                break;
            }
        }
        if (!offline->Root->QueryNumberOfPartitions()) {
            Extension->FtVolume = NULL;
        }
    } else {
        Extension->FtVolume = NULL;
        Extension->IsComplete = FALSE;
    }

    KeSetEvent(offline->Event, IO_NO_INCREMENT, FALSE);
}

VOID
FtpInsertMemberCallback(
    IN  PVOLUME_EXTENSION   Extension
    )

/*++

Routine Description:

    This routine inserts the given member into the given set.

Arguments:

    Extension   - Supplies the volume extension.

Return Value:

    None.

--*/

{
    PINSERT_MEMBER_CONTEXT  context = (PINSERT_MEMBER_CONTEXT) Extension->ZeroRefContext;

    context->Parent->SetMember(context->MemberNumber, context->Member);
    KeSetEvent(&context->Event, IO_NO_INCREMENT, FALSE);
}

VOID
FtpReadWriteCompletionRoutine(
    IN  PTRANSFER_PACKET    TransferPacket
    )

/*++

Routine Description:

    Completion routine for FtDiskReadWrite dispatch routine.

Arguments:

    TransferPacket  - Supplies the transfer packet.

Return Value:

    None.

--*/

{
    PDISPATCH_TP                transferPacket = (PDISPATCH_TP) TransferPacket;
    PIRP                        irp = transferPacket->Irp;
    PVOLUME_EXTENSION           extension = transferPacket->Extension;
    KIRQL                       irql;
    PLIST_ENTRY                 l;
    PDISPATCH_TP                p;
    PIO_STACK_LOCATION          irpSp;
    PIRP                        nextIrp;

    irp->IoStatus = transferPacket->IoStatus;
    if (transferPacket == extension->EmergencyTransferPacket) {

        for (;;) {

            KeAcquireSpinLock(&extension->SpinLock, &irql);
            if (IsListEmpty(&extension->EmergencyTransferPacketQueue)) {
                extension->EmergencyTransferPacketInUse = FALSE;
                KeReleaseSpinLock(&extension->SpinLock, irql);
                break;
            }

            l = RemoveHeadList(&extension->EmergencyTransferPacketQueue);
            KeReleaseSpinLock(&extension->SpinLock, irql);

            nextIrp = CONTAINING_RECORD(l, IRP, Tail.Overlay.ListEntry);

            p = new DISPATCH_TP;
            if (!p) {
                p = transferPacket;
            }

            irpSp = IoGetCurrentIrpStackLocation(nextIrp);

            p->Mdl = nextIrp->MdlAddress;
            p->Offset = irpSp->Parameters.Read.ByteOffset.QuadPart;
            p->Length = irpSp->Parameters.Read.Length;
            p->CompletionRoutine = FtpReadWriteCompletionRoutine;
            p->TargetVolume = extension->FtVolume;
            p->Thread = nextIrp->Tail.Overlay.Thread;
            p->IrpFlags = irpSp->Flags;
            if (irpSp->MajorFunction == IRP_MJ_READ) {
                p->ReadPacket = TRUE;
            } else {
                p->ReadPacket = FALSE;
            }
            p->Irp = nextIrp;
            p->Extension = extension;

            if (p == transferPacket) {
                TRANSFER(p);
                break;
            } else {
                TRANSFER(p);
            }
        }

    } else {
        delete transferPacket;
    }

    if (extension->CountersEnabled) {
        PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(irp);
        if (irpStack->MajorFunction == IRP_MJ_READ ||
            irpStack->MajorFunction == IRP_MJ_WRITE) {
            PPMWMICOUNTERLIB_CONTEXT counterLib;
    
            counterLib = &extension->Root->PmWmiCounterLibContext;
            counterLib->PmWmiCounterIoComplete(
                extension->PmWmiCounterContext, irp,
                (PLARGE_INTEGER) &irpStack->Parameters.Read);
        }
    }

    IoCompleteRequest(irp, IO_DISK_INCREMENT);

    FtpDecrementRefCount(extension);
}

VOID
FtpRefCountCompletion(
    IN  PVOID       Extension,
    IN  NTSTATUS    Status
    )

/*++

Routine Description:

    Completion routine of type FT_COMPLETION_ROUTINE that decrements
    the ref count.

Arguments:

    Extension   - Supplies the device extension.

    Status      - Supplies the status of the operation.

Return Value:

    None.

--*/

{
    PVOLUME_EXTENSION   extension = (PVOLUME_EXTENSION) Extension;

    FtpDecrementRefCount(extension);
}

NTSTATUS
FtpAddPartition(
    IN  PVOLUME_EXTENSION   Extension,
    IN  PDEVICE_OBJECT      Partition,
    IN  PDEVICE_OBJECT      WholeDiskPdo
    )

/*++

Routine Description:

    This routine adds the given partition to the given ft set.

Arguments:

    Extension       - Supplies the extension where the FT set is rooted.

    Partition       - Supplies the new partition.

    WholeDiskPdo    - Supplies the whole disk PDO.

Return Value:

    NTSTATUS

--*/

{
    PFT_VOLUME                          vol = Extension->FtVolume;
    PROOT_EXTENSION                     rootExtension = Extension->Root;
    PFT_LOGICAL_DISK_INFORMATION_SET    diskInfoSet = rootExtension->DiskInfoSet;
    NTSTATUS                            status;
    ULONG                               diskNumber, n;
    LONGLONG                            offset;
    FT_LOGICAL_DISK_ID                  partitionDiskId, diskId;
    PFT_LOGICAL_DISK_DESCRIPTION        parentDesc;
    PFT_VOLUME                          parent, child, c;
    BOOLEAN                             inPagingPath, wasStarted;
    KIRQL                               irql;
    PDEVICE_OBJECT                      leftmost;
    BOOLEAN                             nameChange;
    WCHAR                               deviceNameBuffer[64];
    UNICODE_STRING                      deviceName;
    UCHAR                               registryState[100];
    USHORT                              registryStateSize;

    status = FtpQueryPartitionInformation(Extension->Root,
                                          Partition, &diskNumber, &offset,
                                          NULL, NULL, NULL, NULL, NULL, NULL,
                                          NULL);
    if (!NT_SUCCESS(status)) {
        return status;
    }

    partitionDiskId = diskId =
            diskInfoSet->QueryPartitionLogicalDiskId(diskNumber, offset);
    if (!diskId) {
        return STATUS_INVALID_PARAMETER;
    }

    for (;;) {
        parentDesc = diskInfoSet->GetParentLogicalDiskDescription(diskId);
        if (!parentDesc) {
            return STATUS_INVALID_PARAMETER;
        }
        parent = vol->GetContainedLogicalDisk(parentDesc->LogicalDiskId);
        if (parent) {
            break;
        }
        diskId = parentDesc->LogicalDiskId;
    }

    child = FtpBuildFtVolume(rootExtension, diskId, Partition, WholeDiskPdo);
    if (!child) {
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    parent->SetMember(parentDesc->u.Other.ThisMemberNumber, child);
    KeAcquireSpinLock(&Extension->SpinLock, &irql);
    if (!Extension->IsComplete) {
        KeReleaseSpinLock(&Extension->SpinLock, irql);

        leftmost = Extension->FtVolume->GetLeftmostPartitionObject();

        KeAcquireSpinLock(&Extension->SpinLock, &irql);
        if (!Extension->IsComplete) {

            parentDesc = diskInfoSet->GetParentLogicalDiskDescription(
                         partitionDiskId, &n);
            while (parentDesc) {

                if (parentDesc->u.Other.ByteOffsetToStateInformation &&
                    (c = vol->GetContainedLogicalDisk(parentDesc->LogicalDiskId))) {

                    c->NewStateArrival((PCHAR) parentDesc +
                            parentDesc->u.Other.ByteOffsetToStateInformation);

                    KeReleaseSpinLock(&Extension->SpinLock, irql);

                    if (FtpQueryStateFromRegistry(parentDesc->LogicalDiskId,
                                                  registryState,
                                                  sizeof(registryState),
                                                  &registryStateSize)) {

                        KeAcquireSpinLock(&Extension->SpinLock, &irql);
                        if (Extension->IsComplete) {
                            break;
                        }

                        if (!Extension->IsOffline) {
                            c->NewStateArrival(registryState);
                        }

                    } else {
                        KeAcquireSpinLock(&Extension->SpinLock, &irql);
                        if (Extension->IsComplete) {
                            break;
                        }
                    }
                }

                parentDesc = diskInfoSet->GetParentLogicalDiskDescription(
                             parentDesc, n);
            }
        }
    }

    if (Extension->IsComplete) {

        KeReleaseSpinLock(&Extension->SpinLock, irql);

        KeWaitForSingleObject(&Extension->Semaphore, Executive, KernelMode,
                              FALSE, NULL);
        status = FtpAllSystemsGo(Extension, NULL, TRUE, TRUE, TRUE);
        KeReleaseSemaphore(&Extension->Semaphore, IO_NO_INCREMENT, 1, FALSE);

        if (NT_SUCCESS(status)) {
            vol->StartSyncOperations(FALSE, FtpRefCountCompletion,
                                     Extension);
        }

        KeAcquireSpinLock(&Extension->SpinLock, &irql);
    }

    inPagingPath = Extension->InPagingPath;
    KeReleaseSpinLock(&Extension->SpinLock, irql);

    if (inPagingPath) {
        FtpSendPagingNotification(Partition);
    }

    swprintf(deviceNameBuffer, L"\\Device\\HarddiskVolume%d", Extension->VolumeNumber);
    RtlInitUnicodeString(&deviceName, deviceNameBuffer);
    child->CreateLegacyNameLinks(&deviceName);

    Extension->DeviceObject->AlignmentRequirement |=
            Partition->AlignmentRequirement;

    return STATUS_SUCCESS;
}

VOID
FtpPropogateRegistryState(
    IN  PVOLUME_EXTENSION   Extension,
    IN  PFT_VOLUME          Volume
    )

{
    UCHAR       state[100];
    USHORT      stateSize;
    KIRQL       irql;
    USHORT      n, i;
    PFT_VOLUME  vol;

    if (Volume->QueryLogicalDiskType() == FtPartition) {
        return;
    }

    if (FtpQueryStateFromRegistry(Volume->QueryLogicalDiskId(), state,
                                  100, &stateSize)) {

        KeAcquireSpinLock(&Extension->SpinLock, &irql);
        if (!Extension->IsComplete) {
            Volume->NewStateArrival(state);
        }
        KeReleaseSpinLock(&Extension->SpinLock, irql);
    }

    n = Volume->QueryNumberOfMembers();
    for (i = 0; i < n; i++) {
        vol = Volume->GetMember(i);
        if (!vol) {
            continue;
        }

        FtpPropogateRegistryState(Extension, vol);

    }
}

VOID
FtpComputeParity(
    IN  PVOID   TargetBuffer,
    IN  PVOID   SourceBuffer,
    IN  ULONG   BufferLength
    )

/*++

Routine Description:

    This routine computes the parity of the source and target buffers
    and places the result of the computation into the target buffer.
    I.E.  TargetBuffer ^= SourceBuffer.

Arguments:

    TargetBuffer    - Supplies the target buffer.

    SourceBuffer    - Supplies the source buffer.

    BufferLength    - Supplies the buffer length.

Return Value:

    None.

--*/

{
    PULONGLONG  p, q;
    ULONG       i, n;

    ASSERT(sizeof(ULONGLONG) == 8);

    p = (PULONGLONG) TargetBuffer;
    q = (PULONGLONG) SourceBuffer;
    n = BufferLength/128;
    ASSERT(BufferLength%128 == 0);
    for (i = 0; i < n; i++) {
        *p++ ^= *q++;
        *p++ ^= *q++;
        *p++ ^= *q++;
        *p++ ^= *q++;
        *p++ ^= *q++;
        *p++ ^= *q++;
        *p++ ^= *q++;
        *p++ ^= *q++;
        *p++ ^= *q++;
        *p++ ^= *q++;
        *p++ ^= *q++;
        *p++ ^= *q++;
        *p++ ^= *q++;
        *p++ ^= *q++;
        *p++ ^= *q++;
        *p++ ^= *q++;
    }
}

NTSTATUS
FtpReadPartitionTableEx(
    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,
                                        FTDISK_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,
                                            FTDISK_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;
}