/*++ Copyright (c) 1999 Microsoft Corporation Module Name: volsnap.cxx Abstract: This driver provides volume snapshot capabilities. Author: Norbert P. Kusters (norbertk) 22-Jan-1999 Environment: kernel mode only Notes: Revision History: --*/ extern "C" { #define RTL_USE_AVL_TABLES 0 #include #include #include #include #include #include #include #include #include #include #include #include NTSTATUS DriverEntry( IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING RegistryPath ); } ULONG VsErrorLogSequence = 0; VOID VspWriteVolume( IN PVOID Context ); NTSTATUS VspSetIgnorableBlocksInBitmap( IN PVOID Extension ); VOID VspWorkerThread( IN PVOID RootExtension ); VOID VspCleanupInitialSnapshot( IN PVOLUME_EXTENSION Extension, IN BOOLEAN NeedLock ); VOID VspDestroyAllSnapshots( IN PFILTER_EXTENSION Filter, IN PTEMP_TRANSLATION_TABLE_ENTRY TableEntry ); VOID VspWriteVolumePhase1( IN PVOID TableEntry ); VOID VspFreeCopyIrp( IN PVOLUME_EXTENSION Extension, IN PIRP CopyIrp ); NTSTATUS VspMarkFileAllocationInBitmap( IN PVOLUME_EXTENSION Extension, IN HANDLE FileHandle, IN PVSP_DIFF_AREA_FILE DiffAreaFile, IN BOOLEAN OnlyDiffAreaFile, IN BOOLEAN ClearBits, IN PRTL_BITMAP BitmapToSet ); NTSTATUS VspAbortPreparedSnapshot( IN PFILTER_EXTENSION Filter, IN BOOLEAN NeedLock ); VOID VspCleanupBitsSetInOtherPreparedSnapshots( IN PVOLUME_EXTENSION Extension ); NTSTATUS VspReleaseWrites( IN PFILTER_EXTENSION Filter ); NTSTATUS VspSetApplicationInfo( IN PVOLUME_EXTENSION Extension, IN PIRP Irp ); NTSTATUS VspRefCountCompletionRoutine( IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Filter ); VOID VspCleanupFilter( IN PFILTER_EXTENSION Filter ); VOID VspDecrementRefCount( IN PFILTER_EXTENSION Filter ); NTSTATUS VspSignalCompletion( IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Event ); NTSTATUS VspMarkFreeSpaceInBitmap( IN PVOLUME_EXTENSION Extension, IN HANDLE UseThisHandle, IN PRTL_BITMAP BitmapToSet ); VOID VspAndBitmaps( IN OUT PRTL_BITMAP BaseBitmap, IN PRTL_BITMAP FactorBitmap ); NTSTATUS VspDeleteOldestSnapshot( IN PFILTER_EXTENSION Filter, IN OUT PLIST_ENTRY ListOfDiffAreaFilesToClose, IN OUT PLIST_ENTRY LisfOfDeviceObjectsToDelete ); VOID VspCloseDiffAreaFiles( IN PLIST_ENTRY ListOfDiffAreaFilesToClose, IN PLIST_ENTRY ListOfDeviceObjectsToDelete ); NTSTATUS VspComputeIgnorableProduct( IN PVOLUME_EXTENSION Extension ); #ifdef ALLOC_PRAGMA #pragma alloc_text(INIT, DriverEntry) #endif #ifdef ALLOC_PRAGMA #pragma code_seg("PAGELK") #endif VOID VspAcquire( IN PDO_EXTENSION RootExtension ) { KeWaitForSingleObject(&RootExtension->Semaphore, Executive, KernelMode, FALSE, NULL); } VOID VspRelease( IN PDO_EXTENSION RootExtension ) { KeReleaseSemaphore(&RootExtension->Semaphore, IO_NO_INCREMENT, 1, FALSE); } PVSP_CONTEXT VspAllocateContext( IN PDO_EXTENSION RootExtension ) { PVSP_CONTEXT context; context = (PVSP_CONTEXT) ExAllocateFromNPagedLookasideList( &RootExtension->ContextLookasideList); return context; } VOID VspFreeContext( IN PDO_EXTENSION RootExtension, IN PVSP_CONTEXT Context ) { KIRQL irql; PLIST_ENTRY l; PIRP irp; PIO_STACK_LOCATION irpSp; if (RootExtension->EmergencyContext == Context) { KeAcquireSpinLock(&RootExtension->ESpinLock, &irql); RootExtension->EmergencyContextInUse = FALSE; if (IsListEmpty(&RootExtension->IrpWaitingList)) { InterlockedExchange(&RootExtension->IrpWaitingListNeedsChecking, FALSE); KeReleaseSpinLock(&RootExtension->ESpinLock, irql); return; } l = RemoveHeadList(&RootExtension->IrpWaitingList); KeReleaseSpinLock(&RootExtension->ESpinLock, irql); irp = CONTAINING_RECORD(l, IRP, Tail.Overlay.ListEntry); irpSp = IoGetCurrentIrpStackLocation(irp); RootExtension->DriverObject->MajorFunction[irpSp->MajorFunction]( irpSp->DeviceObject, irp); return; } ExFreeToNPagedLookasideList(&RootExtension->ContextLookasideList, Context); if (!RootExtension->IrpWaitingListNeedsChecking) { return; } KeAcquireSpinLock(&RootExtension->ESpinLock, &irql); if (IsListEmpty(&RootExtension->IrpWaitingList)) { InterlockedExchange(&RootExtension->IrpWaitingListNeedsChecking, FALSE); KeReleaseSpinLock(&RootExtension->ESpinLock, irql); return; } l = RemoveHeadList(&RootExtension->IrpWaitingList); KeReleaseSpinLock(&RootExtension->ESpinLock, irql); irp = CONTAINING_RECORD(l, IRP, Tail.Overlay.ListEntry); irpSp = IoGetCurrentIrpStackLocation(irp); RootExtension->DriverObject->MajorFunction[irpSp->MajorFunction]( irpSp->DeviceObject, irp); } PVOID VspAllocateTempTableEntry( IN PDO_EXTENSION RootExtension ) { PVOID tempTableEntry; tempTableEntry = ExAllocateFromNPagedLookasideList( &RootExtension->TempTableEntryLookasideList); return tempTableEntry; } VOID VspQueueWorkItem( IN PDO_EXTENSION RootExtension, IN PWORK_QUEUE_ITEM WorkItem, IN ULONG QueueNumber ) { KIRQL irql; ASSERT(QueueNumber < NUMBER_OF_THREAD_POOLS); KeAcquireSpinLock(&RootExtension->SpinLock[QueueNumber], &irql); InsertTailList(&RootExtension->WorkerQueue[QueueNumber], &WorkItem->List); KeReleaseSpinLock(&RootExtension->SpinLock[QueueNumber], irql); KeReleaseSemaphore(&RootExtension->WorkerSemaphore[QueueNumber], IO_NO_INCREMENT, 1, FALSE); } VOID VspFreeTempTableEntry( IN PDO_EXTENSION RootExtension, IN PVOID TempTableEntry ) { KIRQL irql; PLIST_ENTRY l; PWORK_QUEUE_ITEM workItem; if (RootExtension->EmergencyTableEntry == TempTableEntry) { KeAcquireSpinLock(&RootExtension->ESpinLock, &irql); RootExtension->EmergencyTableEntryInUse = FALSE; if (IsListEmpty(&RootExtension->WorkItemWaitingList)) { InterlockedExchange( &RootExtension->WorkItemWaitingListNeedsChecking, FALSE); KeReleaseSpinLock(&RootExtension->ESpinLock, irql); return; } l = RemoveHeadList(&RootExtension->WorkItemWaitingList); KeReleaseSpinLock(&RootExtension->ESpinLock, irql); workItem = CONTAINING_RECORD(l, WORK_QUEUE_ITEM, List); VspQueueWorkItem(RootExtension, workItem, 2); return; } ExFreeToNPagedLookasideList(&RootExtension->TempTableEntryLookasideList, TempTableEntry); if (!RootExtension->WorkItemWaitingListNeedsChecking) { return; } KeAcquireSpinLock(&RootExtension->ESpinLock, &irql); if (IsListEmpty(&RootExtension->WorkItemWaitingList)) { InterlockedExchange(&RootExtension->WorkItemWaitingListNeedsChecking, FALSE); KeReleaseSpinLock(&RootExtension->ESpinLock, irql); return; } l = RemoveHeadList(&RootExtension->WorkItemWaitingList); KeReleaseSpinLock(&RootExtension->ESpinLock, irql); workItem = CONTAINING_RECORD(l, WORK_QUEUE_ITEM, List); VspQueueWorkItem(RootExtension, workItem, 2); } VOID VspLogErrorWorker( IN PVOID Context ) { PVSP_CONTEXT context = (PVSP_CONTEXT) Context; PVOLUME_EXTENSION extension = context->ErrorLog.Extension; PFILTER_EXTENSION diffAreaFilter = context->ErrorLog.DiffAreaFilter; PFILTER_EXTENSION filter; NTSTATUS status; UNICODE_STRING filterDosName, diffAreaFilterDosName; ULONG extraSpace; PIO_ERROR_LOG_PACKET errorLogPacket; PWCHAR p; ASSERT(context->Type == VSP_CONTEXT_TYPE_ERROR_LOG); if (extension) { filter = extension->Filter; } else { filter = diffAreaFilter; diffAreaFilter = NULL; } status = IoVolumeDeviceToDosName(filter->DeviceObject, &filterDosName); if (!NT_SUCCESS(status)) { goto Cleanup; } extraSpace = filterDosName.Length + sizeof(WCHAR); if (diffAreaFilter) { status = IoVolumeDeviceToDosName(diffAreaFilter->DeviceObject, &diffAreaFilterDosName); if (!NT_SUCCESS(status)) { ExFreePool(filterDosName.Buffer); goto Cleanup; } extraSpace += diffAreaFilterDosName.Length + sizeof(WCHAR); } extraSpace += sizeof(IO_ERROR_LOG_PACKET); if (extraSpace > 0xFF) { if (diffAreaFilter) { ExFreePool(diffAreaFilterDosName.Buffer); } ExFreePool(filterDosName.Buffer); goto Cleanup; } errorLogPacket = (PIO_ERROR_LOG_PACKET) IoAllocateErrorLogEntry(extension ? extension->DeviceObject : filter->DeviceObject, (UCHAR) extraSpace); if (!errorLogPacket) { if (diffAreaFilter) { ExFreePool(diffAreaFilterDosName.Buffer); } ExFreePool(filterDosName.Buffer); goto Cleanup; } errorLogPacket->ErrorCode = context->ErrorLog.SpecificIoStatus; errorLogPacket->SequenceNumber = VsErrorLogSequence++; errorLogPacket->FinalStatus = context->ErrorLog.FinalStatus; errorLogPacket->UniqueErrorValue = context->ErrorLog.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)); RtlCopyMemory(p, filterDosName.Buffer, filterDosName.Length); p[filterDosName.Length/sizeof(WCHAR)] = 0; if (diffAreaFilter) { errorLogPacket->NumberOfStrings = 2; p = (PWCHAR) ((PCHAR) errorLogPacket + sizeof(IO_ERROR_LOG_PACKET) + filterDosName.Length + sizeof(WCHAR)); RtlCopyMemory(p, diffAreaFilterDosName.Buffer, diffAreaFilterDosName.Length); p[diffAreaFilterDosName.Length/sizeof(WCHAR)] = 0; } IoWriteErrorLogEntry(errorLogPacket); if (diffAreaFilter) { ExFreePool(diffAreaFilterDosName.Buffer); } ExFreePool(filterDosName.Buffer); Cleanup: VspFreeContext(filter->Root, context); if (extension) { ObDereferenceObject(extension->DeviceObject); } ObDereferenceObject(filter->DeviceObject); if (diffAreaFilter) { ObDereferenceObject(diffAreaFilter->DeviceObject); } } VOID VspLogError( IN PVOLUME_EXTENSION Extension, IN PFILTER_EXTENSION DiffAreaFilter, IN NTSTATUS SpecificIoStatus, IN NTSTATUS FinalStatus, IN ULONG UniqueErrorValue ) { PDO_EXTENSION root; PVSP_CONTEXT context; if (Extension) { root = Extension->Root; } else { root = DiffAreaFilter->Root; } context = VspAllocateContext(root); if (!context) { return; } context->Type = VSP_CONTEXT_TYPE_ERROR_LOG; context->ErrorLog.Extension = Extension; context->ErrorLog.DiffAreaFilter = DiffAreaFilter; context->ErrorLog.SpecificIoStatus = SpecificIoStatus; context->ErrorLog.FinalStatus = FinalStatus; context->ErrorLog.UniqueErrorValue = UniqueErrorValue; if (Extension) { ObReferenceObject(Extension->DeviceObject); ObReferenceObject(Extension->Filter->DeviceObject); } if (DiffAreaFilter) { ObReferenceObject(DiffAreaFilter->DeviceObject); } ExInitializeWorkItem(&context->WorkItem, VspLogErrorWorker, context); ExQueueWorkItem(&context->WorkItem, DelayedWorkQueue); } VOID VspWaitForWorkerThreadsToExit( IN PDO_EXTENSION RootExtension ) { PVOID threadObject; CCHAR i, j; if (!RootExtension->WorkerThreadObjects) { return; } threadObject = RootExtension->WorkerThreadObjects[0]; KeWaitForSingleObject(threadObject, Executive, KernelMode, FALSE, NULL); ObDereferenceObject(threadObject); for (i = 1; i < NUMBER_OF_THREAD_POOLS; i++) { for (j = 0; j < KeNumberProcessors; j++) { threadObject = RootExtension->WorkerThreadObjects[ (i - 1)*KeNumberProcessors + j + 1]; KeWaitForSingleObject(threadObject, Executive, KernelMode, FALSE, NULL); ObDereferenceObject(threadObject); } } ExFreePool(RootExtension->WorkerThreadObjects); RootExtension->WorkerThreadObjects = NULL; } NTSTATUS VspCreateWorkerThread( IN PDO_EXTENSION RootExtension ) /*++ Routine Description: This routine will create a new thread for a new volume snapshot. Since a minimum of 2 threads are needed to prevent deadlocks, if there are no threads then 2 threads will be created by this routine. Arguments: RootExtension - Supplies the root extension. Return Value: NTSTATUS Notes: The caller must be holding 'Root->Semaphore'. --*/ { OBJECT_ATTRIBUTES oa; PVSP_CONTEXT context; NTSTATUS status; HANDLE handle; PVOID threadObject; CCHAR i, j, k; KeWaitForSingleObject(&RootExtension->ThreadsRefCountSemaphore, Executive, KernelMode, FALSE, NULL); if (RootExtension->ThreadsRefCount) { RootExtension->ThreadsRefCount++; KeReleaseSemaphore(&RootExtension->ThreadsRefCountSemaphore, IO_NO_INCREMENT, 1, FALSE); return STATUS_SUCCESS; } VspWaitForWorkerThreadsToExit(RootExtension); InitializeObjectAttributes(&oa, NULL, OBJ_KERNEL_HANDLE, NULL, NULL); context = VspAllocateContext(RootExtension); if (!context) { KeReleaseSemaphore(&RootExtension->ThreadsRefCountSemaphore, IO_NO_INCREMENT, 1, FALSE); return STATUS_INSUFFICIENT_RESOURCES; } context->Type = VSP_CONTEXT_TYPE_THREAD_CREATION; context->ThreadCreation.RootExtension = RootExtension; context->ThreadCreation.QueueNumber = 0; ASSERT(!RootExtension->WorkerThreadObjects); RootExtension->WorkerThreadObjects = (PVOID*) ExAllocatePoolWithTag(NonPagedPool, (KeNumberProcessors*2 + 1)*sizeof(PVOID), VOLSNAP_TAG_IO_STATUS); if (!RootExtension->WorkerThreadObjects) { VspFreeContext(RootExtension, context); KeReleaseSemaphore(&RootExtension->ThreadsRefCountSemaphore, IO_NO_INCREMENT, 1, FALSE); return STATUS_INSUFFICIENT_RESOURCES; } status = PsCreateSystemThread(&handle, 0, &oa, 0, NULL, VspWorkerThread, context); if (!NT_SUCCESS(status)) { ExFreePool(RootExtension->WorkerThreadObjects); RootExtension->WorkerThreadObjects = NULL; VspFreeContext(RootExtension, context); KeReleaseSemaphore(&RootExtension->ThreadsRefCountSemaphore, IO_NO_INCREMENT, 1, FALSE); return status; } status = ObReferenceObjectByHandle(handle, THREAD_ALL_ACCESS, NULL, KernelMode, &threadObject, NULL); if (!NT_SUCCESS(status)) { KeReleaseSemaphore(&RootExtension->WorkerSemaphore[0], IO_NO_INCREMENT, 1, FALSE); ZwWaitForSingleObject(handle, FALSE, NULL); ExFreePool(RootExtension->WorkerThreadObjects); RootExtension->WorkerThreadObjects = NULL; KeReleaseSemaphore(&RootExtension->ThreadsRefCountSemaphore, IO_NO_INCREMENT, 1, FALSE); return status; } RootExtension->WorkerThreadObjects[0] = threadObject; ZwClose(handle); for (i = 1; i < NUMBER_OF_THREAD_POOLS; i++) { for (j = 0; j < KeNumberProcessors; j++) { context = VspAllocateContext(RootExtension); if (!context) { status = STATUS_INSUFFICIENT_RESOURCES; handle = NULL; break; } context->Type = VSP_CONTEXT_TYPE_THREAD_CREATION; context->ThreadCreation.RootExtension = RootExtension; context->ThreadCreation.QueueNumber = i; status = PsCreateSystemThread(&handle, 0, &oa, 0, NULL, VspWorkerThread, context); if (!NT_SUCCESS(status)) { VspFreeContext(RootExtension, context); handle = NULL; break; } status = ObReferenceObjectByHandle( handle, THREAD_ALL_ACCESS, NULL, KernelMode, &threadObject, NULL); if (!NT_SUCCESS(status)) { break; } RootExtension->WorkerThreadObjects[ KeNumberProcessors*(i - 1) + j + 1] = threadObject; ZwClose(handle); } if (j < KeNumberProcessors) { KeReleaseSemaphore(&RootExtension->WorkerSemaphore[i], IO_NO_INCREMENT, j, FALSE); if (handle) { KeReleaseSemaphore(&RootExtension->WorkerSemaphore[i], IO_NO_INCREMENT, 1, FALSE); ZwWaitForSingleObject(handle, FALSE, NULL); ZwClose(handle); } for (k = 0; k < j; k++) { threadObject = RootExtension->WorkerThreadObjects[ KeNumberProcessors*(i - 1) + k + 1]; KeWaitForSingleObject(threadObject, Executive, KernelMode, FALSE, NULL); ObDereferenceObject(threadObject); } break; } } if (i < NUMBER_OF_THREAD_POOLS) { for (k = 1; k < i; k++) { KeReleaseSemaphore(&RootExtension->WorkerSemaphore[k], IO_NO_INCREMENT, KeNumberProcessors, FALSE); for (j = 0; j < KeNumberProcessors; j++) { threadObject = RootExtension->WorkerThreadObjects[ KeNumberProcessors*(k - 1) + j + 1]; KeWaitForSingleObject(threadObject, Executive, KernelMode, FALSE, NULL); ObDereferenceObject(threadObject); } } KeReleaseSemaphore(&RootExtension->WorkerSemaphore[0], IO_NO_INCREMENT, 1, FALSE); threadObject = RootExtension->WorkerThreadObjects[0]; KeWaitForSingleObject(threadObject, Executive, KernelMode, FALSE, NULL); ObDereferenceObject(threadObject); ExFreePool(RootExtension->WorkerThreadObjects); RootExtension->WorkerThreadObjects = NULL; KeReleaseSemaphore(&RootExtension->ThreadsRefCountSemaphore, IO_NO_INCREMENT, 1, FALSE); return status; } RootExtension->ThreadsRefCount++; KeReleaseSemaphore(&RootExtension->ThreadsRefCountSemaphore, IO_NO_INCREMENT, 1, FALSE); return STATUS_SUCCESS; } VOID VspWaitForWorkerThreadsToExitWorker( IN PVOID RootExtension ) { PDO_EXTENSION rootExtension = (PDO_EXTENSION) RootExtension; KeWaitForSingleObject(&rootExtension->ThreadsRefCountSemaphore, Executive, KernelMode, FALSE, NULL); VspWaitForWorkerThreadsToExit(rootExtension); rootExtension->WaitForWorkerThreadsToExitWorkItemInUse = FALSE; KeReleaseSemaphore(&rootExtension->ThreadsRefCountSemaphore, IO_NO_INCREMENT, 1, FALSE); } NTSTATUS VspDeleteWorkerThread( IN PDO_EXTENSION RootExtension ) /*++ Routine Description: This routine will delete a worker thread. Arguments: RootExtension - Supplies the root extension. Return Value: NTSTATUS Notes: The caller must be holding 'Root->Semaphore'. --*/ { CCHAR i, j; KeWaitForSingleObject(&RootExtension->ThreadsRefCountSemaphore, Executive, KernelMode, FALSE, NULL); RootExtension->ThreadsRefCount--; if (RootExtension->ThreadsRefCount) { KeReleaseSemaphore(&RootExtension->ThreadsRefCountSemaphore, IO_NO_INCREMENT, 1, FALSE); return STATUS_SUCCESS; } KeReleaseSemaphore(&RootExtension->WorkerSemaphore[0], IO_NO_INCREMENT, 1, FALSE); for (i = 1; i < NUMBER_OF_THREAD_POOLS; i++) { KeReleaseSemaphore(&RootExtension->WorkerSemaphore[i], IO_NO_INCREMENT, KeNumberProcessors, FALSE); } if (RootExtension->WaitForWorkerThreadsToExitWorkItemInUse) { KeReleaseSemaphore(&RootExtension->ThreadsRefCountSemaphore, IO_NO_INCREMENT, 1, FALSE); return STATUS_SUCCESS; } RootExtension->WaitForWorkerThreadsToExitWorkItemInUse = TRUE; ExInitializeWorkItem(&RootExtension->WaitForWorkerThreadsToExitWorkItem, VspWaitForWorkerThreadsToExitWorker, RootExtension); ExQueueWorkItem(&RootExtension->WaitForWorkerThreadsToExitWorkItem, DelayedWorkQueue); KeReleaseSemaphore(&RootExtension->ThreadsRefCountSemaphore, IO_NO_INCREMENT, 1, FALSE); return STATUS_SUCCESS; } VOID VspQueryDiffAreaFileIncrease( IN PVOLUME_EXTENSION Extension, OUT PULONG Increase ) { LONGLONG r; r = (LONGLONG) Extension->MaximumNumberOfTempEntries; r <<= BLOCK_SHIFT; if (r < NOMINAL_DIFF_AREA_FILE_GROWTH) { r = NOMINAL_DIFF_AREA_FILE_GROWTH; } else if (r > MAXIMUM_DIFF_AREA_FILE_GROWTH) { r = MAXIMUM_DIFF_AREA_FILE_GROWTH; } *Increase = (ULONG) r; } NTSTATUS VolSnapDefaultDispatch( IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp ) /*++ Routine Description: This routine is the default dispatch which passes down to the next layer. Arguments: DeviceObject - Supplies the device object. Irp - Supplies the IO request packet. Return Value: NTSTATUS --*/ { PFILTER_EXTENSION filter = (PFILTER_EXTENSION) DeviceObject->DeviceExtension; PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation(Irp); NTSTATUS status; if (filter->DeviceExtensionType == DEVICE_EXTENSION_FILTER) { IoSkipCurrentIrpStackLocation(Irp); return IoCallDriver(filter->TargetObject, Irp); } ASSERT(filter->DeviceExtensionType == DEVICE_EXTENSION_VOLUME); if (irpSp->MajorFunction == IRP_MJ_SYSTEM_CONTROL) { status = Irp->IoStatus.Status; } else { status = STATUS_INVALID_DEVICE_REQUEST; } Irp->IoStatus.Status = status; Irp->IoStatus.Information = 0; IoCompleteRequest(Irp, IO_NO_INCREMENT); return status; } BOOLEAN VspAreBitsSet( IN PVOLUME_EXTENSION Extension, IN PIRP Irp ) { PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation(Irp); LONGLONG start; ULONG startBlock, endBlock; BOOLEAN b; if (!Extension->VolumeBlockBitmap) { return FALSE; } start = irpSp->Parameters.Read.ByteOffset.QuadPart; if (start < 0) { return FALSE; } startBlock = (ULONG) (start >> BLOCK_SHIFT); endBlock = (ULONG) ((start + irpSp->Parameters.Read.Length - 1) >> BLOCK_SHIFT); b = RtlAreBitsSet(Extension->VolumeBlockBitmap, startBlock, endBlock - startBlock + 1); return b; } VOID VspDecrementVolumeRefCount( IN PVOLUME_EXTENSION Extension ) { KIRQL irql; if (InterlockedDecrement(&Extension->RefCount)) { return; } ASSERT(Extension->HoldIncomingRequests); KeSetEvent(&Extension->ZeroRefEvent, IO_NO_INCREMENT, FALSE); } NTSTATUS VspIncrementVolumeRefCount( IN PVOLUME_EXTENSION Extension, IN PIRP Irp, IN PWORK_QUEUE_ITEM WorkItem ) { KIRQL irql; ASSERT(Irp || WorkItem); ASSERT(!Irp || !WorkItem); InterlockedIncrement(&Extension->RefCount); if (Extension->IsDead) { VspDecrementVolumeRefCount(Extension); return STATUS_NO_SUCH_DEVICE; } if (!Extension->HoldIncomingRequests) { return STATUS_SUCCESS; } VspDecrementVolumeRefCount(Extension); KeAcquireSpinLock(&Extension->SpinLock, &irql); if (!Extension->HoldIncomingRequests) { InterlockedIncrement(&Extension->RefCount); KeReleaseSpinLock(&Extension->SpinLock, irql); return STATUS_SUCCESS; } if (Irp) { IoMarkIrpPending(Irp); InsertTailList(&Extension->HoldIrpQueue, &Irp->Tail.Overlay.ListEntry); } else { InsertTailList(&Extension->HoldWorkerQueue, &WorkItem->List); } KeReleaseSpinLock(&Extension->SpinLock, irql); return STATUS_PENDING; } VOID VspSignalContext( IN PVOID Context ) { PVSP_CONTEXT context = (PVSP_CONTEXT) Context; ASSERT(context->Type == VSP_CONTEXT_TYPE_EVENT); KeSetEvent(&context->Event.Event, IO_NO_INCREMENT, FALSE); } VOID VspAcquireNonPagedResource( IN PVOLUME_EXTENSION Extension, IN PWORK_QUEUE_ITEM WorkItem ) { PFILTER_EXTENSION filter = Extension->Filter; KIRQL irql; VSP_CONTEXT context; BOOLEAN synchronousCall; if (WorkItem) { synchronousCall = FALSE; } else { WorkItem = &context.WorkItem; context.Type = VSP_CONTEXT_TYPE_EVENT; KeInitializeEvent(&context.Event.Event, NotificationEvent, FALSE); ExInitializeWorkItem(&context.WorkItem, VspSignalContext, &context); synchronousCall = TRUE; } KeAcquireSpinLock(&filter->SpinLock, &irql); if (filter->NonPagedResourceInUse) { InsertTailList(&filter->NonPagedResourceList, &WorkItem->List); KeReleaseSpinLock(&filter->SpinLock, irql); if (synchronousCall) { KeWaitForSingleObject(&context.Event.Event, Executive, KernelMode, FALSE, NULL); } return; } filter->NonPagedResourceInUse = TRUE; KeReleaseSpinLock(&filter->SpinLock, irql); if (!synchronousCall) { WorkItem->WorkerRoutine(WorkItem->Parameter); } } VOID VspReleaseNonPagedResource( IN PVOLUME_EXTENSION Extension ) { PFILTER_EXTENSION filter = Extension->Filter; KIRQL irql; PLIST_ENTRY l; PWORK_QUEUE_ITEM workItem; KeAcquireSpinLock(&filter->SpinLock, &irql); if (IsListEmpty(&filter->NonPagedResourceList)) { filter->NonPagedResourceInUse = FALSE; KeReleaseSpinLock(&filter->SpinLock, irql); return; } l = RemoveHeadList(&filter->NonPagedResourceList); KeReleaseSpinLock(&filter->SpinLock, irql); workItem = CONTAINING_RECORD(l, WORK_QUEUE_ITEM, List); VspQueueWorkItem(Extension->Root, workItem, 2); } VOID VspAcquirePagedResource( IN PVOLUME_EXTENSION Extension, IN PWORK_QUEUE_ITEM WorkItem ) { PFILTER_EXTENSION filter = Extension->Filter; KIRQL irql; VSP_CONTEXT context; BOOLEAN synchronousCall; if (WorkItem) { synchronousCall = FALSE; } else { WorkItem = &context.WorkItem; context.Type = VSP_CONTEXT_TYPE_EVENT; KeInitializeEvent(&context.Event.Event, NotificationEvent, FALSE); ExInitializeWorkItem(&context.WorkItem, VspSignalContext, &context); synchronousCall = TRUE; } KeAcquireSpinLock(&filter->SpinLock, &irql); if (filter->PagedResourceInUse) { InsertTailList(&filter->PagedResourceList, &WorkItem->List); KeReleaseSpinLock(&filter->SpinLock, irql); if (synchronousCall) { KeWaitForSingleObject(&context.Event.Event, Executive, KernelMode, FALSE, NULL); } return; } filter->PagedResourceInUse = TRUE; KeReleaseSpinLock(&filter->SpinLock, irql); if (!synchronousCall) { VspQueueWorkItem(filter->Root, WorkItem, 1); } } VOID VspReleasePagedResource( IN PVOLUME_EXTENSION Extension ) { PFILTER_EXTENSION filter = Extension->Filter; KIRQL irql; PLIST_ENTRY l; PWORK_QUEUE_ITEM workItem; KeAcquireSpinLock(&filter->SpinLock, &irql); if (IsListEmpty(&filter->PagedResourceList)) { filter->PagedResourceInUse = FALSE; KeReleaseSpinLock(&filter->SpinLock, irql); return; } l = RemoveHeadList(&filter->PagedResourceList); KeReleaseSpinLock(&filter->SpinLock, irql); workItem = CONTAINING_RECORD(l, WORK_QUEUE_ITEM, List); VspQueueWorkItem(filter->Root, workItem, 1); } NTSTATUS VspQueryListOfExtents( IN HANDLE FileHandle, IN LONGLONG FileOffset, OUT PLIST_ENTRY ExtentList ) { NTSTATUS status; IO_STATUS_BLOCK ioStatus; FILE_FS_SIZE_INFORMATION fsSize; ULONG bpc; STARTING_VCN_INPUT_BUFFER input; RETRIEVAL_POINTERS_BUFFER output; LONGLONG start, length, delta; PDIFF_AREA_FILE_ALLOCATION diffAreaFileAllocation; PLIST_ENTRY l; InitializeListHead(ExtentList); status = ZwQueryVolumeInformationFile(FileHandle, &ioStatus, &fsSize, sizeof(fsSize), FileFsSizeInformation); if (!NT_SUCCESS(status)) { return status; } bpc = fsSize.BytesPerSector*fsSize.SectorsPerAllocationUnit; input.StartingVcn.QuadPart = FileOffset/bpc; for (;;) { status = ZwFsControlFile(FileHandle, NULL, NULL, NULL, &ioStatus, FSCTL_GET_RETRIEVAL_POINTERS, &input, sizeof(input), &output, sizeof(output)); if (!NT_SUCCESS(status) && status != STATUS_BUFFER_OVERFLOW) { break; } delta = input.StartingVcn.QuadPart - output.StartingVcn.QuadPart; start = (output.Extents[0].Lcn.QuadPart + delta)*bpc; length = (output.Extents[0].NextVcn.QuadPart - input.StartingVcn.QuadPart)*bpc; diffAreaFileAllocation = (PDIFF_AREA_FILE_ALLOCATION) ExAllocatePoolWithTag(NonPagedPool, sizeof(DIFF_AREA_FILE_ALLOCATION), VOLSNAP_TAG_BIT_HISTORY); if (!diffAreaFileAllocation) { status = STATUS_INSUFFICIENT_RESOURCES; break; } diffAreaFileAllocation->Offset = start; diffAreaFileAllocation->Length = length; InsertTailList(ExtentList, &diffAreaFileAllocation->ListEntry); if (status != STATUS_BUFFER_OVERFLOW) { break; } input.StartingVcn.QuadPart = output.Extents[0].NextVcn.QuadPart; } if (!NT_SUCCESS(status)) { while (!IsListEmpty(ExtentList)) { l = RemoveHeadList(ExtentList); diffAreaFileAllocation = CONTAINING_RECORD(l, DIFF_AREA_FILE_ALLOCATION, ListEntry); ExFreePool(diffAreaFileAllocation); } } return status; } NTSTATUS VspSetFileSizes( IN HANDLE FileHandle, IN LONGLONG FileSize ) { FILE_ALLOCATION_INFORMATION allocInfo; NTSTATUS status; IO_STATUS_BLOCK ioStatus; allocInfo.AllocationSize.QuadPart = FileSize; status = ZwSetInformationFile(FileHandle, &ioStatus, &allocInfo, sizeof(allocInfo), FileAllocationInformation); return status; } VOID VspGrowDiffArea( IN PVOID Context ) { PVSP_CONTEXT context = (PVSP_CONTEXT) Context; PVOLUME_EXTENSION extension = context->GrowDiffArea.Extension; PVSP_DIFF_AREA_FILE diffAreaFile = context->GrowDiffArea.DiffAreaFile; PFILTER_EXTENSION filter = extension->Filter; LONGLONG usableSpace = 0; HANDLE handle; NTSTATUS status; KIRQL irql; LIST_ENTRY extentList; PLIST_ENTRY l; PDIFF_AREA_FILE_ALLOCATION diffAreaFileAllocation; ULONG s, n, i, increase; LONGLONG offset, endOffset, current; PVOLUME_EXTENSION bitmapExtension; LIST_ENTRY listOfDiffAreaFilesToClose; LIST_ENTRY listOfDeviceObjectsToDelete; ASSERT(context->Type == VSP_CONTEXT_TYPE_GROW_DIFF_AREA); VspFreeContext(extension->Root, context); DoOver: VspAcquire(extension->Root); if (extension->IsDead) { VspRelease(extension->Root); ObDereferenceObject(extension->DeviceObject); return; } handle = diffAreaFile->FileHandle; current = diffAreaFile->AllocatedFileSize; increase = extension->DiffAreaFileIncrease; ObReferenceObject(filter->DeviceObject); VspRelease(extension->Root); for (;;) { KeAcquireSpinLock(&filter->SpinLock, &irql); if (filter->MaximumVolumeSpace && filter->AllocatedVolumeSpace + increase > filter->MaximumVolumeSpace) { KeReleaseSpinLock(&filter->SpinLock, irql); status = STATUS_DISK_FULL; } else { KeReleaseSpinLock(&filter->SpinLock, irql); status = VspSetFileSizes(handle, current + increase); if (NT_SUCCESS(status)) { break; } } if (increase > NOMINAL_DIFF_AREA_FILE_GROWTH) { increase = NOMINAL_DIFF_AREA_FILE_GROWTH; continue; } VspAcquire(extension->Root); if (extension->IsDead) { VspRelease(extension->Root); ObDereferenceObject(extension->DeviceObject); ObDereferenceObject(filter->DeviceObject); return; } if (status != STATUS_DISK_FULL) { VspLogError(extension, diffAreaFile->Filter, VS_GROW_DIFF_AREA_FAILED, status, 0); VspRelease(extension->Root); ObDereferenceObject(extension->DeviceObject); ObDereferenceObject(filter->DeviceObject); return; } if (extension->ListEntry.Blink == &filter->VolumeList) { VspLogError(extension, diffAreaFile->Filter, VS_GROW_DIFF_AREA_FAILED_LOW_DISK_SPACE, STATUS_DISK_FULL, 0); VspRelease(extension->Root); ObDereferenceObject(extension->DeviceObject); ObDereferenceObject(filter->DeviceObject); return; } InitializeListHead(&listOfDiffAreaFilesToClose); InitializeListHead(&listOfDeviceObjectsToDelete); status = VspDeleteOldestSnapshot(filter, &listOfDiffAreaFilesToClose, &listOfDeviceObjectsToDelete); if (!NT_SUCCESS(status)) { VspLogError(extension, diffAreaFile->Filter, VS_GROW_DIFF_AREA_FAILED_LOW_DISK_SPACE, STATUS_DISK_FULL, 0); VspRelease(extension->Root); VspCloseDiffAreaFiles(&listOfDiffAreaFilesToClose, &listOfDeviceObjectsToDelete); ObDereferenceObject(extension->DeviceObject); ObDereferenceObject(filter->DeviceObject); return; } VspRelease(extension->Root); VspCloseDiffAreaFiles(&listOfDiffAreaFilesToClose, &listOfDeviceObjectsToDelete); } status = VspQueryListOfExtents(handle, current, &extentList); if (!NT_SUCCESS(status)) { ObDereferenceObject(extension->DeviceObject); ObDereferenceObject(filter->DeviceObject); return; } VspAcquire(extension->Root); if (extension->IsDead) { VspRelease(extension->Root); while (!IsListEmpty(&extentList)) { l = RemoveHeadList(&extentList); diffAreaFileAllocation = CONTAINING_RECORD(l, DIFF_AREA_FILE_ALLOCATION, ListEntry); ExFreePool(diffAreaFileAllocation); } ObDereferenceObject(extension->DeviceObject); ObDereferenceObject(filter->DeviceObject); return; } if (diffAreaFile->Filter->PreparedSnapshot) { status = VspMarkFileAllocationInBitmap( diffAreaFile->Filter->PreparedSnapshot, diffAreaFile->FileHandle, NULL, FALSE, FALSE, NULL); if (!NT_SUCCESS(status)) { VspLogError(extension, diffAreaFile->Filter, VS_CANT_MAP_DIFF_AREA_FILE, status, 1); VspAbortPreparedSnapshot(diffAreaFile->Filter, FALSE); } } if (IsListEmpty(&diffAreaFile->Filter->VolumeList)) { bitmapExtension = NULL; } else { bitmapExtension = CONTAINING_RECORD( diffAreaFile->Filter->VolumeList.Blink, VOLUME_EXTENSION, ListEntry); if (bitmapExtension->IsDead) { bitmapExtension = NULL; } } VspAcquireNonPagedResource(extension, NULL); while (!IsListEmpty(&extentList)) { l = RemoveHeadList(&extentList); InsertTailList(&diffAreaFile->UnusedAllocationList, l); diffAreaFileAllocation = CONTAINING_RECORD(l, DIFF_AREA_FILE_ALLOCATION, ListEntry); s = (ULONG) ((diffAreaFileAllocation->Offset + BLOCK_SIZE - 1)>> BLOCK_SHIFT); offset = ((LONGLONG) s)<Offset + diffAreaFileAllocation->Length; if (endOffset < offset) { continue; } n = (ULONG) ((endOffset - offset)>>BLOCK_SHIFT); if (!n) { continue; } if (bitmapExtension) { KeAcquireSpinLock(&bitmapExtension->SpinLock, &irql); for (i = 0; i < n; i++) { if (RtlCheckBit(bitmapExtension->VolumeBlockBitmap, s + i)) { usableSpace += BLOCK_SIZE; } } KeReleaseSpinLock(&bitmapExtension->SpinLock, irql); } else { usableSpace += n<AllocatedFileSize += increase; KeAcquireSpinLock(&filter->SpinLock, &irql); filter->AllocatedVolumeSpace += increase; KeReleaseSpinLock(&filter->SpinLock, irql); VspReleaseNonPagedResource(extension); VspRelease(extension->Root); ObDereferenceObject(filter->DeviceObject); if (usableSpace < increase) { goto DoOver; } ObDereferenceObject(extension->DeviceObject); } NTSTATUS VspAllocateDiffAreaSpace( IN PVOLUME_EXTENSION Extension, OUT PVSP_DIFF_AREA_FILE* DiffAreaFile, OUT PLONGLONG TargetOffset ) /*++ Routine Description: This routine allocates file space in a diff area file. The algorithm for this allocation is round robin which means that different size allocations can make the various files grow to be different sizes. The earmarked file is used and grown as necessary to get the space desired. Only if it is impossible to use the current file would the allocator go to the next one. If a file needs to be grown, the allocator will try to grow by 10 MB. Arguments: Extension - Supplies the volume extension. DiffAreaFile - Returns the diff area file used in the allocation. FileOffset - Returns the file offset in the diff area file used. Return Value: NTSTATUS Notes: Callers of this routine must be holding 'NonPagedResource'. --*/ { PFILTER_EXTENSION filter = Extension->Filter; NTSTATUS status = STATUS_SUCCESS; PVSP_DIFF_AREA_FILE firstDiffAreaFile, diffAreaFile; ULONG i; PLIST_ENTRY l; LONGLONG remainder, delta; KIRQL irql; PVSP_CONTEXT context; PDIFF_AREA_FILE_ALLOCATION diffAreaFileAllocation; PVOLUME_EXTENSION targetExtension; LONGLONG targetOffset; ULONG bitToCheck; firstDiffAreaFile = Extension->NextDiffAreaFile; i = 0; targetOffset = 0; for (;;) { diffAreaFile = Extension->NextDiffAreaFile; if (diffAreaFile == firstDiffAreaFile) { if (i) { status = STATUS_INSUFFICIENT_RESOURCES; break; } i++; } l = Extension->NextDiffAreaFile->VolumeListEntry.Flink; if (l == &Extension->ListOfDiffAreaFiles) { l = l->Flink; } Extension->NextDiffAreaFile = CONTAINING_RECORD(l, VSP_DIFF_AREA_FILE, VolumeListEntry); if (IsListEmpty(&diffAreaFile->Filter->VolumeList)) { targetExtension = NULL; } else { targetExtension = CONTAINING_RECORD( diffAreaFile->Filter->VolumeList.Blink, VOLUME_EXTENSION, ListEntry); } delta = 0; while (!IsListEmpty(&diffAreaFile->UnusedAllocationList)) { l = diffAreaFile->UnusedAllocationList.Flink; diffAreaFileAllocation = CONTAINING_RECORD(l, DIFF_AREA_FILE_ALLOCATION, ListEntry); remainder = BLOCK_SIZE - (diffAreaFileAllocation->Offset&(BLOCK_SIZE - 1)); if (remainder < BLOCK_SIZE) { if (diffAreaFileAllocation->Length < remainder) { delta += diffAreaFileAllocation->Length; RemoveEntryList(l); ExFreePool(diffAreaFileAllocation); continue; } delta += remainder; diffAreaFileAllocation->Offset += remainder; diffAreaFileAllocation->Length -= remainder; } for (;;) { if (diffAreaFileAllocation->Length < BLOCK_SIZE) { delta += diffAreaFileAllocation->Length; RemoveEntryList(l); ExFreePool(diffAreaFileAllocation); break; } if (targetExtension) { bitToCheck = (ULONG) (diffAreaFileAllocation->Offset>>BLOCK_SHIFT); KeAcquireSpinLock(&targetExtension->SpinLock, &irql); if (!RtlCheckBit(targetExtension->VolumeBlockBitmap, bitToCheck)) { KeReleaseSpinLock(&targetExtension->SpinLock, irql); delta += BLOCK_SIZE; diffAreaFileAllocation->Offset += BLOCK_SIZE; diffAreaFileAllocation->Length -= BLOCK_SIZE; continue; } KeReleaseSpinLock(&targetExtension->SpinLock, irql); } targetOffset = diffAreaFileAllocation->Offset; diffAreaFileAllocation->Offset += BLOCK_SIZE; diffAreaFileAllocation->Length -= BLOCK_SIZE; break; } if (targetOffset) { break; } } if (!targetOffset) { continue; } if (diffAreaFile->NextAvailable + delta + BLOCK_SIZE + Extension->DiffAreaFileIncrease <= diffAreaFile->AllocatedFileSize) { break; } if (diffAreaFile->NextAvailable + Extension->DiffAreaFileIncrease > diffAreaFile->AllocatedFileSize) { break; } if (!Extension->OkToGrowDiffArea) { VspLogError(Extension, diffAreaFile->Filter, VS_GROW_BEFORE_FREE_SPACE, STATUS_SUCCESS, 0); break; } context = VspAllocateContext(Extension->Root); if (!context) { break; } context->Type = VSP_CONTEXT_TYPE_GROW_DIFF_AREA; context->GrowDiffArea.Extension = Extension; context->GrowDiffArea.DiffAreaFile = diffAreaFile; ObReferenceObject(Extension->DeviceObject); ExInitializeWorkItem(&context->WorkItem, VspGrowDiffArea, context); VspQueueWorkItem(Extension->Root, &context->WorkItem, 0); break; } if (NT_SUCCESS(status)) { *DiffAreaFile = diffAreaFile; if (TargetOffset) { *TargetOffset = targetOffset; } diffAreaFile->NextAvailable += delta + BLOCK_SIZE; KeAcquireSpinLock(&filter->SpinLock, &irql); filter->UsedVolumeSpace += delta + BLOCK_SIZE; KeReleaseSpinLock(&filter->SpinLock, irql); } return status; } VOID VspDecrementVolumeIrpRefCount( IN PVOID Irp ) { PIRP irp = (PIRP) Irp; PIO_STACK_LOCATION nextSp = IoGetNextIrpStackLocation(irp); PIO_STACK_LOCATION irpSp; PVOLUME_EXTENSION extension; if (InterlockedDecrement((PLONG) &nextSp->Parameters.Read.Length)) { return; } irpSp = IoGetCurrentIrpStackLocation(irp); extension = (PVOLUME_EXTENSION) irpSp->DeviceObject->DeviceExtension; ASSERT(extension->DeviceExtensionType == DEVICE_EXTENSION_VOLUME); IoCompleteRequest(irp, IO_DISK_INCREMENT); VspDecrementVolumeRefCount(extension); } VOID VspDecrementIrpRefCount( IN PVOID Irp ) { PIRP irp = (PIRP) Irp; PIO_STACK_LOCATION nextSp = IoGetNextIrpStackLocation(irp); PIO_STACK_LOCATION irpSp; PFILTER_EXTENSION filter; PVOLUME_EXTENSION extension; PLIST_ENTRY l; PVSP_DIFF_AREA_FILE diffAreaFile; if (InterlockedDecrement((PLONG) &nextSp->Parameters.Read.Length)) { return; } irpSp = IoGetCurrentIrpStackLocation(irp); filter = (PFILTER_EXTENSION) irpSp->DeviceObject->DeviceExtension; ASSERT(filter->DeviceExtensionType == DEVICE_EXTENSION_FILTER); extension = CONTAINING_RECORD(filter->VolumeList.Blink, VOLUME_EXTENSION, ListEntry); for (l = extension->ListOfDiffAreaFiles.Flink; l != &extension->ListOfDiffAreaFiles; l = l->Flink) { diffAreaFile = CONTAINING_RECORD(l, VSP_DIFF_AREA_FILE, VolumeListEntry); VspDecrementRefCount(diffAreaFile->Filter); } IoCopyCurrentIrpStackLocationToNext(irp); IoSetCompletionRoutine(irp, VspRefCountCompletionRoutine, filter, TRUE, TRUE, TRUE); IoCallDriver(filter->TargetObject, irp); } VOID VspDecrementIrpRefCountWorker( IN PVOID Context ) { PVSP_CONTEXT context = (PVSP_CONTEXT) Context; PVOLUME_EXTENSION extension = context->Extension.Extension; PIRP irp = context->Extension.Irp; if (context->Type == VSP_CONTEXT_TYPE_WRITE_VOLUME) { ExInitializeWorkItem(&context->WorkItem, VspWriteVolume, context); VspAcquireNonPagedResource(extension, &context->WorkItem); } else { ASSERT(context->Type == VSP_CONTEXT_TYPE_EXTENSION); VspFreeContext(extension->Root, context); } VspDecrementIrpRefCount(irp); } VOID VspSignalCallback( IN PFILTER_EXTENSION Filter ) { KeSetEvent((PKEVENT) Filter->ZeroRefContext, IO_NO_INCREMENT, FALSE); } VOID VspCleanupVolumeSnapshot( IN PVOLUME_EXTENSION Extension, IN OUT PLIST_ENTRY ListOfDiffAreaFilesToClose ) /*++ Routine Description: This routine kills an existing volume snapshot. Arguments: Extension - Supplies the volume extension. Return Value: NTSTATUS Notes: Root->Semaphore required for calling this routine. --*/ { PFILTER_EXTENSION filter = Extension->Filter; PLIST_ENTRY l, ll; PVSP_DIFF_AREA_FILE diffAreaFile; KIRQL irql; POLD_HEAP_ENTRY oldHeapEntry; NTSTATUS status; PDIFF_AREA_FILE_ALLOCATION diffAreaFileAllocation; PVOID p; VspAcquirePagedResource(Extension, NULL); if (Extension->DiffAreaFileMap) { status = ZwUnmapViewOfSection(Extension->DiffAreaFileMapProcess, Extension->DiffAreaFileMap); ASSERT(NT_SUCCESS(status)); Extension->DiffAreaFileMap = NULL; } if (Extension->NextDiffAreaFileMap) { status = ZwUnmapViewOfSection(Extension->DiffAreaFileMapProcess, Extension->NextDiffAreaFileMap); ASSERT(NT_SUCCESS(status)); Extension->NextDiffAreaFileMap = NULL; } while (!IsListEmpty(&Extension->OldHeaps)) { l = RemoveHeadList(&Extension->OldHeaps); oldHeapEntry = CONTAINING_RECORD(l, OLD_HEAP_ENTRY, ListEntry); status = ZwUnmapViewOfSection(Extension->DiffAreaFileMapProcess, oldHeapEntry->DiffAreaFileMap); ASSERT(NT_SUCCESS(status)); ExFreePool(oldHeapEntry); } VspReleasePagedResource(Extension); VspCleanupBitsSetInOtherPreparedSnapshots(Extension); while (!IsListEmpty(&Extension->ListOfDiffAreaFiles)) { l = RemoveHeadList(&Extension->ListOfDiffAreaFiles); diffAreaFile = CONTAINING_RECORD(l, VSP_DIFF_AREA_FILE, VolumeListEntry); if (diffAreaFile->FilterListEntryBeingUsed) { RemoveEntryList(&diffAreaFile->FilterListEntry); diffAreaFile->FilterListEntryBeingUsed = FALSE; } KeAcquireSpinLock(&filter->SpinLock, &irql); filter->AllocatedVolumeSpace -= diffAreaFile->AllocatedFileSize; filter->UsedVolumeSpace -= diffAreaFile->NextAvailable; KeReleaseSpinLock(&filter->SpinLock, irql); while (!IsListEmpty(&diffAreaFile->UnusedAllocationList)) { ll = RemoveHeadList(&diffAreaFile->UnusedAllocationList); diffAreaFileAllocation = CONTAINING_RECORD(ll, DIFF_AREA_FILE_ALLOCATION, ListEntry); ExFreePool(diffAreaFileAllocation); } InsertTailList(ListOfDiffAreaFilesToClose, &diffAreaFile->VolumeListEntry); } Extension->NextDiffAreaFile = NULL; KeAcquireSpinLock(&Extension->SpinLock, &irql); if (Extension->VolumeBlockBitmap) { ExFreePool(Extension->VolumeBlockBitmap->Buffer); ExFreePool(Extension->VolumeBlockBitmap); Extension->VolumeBlockBitmap = NULL; } if (Extension->IgnorableProduct) { ExFreePool(Extension->IgnorableProduct->Buffer); ExFreePool(Extension->IgnorableProduct); Extension->IgnorableProduct = NULL; } KeReleaseSpinLock(&Extension->SpinLock, irql); VspAcquirePagedResource(Extension, NULL); if (Extension->ApplicationInformation) { Extension->ApplicationInformationSize = 0; ExFreePool(Extension->ApplicationInformation); Extension->ApplicationInformation = NULL; } VspReleasePagedResource(Extension); if (Extension->EmergencyCopyIrp) { ExFreePool(MmGetMdlVirtualAddress( Extension->EmergencyCopyIrp->MdlAddress)); IoFreeMdl(Extension->EmergencyCopyIrp->MdlAddress); IoFreeIrp(Extension->EmergencyCopyIrp); Extension->EmergencyCopyIrp = NULL; } VspDeleteWorkerThread(filter->Root); } VOID VspEmptyIrpQueue( IN PDRIVER_OBJECT DriverObject, IN PLIST_ENTRY IrpQueue ) { PLIST_ENTRY l; PIRP irp; PIO_STACK_LOCATION irpSp; while (!IsListEmpty(IrpQueue)) { l = RemoveHeadList(IrpQueue); irp = CONTAINING_RECORD(l, IRP, Tail.Overlay.ListEntry); irpSp = IoGetCurrentIrpStackLocation(irp); DriverObject->MajorFunction[irpSp->MajorFunction](irpSp->DeviceObject, irp); } } VOID VspEmptyWorkerQueue( IN PLIST_ENTRY WorkerQueue ) { PLIST_ENTRY l; PWORK_QUEUE_ITEM workItem; while (!IsListEmpty(WorkerQueue)) { l = RemoveHeadList(WorkerQueue); workItem = CONTAINING_RECORD(l, WORK_QUEUE_ITEM, List); workItem->WorkerRoutine(workItem->Parameter); } } VOID VspResumeSnapshotIo( IN PVOLUME_EXTENSION Extension ) { KIRQL irql; BOOLEAN emptyQueue, eQQ; LIST_ENTRY q, qq; KeAcquireSpinLock(&Extension->SpinLock, &irql); if (IsListEmpty(&Extension->HoldIrpQueue)) { emptyQueue = FALSE; } else { emptyQueue = TRUE; q = Extension->HoldIrpQueue; InitializeListHead(&Extension->HoldIrpQueue); } if (IsListEmpty(&Extension->HoldWorkerQueue)) { eQQ = FALSE; } else { eQQ = TRUE; qq = Extension->HoldWorkerQueue; InitializeListHead(&Extension->HoldWorkerQueue); } InterlockedIncrement(&Extension->RefCount); InterlockedExchange(&Extension->HoldIncomingRequests, FALSE); KeReleaseSpinLock(&Extension->SpinLock, irql); if (emptyQueue) { q.Blink->Flink = &q; q.Flink->Blink = &q; VspEmptyIrpQueue(Extension->Root->DriverObject, &q); } if (eQQ) { qq.Blink->Flink = &qq; qq.Flink->Blink = &qq; VspEmptyWorkerQueue(&qq); } } VOID VspPauseSnapshotIo( IN PVOLUME_EXTENSION Extension ) { KIRQL irql; VspReleaseWrites(Extension->Filter); KeAcquireSpinLock(&Extension->SpinLock, &irql); ASSERT(!Extension->HoldIncomingRequests); KeInitializeEvent(&Extension->ZeroRefEvent, NotificationEvent, FALSE); InterlockedExchange(&Extension->HoldIncomingRequests, TRUE); KeReleaseSpinLock(&Extension->SpinLock, irql); VspDecrementVolumeRefCount(Extension); KeWaitForSingleObject(&Extension->ZeroRefEvent, Executive, KernelMode, FALSE, NULL); } VOID VspResumeVolumeIo( IN PFILTER_EXTENSION Filter ) { KIRQL irql; BOOLEAN emptyQueue; LIST_ENTRY q; KeAcquireSpinLock(&Filter->SpinLock, &irql); InterlockedIncrement(&Filter->RefCount); InterlockedExchange(&Filter->HoldIncomingWrites, FALSE); if (IsListEmpty(&Filter->HoldQueue)) { emptyQueue = FALSE; } else { emptyQueue = TRUE; q = Filter->HoldQueue; InitializeListHead(&Filter->HoldQueue); } KeReleaseSpinLock(&Filter->SpinLock, irql); if (emptyQueue) { q.Blink->Flink = &q; q.Flink->Blink = &q; VspEmptyIrpQueue(Filter->Root->DriverObject, &q); } } VOID VspPauseVolumeIo( IN PFILTER_EXTENSION Filter ) { KEVENT event; KIRQL irql; KeInitializeEvent(&event, NotificationEvent, FALSE); KeAcquireSpinLock(&Filter->SpinLock, &irql); ASSERT(!Filter->HoldIncomingWrites); InterlockedExchange(&Filter->HoldIncomingWrites, TRUE); Filter->ZeroRefCallback = VspSignalCallback; Filter->ZeroRefContext = &event; KeReleaseSpinLock(&Filter->SpinLock, irql); VspDecrementRefCount(Filter); KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL); } NTSTATUS VspDeleteOldestSnapshot( IN PFILTER_EXTENSION Filter, IN OUT PLIST_ENTRY ListOfDiffAreaFilesToClose, IN OUT PLIST_ENTRY LisfOfDeviceObjectsToDelete ) /*++ Routine Description: This routine deletes the oldest volume snapshot on the given volume. Arguments: Filter - Supplies the filter extension. Return Value: NTSTATUS Notes: This routine assumes that Root->Semaphore is being held. --*/ { PFILTER_EXTENSION filter = Filter; PLIST_ENTRY l; PVOLUME_EXTENSION extension; KIRQL irql; if (IsListEmpty(&filter->VolumeList)) { return STATUS_INVALID_PARAMETER; } l = filter->VolumeList.Flink; extension = CONTAINING_RECORD(l, VOLUME_EXTENSION, ListEntry); KeAcquireSpinLock(&extension->SpinLock, &irql); InterlockedExchange(&extension->IsDead, TRUE); InterlockedExchange(&extension->IsStarted, FALSE); KeReleaseSpinLock(&extension->SpinLock, irql); VspPauseSnapshotIo(extension); VspResumeSnapshotIo(extension); VspPauseVolumeIo(filter); ObReferenceObject(extension->DeviceObject); KeAcquireSpinLock(&filter->SpinLock, &irql); RemoveEntryList(&extension->ListEntry); if (IsListEmpty(&filter->VolumeList)) { InterlockedExchange(&filter->SnapshotsPresent, FALSE); } KeReleaseSpinLock(&filter->SpinLock, irql); VspResumeVolumeIo(filter); VspCleanupVolumeSnapshot(extension, ListOfDiffAreaFilesToClose); if (extension->AliveToPnp) { InsertTailList(&filter->DeadVolumeList, &extension->ListEntry); IoInvalidateDeviceRelations(filter->Pdo, BusRelations); } else { IoDeleteDevice(extension->DeviceObject); } InsertTailList(LisfOfDeviceObjectsToDelete, &extension->HoldIrpQueue); return STATUS_SUCCESS; } VOID VspCloseDiffAreaFiles( IN PLIST_ENTRY ListOfDiffAreaFilesToClose, IN PLIST_ENTRY ListOfDeviceObjectsToDelete ) { PLIST_ENTRY l; PVSP_DIFF_AREA_FILE diffAreaFile; PVOLUME_EXTENSION extension; while (!IsListEmpty(ListOfDiffAreaFilesToClose)) { l = RemoveHeadList(ListOfDiffAreaFilesToClose); diffAreaFile = CONTAINING_RECORD(l, VSP_DIFF_AREA_FILE, VolumeListEntry); ZwClose(diffAreaFile->FileHandle); ExFreePool(diffAreaFile); } while (!IsListEmpty(ListOfDeviceObjectsToDelete)) { l = RemoveHeadList(ListOfDeviceObjectsToDelete); extension = CONTAINING_RECORD(l, VOLUME_EXTENSION, HoldIrpQueue); ObDereferenceObject(extension->DeviceObject); } } VOID VspDestroyAllSnapshotsWorker( IN PVOID Context ) /*++ Routine Description: This routine will delete all of the snapshots in the system. Arguments: Filter - Supplies the filter extension. Return Value: None. --*/ { PVSP_CONTEXT context = (PVSP_CONTEXT) Context; PFILTER_EXTENSION filter = context->Filter.Filter; LIST_ENTRY listOfDiffAreaFilesToClose; LIST_ENTRY listOfDeviceObjectToDelete; KeWaitForSingleObject(&filter->EndCommitProcessCompleted, Executive, KernelMode, FALSE, NULL); InitializeListHead(&listOfDiffAreaFilesToClose); InitializeListHead(&listOfDeviceObjectToDelete); VspAcquire(filter->Root); while (!IsListEmpty(&filter->VolumeList)) { VspDeleteOldestSnapshot(filter, &listOfDiffAreaFilesToClose, &listOfDeviceObjectToDelete); } InterlockedExchange(&filter->DestroyAllSnapshotsPending, FALSE); VspRelease(filter->Root); VspCloseDiffAreaFiles(&listOfDiffAreaFilesToClose, &listOfDeviceObjectToDelete); ObDereferenceObject(filter->DeviceObject); } VOID VspAbortTableEntryWorker( IN PVOID TableEntry ) { PTEMP_TRANSLATION_TABLE_ENTRY tableEntry = (PTEMP_TRANSLATION_TABLE_ENTRY) TableEntry; PVOLUME_EXTENSION extension = tableEntry->Extension; RtlDeleteElementGenericTable(&extension->TempVolumeBlockTable, tableEntry); VspReleaseNonPagedResource(extension); ObDereferenceObject(extension->Filter->DeviceObject); ObDereferenceObject(extension->DeviceObject); } VOID VspDestroyAllSnapshots( IN PFILTER_EXTENSION Filter, IN PTEMP_TRANSLATION_TABLE_ENTRY TableEntry ) /*++ Routine Description: This routine will delete all of the snapshots in the system. Arguments: Filter - Supplies the filter extension. Return Value: None. --*/ { PVOLUME_EXTENSION extension; PIRP irp; KIRQL irql; PWORK_QUEUE_ITEM workItem; NTSTATUS status; PVSP_CONTEXT context; if (TableEntry) { extension = TableEntry->Extension; irp = TableEntry->WriteIrp; TableEntry->WriteIrp = NULL; if (TableEntry->CopyIrp) { VspFreeCopyIrp(extension, TableEntry->CopyIrp); TableEntry->CopyIrp = NULL; } KeAcquireSpinLock(&extension->SpinLock, &irql); RtlSetBit(extension->VolumeBlockBitmap, (ULONG) (TableEntry->VolumeOffset>>BLOCK_SHIFT)); TableEntry->IsComplete = TRUE; KeReleaseSpinLock(&extension->SpinLock, irql); VspEmptyWorkerQueue(&TableEntry->WaitingQueueDpc); ObReferenceObject(extension->DeviceObject); ObReferenceObject(extension->Filter->DeviceObject); if (irp) { VspDecrementIrpRefCount(irp); } workItem = &TableEntry->WorkItem; ExInitializeWorkItem(workItem, VspAbortTableEntryWorker, TableEntry); VspAcquireNonPagedResource(extension, workItem); } if (InterlockedExchange(&Filter->DestroyAllSnapshotsPending, TRUE)) { return; } context = &Filter->DestroyContext; context->Type = VSP_CONTEXT_TYPE_FILTER; context->Filter.Filter = Filter; ObReferenceObject(Filter->DeviceObject); ExInitializeWorkItem(&context->WorkItem, VspDestroyAllSnapshotsWorker, context); VspQueueWorkItem(Filter->Root, &context->WorkItem, 0); } VOID VspWriteVolumePhase5( IN PVOID TableEntry ) { PTEMP_TRANSLATION_TABLE_ENTRY tableEntry = (PTEMP_TRANSLATION_TABLE_ENTRY) TableEntry; PVOLUME_EXTENSION extension = tableEntry->Extension; RtlDeleteElementGenericTable(&extension->TempVolumeBlockTable, tableEntry); VspReleaseNonPagedResource(extension); VspDecrementVolumeRefCount(extension); } VOID VspWriteVolumePhase4( IN PVOID TableEntry ) /*++ Routine Description: This routine is queued from the completion of writting a block to make up a table entry for the write. This routine will create and insert the table entry. Arguments: Context - Supplies the context. Return Value: None. --*/ { PTEMP_TRANSLATION_TABLE_ENTRY tableEntry = (PTEMP_TRANSLATION_TABLE_ENTRY) TableEntry; PVOLUME_EXTENSION extension = tableEntry->Extension; PFILTER_EXTENSION filter = extension->Filter; TRANSLATION_TABLE_ENTRY keyTableEntry; PVOID r; KIRQL irql; RtlZeroMemory(&keyTableEntry, sizeof(TRANSLATION_TABLE_ENTRY)); keyTableEntry.VolumeOffset = tableEntry->VolumeOffset; keyTableEntry.TargetObject = tableEntry->TargetObject; keyTableEntry.TargetOffset = tableEntry->TargetOffset; _try { r = RtlInsertElementGenericTable(&extension->VolumeBlockTable, &keyTableEntry, sizeof(TRANSLATION_TABLE_ENTRY), NULL); } _except (EXCEPTION_EXECUTE_HANDLER) { r = NULL; } VspReleasePagedResource(extension); if (!r) { KeAcquireSpinLock(&extension->SpinLock, &irql); if (extension->PageFileSpaceCreatePending) { ExInitializeWorkItem(&tableEntry->WorkItem, VspWriteVolumePhase4, tableEntry); InsertTailList(&extension->WaitingForPageFileSpace, &tableEntry->WorkItem.List); KeReleaseSpinLock(&extension->SpinLock, irql); return; } KeReleaseSpinLock(&extension->SpinLock, irql); if (!filter->DestroyAllSnapshotsPending) { VspLogError(extension, NULL, VS_ABORT_SNAPSHOTS_NO_HEAP, STATUS_SUCCESS, 0); } VspDestroyAllSnapshots(filter, tableEntry); VspDecrementVolumeRefCount(extension); return; } ExInitializeWorkItem(&tableEntry->WorkItem, VspWriteVolumePhase5, tableEntry); VspAcquireNonPagedResource(extension, &tableEntry->WorkItem); } VOID VspWriteVolumeRefCount( IN PVOID TableEntry ) { PTEMP_TRANSLATION_TABLE_ENTRY tableEntry = (PTEMP_TRANSLATION_TABLE_ENTRY) TableEntry; PVOLUME_EXTENSION extension = tableEntry->Extension; PWORK_QUEUE_ITEM workItem; NTSTATUS status; workItem = &tableEntry->WorkItem; status = VspIncrementVolumeRefCount(extension, NULL, workItem); if (!NT_SUCCESS(status)) { VspDestroyAllSnapshots(extension->Filter, tableEntry); return; } if (status == STATUS_PENDING) { return; } ExInitializeWorkItem(&tableEntry->WorkItem, VspWriteVolumePhase4, tableEntry); VspAcquirePagedResource(extension, &tableEntry->WorkItem); } NTSTATUS VspWriteVolumePhase3( IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID TableEntry ) /*++ Routine Description: This routine is the completion for a write to the diff area file. Arguments: Context - Supplies the context. Return Value: STATUS_MORE_PROCESSING_REQUIRED --*/ { PTEMP_TRANSLATION_TABLE_ENTRY tableEntry = (PTEMP_TRANSLATION_TABLE_ENTRY) TableEntry; PVOLUME_EXTENSION extension = tableEntry->Extension; PFILTER_EXTENSION filter = extension->Filter; NTSTATUS status = Irp->IoStatus.Status; KIRQL irql; BOOLEAN emptyQueue; PLIST_ENTRY l; PWORK_QUEUE_ITEM workItem; PVSP_CONTEXT context; PIRP irp; if (!NT_SUCCESS(status)) { if (!filter->DestroyAllSnapshotsPending) { VspLogError(extension, NULL, VS_ABORT_SNAPSHOTS_IO_FAILURE, status, 1); } VspDestroyAllSnapshots(filter, tableEntry); return STATUS_MORE_PROCESSING_REQUIRED; } VspFreeCopyIrp(extension, Irp); tableEntry->CopyIrp = NULL; KeAcquireSpinLock(&extension->SpinLock, &irql); RtlSetBit(extension->VolumeBlockBitmap, (ULONG) (tableEntry->VolumeOffset>>BLOCK_SHIFT)); tableEntry->IsComplete = TRUE; KeReleaseSpinLock(&extension->SpinLock, irql); while (!IsListEmpty(&tableEntry->WaitingQueueDpc)) { l = RemoveHeadList(&tableEntry->WaitingQueueDpc); workItem = CONTAINING_RECORD(l, WORK_QUEUE_ITEM, List); context = (PVSP_CONTEXT) workItem->Parameter; if (context->Type == VSP_CONTEXT_TYPE_READ_SNAPSHOT) { context->ReadSnapshot.TargetObject = tableEntry->TargetObject; context->ReadSnapshot.TargetOffset = tableEntry->TargetOffset; } workItem->WorkerRoutine(workItem->Parameter); } irp = tableEntry->WriteIrp; tableEntry->WriteIrp = NULL; ExInitializeWorkItem(&tableEntry->WorkItem, VspWriteVolumeRefCount, tableEntry); status = VspIncrementVolumeRefCount(extension, NULL, &tableEntry->WorkItem); if (!NT_SUCCESS(status)) { VspDestroyAllSnapshots(filter, tableEntry); VspDecrementIrpRefCount(irp); return STATUS_MORE_PROCESSING_REQUIRED; } VspDecrementIrpRefCount(irp); if (status != STATUS_PENDING) { ExInitializeWorkItem(&tableEntry->WorkItem, VspWriteVolumePhase4, tableEntry); VspAcquirePagedResource(extension, &tableEntry->WorkItem); } return STATUS_MORE_PROCESSING_REQUIRED; } NTSTATUS VspWriteVolumePhase2( IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID TableEntry ) /*++ Routine Description: This routine is the completion for a read who's data will create the table entry for the block that is being written to. Arguments: Context - Supplies the context. Return Value: STATUS_MORE_PROCESSING_REQUIRED --*/ { NTSTATUS status = Irp->IoStatus.Status; PIO_STACK_LOCATION nextSp = IoGetNextIrpStackLocation(Irp); PTEMP_TRANSLATION_TABLE_ENTRY tableEntry = (PTEMP_TRANSLATION_TABLE_ENTRY) TableEntry; if (!NT_SUCCESS(status)) { if (!tableEntry->Extension->Filter->DestroyAllSnapshotsPending) { VspLogError(tableEntry->Extension, NULL, VS_ABORT_SNAPSHOTS_IO_FAILURE, status, 2); } VspDestroyAllSnapshots(tableEntry->Extension->Filter, tableEntry); return STATUS_MORE_PROCESSING_REQUIRED; } Irp->Tail.Overlay.Thread = PsGetCurrentThread(); nextSp = IoGetNextIrpStackLocation(Irp); nextSp->Parameters.Write.ByteOffset.QuadPart = tableEntry->TargetOffset; nextSp->Parameters.Write.Length = BLOCK_SIZE; nextSp->MajorFunction = IRP_MJ_WRITE; nextSp->DeviceObject = tableEntry->TargetObject; nextSp->Flags = SL_OVERRIDE_VERIFY_VOLUME; IoSetCompletionRoutine(Irp, VspWriteVolumePhase3, tableEntry, TRUE, TRUE, TRUE); IoCallDriver(tableEntry->TargetObject, Irp); return STATUS_MORE_PROCESSING_REQUIRED; } VOID VspWriteVolumePhase1( IN PVOID TableEntry ) /*++ Routine Description: This routine is the first phase of copying volume data to the diff area file. An irp and buffer are created for the initial read of the block. Arguments: Context - Supplies the context. Return Value: None. --*/ { PTEMP_TRANSLATION_TABLE_ENTRY tableEntry = (PTEMP_TRANSLATION_TABLE_ENTRY) TableEntry; PVOLUME_EXTENSION extension = tableEntry->Extension; PFILTER_EXTENSION filter = extension->Filter; PIRP irp = tableEntry->CopyIrp; PIO_STACK_LOCATION nextSp; irp->Tail.Overlay.Thread = PsGetCurrentThread(); nextSp = IoGetNextIrpStackLocation(irp); nextSp->Parameters.Read.ByteOffset.QuadPart = tableEntry->VolumeOffset; nextSp->Parameters.Read.Length = BLOCK_SIZE; nextSp->MajorFunction = IRP_MJ_READ; nextSp->DeviceObject = filter->TargetObject; nextSp->Flags = SL_OVERRIDE_VERIFY_VOLUME; if (tableEntry->VolumeOffset + BLOCK_SIZE > extension->VolumeSize) { if (extension->VolumeSize > tableEntry->VolumeOffset) { nextSp->Parameters.Read.Length = (ULONG) (extension->VolumeSize - tableEntry->VolumeOffset); } } IoSetCompletionRoutine(irp, VspWriteVolumePhase2, tableEntry, TRUE, TRUE, TRUE); IoCallDriver(filter->TargetObject, irp); } VOID VspUnmapNextDiffAreaFileMap( IN PVOID Context ) { PVSP_CONTEXT context = (PVSP_CONTEXT) Context; PVOLUME_EXTENSION extension = context->Extension.Extension; NTSTATUS status; ASSERT(context->Type == VSP_CONTEXT_TYPE_EXTENSION); VspFreeContext(extension->Root, context); if (extension->NextDiffAreaFileMap) { status = ZwUnmapViewOfSection(extension->DiffAreaFileMapProcess, extension->NextDiffAreaFileMap); ASSERT(NT_SUCCESS(status)); extension->NextDiffAreaFileMap = NULL; } VspReleasePagedResource(extension); ObDereferenceObject(extension->Filter->DeviceObject); ObDereferenceObject(extension->DeviceObject); } NTSTATUS VspTruncatePreviousDiffArea( IN PVOLUME_EXTENSION Extension ) /*++ Routine Description: This routine takes the snapshot that occurred before this one and truncates its diff area file to the current used size since diff area files can't grow after a new snapshot is added on top. Arguments: Extension - Supplies the volume extension. Return Value: NTSTATUS --*/ { PFILTER_EXTENSION filter = Extension->Filter; PLIST_ENTRY l, ll; PVOLUME_EXTENSION extension; PVSP_DIFF_AREA_FILE diffAreaFile; NTSTATUS status; LONGLONG diff; KIRQL irql; PDIFF_AREA_FILE_ALLOCATION diffAreaFileAllocation; PVSP_CONTEXT context; l = Extension->ListEntry.Blink; if (l == &filter->VolumeList) { return STATUS_SUCCESS; } extension = CONTAINING_RECORD(l, VOLUME_EXTENSION, ListEntry); for (l = extension->ListOfDiffAreaFiles.Flink; l != &extension->ListOfDiffAreaFiles; l = l->Flink) { diffAreaFile = CONTAINING_RECORD(l, VSP_DIFF_AREA_FILE, VolumeListEntry); status = VspSetFileSizes(diffAreaFile->FileHandle, diffAreaFile->NextAvailable); if (NT_SUCCESS(status)) { VspAcquireNonPagedResource(extension, NULL); diff = diffAreaFile->AllocatedFileSize - diffAreaFile->NextAvailable; diffAreaFile->AllocatedFileSize -= diff; VspReleaseNonPagedResource(extension); KeAcquireSpinLock(&filter->SpinLock, &irql); filter->AllocatedVolumeSpace -= diff; KeReleaseSpinLock(&filter->SpinLock, irql); } while (!IsListEmpty(&diffAreaFile->UnusedAllocationList)) { ll = RemoveHeadList(&diffAreaFile->UnusedAllocationList); diffAreaFileAllocation = CONTAINING_RECORD(ll, DIFF_AREA_FILE_ALLOCATION, ListEntry); ExFreePool(diffAreaFileAllocation); } } if (extension->EmergencyCopyIrp) { ExFreePool(MmGetMdlVirtualAddress( extension->EmergencyCopyIrp->MdlAddress)); IoFreeMdl(extension->EmergencyCopyIrp->MdlAddress); IoFreeIrp(extension->EmergencyCopyIrp); extension->EmergencyCopyIrp = NULL; } context = VspAllocateContext(Extension->Root); if (context) { context->Type = VSP_CONTEXT_TYPE_EXTENSION; context->Extension.Extension = extension; ExInitializeWorkItem(&context->WorkItem, VspUnmapNextDiffAreaFileMap, context); ObReferenceObject(extension->DeviceObject); ObReferenceObject(extension->Filter->DeviceObject); VspAcquirePagedResource(extension, &context->WorkItem); } return STATUS_SUCCESS; } VOID VspOrBitmaps( IN OUT PRTL_BITMAP BaseBitmap, IN PRTL_BITMAP FactorBitmap ) { ULONG n, i; PULONG p, q; n = (BaseBitmap->SizeOfBitMap + 8*sizeof(ULONG) - 1)/(8*sizeof(ULONG)); p = BaseBitmap->Buffer; q = FactorBitmap->Buffer; for (i = 0; i < n; i++) { *p++ |= *q++; } } VOID VspAdjustBitmap( IN PVOID Context ) { PVSP_CONTEXT context = (PVSP_CONTEXT) Context; PVOLUME_EXTENSION extension = context->Extension.Extension; NTSTATUS status; KIRQL irql; PLIST_ENTRY l; PWORK_QUEUE_ITEM workItem; PWORKER_THREAD_ROUTINE workerRoutine; PVOID parameter; ASSERT(context->Type == VSP_CONTEXT_TYPE_EXTENSION); VspFreeContext(extension->Root, context); status = VspComputeIgnorableProduct(extension); KeAcquireSpinLock(&extension->SpinLock, &irql); if (extension->IgnorableProduct) { if (NT_SUCCESS(status) && extension->VolumeBlockBitmap) { VspOrBitmaps(extension->VolumeBlockBitmap, extension->IgnorableProduct); } ExFreePool(extension->IgnorableProduct->Buffer); ExFreePool(extension->IgnorableProduct); extension->IgnorableProduct = NULL; } KeReleaseSpinLock(&extension->SpinLock, irql); KeAcquireSpinLock(&extension->Root->ESpinLock, &irql); ASSERT(extension->Root->AdjustBitmapInProgress); if (IsListEmpty(&extension->Root->AdjustBitmapQueue)) { extension->Root->AdjustBitmapInProgress = FALSE; KeReleaseSpinLock(&extension->Root->ESpinLock, irql); } else { l = RemoveHeadList(&extension->Root->AdjustBitmapQueue); KeReleaseSpinLock(&extension->Root->ESpinLock, irql); workItem = CONTAINING_RECORD(l, WORK_QUEUE_ITEM, List); workerRoutine = workItem->WorkerRoutine; parameter = workItem->Parameter; ExInitializeWorkItem(workItem, workerRoutine, parameter); ExQueueWorkItem(workItem, DelayedWorkQueue); } ObDereferenceObject(extension->Filter->DeviceObject); ObDereferenceObject(extension->DeviceObject); } VOID VspSetIgnorableBlocksInBitmapWorker( IN PVOID Context ) { PVSP_CONTEXT context = (PVSP_CONTEXT) Context; PVOLUME_EXTENSION extension = context->Extension.Extension; NTSTATUS status; KIRQL irql; ASSERT(context->Type == VSP_CONTEXT_TYPE_EXTENSION); status = VspSetIgnorableBlocksInBitmap(extension); if (NT_SUCCESS(status)) { InterlockedExchange(&extension->OkToGrowDiffArea, TRUE); } else { if (!extension->Filter->DestroyAllSnapshotsPending) { VspLogError(extension, NULL, VS_ABORT_SNAPSHOTS_FAILED_FREE_SPACE_DETECTION, status, 0); } VspDestroyAllSnapshots(extension->Filter, NULL); } KeSetEvent(&extension->Filter->EndCommitProcessCompleted, IO_NO_INCREMENT, FALSE); ExInitializeWorkItem(&context->WorkItem, VspAdjustBitmap, context); KeAcquireSpinLock(&extension->Root->ESpinLock, &irql); if (extension->Root->AdjustBitmapInProgress) { InsertTailList(&extension->Root->AdjustBitmapQueue, &context->WorkItem.List); KeReleaseSpinLock(&extension->Root->ESpinLock, irql); } else { extension->Root->AdjustBitmapInProgress = TRUE; KeReleaseSpinLock(&extension->Root->ESpinLock, irql); ExQueueWorkItem(&context->WorkItem, DelayedWorkQueue); } } VOID VspFreeCopyIrp( IN PVOLUME_EXTENSION Extension, IN PIRP CopyIrp ) { KIRQL irql; PLIST_ENTRY l; PWORK_QUEUE_ITEM workItem; PTEMP_TRANSLATION_TABLE_ENTRY tableEntry; if (Extension->EmergencyCopyIrp == CopyIrp) { KeAcquireSpinLock(&Extension->SpinLock, &irql); if (IsListEmpty(&Extension->EmergencyCopyIrpQueue)) { Extension->EmergencyCopyIrpInUse = FALSE; KeReleaseSpinLock(&Extension->SpinLock, irql); return; } l = RemoveHeadList(&Extension->EmergencyCopyIrpQueue); KeReleaseSpinLock(&Extension->SpinLock, irql); workItem = CONTAINING_RECORD(l, WORK_QUEUE_ITEM, List); tableEntry = (PTEMP_TRANSLATION_TABLE_ENTRY) workItem->Parameter; tableEntry->CopyIrp = CopyIrp; VspWriteVolumePhase1(tableEntry); return; } if (!Extension->EmergencyCopyIrpInUse) { ExFreePool(MmGetMdlVirtualAddress(CopyIrp->MdlAddress)); IoFreeMdl(CopyIrp->MdlAddress); IoFreeIrp(CopyIrp); return; } KeAcquireSpinLock(&Extension->SpinLock, &irql); if (IsListEmpty(&Extension->EmergencyCopyIrpQueue)) { KeReleaseSpinLock(&Extension->SpinLock, irql); ExFreePool(MmGetMdlVirtualAddress(CopyIrp->MdlAddress)); IoFreeMdl(CopyIrp->MdlAddress); IoFreeIrp(CopyIrp); return; } l = RemoveHeadList(&Extension->EmergencyCopyIrpQueue); KeReleaseSpinLock(&Extension->SpinLock, irql); workItem = CONTAINING_RECORD(l, WORK_QUEUE_ITEM, List); tableEntry = (PTEMP_TRANSLATION_TABLE_ENTRY) workItem->Parameter; tableEntry->CopyIrp = CopyIrp; VspWriteVolumePhase1(tableEntry); } VOID VspApplyThresholdDelta( IN PVOLUME_EXTENSION Extension, IN ULONG IncreaseDelta ) { PLIST_ENTRY l; PVSP_DIFF_AREA_FILE diffAreaFile; PVSP_CONTEXT context; for (l = Extension->ListOfDiffAreaFiles.Flink; l != &Extension->ListOfDiffAreaFiles; l = l->Flink) { diffAreaFile = CONTAINING_RECORD(l, VSP_DIFF_AREA_FILE, VolumeListEntry); if (diffAreaFile->NextAvailable + Extension->DiffAreaFileIncrease <= diffAreaFile->AllocatedFileSize) { continue; } if (diffAreaFile->NextAvailable + Extension->DiffAreaFileIncrease - IncreaseDelta > diffAreaFile->AllocatedFileSize) { continue; } if (!Extension->OkToGrowDiffArea) { VspLogError(Extension, diffAreaFile->Filter, VS_GROW_BEFORE_FREE_SPACE, STATUS_SUCCESS, 0); continue; } context = VspAllocateContext(Extension->Root); if (!context) { continue; } context->Type = VSP_CONTEXT_TYPE_GROW_DIFF_AREA; context->GrowDiffArea.Extension = Extension; context->GrowDiffArea.DiffAreaFile = diffAreaFile; ObReferenceObject(Extension->DeviceObject); ExInitializeWorkItem(&context->WorkItem, VspGrowDiffArea, context); VspQueueWorkItem(Extension->Root, &context->WorkItem, 0); } } VOID VspWriteVolume( IN PVOID Context ) /*++ Routine Description: This routine performs a volume write, making sure that all of the parts of the volume write have an old version of the data placed in the diff area for the snapshot. Arguments: Irp - Supplies the I/O request packet. Return Value: None. --*/ { PVSP_CONTEXT context = (PVSP_CONTEXT) Context; PVOLUME_EXTENSION extension = context->WriteVolume.Extension; PIRP irp = (PIRP) context->WriteVolume.Irp; PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation(irp); PIO_STACK_LOCATION nextSp = IoGetNextIrpStackLocation(irp); PFILTER_EXTENSION filter = extension->Filter; LONGLONG start, end, roundedStart, roundedEnd; ULONG irpLength, increase, increaseDelta; TEMP_TRANSLATION_TABLE_ENTRY keyTableEntry; PTEMP_TRANSLATION_TABLE_ENTRY tableEntry; PVOID nodeOrParent; TABLE_SEARCH_RESULT searchResult; KIRQL irql; NTSTATUS status; CCHAR stackSize; PVSP_DIFF_AREA_FILE diffAreaFile; PDO_EXTENSION rootExtension; PVOID buffer; PMDL mdl; ASSERT(context->Type == VSP_CONTEXT_TYPE_WRITE_VOLUME); start = irpSp->Parameters.Read.ByteOffset.QuadPart; irpLength = irpSp->Parameters.Read.Length; end = start + irpLength; if (context->WriteVolume.RoundedStart) { roundedStart = context->WriteVolume.RoundedStart; } else { roundedStart = start&(~(BLOCK_SIZE - 1)); } roundedEnd = end&(~(BLOCK_SIZE - 1)); if (roundedEnd != end) { roundedEnd += BLOCK_SIZE; } ASSERT(extension->VolumeBlockBitmap); for (; roundedStart < roundedEnd; roundedStart += BLOCK_SIZE) { KeAcquireSpinLock(&extension->SpinLock, &irql); if (RtlCheckBit(extension->VolumeBlockBitmap, (ULONG) (roundedStart>>BLOCK_SHIFT))) { KeReleaseSpinLock(&extension->SpinLock, irql); continue; } KeReleaseSpinLock(&extension->SpinLock, irql); keyTableEntry.VolumeOffset = roundedStart; tableEntry = (PTEMP_TRANSLATION_TABLE_ENTRY) RtlLookupElementGenericTableFull( &extension->TempVolumeBlockTable, &keyTableEntry, &nodeOrParent, &searchResult); if (tableEntry) { context = VspAllocateContext(extension->Root); if (context) { context->Type = VSP_CONTEXT_TYPE_EXTENSION; context->Extension.Extension = extension; context->Extension.Irp = irp; } else { context = (PVSP_CONTEXT) Context; ASSERT(context->Type == VSP_CONTEXT_TYPE_WRITE_VOLUME); context->WriteVolume.RoundedStart = roundedStart; } ExInitializeWorkItem(&context->WorkItem, VspDecrementIrpRefCountWorker, context); KeAcquireSpinLock(&extension->SpinLock, &irql); if (tableEntry->IsComplete) { KeReleaseSpinLock(&extension->SpinLock, irql); if (context->Type == VSP_CONTEXT_TYPE_EXTENSION) { VspFreeContext(extension->Root, context); } continue; } InterlockedIncrement((PLONG) &nextSp->Parameters.Write.Length); InsertTailList(&tableEntry->WaitingQueueDpc, &context->WorkItem.List); KeReleaseSpinLock(&extension->SpinLock, irql); if (context == Context) { VspReleaseNonPagedResource(extension); return; } continue; } RtlZeroMemory(&keyTableEntry, sizeof(TEMP_TRANSLATION_TABLE_ENTRY)); keyTableEntry.VolumeOffset = roundedStart; ASSERT(!extension->TempTableEntry); extension->TempTableEntry = VspAllocateTempTableEntry(extension->Root); if (!extension->TempTableEntry) { rootExtension = extension->Root; KeAcquireSpinLock(&rootExtension->ESpinLock, &irql); if (rootExtension->EmergencyTableEntryInUse) { context = (PVSP_CONTEXT) Context; ASSERT(context->Type == VSP_CONTEXT_TYPE_WRITE_VOLUME); context->WriteVolume.RoundedStart = roundedStart; InsertTailList(&rootExtension->WorkItemWaitingList, &context->WorkItem.List); if (!rootExtension->WorkItemWaitingListNeedsChecking) { InterlockedExchange( &rootExtension->WorkItemWaitingListNeedsChecking, TRUE); } KeReleaseSpinLock(&rootExtension->ESpinLock, irql); VspReleaseNonPagedResource(extension); return; } rootExtension->EmergencyTableEntryInUse = TRUE; KeReleaseSpinLock(&rootExtension->ESpinLock, irql); extension->TempTableEntry = rootExtension->EmergencyTableEntry; } tableEntry = (PTEMP_TRANSLATION_TABLE_ENTRY) RtlInsertElementGenericTableFull( &extension->TempVolumeBlockTable, &keyTableEntry, sizeof(TEMP_TRANSLATION_TABLE_ENTRY), NULL, nodeOrParent, searchResult); ASSERT(tableEntry); if (extension->TempVolumeBlockTable.NumberGenericTableElements > extension->MaximumNumberOfTempEntries) { extension->MaximumNumberOfTempEntries = extension->TempVolumeBlockTable.NumberGenericTableElements; VspQueryDiffAreaFileIncrease(extension, &increase); ASSERT(increase >= extension->DiffAreaFileIncrease); increaseDelta = increase - extension->DiffAreaFileIncrease; if (increaseDelta) { InterlockedExchange((PLONG) &extension->DiffAreaFileIncrease, (LONG) increase); VspApplyThresholdDelta(extension, increaseDelta); } } tableEntry->Extension = extension; tableEntry->WriteIrp = irp; status = VspAllocateDiffAreaSpace(extension, &diffAreaFile, &tableEntry->TargetOffset); if (!NT_SUCCESS(status)) { if (!filter->DestroyAllSnapshotsPending) { VspLogError(extension, NULL, VS_ABORT_SNAPSHOTS_OUT_OF_DIFF_AREA, STATUS_SUCCESS, 0); } RtlDeleteElementGenericTable(&extension->TempVolumeBlockTable, tableEntry); VspDestroyAllSnapshots(filter, NULL); break; } tableEntry->TargetObject = diffAreaFile->Filter->TargetObject; tableEntry->IsComplete = FALSE; InitializeListHead(&tableEntry->WaitingQueueDpc); tableEntry->CopyIrp = IoAllocateIrp( (CCHAR) extension->Root->StackSize, FALSE); buffer = ExAllocatePoolWithTagPriority(NonPagedPool, BLOCK_SIZE, VOLSNAP_TAG_BUFFER, LowPoolPriority); mdl = IoAllocateMdl(buffer, BLOCK_SIZE, FALSE, FALSE, NULL); if (!tableEntry->CopyIrp || !buffer || !mdl) { if (tableEntry->CopyIrp) { IoFreeIrp(tableEntry->CopyIrp); tableEntry->CopyIrp = NULL; } if (buffer) { ExFreePool(buffer); } if (mdl) { IoFreeMdl(mdl); } KeAcquireSpinLock(&extension->SpinLock, &irql); if (extension->EmergencyCopyIrpInUse) { InterlockedIncrement((PLONG) &nextSp->Parameters.Write.Length); ExInitializeWorkItem(&tableEntry->WorkItem, VspWriteVolumePhase1, tableEntry); InsertTailList(&extension->EmergencyCopyIrpQueue, &tableEntry->WorkItem.List); KeReleaseSpinLock(&extension->SpinLock, irql); continue; } extension->EmergencyCopyIrpInUse = TRUE; KeReleaseSpinLock(&extension->SpinLock, irql); tableEntry->CopyIrp = extension->EmergencyCopyIrp; } else { MmBuildMdlForNonPagedPool(mdl); tableEntry->CopyIrp->MdlAddress = mdl; } InterlockedIncrement((PLONG) &nextSp->Parameters.Write.Length); VspWriteVolumePhase1(tableEntry); } context = (PVSP_CONTEXT) Context; VspFreeContext(filter->Root, context); VspReleaseNonPagedResource(extension); VspDecrementIrpRefCount(irp); } VOID VspIrpsTimerDpc( IN PKDPC TimerDpc, IN PVOID Context, IN PVOID SystemArgument1, IN PVOID SystemArgument2 ) { PFILTER_EXTENSION filter = (PFILTER_EXTENSION) Context; KIRQL irql; LIST_ENTRY q; PLIST_ENTRY l; PIRP irp; BOOLEAN emptyQueue; VspLogError(NULL, filter, VS_FLUSH_AND_HOLD_IRP_TIMEOUT, STATUS_SUCCESS, 0); IoStopTimer(filter->DeviceObject); KeAcquireSpinLock(&filter->SpinLock, &irql); InterlockedIncrement(&filter->RefCount); InterlockedExchange(&filter->TimerIsSet, FALSE); InterlockedExchange(&filter->HoldIncomingWrites, FALSE); if (IsListEmpty(&filter->HoldQueue)) { emptyQueue = FALSE; } else { emptyQueue = TRUE; q = filter->HoldQueue; InitializeListHead(&filter->HoldQueue); } KeReleaseSpinLock(&filter->SpinLock, irql); if (emptyQueue) { q.Blink->Flink = &q; q.Flink->Blink = &q; VspEmptyIrpQueue(filter->Root->DriverObject, &q); } } VOID VspEndCommitDpc( IN PKDPC TimerDpc, IN PVOID Context, IN PVOID SystemArgument1, IN PVOID SystemArgument2 ) { PFILTER_EXTENSION filter = (PFILTER_EXTENSION) Context; VspLogError(NULL, filter, VS_END_COMMIT_TIMEOUT, STATUS_CANCELLED, 0); KeSetEvent(&filter->EndCommitProcessCompleted, IO_NO_INCREMENT, FALSE); ObDereferenceObject(filter->DeviceObject); } NTSTATUS VspCheckForMemoryPressure( IN PFILTER_EXTENSION Filter ) /*++ Routine Description: This routine will allocate 256 K of paged and non paged pool. If these allocs succeed, it indicates that the system is not under memory pressure and so it is ok to hold write irps for the next second. Arguments: Filter - Supplies the filter extension. Return Value: NTSTATUS --*/ { PVOID p, np; p = ExAllocatePoolWithTagPriority(PagedPool, MEMORY_PRESSURE_CHECK_ALLOC_SIZE, VOLSNAP_TAG_SHORT_TERM, LowPoolPriority); if (!p) { VspLogError(NULL, Filter, VS_MEMORY_PRESSURE_DURING_LOVELACE, STATUS_INSUFFICIENT_RESOURCES, 1); return STATUS_INSUFFICIENT_RESOURCES; } np = ExAllocatePoolWithTagPriority(NonPagedPool, MEMORY_PRESSURE_CHECK_ALLOC_SIZE, VOLSNAP_TAG_SHORT_TERM, LowPoolPriority); if (!np) { ExFreePool(p); VspLogError(NULL, Filter, VS_MEMORY_PRESSURE_DURING_LOVELACE, STATUS_INSUFFICIENT_RESOURCES, 2); return STATUS_INSUFFICIENT_RESOURCES; } ExFreePool(np); ExFreePool(p); return STATUS_SUCCESS; } VOID VspOneSecondTimerWorker( IN PDEVICE_OBJECT DeviceObject, IN PVOID WorkItem ) { PFILTER_EXTENSION filter = (PFILTER_EXTENSION) DeviceObject->DeviceExtension; PIO_WORKITEM workItem = (PIO_WORKITEM) WorkItem; NTSTATUS status; status = VspCheckForMemoryPressure(filter); if (!NT_SUCCESS(status)) { VspReleaseWrites(filter); } IoFreeWorkItem(workItem); } VOID VspOneSecondTimer( IN PDEVICE_OBJECT DeviceObject, IN PVOID Filter ) /*++ Routine Description: This routine will get called once every second after an IoStartTimer. This routine checks for memory pressure and aborts the lovelace operation if any memory pressure is detected. Arguments: DeviceObject - Supplies the device object. Filter - Supplies the filter extension. Return Value: None. --*/ { PFILTER_EXTENSION filter = (PFILTER_EXTENSION) Filter; PIO_WORKITEM workItem; workItem = IoAllocateWorkItem(filter->DeviceObject); if (!workItem) { VspLogError(NULL, filter, VS_MEMORY_PRESSURE_DURING_LOVELACE, STATUS_INSUFFICIENT_RESOURCES, 3); VspReleaseWrites(filter); return; } IoQueueWorkItem(workItem, VspOneSecondTimerWorker, CriticalWorkQueue, workItem); } NTSTATUS VolSnapAddDevice( IN PDRIVER_OBJECT DriverObject, IN PDEVICE_OBJECT PhysicalDeviceObject ) /*++ Routine Description: This routine creates and initializes a new FILTER for the corresponding volume PDO. Arguments: DriverObject - Supplies the VOLSNAP driver object. PhysicalDeviceObject - Supplies the volume PDO. Return Value: NTSTATUS --*/ { PDEVICE_OBJECT attachedDevice; NTSTATUS status; PDEVICE_OBJECT deviceObject; PDO_EXTENSION rootExtension; PFILTER_EXTENSION filter; PVSP_DIFF_AREA_VOLUME diffAreaVolume; attachedDevice = IoGetAttachedDeviceReference(PhysicalDeviceObject); if (attachedDevice) { if (attachedDevice->Characteristics&FILE_REMOVABLE_MEDIA) { ObDereferenceObject(attachedDevice); return STATUS_SUCCESS; } ObDereferenceObject(attachedDevice); } status = IoCreateDevice(DriverObject, sizeof(FILTER_EXTENSION), NULL, FILE_DEVICE_DISK, 0, FALSE, &deviceObject); if (!NT_SUCCESS(status)) { return status; } rootExtension = (PDO_EXTENSION) IoGetDriverObjectExtension(DriverObject, VolSnapAddDevice); if (!rootExtension) { IoDeleteDevice(deviceObject); return STATUS_NO_SUCH_DEVICE; } filter = (PFILTER_EXTENSION) deviceObject->DeviceExtension; RtlZeroMemory(filter, sizeof(FILTER_EXTENSION)); filter->DeviceObject = deviceObject; filter->Root = rootExtension; filter->DeviceExtensionType = DEVICE_EXTENSION_FILTER; KeInitializeSpinLock(&filter->SpinLock); filter->TargetObject = IoAttachDeviceToDeviceStack(deviceObject, PhysicalDeviceObject); if (!filter->TargetObject) { IoDeleteDevice(deviceObject); return STATUS_NO_SUCH_DEVICE; } filter->Pdo = PhysicalDeviceObject; filter->RefCount = 1; InitializeListHead(&filter->HoldQueue); KeInitializeTimer(&filter->HoldWritesTimer); KeInitializeDpc(&filter->HoldWritesTimerDpc, VspIrpsTimerDpc, filter); KeInitializeEvent(&filter->EndCommitProcessCompleted, NotificationEvent, TRUE); InitializeListHead(&filter->VolumeList); InitializeListHead(&filter->DeadVolumeList); InitializeListHead(&filter->DiffAreaFilesOnThisFilter); InitializeListHead(&filter->DiffAreaVolumes); diffAreaVolume = (PVSP_DIFF_AREA_VOLUME) ExAllocatePoolWithTag((POOL_TYPE)(PagedPool | POOL_COLD_ALLOCATION), sizeof(VSP_DIFF_AREA_VOLUME), VOLSNAP_TAG_DIFF_VOLUME); if (!diffAreaVolume) { IoDetachDevice(filter->TargetObject); IoDeleteDevice(deviceObject); return STATUS_INSUFFICIENT_RESOURCES; } diffAreaVolume->Filter = filter; InsertTailList(&filter->DiffAreaVolumes, &diffAreaVolume->ListEntry); KeInitializeTimer(&filter->EndCommitTimer); KeInitializeDpc(&filter->EndCommitTimerDpc, VspEndCommitDpc, filter); InitializeListHead(&filter->NonPagedResourceList); InitializeListHead(&filter->PagedResourceList); status = IoInitializeTimer(deviceObject, VspOneSecondTimer, filter); if (!NT_SUCCESS(status)) { IoDetachDevice(filter->TargetObject); IoDeleteDevice(deviceObject); return status; } deviceObject->Flags |= DO_DIRECT_IO; if (filter->TargetObject->Flags & DO_POWER_PAGABLE) { deviceObject->Flags |= DO_POWER_PAGABLE; } if (filter->TargetObject->Flags & DO_POWER_INRUSH) { deviceObject->Flags |= DO_POWER_INRUSH; } VspAcquire(filter->Root); if (filter->TargetObject->StackSize > filter->Root->StackSize) { InterlockedExchange(&filter->Root->StackSize, (LONG) filter->TargetObject->StackSize); } InsertTailList(&filter->Root->FilterList, &filter->ListEntry); VspRelease(filter->Root); deviceObject->Flags &= ~DO_DEVICE_INITIALIZING; return STATUS_SUCCESS; } NTSTATUS VolSnapCreate( 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 --*/ { PFILTER_EXTENSION filter = (PFILTER_EXTENSION) DeviceObject->DeviceExtension; if (filter->DeviceExtensionType == DEVICE_EXTENSION_FILTER) { IoSkipCurrentIrpStackLocation(Irp); return IoCallDriver(filter->TargetObject, Irp); } ASSERT(filter->DeviceExtensionType == DEVICE_EXTENSION_VOLUME); Irp->IoStatus.Status = STATUS_SUCCESS; Irp->IoStatus.Information = 0; IoCompleteRequest(Irp, IO_NO_INCREMENT); return STATUS_SUCCESS; } NTSTATUS VspReadSnapshotPhase2( IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Context ) { PVSP_CONTEXT context = (PVSP_CONTEXT) Context; PVOLUME_EXTENSION extension = context->ReadSnapshot.Extension; PIRP irp = context->ReadSnapshot.OriginalReadIrp; PIO_STACK_LOCATION nextSp = IoGetNextIrpStackLocation(irp); ASSERT(context->Type == VSP_CONTEXT_TYPE_READ_SNAPSHOT); if (!NT_SUCCESS(Irp->IoStatus.Status)) { irp->IoStatus = Irp->IoStatus; } IoFreeMdl(Irp->MdlAddress); IoFreeIrp(Irp); VspFreeContext(extension->Root, context); VspDecrementVolumeIrpRefCount(irp); return STATUS_MORE_PROCESSING_REQUIRED; } VOID VspReadSnapshotPhase1( IN PVOID Context ) /*++ Routine Description: This routine is called when a read snapshot routine is waiting for somebody else to finish updating the public area of a table entry. When this routine is called, the public area of the table entry is valid. Arguments: Context - Supplies the context. Return Value: None. --*/ { PVSP_CONTEXT context = (PVSP_CONTEXT) Context; PVOLUME_EXTENSION extension = context->ReadSnapshot.Extension; TEMP_TRANSLATION_TABLE_ENTRY keyTempTableEntry; PTEMP_TRANSLATION_TABLE_ENTRY tempTableEntry; TRANSLATION_TABLE_ENTRY keyTableEntry; PTRANSLATION_TABLE_ENTRY tableEntry; NTSTATUS status; PIRP irp; PIO_STACK_LOCATION nextSp; PCHAR vp; PMDL mdl; ASSERT(context->Type == VSP_CONTEXT_TYPE_READ_SNAPSHOT); if (!context->ReadSnapshot.TargetObject) { irp = context->ReadSnapshot.OriginalReadIrp; irp->IoStatus.Status = STATUS_NO_SUCH_DEVICE; irp->IoStatus.Information = 0; VspFreeContext(extension->Root, context); VspDecrementVolumeIrpRefCount(irp); return; } irp = IoAllocateIrp(context->ReadSnapshot.TargetObject->StackSize, FALSE); if (!irp) { irp = context->ReadSnapshot.OriginalReadIrp; irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES; irp->IoStatus.Information = 0; VspFreeContext(extension->Root, context); VspDecrementVolumeIrpRefCount(irp); return; } vp = (PCHAR) MmGetMdlVirtualAddress( context->ReadSnapshot.OriginalReadIrp->MdlAddress) + context->ReadSnapshot.OriginalReadIrpOffset; mdl = IoAllocateMdl(vp, context->ReadSnapshot.Length, FALSE, FALSE, NULL); if (!mdl) { IoFreeIrp(irp); irp = context->ReadSnapshot.OriginalReadIrp; irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES; irp->IoStatus.Information = 0; VspFreeContext(extension->Root, context); VspDecrementVolumeIrpRefCount(irp); return; } IoBuildPartialMdl(context->ReadSnapshot.OriginalReadIrp->MdlAddress, mdl, vp, context->ReadSnapshot.Length); irp->MdlAddress = mdl; irp->Tail.Overlay.Thread = PsGetCurrentThread(); nextSp = IoGetNextIrpStackLocation(irp); nextSp->Parameters.Read.ByteOffset.QuadPart = context->ReadSnapshot.TargetOffset + context->ReadSnapshot.BlockOffset; nextSp->Parameters.Read.Length = context->ReadSnapshot.Length; nextSp->MajorFunction = IRP_MJ_READ; nextSp->DeviceObject = context->ReadSnapshot.TargetObject; nextSp->Flags = SL_OVERRIDE_VERIFY_VOLUME; IoSetCompletionRoutine(irp, VspReadSnapshotPhase2, context, TRUE, TRUE, TRUE); IoCallDriver(context->ReadSnapshot.TargetObject, irp); } VOID VspReadSnapshot( IN PVOID Context ) /*++ Routine Description: This routine kicks off a read snapshot. First the table is searched to see if any of the data for this IRP resides in the diff area. If not, then the Irp is sent directly to the original volume and then the diff area is checked again when it returns to fill in any gaps that may have been written while the IRP was in transit. Arguments: Irp - Supplies the I/O request packet. Return Value: None. --*/ { PVSP_CONTEXT context = (PVSP_CONTEXT) Context; PVOLUME_EXTENSION extension = context->Extension.Extension; PIRP irp = context->Extension.Irp; PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation(irp); PIO_STACK_LOCATION nextSp = IoGetNextIrpStackLocation(irp); PFILTER_EXTENSION filter = extension->Filter; LONGLONG start, end, roundedStart, roundedEnd; ULONG irpOffset, irpLength, length, blockOffset; TRANSLATION_TABLE_ENTRY keyTableEntry; TEMP_TRANSLATION_TABLE_ENTRY keyTempTableEntry; PVOLUME_EXTENSION e; PTRANSLATION_TABLE_ENTRY tableEntry; PTEMP_TRANSLATION_TABLE_ENTRY tempTableEntry; KIRQL irql; NTSTATUS status; ASSERT(context->Type == VSP_CONTEXT_TYPE_EXTENSION); VspFreeContext(extension->Root, context); start = irpSp->Parameters.Read.ByteOffset.QuadPart; irpLength = irpSp->Parameters.Read.Length; end = start + irpLength; roundedStart = start&(~(BLOCK_SIZE - 1)); roundedEnd = end&(~(BLOCK_SIZE - 1)); if (roundedEnd != end) { roundedEnd += BLOCK_SIZE; } irpOffset = 0; RtlZeroMemory(&keyTableEntry, sizeof(keyTableEntry)); for (; roundedStart < roundedEnd; roundedStart += BLOCK_SIZE) { if (roundedStart < start) { blockOffset = (ULONG) (start - roundedStart); } else { blockOffset = 0; } length = BLOCK_SIZE - blockOffset; if (irpLength < length) { length = irpLength; } keyTableEntry.VolumeOffset = roundedStart; e = extension; status = STATUS_SUCCESS; for (;;) { _try { tableEntry = (PTRANSLATION_TABLE_ENTRY) RtlLookupElementGenericTable(&e->VolumeBlockTable, &keyTableEntry); } _except (EXCEPTION_EXECUTE_HANDLER) { status = GetExceptionCode(); tableEntry = NULL; } if (tableEntry) { break; } if (!NT_SUCCESS(status)) { irp->IoStatus.Status = status; irp->IoStatus.Information = 0; break; } KeAcquireSpinLock(&filter->SpinLock, &irql); if (e->ListEntry.Flink == &filter->VolumeList) { KeReleaseSpinLock(&filter->SpinLock, irql); break; } e = CONTAINING_RECORD(e->ListEntry.Flink, VOLUME_EXTENSION, ListEntry); KeReleaseSpinLock(&filter->SpinLock, irql); } if (!tableEntry) { if (!NT_SUCCESS(status)) { break; } keyTempTableEntry.VolumeOffset = roundedStart; VspAcquireNonPagedResource(e, NULL); tempTableEntry = (PTEMP_TRANSLATION_TABLE_ENTRY) RtlLookupElementGenericTable( &e->TempVolumeBlockTable, &keyTempTableEntry); if (!tempTableEntry) { VspReleaseNonPagedResource(e); irpOffset += length; irpLength -= length; continue; } } context = VspAllocateContext(extension->Root); if (!context) { if (!tableEntry) { VspReleaseNonPagedResource(e); } irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES; irp->IoStatus.Information = 0; break; } context->Type = VSP_CONTEXT_TYPE_READ_SNAPSHOT; context->ReadSnapshot.Extension = extension; context->ReadSnapshot.OriginalReadIrp = irp; context->ReadSnapshot.OriginalReadIrpOffset = irpOffset; context->ReadSnapshot.OriginalVolumeOffset = roundedStart; context->ReadSnapshot.BlockOffset = blockOffset; context->ReadSnapshot.Length = length; context->ReadSnapshot.TargetObject = NULL; context->ReadSnapshot.TargetOffset = 0; if (!tableEntry) { KeAcquireSpinLock(&e->SpinLock, &irql); if (!tempTableEntry->IsComplete) { InterlockedIncrement((PLONG) &nextSp->Parameters.Read.Length); ExInitializeWorkItem(&context->WorkItem, VspReadSnapshotPhase1, context); InsertTailList(&tempTableEntry->WaitingQueueDpc, &context->WorkItem.List); KeReleaseSpinLock(&e->SpinLock, irql); VspReleaseNonPagedResource(e); irpOffset += length; irpLength -= length; continue; } KeReleaseSpinLock(&e->SpinLock, irql); context->ReadSnapshot.TargetObject = tempTableEntry->TargetObject; context->ReadSnapshot.TargetOffset = tempTableEntry->TargetOffset; VspReleaseNonPagedResource(e); InterlockedIncrement((PLONG) &nextSp->Parameters.Read.Length); VspReadSnapshotPhase1(context); irpOffset += length; irpLength -= length; continue; } context->ReadSnapshot.TargetObject = tableEntry->TargetObject; context->ReadSnapshot.TargetOffset = tableEntry->TargetOffset; InterlockedIncrement((PLONG) &nextSp->Parameters.Read.Length); VspReadSnapshotPhase1(context); irpOffset += length; irpLength -= length; } VspReleasePagedResource(extension); VspDecrementVolumeIrpRefCount(irp); } NTSTATUS VspReadCompletionForReadSnapshot( IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Extension ) /*++ Routine Description: This routine is the completion to a read of the filter in response to a snapshot read. This completion routine queues a worker routine to look at the diff area table and fill in any parts of the original that have been invalidated. Arguments: DeviceObject - Supplies the device object. Irp - Supplies the I/O request packet. Extension - Supplies the volume extension. Return Value: NTSTATUS --*/ { PVOLUME_EXTENSION extension = (PVOLUME_EXTENSION) Extension; PIO_STACK_LOCATION nextSp = IoGetNextIrpStackLocation(Irp); PVSP_CONTEXT context; nextSp->Parameters.Read.Length = 1; ; // Use this for a ref count. if (!NT_SUCCESS(Irp->IoStatus.Status)) { VspDecrementVolumeIrpRefCount(Irp); return STATUS_MORE_PROCESSING_REQUIRED; } context = VspAllocateContext(extension->Root); if (!context) { Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES; Irp->IoStatus.Information = 0; VspDecrementVolumeIrpRefCount(Irp); return STATUS_MORE_PROCESSING_REQUIRED; } context->Type = VSP_CONTEXT_TYPE_EXTENSION; context->Extension.Extension = extension; context->Extension.Irp = Irp; ExInitializeWorkItem(&context->WorkItem, VspReadSnapshot, context); VspAcquirePagedResource(extension, &context->WorkItem); return STATUS_MORE_PROCESSING_REQUIRED; } RTL_GENERIC_COMPARE_RESULTS VspTableCompareRoutine( IN PRTL_GENERIC_TABLE Table, IN PVOID First, IN PVOID Second ) { PTRANSLATION_TABLE_ENTRY first = (PTRANSLATION_TABLE_ENTRY) First; PTRANSLATION_TABLE_ENTRY second = (PTRANSLATION_TABLE_ENTRY) Second; if (first->VolumeOffset < second->VolumeOffset) { return GenericLessThan; } else if (first->VolumeOffset > second->VolumeOffset) { return GenericGreaterThan; } return GenericEqual; } VOID VspCreateHeap( IN PVOID Context ) { PVSP_CONTEXT context = (PVSP_CONTEXT) Context; PVOLUME_EXTENSION extension = context->Extension.Extension; ULONG increase; OBJECT_ATTRIBUTES oa; NTSTATUS status; SIZE_T size; LARGE_INTEGER sectionSize, sectionOffset; HANDLE h; PVOID mapPointer; KIRQL irql; BOOLEAN emptyQueue; LIST_ENTRY q; PLIST_ENTRY l; PWORK_QUEUE_ITEM workItem; ASSERT(context->Type == VSP_CONTEXT_TYPE_EXTENSION); VspFreeContext(extension->Root, context); increase = extension->DiffAreaFileIncrease; increase >>= BLOCK_SHIFT; size = increase*(sizeof(TRANSLATION_TABLE_ENTRY) + sizeof(RTL_BALANCED_LINKS)); size = (size + 0xFFFF)&(~0xFFFF); ASSERT(size >= MINIMUM_TABLE_HEAP_SIZE); InitializeObjectAttributes(&oa, NULL, OBJ_KERNEL_HANDLE, NULL, NULL); DoOver: sectionSize.QuadPart = size; status = ZwCreateSection(&h, STANDARD_RIGHTS_REQUIRED | SECTION_QUERY | SECTION_MAP_READ | SECTION_MAP_WRITE, &oa, §ionSize, PAGE_READWRITE, SEC_COMMIT, NULL); if (!NT_SUCCESS(status)) { if (size > MINIMUM_TABLE_HEAP_SIZE) { size = MINIMUM_TABLE_HEAP_SIZE; goto DoOver; } VspLogError(extension, NULL, VS_CANT_CREATE_HEAP, status, 1); goto Finish; } sectionOffset.QuadPart = 0; mapPointer = NULL; status = ZwMapViewOfSection(h, NtCurrentProcess(), &mapPointer, 0, 0, §ionOffset, &size, ViewShare, 0, PAGE_READWRITE); ZwClose(h); if (!NT_SUCCESS(status)) { if (size > MINIMUM_TABLE_HEAP_SIZE) { size = MINIMUM_TABLE_HEAP_SIZE; goto DoOver; } VspLogError(extension, NULL, VS_CANT_CREATE_HEAP, status, 2); goto Finish; } VspAcquire(extension->Root); if (extension->IsDead) { VspRelease(extension->Root); status = ZwUnmapViewOfSection(NtCurrentProcess(), mapPointer); ASSERT(NT_SUCCESS(status)); goto Finish; } VspAcquirePagedResource(extension, NULL); extension->NextDiffAreaFileMap = mapPointer; extension->NextDiffAreaFileMapSize = (ULONG) size; extension->DiffAreaFileMapProcess = NtCurrentProcess(); VspReleasePagedResource(extension); VspRelease(extension->Root); Finish: KeAcquireSpinLock(&extension->SpinLock, &irql); if (extension->PageFileSpaceCreatePending) { extension->PageFileSpaceCreatePending = FALSE; if (IsListEmpty(&extension->WaitingForPageFileSpace)) { emptyQueue = FALSE; } else { emptyQueue = TRUE; q = extension->WaitingForPageFileSpace; InitializeListHead(&extension->WaitingForPageFileSpace); } } else { emptyQueue = FALSE; } KeReleaseSpinLock(&extension->SpinLock, irql); if (emptyQueue) { q.Flink->Blink = &q; q.Blink->Flink = &q; while (!IsListEmpty(&q)) { l = RemoveHeadList(&q); workItem = CONTAINING_RECORD(l, WORK_QUEUE_ITEM, List); VspAcquirePagedResource(extension, workItem); } } ObDereferenceObject(extension->DeviceObject); } PVOID VspTableAllocateRoutine( IN PRTL_GENERIC_TABLE Table, IN CLONG Size ) { PVOLUME_EXTENSION extension = (PVOLUME_EXTENSION) Table->TableContext; PVOID p; POLD_HEAP_ENTRY oldHeap; PVSP_CONTEXT context; KIRQL irql; if (extension->NextAvailable + Size <= extension->DiffAreaFileMapSize) { p = (PCHAR) extension->DiffAreaFileMap + extension->NextAvailable; extension->NextAvailable += Size; return p; } if (!extension->NextDiffAreaFileMap) { return NULL; } oldHeap = (POLD_HEAP_ENTRY) ExAllocatePoolWithTag(PagedPool, sizeof(OLD_HEAP_ENTRY), VOLSNAP_TAG_OLD_HEAP); if (!oldHeap) { return NULL; } context = VspAllocateContext(extension->Root); if (!context) { ExFreePool(oldHeap); return NULL; } KeAcquireSpinLock(&extension->SpinLock, &irql); ASSERT(!extension->PageFileSpaceCreatePending); ASSERT(IsListEmpty(&extension->WaitingForPageFileSpace)); extension->PageFileSpaceCreatePending = TRUE; KeReleaseSpinLock(&extension->SpinLock, irql); oldHeap->DiffAreaFileMap = extension->DiffAreaFileMap; InsertTailList(&extension->OldHeaps, &oldHeap->ListEntry); extension->DiffAreaFileMap = extension->NextDiffAreaFileMap; extension->DiffAreaFileMapSize = extension->NextDiffAreaFileMapSize; extension->NextAvailable = 0; extension->NextDiffAreaFileMap = NULL; context->Type = VSP_CONTEXT_TYPE_EXTENSION; context->Extension.Extension = extension; context->Extension.Irp = NULL; ObReferenceObject(extension->DeviceObject); ExInitializeWorkItem(&context->WorkItem, VspCreateHeap, context); VspQueueWorkItem(extension->Root, &context->WorkItem, 0); p = extension->DiffAreaFileMap; extension->NextAvailable += Size; return p; } VOID VspTableFreeRoutine( IN PRTL_GENERIC_TABLE Table, IN PVOID Buffer ) { } PVOID VspTempTableAllocateRoutine( IN PRTL_GENERIC_TABLE Table, IN CLONG Size ) { PVOLUME_EXTENSION extension = (PVOLUME_EXTENSION) Table->TableContext; PVOID r; ASSERT(Size <= sizeof(RTL_BALANCED_LINKS) + sizeof(TEMP_TRANSLATION_TABLE_ENTRY)); r = extension->TempTableEntry; extension->TempTableEntry = NULL; return r; } VOID VspTempTableFreeRoutine( IN PRTL_GENERIC_TABLE Table, IN PVOID Buffer ) { PVOLUME_EXTENSION extension = (PVOLUME_EXTENSION) Table->TableContext; VspFreeTempTableEntry(extension->Root, Buffer); } PFILTER_EXTENSION VspFindFilter( IN PDO_EXTENSION RootExtension, IN PFILTER_EXTENSION Filter, IN PUNICODE_STRING VolumeName, IN PFILE_OBJECT FileObject ) { NTSTATUS status; PDEVICE_OBJECT deviceObject, d; PLIST_ENTRY l; PFILTER_EXTENSION filter; if (VolumeName) { status = IoGetDeviceObjectPointer(VolumeName, FILE_READ_ATTRIBUTES, &FileObject, &deviceObject); if (!NT_SUCCESS(status)) { if (Filter) { VspLogError(NULL, Filter, VS_FAILURE_ADDING_DIFF_AREA, status, 1); } return NULL; } } deviceObject = IoGetAttachedDeviceReference(FileObject->DeviceObject); for (l = RootExtension->FilterList.Flink; l != &RootExtension->FilterList; l = l->Flink) { filter = CONTAINING_RECORD(l, FILTER_EXTENSION, ListEntry); d = IoGetAttachedDeviceReference(filter->DeviceObject); ObDereferenceObject(d); if (d == deviceObject) { break; } } ObDereferenceObject(deviceObject); if (VolumeName) { ObDereferenceObject(FileObject); } if (l != &RootExtension->FilterList) { return filter; } if (Filter) { VspLogError(NULL, Filter, VS_FAILURE_ADDING_DIFF_AREA, STATUS_NOT_FOUND, 2); } return NULL; } NTSTATUS VspIsNtfs( IN HANDLE FileHandle, OUT PBOOLEAN IsNtfs ) { ULONG size; PFILE_FS_ATTRIBUTE_INFORMATION fsAttributeInfo; NTSTATUS status; IO_STATUS_BLOCK ioStatus; size = FIELD_OFFSET(FILE_FS_ATTRIBUTE_INFORMATION, FileSystemName) + 4*sizeof(WCHAR); fsAttributeInfo = (PFILE_FS_ATTRIBUTE_INFORMATION) ExAllocatePoolWithTag(PagedPool, size, VOLSNAP_TAG_SHORT_TERM); if (!fsAttributeInfo) { return STATUS_INSUFFICIENT_RESOURCES; } status = ZwQueryVolumeInformationFile(FileHandle, &ioStatus, fsAttributeInfo, size, FileFsAttributeInformation); if (status == STATUS_BUFFER_OVERFLOW) { *IsNtfs = FALSE; ExFreePool(fsAttributeInfo); return STATUS_SUCCESS; } if (!NT_SUCCESS(status)) { ExFreePool(fsAttributeInfo); return status; } if (fsAttributeInfo->FileSystemNameLength == 8 && fsAttributeInfo->FileSystemName[0] == 'N' && fsAttributeInfo->FileSystemName[1] == 'T' && fsAttributeInfo->FileSystemName[2] == 'F' && fsAttributeInfo->FileSystemName[3] == 'S') { ExFreePool(fsAttributeInfo); *IsNtfs = TRUE; return STATUS_SUCCESS; } ExFreePool(fsAttributeInfo); *IsNtfs = FALSE; return STATUS_SUCCESS; } LONGLONG VspQueryVolumeSize( IN PFILTER_EXTENSION Filter ) { PDEVICE_OBJECT targetObject; KEVENT event; PIRP irp; GET_LENGTH_INFORMATION lengthInfo; IO_STATUS_BLOCK ioStatus; NTSTATUS status; targetObject = Filter->TargetObject; KeInitializeEvent(&event, NotificationEvent, FALSE); irp = IoBuildDeviceIoControlRequest(IOCTL_DISK_GET_LENGTH_INFO, targetObject, NULL, 0, &lengthInfo, sizeof(lengthInfo), FALSE, &event, &ioStatus); if (!irp) { return 0; } status = IoCallDriver(targetObject, irp); if (status == STATUS_PENDING) { KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL); status = ioStatus.Status; } if (!NT_SUCCESS(status)) { return 0; } return lengthInfo.Length.QuadPart; } NTSTATUS VspQueryVolumeNumber( IN PVOLUME_EXTENSION Extension, IN PIRP Irp ) { 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"VOLSNAP ", 16); Irp->IoStatus.Information = sizeof(VOLUME_NUMBER); return STATUS_SUCCESS; } VOID VspCancelRoutine( 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. --*/ { PFILTER_EXTENSION filter = (PFILTER_EXTENSION) DeviceObject->DeviceExtension; ASSERT(Irp == filter->FlushAndHoldIrp); filter->FlushAndHoldIrp = NULL; RemoveEntryList(&Irp->Tail.Overlay.ListEntry); IoReleaseCancelSpinLock(Irp->CancelIrql); Irp->IoStatus.Status = STATUS_CANCELLED; Irp->IoStatus.Information = 0; IoCompleteRequest(Irp, IO_NO_INCREMENT); } VOID VspFsTimerDpc( IN PKDPC TimerDpc, IN PVOID Context, IN PVOID SystemArgument1, IN PVOID SystemArgument2 ) { PDO_EXTENSION rootExtension = (PDO_EXTENSION) Context; KIRQL irql; PIRP irp; PFILTER_EXTENSION filter; IoAcquireCancelSpinLock(&irql); while (!IsListEmpty(&rootExtension->HoldIrps)) { irp = CONTAINING_RECORD(rootExtension->HoldIrps.Flink, IRP, Tail.Overlay.ListEntry); irp->CancelIrql = irql; IoSetCancelRoutine(irp, NULL); filter = (PFILTER_EXTENSION) IoGetCurrentIrpStackLocation(irp)-> DeviceObject->DeviceExtension; ObReferenceObject(filter->DeviceObject); VspCancelRoutine(filter->DeviceObject, irp); VspLogError(NULL, filter, VS_FLUSH_AND_HOLD_FS_TIMEOUT, STATUS_CANCELLED, 0); ObDereferenceObject(filter->DeviceObject); IoAcquireCancelSpinLock(&irql); } rootExtension->HoldRefCount = 0; IoReleaseCancelSpinLock(irql); } VOID VspZeroRefCallback( IN PFILTER_EXTENSION Filter ) { PIRP irp = (PIRP) Filter->ZeroRefContext; LARGE_INTEGER timeout; timeout.QuadPart = -10*1000*1000*((LONGLONG) Filter->HoldWritesTimeout); KeSetTimer(&Filter->HoldWritesTimer, timeout, &Filter->HoldWritesTimerDpc); InterlockedExchange(&Filter->TimerIsSet, TRUE); irp->IoStatus.Status = STATUS_SUCCESS; irp->IoStatus.Information = 0; IoCompleteRequest(irp, IO_SOUND_INCREMENT); } VOID VspFlushAndHoldWriteIrps( IN PIRP Irp, IN ULONG HoldWritesTimeout ) /*++ Routine Description: This routine waits for outstanding write requests to complete while holding incoming write requests. This IRP will complete when all outstanding IRPs have completed. A timer will be set for the given timeout value and held writes irps will be released after that point or when IOCTL_VOLSNAP_RELEASE_WRITES comes in, whichever is sooner. Arguments: Irp - Supplies the I/O request packet. HoldWritesTimeout - Supplies the maximum length of time in seconds that a write IRP will be held up. Return Value: None. --*/ { PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation(Irp); PFILTER_EXTENSION filter = (PFILTER_EXTENSION) irpSp->DeviceObject->DeviceExtension; KIRQL irql; NTSTATUS status; KeAcquireSpinLock(&filter->SpinLock, &irql); if (filter->HoldIncomingWrites) { KeReleaseSpinLock(&filter->SpinLock, irql); Irp->IoStatus.Information = 0; Irp->IoStatus.Status = STATUS_INVALID_PARAMETER; IoCompleteRequest(Irp, IO_NO_INCREMENT); return; } filter->HoldWritesTimeout = HoldWritesTimeout; InterlockedExchange(&filter->HoldIncomingWrites, TRUE); filter->ZeroRefCallback = VspZeroRefCallback; filter->ZeroRefContext = Irp; KeReleaseSpinLock(&filter->SpinLock, irql); VspDecrementRefCount(filter); IoStartTimer(filter->DeviceObject); status = VspCheckForMemoryPressure(filter); if (!NT_SUCCESS(status)) { VspReleaseWrites(filter); } } NTSTATUS VspFlushAndHoldWrites( IN PFILTER_EXTENSION Filter, IN PIRP Irp ) /*++ Routine Description: This routine is called for multiple volumes at once. On the first call the GUID is checked and if it is different than the current one then the current set is aborted. If the GUID is new then subsequent calls are compared to the GUID passed in here until the required number of calls is completed. A timer is used to wait until all of the IRPs have reached this driver and then another time out is used after all of these calls complete to wait for IOCTL_VOLSNAP_RELEASE_WRITES to be sent to all of the volumes involved. Arguments: Filter - Supplies the filter device extension. Irp - Supplies the I/O request packet. Return Value: NTSTATUS --*/ { PDO_EXTENSION rootExtension = Filter->Root; PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation(Irp); PVOLSNAP_FLUSH_AND_HOLD_INPUT input; KIRQL irql; LARGE_INTEGER timeout; LIST_ENTRY q; PLIST_ENTRY l; PIRP irp; PFILTER_EXTENSION filter; ULONG irpTimeout; if (irpSp->Parameters.DeviceIoControl.InputBufferLength < sizeof(VOLSNAP_FLUSH_AND_HOLD_INPUT)) { return STATUS_INVALID_PARAMETER; } input = (PVOLSNAP_FLUSH_AND_HOLD_INPUT) Irp->AssociatedIrp.SystemBuffer; if (!input->NumberOfVolumesToFlush || !input->SecondsToHoldFileSystemsTimeout || !input->SecondsToHoldIrpsTimeout) { return STATUS_INVALID_PARAMETER; } IoAcquireCancelSpinLock(&irql); if (Filter->FlushAndHoldIrp) { IoReleaseCancelSpinLock(irql); VspLogError(NULL, Filter, VS_TWO_FLUSH_AND_HOLDS, STATUS_INVALID_PARAMETER, 1); return STATUS_INVALID_PARAMETER; } if (rootExtension->HoldRefCount) { if (!IsEqualGUID(rootExtension->HoldInstanceGuid, input->InstanceId)) { IoReleaseCancelSpinLock(irql); VspLogError(NULL, Filter, VS_TWO_FLUSH_AND_HOLDS, STATUS_INVALID_PARAMETER, 2); return STATUS_INVALID_PARAMETER; } } else { if (IsEqualGUID(rootExtension->HoldInstanceGuid, input->InstanceId)) { IoReleaseCancelSpinLock(irql); VspLogError(NULL, Filter, VS_TWO_FLUSH_AND_HOLDS, STATUS_INVALID_PARAMETER, 3); return STATUS_INVALID_PARAMETER; } rootExtension->HoldRefCount = input->NumberOfVolumesToFlush + 1; rootExtension->HoldInstanceGuid = input->InstanceId; rootExtension->SecondsToHoldFsTimeout = input->SecondsToHoldFileSystemsTimeout; rootExtension->SecondsToHoldIrpTimeout = input->SecondsToHoldIrpsTimeout; timeout.QuadPart = -10*1000*1000* ((LONGLONG) rootExtension->SecondsToHoldFsTimeout); KeSetTimer(&rootExtension->HoldTimer, timeout, &rootExtension->HoldTimerDpc); } Filter->FlushAndHoldIrp = Irp; InsertTailList(&rootExtension->HoldIrps, &Irp->Tail.Overlay.ListEntry); IoSetCancelRoutine(Irp, VspCancelRoutine); IoMarkIrpPending(Irp); rootExtension->HoldRefCount--; if (rootExtension->HoldRefCount != 1) { IoReleaseCancelSpinLock(irql); return STATUS_PENDING; } InitializeListHead(&q); while (!IsListEmpty(&rootExtension->HoldIrps)) { l = RemoveHeadList(&rootExtension->HoldIrps); irp = CONTAINING_RECORD(l, IRP, Tail.Overlay.ListEntry); filter = (PFILTER_EXTENSION) IoGetCurrentIrpStackLocation(irp)->DeviceObject-> DeviceExtension; InsertTailList(&q, l); filter->FlushAndHoldIrp = NULL; IoSetCancelRoutine(irp, NULL); } irpTimeout = rootExtension->SecondsToHoldIrpTimeout; if (KeCancelTimer(&rootExtension->HoldTimer)) { IoReleaseCancelSpinLock(irql); VspFsTimerDpc(&rootExtension->HoldTimerDpc, rootExtension->HoldTimerDpc.DeferredContext, rootExtension->HoldTimerDpc.SystemArgument1, rootExtension->HoldTimerDpc.SystemArgument2); } else { IoReleaseCancelSpinLock(irql); } while (!IsListEmpty(&q)) { l = RemoveHeadList(&q); irp = CONTAINING_RECORD(l, IRP, Tail.Overlay.ListEntry); VspFlushAndHoldWriteIrps(irp, irpTimeout); } return STATUS_PENDING; } NTSTATUS VspCreateDiffAreaFileName( IN PDEVICE_OBJECT DeviceObject, IN ULONG VolumeSnapshotNumber, OUT PUNICODE_STRING DiffAreaFileName ) /*++ Routine Description: This routine builds the diff area file name for the given diff area volume and the given volume snapshot number. The name formed will look like \. Arguments: Filter - Supplies the filter extension. VolumeSnapshotNumber - Supplies the volume snapshot number. DiffAreaFileName - Returns the name of the diff area file. Return Value: NTSTATUS --*/ { PDEVICE_OBJECT targetObject = DeviceObject; KEVENT event; PMOUNTDEV_NAME name; UCHAR buffer[512]; PIRP irp; IO_STATUS_BLOCK ioStatus; NTSTATUS status; UNICODE_STRING sysvol, guidString, numberString, string; WCHAR numberBuffer[20]; KeInitializeEvent(&event, NotificationEvent, FALSE); name = (PMOUNTDEV_NAME) buffer; irp = IoBuildDeviceIoControlRequest(IOCTL_MOUNTDEV_QUERY_DEVICE_NAME, targetObject, NULL, 0, name, 512, FALSE, &event, &ioStatus); if (!irp) { return STATUS_INSUFFICIENT_RESOURCES; } status = IoCallDriver(targetObject, irp); if (status == STATUS_PENDING) { KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL); status = ioStatus.Status; } if (!NT_SUCCESS(status)) { return status; } RtlInitUnicodeString(&sysvol, RTL_SYSTEM_VOLUME_INFORMATION_FOLDER); if (VolumeSnapshotNumber == (ULONG) -1) { swprintf(numberBuffer, L"\\*"); } else { swprintf(numberBuffer, L"\\%d", VolumeSnapshotNumber); } RtlInitUnicodeString(&numberString, numberBuffer); status = RtlStringFromGUID(VSP_DIFF_AREA_FILE_GUID, &guidString); if (!NT_SUCCESS(status)) { return status; } string.MaximumLength = name->NameLength + sizeof(WCHAR) + sysvol.Length + numberString.Length + guidString.Length + sizeof(WCHAR); string.Length = 0; string.Buffer = (PWCHAR) ExAllocatePoolWithTag(PagedPool, string.MaximumLength, VOLSNAP_TAG_SHORT_TERM); if (!string.Buffer) { ExFreePool(guidString.Buffer); return STATUS_INSUFFICIENT_RESOURCES; } string.Length = name->NameLength; RtlCopyMemory(string.Buffer, name->Name, string.Length); string.Buffer[string.Length/sizeof(WCHAR)] = '\\'; string.Length += sizeof(WCHAR); if (VolumeSnapshotNumber != (ULONG) -1) { RtlCreateSystemVolumeInformationFolder(&string); } RtlAppendUnicodeStringToString(&string, &sysvol); RtlAppendUnicodeStringToString(&string, &numberString); RtlAppendUnicodeStringToString(&string, &guidString); ExFreePool(guidString.Buffer); string.Buffer[string.Length/sizeof(WCHAR)] = 0; *DiffAreaFileName = string; return STATUS_SUCCESS; } NTSTATUS VspCreateSecurityDescriptor( OUT PSECURITY_DESCRIPTOR* SecurityDescriptor, OUT PACL* Acl ) { PSECURITY_DESCRIPTOR sd; NTSTATUS status; ULONG aclLength; PACL acl; sd = (PSECURITY_DESCRIPTOR) ExAllocatePoolWithTag(PagedPool, sizeof(SECURITY_DESCRIPTOR), VOLSNAP_TAG_SHORT_TERM); if (!sd) { return STATUS_INSUFFICIENT_RESOURCES; } status = RtlCreateSecurityDescriptor(sd, SECURITY_DESCRIPTOR_REVISION); if (!NT_SUCCESS(status)) { ExFreePool(sd); return status; } aclLength = sizeof(ACL) + sizeof(ACCESS_ALLOWED_ACE) + RtlLengthSid(SeExports->SeWorldSid) - sizeof(ULONG); acl = (PACL) ExAllocatePoolWithTag(PagedPool, aclLength, VOLSNAP_TAG_SHORT_TERM); if (!acl) { ExFreePool(sd); return STATUS_INSUFFICIENT_RESOURCES; } status = RtlCreateAcl(acl, aclLength, ACL_REVISION); if (!NT_SUCCESS(status)) { ExFreePool(acl); ExFreePool(sd); return status; } status = RtlAddAccessAllowedAce(acl, ACL_REVISION, DELETE, SeExports->SeWorldSid); if (!NT_SUCCESS(status)) { ExFreePool(acl); ExFreePool(sd); return status; } status = RtlSetDaclSecurityDescriptor(sd, TRUE, acl, FALSE); if (!NT_SUCCESS(status)) { ExFreePool(acl); ExFreePool(sd); return status; } *SecurityDescriptor = sd; *Acl = acl; return STATUS_SUCCESS; } NTSTATUS VspPinFile( IN PVSP_DIFF_AREA_FILE DiffAreaFile ) /*++ Routine Description: This routine pins down the extents of the given diff area file so that defrag operations are disabled. Arguments: DiffAreaFile - Supplies the diff area file. Return Value: NTSTATUS --*/ { NTSTATUS status; UNICODE_STRING volumeName; OBJECT_ATTRIBUTES oa; HANDLE h; IO_STATUS_BLOCK ioStatus; MARK_HANDLE_INFO markHandleInfo; status = VspCreateDiffAreaFileName(DiffAreaFile->Filter->TargetObject, (ULONG) -1, &volumeName); if (!NT_SUCCESS(status)) { return status; } volumeName.Length -= 66*sizeof(WCHAR); volumeName.Buffer[volumeName.Length/sizeof(WCHAR)] = 0; InitializeObjectAttributes(&oa, &volumeName, OBJ_CASE_INSENSITIVE, NULL, NULL); status = ZwOpenFile(&h, FILE_GENERIC_READ, &oa, &ioStatus, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, FILE_SYNCHRONOUS_IO_NONALERT); ExFreePool(volumeName.Buffer); if (!NT_SUCCESS(status)) { return status; } RtlZeroMemory(&markHandleInfo, sizeof(MARK_HANDLE_INFO)); markHandleInfo.VolumeHandle = h; markHandleInfo.HandleInfo = MARK_HANDLE_PROTECT_CLUSTERS; status = ZwFsControlFile(DiffAreaFile->FileHandle, NULL, NULL, NULL, &ioStatus, FSCTL_MARK_HANDLE, &markHandleInfo, sizeof(markHandleInfo), NULL, 0); ZwClose(h); return status; } NTSTATUS VspOptimizeDiffAreaFileLocation( IN PFILTER_EXTENSION Filter, IN HANDLE FileHandle, IN PVOLUME_EXTENSION BitmapExtension, IN LONGLONG StartingOffset, IN LONGLONG FileSize ) /*++ Routine Description: This routine optimizes the location of the diff area file so that more of it can be used. Arguments: Filter - Supplies the filter extension where the diff area resides. FileHandle - Provides a handle to the diff area. BitmapExtension - Supplies the extension of the active snapshot on the given filter, if any. StartingOffset - Supplies the starting point of where to optimize the file. FileSize - Supplies the allocated size of the file. Return Value: NTSTATUS --*/ { NTSTATUS status; IO_STATUS_BLOCK ioStatus; FILE_FS_SIZE_INFORMATION fsSize; ULONG bitmapSize; PVOID bitmapBuffer; RTL_BITMAP bitmap; PMOUNTDEV_NAME mountdevName; UCHAR buffer[200]; KEVENT event; PIRP irp; UNICODE_STRING fileName; OBJECT_ATTRIBUTES oa; HANDLE h; KIRQL irql; ULONG numBitsToFind, bitIndex, bpc, bitsFound; MOVE_FILE_DATA moveFileData; // Align the given file and if 'BitmapExtension' is available, try to // confine the file to the bits already set in the bitmap in // 'BitmapExtension'. status = ZwQueryVolumeInformationFile(FileHandle, &ioStatus, &fsSize, sizeof(fsSize), FileFsSizeInformation); if (!NT_SUCCESS(status)) { return status; } bitmapSize = (ULONG) (fsSize.TotalAllocationUnits.QuadPart* fsSize.SectorsPerAllocationUnit* fsSize.BytesPerSector/BLOCK_SIZE); bitmapBuffer = ExAllocatePoolWithTag(NonPagedPool, (bitmapSize + 8*sizeof(ULONG) - 1)/ (8*sizeof(ULONG))*sizeof(ULONG), VOLSNAP_TAG_BITMAP); if (!bitmapBuffer) { return STATUS_INSUFFICIENT_RESOURCES; } RtlInitializeBitMap(&bitmap, (PULONG) bitmapBuffer, bitmapSize); RtlClearAllBits(&bitmap); mountdevName = (PMOUNTDEV_NAME) buffer; KeInitializeEvent(&event, NotificationEvent, FALSE); irp = IoBuildDeviceIoControlRequest(IOCTL_MOUNTDEV_QUERY_DEVICE_NAME, Filter->TargetObject, NULL, 0, mountdevName, 200, FALSE, &event, &ioStatus); if (!irp) { ExFreePool(bitmapBuffer); return STATUS_INSUFFICIENT_RESOURCES; } status = IoCallDriver(Filter->TargetObject, irp); if (status == STATUS_PENDING) { KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL); status = ioStatus.Status; } if (!NT_SUCCESS(status)) { ExFreePool(bitmapBuffer); return status; } mountdevName->Name[mountdevName->NameLength/sizeof(WCHAR)] = 0; RtlInitUnicodeString(&fileName, mountdevName->Name); InitializeObjectAttributes(&oa, &fileName, OBJ_CASE_INSENSITIVE, NULL, NULL); status = ZwOpenFile(&h, FILE_GENERIC_READ, &oa, &ioStatus, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, FILE_SYNCHRONOUS_IO_NONALERT); if (!NT_SUCCESS(status)) { ExFreePool(bitmapBuffer); return status; } status = VspMarkFreeSpaceInBitmap(NULL, h, &bitmap); if (!NT_SUCCESS(status)) { ZwClose(h); ExFreePool(bitmapBuffer); return status; } if (BitmapExtension) { VspAcquire(BitmapExtension->Root); if (!BitmapExtension->IsDead) { KeAcquireSpinLock(&BitmapExtension->SpinLock, &irql); if (BitmapExtension->VolumeBlockBitmap) { if (BitmapExtension->VolumeBlockBitmap->SizeOfBitMap < bitmap.SizeOfBitMap) { bitmap.SizeOfBitMap = BitmapExtension->VolumeBlockBitmap->SizeOfBitMap; } VspAndBitmaps(&bitmap, BitmapExtension->VolumeBlockBitmap); if (bitmap.SizeOfBitMap < bitmapSize) { bitmap.SizeOfBitMap = bitmapSize; RtlClearBits(&bitmap, BitmapExtension->VolumeBlockBitmap->SizeOfBitMap, bitmapSize - BitmapExtension->VolumeBlockBitmap->SizeOfBitMap); } } KeReleaseSpinLock(&BitmapExtension->SpinLock, irql); } VspRelease(BitmapExtension->Root); } numBitsToFind = (ULONG) ((FileSize - StartingOffset)/BLOCK_SIZE); bpc = fsSize.SectorsPerAllocationUnit*fsSize.BytesPerSector; while (numBitsToFind) { bitsFound = numBitsToFind; if (bitsFound > 64) { bitsFound = 64; } bitIndex = RtlFindSetBits(&bitmap, bitsFound, 0); if (bitIndex == (ULONG) -1) { ZwClose(h); ExFreePool(bitmapBuffer); return STATUS_UNSUCCESSFUL; } moveFileData.FileHandle = FileHandle; moveFileData.StartingVcn.QuadPart = StartingOffset/bpc; moveFileData.StartingLcn.QuadPart = (((LONGLONG) bitIndex)<AllocatedFileSize; status = VspCreateDiffAreaFileName(DiffAreaFile->Filter->TargetObject, DiffAreaFile->Extension->VolumeNumber, &diffAreaFileName); if (!NT_SUCCESS(status)) { return status; } status = VspCreateSecurityDescriptor(&securityDescriptor, &acl); if (!NT_SUCCESS(status)) { ExFreePool(diffAreaFileName.Buffer); return status; } InitializeObjectAttributes(&oa, &diffAreaFileName, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, securityDescriptor); status = ZwCreateFile(&DiffAreaFile->FileHandle, FILE_GENERIC_READ | FILE_GENERIC_WRITE, &oa, &ioStatus, &diffAreaFileSize, FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM, 0, FILE_OVERWRITE_IF, FILE_SYNCHRONOUS_IO_NONALERT | FILE_NON_DIRECTORY_FILE | FILE_DELETE_ON_CLOSE | FILE_NO_COMPRESSION, NULL, 0); ExFreePool(acl); ExFreePool(securityDescriptor); ExFreePool(diffAreaFileName.Buffer); if (!NT_SUCCESS(status)) { if (status == STATUS_DISK_FULL) { VspLogError(DiffAreaFile->Extension, DiffAreaFile->Filter, VS_DIFF_AREA_CREATE_FAILED_LOW_DISK_SPACE, status, 0); } else { VspLogError(DiffAreaFile->Extension, DiffAreaFile->Filter, VS_DIFF_AREA_CREATE_FAILED, status, 0); } return status; } status = VspIsNtfs(DiffAreaFile->FileHandle, &isNtfs); if (!NT_SUCCESS(status) || !isNtfs) { VspLogError(DiffAreaFile->Extension, DiffAreaFile->Filter, VS_NOT_NTFS, status, 0); ZwClose(DiffAreaFile->FileHandle); return STATUS_INVALID_PARAMETER; } VspAcquire(DiffAreaFile->Filter->Root); if (IsListEmpty(&DiffAreaFile->Filter->VolumeList)) { bitmapExtension = NULL; } else { bitmapExtension = CONTAINING_RECORD( DiffAreaFile->Filter->VolumeList.Blink, VOLUME_EXTENSION, ListEntry); if (bitmapExtension->IsDead) { bitmapExtension = NULL; } else { ObReferenceObject(bitmapExtension->DeviceObject); } } VspRelease(DiffAreaFile->Filter->Root); VspOptimizeDiffAreaFileLocation(DiffAreaFile->Filter, DiffAreaFile->FileHandle, bitmapExtension, 0, DiffAreaFile->AllocatedFileSize); if (bitmapExtension) { ObDereferenceObject(bitmapExtension->DeviceObject); } status = VspPinFile(DiffAreaFile); if (!NT_SUCCESS(status)) { VspLogError(DiffAreaFile->Extension, DiffAreaFile->Filter, VS_PIN_DIFF_AREA_FAILED, status, 0); ZwClose(DiffAreaFile->FileHandle); return status; } return STATUS_SUCCESS; } NTSTATUS VspCreateInitialDiffAreaFiles( IN PVOLUME_EXTENSION Extension, IN LONGLONG InitialDiffAreaAllocation ) /*++ Routine Description: This routine creates the initial diff area file entries for the given device extension. Arguments: Extension - Supplies the volume extension. Return Value: NTSTATUS --*/ { PFILTER_EXTENSION filter = Extension->Filter; NTSTATUS status; PLIST_ENTRY l; PVSP_DIFF_AREA_VOLUME diffAreaVolume; PVSP_DIFF_AREA_FILE diffAreaFile; KIRQL irql; VspAcquire(Extension->Root); if (IsListEmpty(&filter->DiffAreaVolumes)) { VspRelease(Extension->Root); return STATUS_INVALID_PARAMETER; } status = STATUS_SUCCESS; InitializeListHead(&Extension->ListOfDiffAreaFiles); for (l = filter->DiffAreaVolumes.Flink; l != &filter->DiffAreaVolumes; l = l->Flink) { diffAreaVolume = CONTAINING_RECORD(l, VSP_DIFF_AREA_VOLUME, ListEntry); diffAreaFile = (PVSP_DIFF_AREA_FILE) ExAllocatePoolWithTag(NonPagedPool, sizeof(VSP_DIFF_AREA_FILE), VOLSNAP_TAG_DIFF_FILE); if (!diffAreaFile) { status = STATUS_INSUFFICIENT_RESOURCES; break; } diffAreaFile->Extension = Extension; diffAreaFile->Filter = diffAreaVolume->Filter; diffAreaFile->FileHandle = NULL; diffAreaFile->NextAvailable = 0; diffAreaFile->AllocatedFileSize = InitialDiffAreaAllocation; InsertTailList(&Extension->ListOfDiffAreaFiles, &diffAreaFile->VolumeListEntry); diffAreaFile->FilterListEntryBeingUsed = FALSE; KeAcquireSpinLock(&filter->SpinLock, &irql); filter->AllocatedVolumeSpace += diffAreaFile->AllocatedFileSize; KeReleaseSpinLock(&filter->SpinLock, irql); InitializeListHead(&diffAreaFile->UnusedAllocationList); } VspRelease(Extension->Root); for (l = Extension->ListOfDiffAreaFiles.Flink; l != &Extension->ListOfDiffAreaFiles; l = l->Flink) { diffAreaFile = CONTAINING_RECORD(l, VSP_DIFF_AREA_FILE, VolumeListEntry); status = VspOpenDiffAreaFile(diffAreaFile); if (!NT_SUCCESS(status)) { break; } } if (!NT_SUCCESS(status)) { while (!IsListEmpty(&Extension->ListOfDiffAreaFiles)) { l = RemoveHeadList(&Extension->ListOfDiffAreaFiles); diffAreaFile = CONTAINING_RECORD(l, VSP_DIFF_AREA_FILE, VolumeListEntry); if (diffAreaFile->FileHandle) { ZwClose(diffAreaFile->FileHandle); } KeAcquireSpinLock(&filter->SpinLock, &irql); filter->AllocatedVolumeSpace -= diffAreaFile->AllocatedFileSize; KeReleaseSpinLock(&filter->SpinLock, irql); ASSERT(!diffAreaFile->FilterListEntryBeingUsed); ExFreePool(diffAreaFile); } return status; } Extension->NextDiffAreaFile = CONTAINING_RECORD(Extension->ListOfDiffAreaFiles.Flink, VSP_DIFF_AREA_FILE, VolumeListEntry); return status; } VOID VspDeleteInitialDiffAreaFiles( IN PVOLUME_EXTENSION Extension ) { PFILTER_EXTENSION filter = Extension->Filter; PLIST_ENTRY l, ll; PVSP_DIFF_AREA_FILE diffAreaFile; KIRQL irql; PDIFF_AREA_FILE_ALLOCATION diffAreaFileAllocation; while (!IsListEmpty(&Extension->ListOfDiffAreaFiles)) { l = RemoveHeadList(&Extension->ListOfDiffAreaFiles); diffAreaFile = CONTAINING_RECORD(l, VSP_DIFF_AREA_FILE, VolumeListEntry); ZwClose(diffAreaFile->FileHandle); KeAcquireSpinLock(&filter->SpinLock, &irql); filter->AllocatedVolumeSpace -= diffAreaFile->AllocatedFileSize; KeReleaseSpinLock(&filter->SpinLock, irql); while (!IsListEmpty(&diffAreaFile->UnusedAllocationList)) { ll = RemoveHeadList(&diffAreaFile->UnusedAllocationList); diffAreaFileAllocation = CONTAINING_RECORD(ll, DIFF_AREA_FILE_ALLOCATION, ListEntry); ExFreePool(diffAreaFileAllocation); } if (diffAreaFile->FilterListEntryBeingUsed) { RemoveEntryList(&diffAreaFile->FilterListEntry); diffAreaFile->FilterListEntryBeingUsed = FALSE; } ExFreePool(diffAreaFile); } Extension->NextDiffAreaFile = NULL; } NTSTATUS VspMarkFileAllocationInBitmap( IN PVOLUME_EXTENSION Extension, IN HANDLE FileHandle, IN PVSP_DIFF_AREA_FILE DiffAreaFile, IN BOOLEAN OnlyDiffAreaFile, IN BOOLEAN ClearBits, IN PRTL_BITMAP BitmapToSet ) { NTSTATUS status; BOOLEAN isNtfs; IO_STATUS_BLOCK ioStatus; FILE_FS_SIZE_INFORMATION fsSize; ULONG bpc; STARTING_VCN_INPUT_BUFFER input; RETRIEVAL_POINTERS_BUFFER output; LONGLONG start, length, end, roundedStart, roundedEnd; ULONG startBit, numBits, i; KIRQL irql; PDIFF_AREA_FILE_ALLOCATION diffAreaFileAllocation; status = VspIsNtfs(FileHandle, &isNtfs); if (!NT_SUCCESS(status) || !isNtfs) { return status; } status = ZwQueryVolumeInformationFile(FileHandle, &ioStatus, &fsSize, sizeof(fsSize), FileFsSizeInformation); if (!NT_SUCCESS(status)) { return status; } bpc = fsSize.BytesPerSector*fsSize.SectorsPerAllocationUnit; input.StartingVcn.QuadPart = 0; for (;;) { status = ZwFsControlFile(FileHandle, NULL, NULL, NULL, &ioStatus, FSCTL_GET_RETRIEVAL_POINTERS, &input, sizeof(input), &output, sizeof(output)); if (!NT_SUCCESS(status) && status != STATUS_BUFFER_OVERFLOW) { if (status == STATUS_END_OF_FILE) { status = STATUS_SUCCESS; } break; } start = output.Extents[0].Lcn.QuadPart*bpc; length = output.Extents[0].NextVcn.QuadPart - output.StartingVcn.QuadPart; length *= bpc; end = start + length; if (DiffAreaFile) { diffAreaFileAllocation = (PDIFF_AREA_FILE_ALLOCATION) ExAllocatePoolWithTag(NonPagedPool, sizeof(DIFF_AREA_FILE_ALLOCATION), VOLSNAP_TAG_BIT_HISTORY); if (!diffAreaFileAllocation) { status = STATUS_INSUFFICIENT_RESOURCES; break; } diffAreaFileAllocation->Offset = start; diffAreaFileAllocation->Length = length; InsertTailList(&DiffAreaFile->UnusedAllocationList, &diffAreaFileAllocation->ListEntry); } if (OnlyDiffAreaFile) { if (status != STATUS_BUFFER_OVERFLOW) { break; } input.StartingVcn.QuadPart = output.Extents[0].NextVcn.QuadPart; continue; } roundedStart = start&(~(BLOCK_SIZE - 1)); roundedEnd = end&(~(BLOCK_SIZE - 1)); if (start != roundedStart) { roundedStart += BLOCK_SIZE; } if (roundedStart >= roundedEnd) { if (status != STATUS_BUFFER_OVERFLOW) { break; } input.StartingVcn.QuadPart = output.Extents[0].NextVcn.QuadPart; continue; } startBit = (ULONG) (roundedStart>>BLOCK_SHIFT); numBits = (ULONG) ((roundedEnd - roundedStart)>>BLOCK_SHIFT); if (BitmapToSet) { ASSERT(!ClearBits); RtlSetBits(BitmapToSet, startBit, numBits); } else { KeAcquireSpinLock(&Extension->SpinLock, &irql); if (ClearBits) { RtlClearBits(Extension->VolumeBlockBitmap, startBit, numBits); } else if (Extension->IgnorableProduct) { for (i = 0; i < numBits; i++) { if (RtlCheckBit(Extension->IgnorableProduct, i + startBit)) { RtlSetBit(Extension->VolumeBlockBitmap, i + startBit); } } } else { RtlSetBits(Extension->VolumeBlockBitmap, startBit, numBits); } KeReleaseSpinLock(&Extension->SpinLock, irql); } if (status != STATUS_BUFFER_OVERFLOW) { break; } input.StartingVcn.QuadPart = output.Extents[0].NextVcn.QuadPart; } return status; } NTSTATUS VspSetDiffAreaBlocksInBitmap( IN PVOLUME_EXTENSION Extension ) { NTSTATUS status, status2; PLIST_ENTRY l, ll; PVSP_DIFF_AREA_FILE diffAreaFile; for (l = Extension->ListOfDiffAreaFiles.Flink; l != &Extension->ListOfDiffAreaFiles; l = l->Flink) { diffAreaFile = CONTAINING_RECORD(l, VSP_DIFF_AREA_FILE, VolumeListEntry); ASSERT(!diffAreaFile->FilterListEntryBeingUsed); InsertTailList(&diffAreaFile->Filter->DiffAreaFilesOnThisFilter, &diffAreaFile->FilterListEntry); diffAreaFile->FilterListEntryBeingUsed = TRUE; if (diffAreaFile->Filter == Extension->Filter) { status = VspMarkFileAllocationInBitmap(Extension, diffAreaFile->FileHandle, diffAreaFile, FALSE, FALSE, NULL); if (!NT_SUCCESS(status)) { VspLogError(Extension, diffAreaFile->Filter, VS_CANT_MAP_DIFF_AREA_FILE, status, 2); } } else { if (diffAreaFile->Filter->PreparedSnapshot) { status = VspMarkFileAllocationInBitmap( diffAreaFile->Filter->PreparedSnapshot, diffAreaFile->FileHandle, diffAreaFile, FALSE, FALSE, NULL); if (!NT_SUCCESS(status)) { VspLogError(Extension, diffAreaFile->Filter, VS_CANT_MAP_DIFF_AREA_FILE, status, 3); } } else { status = VspMarkFileAllocationInBitmap( Extension, diffAreaFile->FileHandle, diffAreaFile, TRUE, FALSE, NULL); if (!NT_SUCCESS(status)) { VspLogError(Extension, diffAreaFile->Filter, VS_CANT_MAP_DIFF_AREA_FILE, status, 4); } } } if (!NT_SUCCESS(status)) { for (ll = Extension->ListOfDiffAreaFiles.Flink; l != ll; ll = ll->Flink) { diffAreaFile = CONTAINING_RECORD(ll, VSP_DIFF_AREA_FILE, VolumeListEntry); if (diffAreaFile->FilterListEntryBeingUsed) { RemoveEntryList(&diffAreaFile->FilterListEntry); diffAreaFile->FilterListEntryBeingUsed = FALSE; } if (diffAreaFile->Filter != Extension->Filter && diffAreaFile->Filter->PreparedSnapshot) { status2 = VspMarkFileAllocationInBitmap( diffAreaFile->Filter->PreparedSnapshot, diffAreaFile->FileHandle, NULL, FALSE, TRUE, NULL); if (!NT_SUCCESS(status2)) { VspLogError(Extension, diffAreaFile->Filter, VS_CANT_MAP_DIFF_AREA_FILE, status, 5); VspAbortPreparedSnapshot(diffAreaFile->Filter, FALSE); } } } return status; } } for (l = Extension->Filter->DiffAreaFilesOnThisFilter.Flink; l != &Extension->Filter->DiffAreaFilesOnThisFilter; l = l->Flink) { diffAreaFile = CONTAINING_RECORD(l, VSP_DIFF_AREA_FILE, FilterListEntry); if (diffAreaFile->Extension == Extension) { continue; } status = VspMarkFileAllocationInBitmap( Extension, diffAreaFile->FileHandle, NULL, FALSE, FALSE, NULL); if (!NT_SUCCESS(status)) { VspLogError(Extension, diffAreaFile->Filter, VS_CANT_MAP_DIFF_AREA_FILE, status, 6); VspCleanupBitsSetInOtherPreparedSnapshots(Extension); return status; } } return STATUS_SUCCESS; } NTSTATUS VspCreateInitialHeap( IN PVOLUME_EXTENSION Extension ) { PVSP_CONTEXT context; NTSTATUS status; context = VspAllocateContext(Extension->Root); if (!context) { return STATUS_INSUFFICIENT_RESOURCES; } context->Type = VSP_CONTEXT_TYPE_EXTENSION; context->Extension.Extension = Extension; context->Extension.Irp = NULL; ObReferenceObject(Extension->DeviceObject); VspCreateHeap(context); if (!Extension->NextDiffAreaFileMap) { return STATUS_INSUFFICIENT_RESOURCES; } ASSERT(!Extension->DiffAreaFileMap); Extension->DiffAreaFileMap = Extension->NextDiffAreaFileMap; Extension->DiffAreaFileMapSize = Extension->NextDiffAreaFileMapSize; Extension->NextAvailable = 0; Extension->NextDiffAreaFileMap = NULL; context = VspAllocateContext(Extension->Root); if (!context) { status = ZwUnmapViewOfSection(Extension->DiffAreaFileMapProcess, Extension->DiffAreaFileMap); ASSERT(NT_SUCCESS(status)); Extension->DiffAreaFileMap = NULL; return STATUS_INSUFFICIENT_RESOURCES; } context->Type = VSP_CONTEXT_TYPE_EXTENSION; context->Extension.Extension = Extension; context->Extension.Irp = NULL; ObReferenceObject(Extension->DeviceObject); VspCreateHeap(context); if (!Extension->NextDiffAreaFileMap) { status = ZwUnmapViewOfSection(Extension->DiffAreaFileMapProcess, Extension->DiffAreaFileMap); ASSERT(NT_SUCCESS(status)); Extension->DiffAreaFileMap = NULL; return STATUS_INSUFFICIENT_RESOURCES; } return STATUS_SUCCESS; } NTSTATUS VspComputeIgnorableBitmap( IN PVOLUME_EXTENSION Extension, IN OUT PRTL_BITMAP Bitmap ) { PFILTER_EXTENSION filter = Extension->Filter; WCHAR nameBuffer[150]; UNICODE_STRING name, guidString; OBJECT_ATTRIBUTES oa; NTSTATUS status; HANDLE h, fileHandle; IO_STATUS_BLOCK ioStatus; CHAR buffer[200]; PFILE_NAMES_INFORMATION fileNamesInfo; BOOLEAN restartScan; PLIST_ENTRY l; PVOLUME_EXTENSION e; PTRANSLATION_TABLE_ENTRY p; swprintf(nameBuffer, L"\\Device\\HarddiskVolumeShadowCopy%d\\pagefile.sys", Extension->VolumeNumber); RtlInitUnicodeString(&name, nameBuffer); InitializeObjectAttributes(&oa, &name, OBJ_CASE_INSENSITIVE, NULL, NULL); status = ZwOpenFile(&h, FILE_GENERIC_READ, &oa, &ioStatus, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, FILE_SYNCHRONOUS_IO_NONALERT); if (NT_SUCCESS(status)) { VspMarkFileAllocationInBitmap(NULL, h, NULL, FALSE, FALSE, Bitmap); ZwClose(h); } swprintf(nameBuffer, L"\\Device\\HarddiskVolumeShadowCopy%d\\System Volume Information\\", Extension->VolumeNumber); RtlInitUnicodeString(&name, nameBuffer); InitializeObjectAttributes(&oa, &name, OBJ_CASE_INSENSITIVE, NULL, NULL); status = ZwOpenFile(&h, FILE_LIST_DIRECTORY | SYNCHRONIZE, &oa, &ioStatus, FILE_SHARE_READ | FILE_SHARE_WRITE, FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT); if (!NT_SUCCESS(status)) { if (status == STATUS_OBJECT_NAME_NOT_FOUND) { status = STATUS_SUCCESS; } return status; } status = RtlStringFromGUID(VSP_DIFF_AREA_FILE_GUID, &guidString); if (!NT_SUCCESS(status)) { ZwClose(h); return status; } name.Buffer = nameBuffer; name.Length = sizeof(WCHAR) + guidString.Length; name.MaximumLength = name.Length + sizeof(WCHAR); name.Buffer[0] = '*'; RtlCopyMemory(&name.Buffer[1], guidString.Buffer, guidString.Length); name.Buffer[name.Length/sizeof(WCHAR)] = 0; ExFreePool(guidString.Buffer); fileNamesInfo = (PFILE_NAMES_INFORMATION) buffer; restartScan = TRUE; for (;;) { status = ZwQueryDirectoryFile(h, NULL, NULL, NULL, &ioStatus, fileNamesInfo, 200, FileNamesInformation, TRUE, restartScan ? &name : NULL, restartScan); if (!NT_SUCCESS(status)) { break; } name.Length = name.MaximumLength = (USHORT) fileNamesInfo->FileNameLength; name.Buffer = fileNamesInfo->FileName; InitializeObjectAttributes(&oa, &name, OBJ_CASE_INSENSITIVE, h, NULL); status = ZwOpenFile(&fileHandle, FILE_GENERIC_READ, &oa, &ioStatus, FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE, FILE_SYNCHRONOUS_IO_NONALERT); if (!NT_SUCCESS(status)) { continue; } VspMarkFileAllocationInBitmap(NULL, fileHandle, NULL, FALSE, FALSE, Bitmap); ZwClose(fileHandle); restartScan = FALSE; } ZwClose(h); status = VspMarkFreeSpaceInBitmap(Extension, NULL, Bitmap); if (!NT_SUCCESS(status)) { return status; } VspAcquire(Extension->Root); if (Extension->IsDead) { VspRelease(Extension->Root); return STATUS_UNSUCCESSFUL; } for (l = &Extension->ListEntry; l != &filter->VolumeList; l = l->Flink) { e = CONTAINING_RECORD(l, VOLUME_EXTENSION, ListEntry); VspAcquirePagedResource(e, NULL); p = (PTRANSLATION_TABLE_ENTRY) RtlEnumerateGenericTable(&e->VolumeBlockTable, TRUE); while (p) { RtlSetBit(Bitmap, (ULONG) (p->VolumeOffset>>BLOCK_SHIFT)); p = (PTRANSLATION_TABLE_ENTRY) RtlEnumerateGenericTable(&e->VolumeBlockTable, FALSE); } VspReleasePagedResource(e); } VspRelease(Extension->Root); return STATUS_SUCCESS; } VOID VspAndBitmaps( IN OUT PRTL_BITMAP BaseBitmap, IN PRTL_BITMAP FactorBitmap ) { ULONG n, i; PULONG p, q; n = (BaseBitmap->SizeOfBitMap + 8*sizeof(ULONG) - 1)/(8*sizeof(ULONG)); p = BaseBitmap->Buffer; q = FactorBitmap->Buffer; for (i = 0; i < n; i++) { *p++ &= *q++; } } NTSTATUS VspComputeIgnorableProduct( IN PVOLUME_EXTENSION Extension ) { PFILTER_EXTENSION filter = Extension->Filter; ULONG bitmapSize; PVOID bitmapBuffer; RTL_BITMAP bitmap; ULONG i, j; PLIST_ENTRY l; PVOLUME_EXTENSION e; NTSTATUS status; KIRQL irql; KeAcquireSpinLock(&Extension->SpinLock, &irql); if (!Extension->IgnorableProduct) { KeReleaseSpinLock(&Extension->SpinLock, irql); return STATUS_INVALID_PARAMETER; } bitmapSize = Extension->IgnorableProduct->SizeOfBitMap; RtlSetAllBits(Extension->IgnorableProduct); KeReleaseSpinLock(&Extension->SpinLock, irql); bitmapBuffer = ExAllocatePoolWithTag( NonPagedPool, (bitmapSize + 8*sizeof(ULONG) - 1)/ (8*sizeof(ULONG))*sizeof(ULONG), VOLSNAP_TAG_BITMAP); if (!bitmapBuffer) { return STATUS_INSUFFICIENT_RESOURCES; } RtlInitializeBitMap(&bitmap, (PULONG) bitmapBuffer, bitmapSize); for (i = 1; ; i++) { RtlClearAllBits(&bitmap); VspAcquire(Extension->Root); l = filter->VolumeList.Blink; if (l != &Extension->ListEntry) { VspRelease(Extension->Root); ExFreePool(bitmapBuffer); return STATUS_INVALID_PARAMETER; } j = 0; for (;;) { if (l == &filter->VolumeList) { break; } j++; if (j == i) { break; } l = l->Blink; } if (j < i) { VspRelease(Extension->Root); break; } e = CONTAINING_RECORD(l, VOLUME_EXTENSION, ListEntry); ObReferenceObject(e->DeviceObject); VspRelease(Extension->Root); status = VspComputeIgnorableBitmap(e, &bitmap); if (!NT_SUCCESS(status)) { VspAcquire(Extension->Root); if (e->IsDead) { VspRelease(Extension->Root); ObDereferenceObject(e->DeviceObject); ExFreePool(bitmapBuffer); return STATUS_SUCCESS; } VspRelease(Extension->Root); ObDereferenceObject(e->DeviceObject); ExFreePool(bitmapBuffer); return status; } ObDereferenceObject(e->DeviceObject); KeAcquireSpinLock(&Extension->SpinLock, &irql); if (Extension->IgnorableProduct) { VspAndBitmaps(Extension->IgnorableProduct, &bitmap); } KeReleaseSpinLock(&Extension->SpinLock, irql); } ExFreePool(bitmapBuffer); return STATUS_SUCCESS; } VOID VspQueryMinimumDiffAreaFileSize( IN PDO_EXTENSION RootExtension, OUT PLONGLONG MinDiffAreaFileSize ) { ULONG zero, size; RTL_QUERY_REGISTRY_TABLE queryTable[2]; NTSTATUS status; zero = 0; RtlZeroMemory(queryTable, 2*sizeof(RTL_QUERY_REGISTRY_TABLE)); queryTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT; queryTable[0].Name = L"MinDiffAreaFileSize"; queryTable[0].EntryContext = &size; queryTable[0].DefaultType = REG_DWORD; queryTable[0].DefaultData = &zero; queryTable[0].DefaultLength = sizeof(ULONG); status = RtlQueryRegistryValues(RTL_REGISTRY_ABSOLUTE, RootExtension->RegistryPath.Buffer, queryTable, NULL, NULL); if (!NT_SUCCESS(status)) { size = zero; } *MinDiffAreaFileSize = ((LONGLONG) size)*1024*1024; } VOID VspPrepareForSnapshotWorker( IN PDEVICE_OBJECT DeviceObject, IN PVOID Context ) { PVSP_CONTEXT context = (PVSP_CONTEXT) Context; PFILTER_EXTENSION Filter = (PFILTER_EXTENSION) DeviceObject->DeviceExtension; PIRP Irp = context->Dispatch.Irp; PDO_EXTENSION rootExtension = Filter->Root; PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation(Irp); PVOLSNAP_PREPARE_INFO input = (PVOLSNAP_PREPARE_INFO) Irp->AssociatedIrp.SystemBuffer; LONGLONG minDiffAreaFileSize; KIRQL irql; ULONG volumeNumber; WCHAR buffer[100]; UNICODE_STRING volumeName; NTSTATUS status; PDEVICE_OBJECT deviceObject; PVOLUME_EXTENSION extension, e; ULONG bitmapSize, n; PVOID bitmapBuffer, p; PVOID buf; PMDL mdl; ASSERT(context->Type == VSP_CONTEXT_TYPE_DISPATCH); if (irpSp->Parameters.DeviceIoControl.InputBufferLength < sizeof(VOLSNAP_PREPARE_INFO)) { Irp->IoStatus.Status = STATUS_INVALID_PARAMETER; goto Finish; } if (input->Attributes&(~VOLSNAP_ALL_ATTRIBUTES)) { Irp->IoStatus.Status = STATUS_INVALID_PARAMETER; goto Finish; } if (input->Attributes&VOLSNAP_ATTRIBUTE_PERSISTENT) { Irp->IoStatus.Status = STATUS_NOT_SUPPORTED; goto Finish; } KeWaitForSingleObject(&Filter->EndCommitProcessCompleted, Executive, KernelMode, FALSE, NULL); VspQueryMinimumDiffAreaFileSize(Filter->Root, &minDiffAreaFileSize); if (input->InitialDiffAreaAllocation < 2*NOMINAL_DIFF_AREA_FILE_GROWTH) { input->InitialDiffAreaAllocation = 2*NOMINAL_DIFF_AREA_FILE_GROWTH; } if (input->InitialDiffAreaAllocation < minDiffAreaFileSize) { input->InitialDiffAreaAllocation = minDiffAreaFileSize; } for (volumeNumber = 1;; volumeNumber++) { swprintf(buffer, L"\\Device\\HarddiskVolumeShadowCopy%d", volumeNumber); RtlInitUnicodeString(&volumeName, buffer); status = IoCreateDevice(rootExtension->DriverObject, sizeof(VOLUME_EXTENSION), &volumeName, FILE_DEVICE_DISK, 0, FALSE, &deviceObject); if (status != STATUS_OBJECT_NAME_COLLISION) { break; } } if (!NT_SUCCESS(status)) { Irp->IoStatus.Status = status; goto Finish; } extension = (PVOLUME_EXTENSION) deviceObject->DeviceExtension; RtlZeroMemory(extension, sizeof(VOLUME_EXTENSION)); extension->DeviceObject = deviceObject; extension->Root = Filter->Root; extension->DeviceExtensionType = DEVICE_EXTENSION_VOLUME; KeInitializeSpinLock(&extension->SpinLock); extension->Filter = Filter; extension->RefCount = 1; InitializeListHead(&extension->HoldIrpQueue); InitializeListHead(&extension->HoldWorkerQueue); KeInitializeEvent(&extension->ZeroRefEvent, NotificationEvent, FALSE); extension->VolumeNumber = volumeNumber; RtlInitializeGenericTable(&extension->VolumeBlockTable, VspTableCompareRoutine, VspTableAllocateRoutine, VspTableFreeRoutine, extension); RtlInitializeGenericTable(&extension->TempVolumeBlockTable, VspTableCompareRoutine, VspTempTableAllocateRoutine, VspTempTableFreeRoutine, extension); extension->DiffAreaFileIncrease = NOMINAL_DIFF_AREA_FILE_GROWTH; status = VspCreateInitialDiffAreaFiles(extension, input->InitialDiffAreaAllocation); if (!NT_SUCCESS(status)) { IoDeleteDevice(deviceObject); Irp->IoStatus.Status = status; goto Finish; } status = VspCreateWorkerThread(rootExtension); if (!NT_SUCCESS(status)) { VspLogError(extension, NULL, VS_CREATE_WORKER_THREADS_FAILED, status, 0); VspDeleteInitialDiffAreaFiles(extension); IoDeleteDevice(deviceObject); Irp->IoStatus.Status = status; goto Finish; } extension->VolumeBlockBitmap = (PRTL_BITMAP) ExAllocatePoolWithTag( NonPagedPool, sizeof(RTL_BITMAP), VOLSNAP_TAG_BITMAP); if (!extension->VolumeBlockBitmap) { VspDeleteWorkerThread(rootExtension); VspDeleteInitialDiffAreaFiles(extension); IoDeleteDevice(deviceObject); Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES; goto Finish; } extension->VolumeSize = VspQueryVolumeSize(Filter); if (!extension->VolumeSize) { ExFreePool(extension->VolumeBlockBitmap); extension->VolumeBlockBitmap = NULL; VspDeleteWorkerThread(rootExtension); VspDeleteInitialDiffAreaFiles(extension); IoDeleteDevice(deviceObject); Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES; goto Finish; } bitmapSize = (ULONG) ((extension->VolumeSize + BLOCK_SIZE - 1)>> BLOCK_SHIFT); bitmapBuffer = ExAllocatePoolWithTag(NonPagedPool, (bitmapSize + 8*sizeof(ULONG) - 1)/ (8*sizeof(ULONG))*sizeof(ULONG), VOLSNAP_TAG_BITMAP); if (!bitmapBuffer) { VspLogError(extension, NULL, VS_CANT_ALLOCATE_BITMAP, STATUS_INSUFFICIENT_RESOURCES, 0); ExFreePool(extension->VolumeBlockBitmap); extension->VolumeBlockBitmap = NULL; VspDeleteWorkerThread(rootExtension); VspDeleteInitialDiffAreaFiles(extension); IoDeleteDevice(deviceObject); Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES; goto Finish; } RtlInitializeBitMap(extension->VolumeBlockBitmap, (PULONG) bitmapBuffer, bitmapSize); RtlClearAllBits(extension->VolumeBlockBitmap); status = VspCreateInitialHeap(extension); if (!NT_SUCCESS(status)) { ExFreePool(bitmapBuffer); ExFreePool(extension->VolumeBlockBitmap); extension->VolumeBlockBitmap = NULL; VspDeleteWorkerThread(rootExtension); VspDeleteInitialDiffAreaFiles(extension); IoDeleteDevice(deviceObject); Irp->IoStatus.Status = status; goto Finish; } InitializeListHead(&extension->OldHeaps); extension->EmergencyCopyIrp = IoAllocateIrp((CCHAR) extension->Root->StackSize, FALSE); if (!extension->EmergencyCopyIrp) { status = ZwUnmapViewOfSection(extension->DiffAreaFileMapProcess, extension->DiffAreaFileMap); ASSERT(NT_SUCCESS(status)); status = ZwUnmapViewOfSection(extension->DiffAreaFileMapProcess, extension->NextDiffAreaFileMap); ASSERT(NT_SUCCESS(status)); ExFreePool(bitmapBuffer); ExFreePool(extension->VolumeBlockBitmap); extension->VolumeBlockBitmap = NULL; VspDeleteWorkerThread(rootExtension); VspDeleteInitialDiffAreaFiles(extension); IoDeleteDevice(deviceObject); Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES; goto Finish; } buf = ExAllocatePoolWithTag(NonPagedPool, BLOCK_SIZE, VOLSNAP_TAG_BUFFER); if (!buf) { IoFreeIrp(extension->EmergencyCopyIrp); status = ZwUnmapViewOfSection(extension->DiffAreaFileMapProcess, extension->DiffAreaFileMap); ASSERT(NT_SUCCESS(status)); status = ZwUnmapViewOfSection(extension->DiffAreaFileMapProcess, extension->NextDiffAreaFileMap); ASSERT(NT_SUCCESS(status)); ExFreePool(bitmapBuffer); ExFreePool(extension->VolumeBlockBitmap); extension->VolumeBlockBitmap = NULL; VspDeleteWorkerThread(rootExtension); VspDeleteInitialDiffAreaFiles(extension); IoDeleteDevice(deviceObject); Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES; goto Finish; } mdl = IoAllocateMdl(buf, BLOCK_SIZE, FALSE, FALSE, NULL); if (!mdl) { ExFreePool(buf); IoFreeIrp(extension->EmergencyCopyIrp); status = ZwUnmapViewOfSection(extension->DiffAreaFileMapProcess, extension->DiffAreaFileMap); ASSERT(NT_SUCCESS(status)); status = ZwUnmapViewOfSection(extension->DiffAreaFileMapProcess, extension->NextDiffAreaFileMap); ASSERT(NT_SUCCESS(status)); ExFreePool(bitmapBuffer); ExFreePool(extension->VolumeBlockBitmap); extension->VolumeBlockBitmap = NULL; VspDeleteWorkerThread(rootExtension); VspDeleteInitialDiffAreaFiles(extension); IoDeleteDevice(deviceObject); Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES; goto Finish; } MmBuildMdlForNonPagedPool(mdl); extension->EmergencyCopyIrp->MdlAddress = mdl; InitializeListHead(&extension->EmergencyCopyIrpQueue); InitializeListHead(&extension->WaitingForPageFileSpace); VspAcquire(rootExtension); if (!IsListEmpty(&Filter->VolumeList)) { extension->IgnorableProduct = (PRTL_BITMAP) ExAllocatePoolWithTag(NonPagedPool, sizeof(RTL_BITMAP), VOLSNAP_TAG_BITMAP); if (!extension->IgnorableProduct) { VspRelease(rootExtension); ExFreePool(buf); IoFreeIrp(extension->EmergencyCopyIrp); IoFreeMdl(mdl); status = ZwUnmapViewOfSection(extension->DiffAreaFileMapProcess, extension->DiffAreaFileMap); ASSERT(NT_SUCCESS(status)); status = ZwUnmapViewOfSection(extension->DiffAreaFileMapProcess, extension->NextDiffAreaFileMap); ASSERT(NT_SUCCESS(status)); ExFreePool(bitmapBuffer); ExFreePool(extension->VolumeBlockBitmap); extension->VolumeBlockBitmap = NULL; VspDeleteWorkerThread(rootExtension); VspDeleteInitialDiffAreaFiles(extension); IoDeleteDevice(deviceObject); Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES; goto Finish; } p = ExAllocatePoolWithTag(NonPagedPool, (bitmapSize + 8*sizeof(ULONG) - 1)/ (8*sizeof(ULONG))*sizeof(ULONG), VOLSNAP_TAG_BITMAP); if (!p) { ExFreePool(extension->IgnorableProduct); extension->IgnorableProduct = NULL; VspRelease(rootExtension); ExFreePool(buf); IoFreeMdl(mdl); IoFreeIrp(extension->EmergencyCopyIrp); status = ZwUnmapViewOfSection(extension->DiffAreaFileMapProcess, extension->DiffAreaFileMap); ASSERT(NT_SUCCESS(status)); status = ZwUnmapViewOfSection(extension->DiffAreaFileMapProcess, extension->NextDiffAreaFileMap); ASSERT(NT_SUCCESS(status)); ExFreePool(bitmapBuffer); ExFreePool(extension->VolumeBlockBitmap); extension->VolumeBlockBitmap = NULL; VspDeleteWorkerThread(rootExtension); VspDeleteInitialDiffAreaFiles(extension); IoDeleteDevice(deviceObject); Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES; goto Finish; } RtlInitializeBitMap(extension->IgnorableProduct, (PULONG) p, bitmapSize); RtlSetAllBits(extension->IgnorableProduct); e = CONTAINING_RECORD(Filter->VolumeList.Blink, VOLUME_EXTENSION, ListEntry); KeAcquireSpinLock(&e->SpinLock, &irql); if (e->VolumeBlockBitmap) { n = extension->IgnorableProduct->SizeOfBitMap; extension->IgnorableProduct->SizeOfBitMap = e->VolumeBlockBitmap->SizeOfBitMap; VspAndBitmaps(extension->IgnorableProduct, e->VolumeBlockBitmap); extension->IgnorableProduct->SizeOfBitMap = n; } KeReleaseSpinLock(&e->SpinLock, irql); } status = VspSetDiffAreaBlocksInBitmap(extension); if (!NT_SUCCESS(status)) { if (extension->IgnorableProduct) { ExFreePool(extension->IgnorableProduct->Buffer); ExFreePool(extension->IgnorableProduct); extension->IgnorableProduct = NULL; } VspRelease(rootExtension); ExFreePool(buf); IoFreeMdl(mdl); IoFreeIrp(extension->EmergencyCopyIrp); status = ZwUnmapViewOfSection(extension->DiffAreaFileMapProcess, extension->DiffAreaFileMap); ASSERT(NT_SUCCESS(status)); status = ZwUnmapViewOfSection(extension->DiffAreaFileMapProcess, extension->NextDiffAreaFileMap); ASSERT(NT_SUCCESS(status)); ExFreePool(bitmapBuffer); ExFreePool(extension->VolumeBlockBitmap); extension->VolumeBlockBitmap = NULL; VspDeleteWorkerThread(rootExtension); VspDeleteInitialDiffAreaFiles(extension); IoDeleteDevice(deviceObject); Irp->IoStatus.Status = status; goto Finish; } KeAcquireSpinLock(&Filter->SpinLock, &irql); e = Filter->PreparedSnapshot; Filter->PreparedSnapshot = extension; KeReleaseSpinLock(&Filter->SpinLock, irql); VspRelease(rootExtension); if (e) { VspCleanupInitialSnapshot(e, TRUE); } deviceObject->Flags |= DO_DIRECT_IO; deviceObject->StackSize = Filter->DeviceObject->StackSize; deviceObject->Flags &= ~DO_DEVICE_INITIALIZING; Finish: IoFreeWorkItem(context->Dispatch.IoWorkItem); VspFreeContext(rootExtension, context); IoCompleteRequest(Irp, IO_NO_INCREMENT); } NTSTATUS VspPrepareForSnapshot( IN PFILTER_EXTENSION Filter, IN PIRP Irp ) /*++ Routine Description: This routine prepares a snapshot device object to be used later for a snapshot. This phase is distict from commit snapshot because it can be called before IRPs are held. Besides creating the device object, this routine will also pre allocate some of the diff area. Arguments: Filter - Supplies the filter extension. Irp - Supplies the I/O request packet. Return Value: NTSTATUS --*/ { PVSP_CONTEXT context; Irp->IoStatus.Status = STATUS_SUCCESS; Irp->IoStatus.Information = 0; context = VspAllocateContext(Filter->Root); if (!context) { return STATUS_INSUFFICIENT_RESOURCES; } context->Type = VSP_CONTEXT_TYPE_DISPATCH; context->Dispatch.IoWorkItem = IoAllocateWorkItem(Filter->DeviceObject); if (!context->Dispatch.IoWorkItem) { VspFreeContext(Filter->Root, context); return STATUS_INSUFFICIENT_RESOURCES; } IoMarkIrpPending(Irp); context->Dispatch.Irp = Irp; IoQueueWorkItem(context->Dispatch.IoWorkItem, VspPrepareForSnapshotWorker, DelayedWorkQueue, context); return STATUS_PENDING; } VOID VspCleanupBitsSetInOtherPreparedSnapshots( IN PVOLUME_EXTENSION Extension ) { PLIST_ENTRY l; PVSP_DIFF_AREA_FILE diffAreaFile; NTSTATUS status; for (l = Extension->ListOfDiffAreaFiles.Flink; l != &Extension->ListOfDiffAreaFiles; l = l->Flink) { diffAreaFile = CONTAINING_RECORD(l, VSP_DIFF_AREA_FILE, VolumeListEntry); if (diffAreaFile->FilterListEntryBeingUsed) { RemoveEntryList(&diffAreaFile->FilterListEntry); diffAreaFile->FilterListEntryBeingUsed = FALSE; } if (diffAreaFile->Filter != Extension->Filter && diffAreaFile->Filter->PreparedSnapshot) { status = VspMarkFileAllocationInBitmap( diffAreaFile->Filter->PreparedSnapshot, diffAreaFile->FileHandle, NULL, FALSE, TRUE, NULL); if (!NT_SUCCESS(status)) { VspLogError(Extension, diffAreaFile->Filter, VS_CANT_MAP_DIFF_AREA_FILE, status, 7); VspAbortPreparedSnapshot(diffAreaFile->Filter, FALSE); } } } } VOID VspCleanupInitialMaps( IN PVOID Context ) { PVSP_CONTEXT context = (PVSP_CONTEXT) Context; PVOLUME_EXTENSION extension = context->Extension.Extension; NTSTATUS status; ASSERT(context->Type == VSP_CONTEXT_TYPE_EXTENSION); status = ZwUnmapViewOfSection(extension->DiffAreaFileMapProcess, extension->DiffAreaFileMap); ASSERT(NT_SUCCESS(status)); status = ZwUnmapViewOfSection(extension->DiffAreaFileMapProcess, extension->NextDiffAreaFileMap); ASSERT(NT_SUCCESS(status)); VspFreeContext(extension->Root, context); VspReleasePagedResource(extension); ObDereferenceObject(extension->DeviceObject); } VOID VspCleanupInitialSnapshot( IN PVOLUME_EXTENSION Extension, IN BOOLEAN NeedLock ) { PVSP_CONTEXT context; NTSTATUS status; KIRQL irql; context = VspAllocateContext(Extension->Root); if (context) { context->Type = VSP_CONTEXT_TYPE_EXTENSION; context->Extension.Extension = Extension; context->Extension.Irp = NULL; ExInitializeWorkItem(&context->WorkItem, VspCleanupInitialMaps, context); ObReferenceObject(Extension->DeviceObject); VspAcquirePagedResource(Extension, &context->WorkItem); } else { status = ZwUnmapViewOfSection(Extension->DiffAreaFileMapProcess, Extension->DiffAreaFileMap); ASSERT(NT_SUCCESS(status)); status = ZwUnmapViewOfSection(Extension->DiffAreaFileMapProcess, Extension->NextDiffAreaFileMap); ASSERT(NT_SUCCESS(status)); } if (NeedLock) { VspAcquire(Extension->Root); } VspDeleteWorkerThread(Extension->Root); VspCleanupBitsSetInOtherPreparedSnapshots(Extension); VspDeleteInitialDiffAreaFiles(Extension); if (NeedLock) { VspRelease(Extension->Root); } KeAcquireSpinLock(&Extension->SpinLock, &irql); ExFreePool(Extension->VolumeBlockBitmap->Buffer); ExFreePool(Extension->VolumeBlockBitmap); Extension->VolumeBlockBitmap = NULL; if (Extension->IgnorableProduct) { ExFreePool(Extension->IgnorableProduct->Buffer); ExFreePool(Extension->IgnorableProduct); Extension->IgnorableProduct = NULL; } KeReleaseSpinLock(&Extension->SpinLock, irql); ExFreePool(MmGetMdlVirtualAddress( Extension->EmergencyCopyIrp->MdlAddress)); IoFreeMdl(Extension->EmergencyCopyIrp->MdlAddress); IoFreeIrp(Extension->EmergencyCopyIrp); IoDeleteDevice(Extension->DeviceObject); } NTSTATUS VspAbortPreparedSnapshot( IN PFILTER_EXTENSION Filter, IN BOOLEAN NeedLock ) /*++ Routine Description: This routine aborts the prepared snapshot. Arguments: Filter - Supplies the filter extension. Return Value: NTSTATUS --*/ { KIRQL irql; PVOLUME_EXTENSION extension; if (NeedLock) { VspAcquire(Filter->Root); } KeAcquireSpinLock(&Filter->SpinLock, &irql); extension = Filter->PreparedSnapshot; Filter->PreparedSnapshot = NULL; KeReleaseSpinLock(&Filter->SpinLock, irql); if (NeedLock) { VspRelease(Filter->Root); } if (!extension) { return STATUS_INVALID_PARAMETER; } VspCleanupInitialSnapshot(extension, NeedLock); return STATUS_SUCCESS; } NTSTATUS VspMarkFreeSpaceInBitmap( IN PVOLUME_EXTENSION Extension, IN HANDLE UseThisHandle, IN PRTL_BITMAP BitmapToSet ) /*++ Routine Description: This routine opens the snapshot volume and marks off the free space in the NTFS bitmap as 'ignorable'. Arguments: Extension - Supplies the volume extension. Return Value: NTSTATUS --*/ { WCHAR buffer[100]; KEVENT event; IO_STATUS_BLOCK ioStatus; UNICODE_STRING fileName; OBJECT_ATTRIBUTES oa; NTSTATUS status; HANDLE h; LARGE_INTEGER timeout; BOOLEAN isNtfs; FILE_FS_SIZE_INFORMATION fsSize; ULONG bitmapSize; STARTING_LCN_INPUT_BUFFER input; PVOLUME_BITMAP_BUFFER output; RTL_BITMAP freeSpaceBitmap; ULONG bpc, f, numBits, startBit, s, n, i; KIRQL irql; ULONG r; if (UseThisHandle) { h = UseThisHandle; } else { swprintf(buffer, L"\\Device\\HarddiskVolumeShadowCopy%d", Extension->VolumeNumber); RtlInitUnicodeString(&fileName, buffer); InitializeObjectAttributes(&oa, &fileName, OBJ_CASE_INSENSITIVE, NULL, NULL); KeInitializeEvent(&event, NotificationEvent, FALSE); timeout.QuadPart = -10*1000; // 1 millisecond. for (i = 0; i < 5000; i++) { status = ZwOpenFile(&h, FILE_GENERIC_READ, &oa, &ioStatus, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, FILE_SYNCHRONOUS_IO_NONALERT); if (NT_SUCCESS(status)) { break; } if (status != STATUS_NO_SUCH_DEVICE) { return status; } KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, &timeout); } if (!NT_SUCCESS(status)) { return status; } } status = VspIsNtfs(h, &isNtfs); if (!NT_SUCCESS(status) || !isNtfs) { if (!UseThisHandle) { ZwClose(h); } return status; } status = ZwQueryVolumeInformationFile(h, &ioStatus, &fsSize, sizeof(fsSize), FileFsSizeInformation); if (!NT_SUCCESS(status)) { if (!UseThisHandle) { ZwClose(h); } return status; } bitmapSize = (ULONG) ((fsSize.TotalAllocationUnits.QuadPart+7)/8 + FIELD_OFFSET(VOLUME_BITMAP_BUFFER, Buffer) + 3); input.StartingLcn.QuadPart = 0; output = (PVOLUME_BITMAP_BUFFER) ExAllocatePoolWithTag(PagedPool, bitmapSize, VOLSNAP_TAG_BITMAP); if (!output) { if (!UseThisHandle) { ZwClose(h); } return STATUS_INSUFFICIENT_RESOURCES; } status = ZwFsControlFile(h, NULL, NULL, NULL, &ioStatus, FSCTL_GET_VOLUME_BITMAP, &input, sizeof(input), output, bitmapSize); if (!UseThisHandle) { ZwClose(h); } if (!NT_SUCCESS(status)) { ExFreePool(output); return status; } ASSERT(output->BitmapSize.HighPart == 0); RtlInitializeBitMap(&freeSpaceBitmap, (PULONG) output->Buffer, output->BitmapSize.LowPart); bpc = fsSize.BytesPerSector*fsSize.SectorsPerAllocationUnit; if (bpc < BLOCK_SIZE) { f = BLOCK_SIZE/bpc; } else { f = bpc/BLOCK_SIZE; } startBit = 0; for (;;) { if (startBit < freeSpaceBitmap.SizeOfBitMap) { numBits = RtlFindNextForwardRunClear(&freeSpaceBitmap, startBit, &startBit); } else { numBits = 0; } if (!numBits) { break; } if (bpc == BLOCK_SIZE) { s = startBit; n = numBits; } else if (bpc < BLOCK_SIZE) { s = (startBit + f - 1)/f; r = startBit%f; if (r) { if (numBits > f - r) { n = numBits - (f - r); } else { n = 0; } } else { n = numBits; } n /= f; } else { s = startBit*f; n = numBits*f; } if (n) { if (BitmapToSet) { RtlSetBits(BitmapToSet, s, n); } else { KeAcquireSpinLock(&Extension->SpinLock, &irql); if (Extension->VolumeBlockBitmap) { if (Extension->IgnorableProduct) { for (i = 0; i < n; i++) { if (RtlCheckBit(Extension->IgnorableProduct, i + s)) { RtlSetBit(Extension->VolumeBlockBitmap, i + s); } } } else { RtlSetBits(Extension->VolumeBlockBitmap, s, n); } } KeReleaseSpinLock(&Extension->SpinLock, irql); } } startBit += numBits; } ExFreePool(output); return STATUS_SUCCESS; } NTSTATUS VspSetIgnorableBlocksInBitmap( IN PVOID Extension ) /*++ Routine Description: This routine opens all of the Diff Area files on the given volume and marks them off as ignorable in the bitmap to avoid bad recursions and to improve performance. The free space is also marked off. If a diff area file for this snapshot was allocated on this volume then its diff area was pre marked off on the bitmap. This routine will check make sure that the location has not moved. This routine will eventually mark the pagefile too but that is just pure performance and not required. Arguments: Extension - Supplies the volume extension. Return Value: NTSTATUS --*/ { PVOLUME_EXTENSION extension = (PVOLUME_EXTENSION) Extension; WCHAR nameBuffer[100]; UNICODE_STRING name; OBJECT_ATTRIBUTES oa; NTSTATUS status, status2; HANDLE h; IO_STATUS_BLOCK ioStatus; KIRQL irql; status = VspMarkFreeSpaceInBitmap(extension, NULL, NULL); swprintf(nameBuffer, L"\\Device\\HarddiskVolumeShadowCopy%d\\pagefile.sys", extension->VolumeNumber); RtlInitUnicodeString(&name, nameBuffer); InitializeObjectAttributes(&oa, &name, OBJ_CASE_INSENSITIVE, NULL, NULL); status2 = ZwOpenFile(&h, FILE_GENERIC_READ, &oa, &ioStatus, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, FILE_SYNCHRONOUS_IO_NONALERT); if (NT_SUCCESS(status2)) { VspMarkFileAllocationInBitmap(extension, h, NULL, FALSE, FALSE, NULL); ZwClose(h); } return status; } NTSTATUS VspCommitSnapshot( IN PFILTER_EXTENSION Filter, IN PIRP Irp ) /*++ Routine Description: This routine commits the prepared snapshot. Arguments: Filter - Supplies the filter extension. Irp - Supplies the I/O request packet. Return Value: NTSTATUS --*/ { KIRQL irql; PVOLUME_EXTENSION extension, previousExtension; PLIST_ENTRY l; PVSP_DIFF_AREA_FILE diffAreaFile; VspAcquire(Filter->Root); KeAcquireSpinLock(&Filter->SpinLock, &irql); extension = Filter->PreparedSnapshot; Filter->PreparedSnapshot = NULL; KeReleaseSpinLock(&Filter->SpinLock, irql); if (!extension) { VspRelease(Filter->Root); return STATUS_INVALID_PARAMETER; } if (!Filter->HoldIncomingWrites) { VspRelease(Filter->Root); VspCleanupInitialSnapshot(extension, TRUE); return STATUS_INVALID_PARAMETER; } KeAcquireSpinLock(&Filter->SpinLock, &irql); InterlockedExchange(&Filter->SnapshotsPresent, TRUE); InsertTailList(&Filter->VolumeList, &extension->ListEntry); KeReleaseSpinLock(&Filter->SpinLock, irql); l = extension->ListEntry.Blink; if (l != &Filter->VolumeList) { previousExtension = CONTAINING_RECORD(l, VOLUME_EXTENSION, ListEntry); KeAcquireSpinLock(&previousExtension->SpinLock, &irql); ExFreePool(previousExtension->VolumeBlockBitmap->Buffer); ExFreePool(previousExtension->VolumeBlockBitmap); previousExtension->VolumeBlockBitmap = NULL; KeReleaseSpinLock(&previousExtension->SpinLock, irql); } KeQuerySystemTime(&extension->CommitTimeStamp); VspRelease(Filter->Root); return STATUS_SUCCESS; } NTSTATUS VspEndCommitSnapshot( IN PFILTER_EXTENSION Filter, IN PIRP Irp ) /*++ Routine Description: This routine commits the prepared snapshot. Arguments: Filter - Supplies the filter extension. Irp - Supplies the I/O request packet. Return Value: NTSTATUS --*/ { PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation(Irp); PLIST_ENTRY l; PVOLUME_EXTENSION extension; WCHAR buffer[100]; UNICODE_STRING volumeName; PVOLSNAP_NAME output; NTSTATUS status; LARGE_INTEGER timeout; VspAcquire(Filter->Root); l = Filter->VolumeList.Blink; if (l == &Filter->VolumeList) { VspRelease(Filter->Root); return STATUS_INVALID_PARAMETER; } extension = CONTAINING_RECORD(l, VOLUME_EXTENSION, ListEntry); if (extension->HasEndCommit) { VspRelease(Filter->Root); return STATUS_INVALID_PARAMETER; } if (irpSp->Parameters.DeviceIoControl.InputBufferLength) { status = VspSetApplicationInfo(extension, Irp); if (!NT_SUCCESS(status)) { VspRelease(Filter->Root); return status; } } swprintf(buffer, L"\\Device\\HarddiskVolumeShadowCopy%d", extension->VolumeNumber); RtlInitUnicodeString(&volumeName, buffer); Irp->IoStatus.Information = FIELD_OFFSET(VOLSNAP_NAME, Name) + volumeName.Length + sizeof(WCHAR); if (Irp->IoStatus.Information > irpSp->Parameters.DeviceIoControl.OutputBufferLength) { VspRelease(Filter->Root); Irp->IoStatus.Information = 0; return STATUS_INVALID_PARAMETER; } output = (PVOLSNAP_NAME) Irp->AssociatedIrp.SystemBuffer; output->NameLength = volumeName.Length; RtlCopyMemory(output->Name, volumeName.Buffer, output->NameLength + sizeof(WCHAR)); extension->HasEndCommit = TRUE; VspTruncatePreviousDiffArea(extension); if (!KeCancelTimer(&Filter->EndCommitTimer)) { ObReferenceObject(Filter->DeviceObject); } KeResetEvent(&Filter->EndCommitProcessCompleted); timeout.QuadPart = (LONGLONG) -10*1000*1000*120*10; // 20 minutes. KeSetTimer(&Filter->EndCommitTimer, timeout, &Filter->EndCommitTimerDpc); VspRelease(Filter->Root); IoInvalidateDeviceRelations(Filter->Pdo, BusRelations); return STATUS_SUCCESS; } NTSTATUS VspVolumeRefCountCompletionRoutine( IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Extension ) { PVOLUME_EXTENSION extension = (PVOLUME_EXTENSION) Extension; VspDecrementVolumeRefCount(extension); return STATUS_SUCCESS; } NTSTATUS VspQueryNamesOfSnapshots( IN PFILTER_EXTENSION Filter, IN PIRP Irp ) /*++ Routine Description: This routine returns the names of all of the snapshots for this filter. Arguments: Filter - Supplies the filter extension. Irp - Supplies the I/O request packet. Return Value: NTSTATUS --*/ { PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation(Irp); PVOLSNAP_NAMES output; PLIST_ENTRY l; PVOLUME_EXTENSION extension; WCHAR buffer[100]; UNICODE_STRING name; PWCHAR buf; Irp->IoStatus.Information = FIELD_OFFSET(VOLSNAP_NAMES, Names); if (irpSp->Parameters.DeviceIoControl.OutputBufferLength < Irp->IoStatus.Information) { Irp->IoStatus.Information = 0; return STATUS_INVALID_PARAMETER; } KeWaitForSingleObject(&Filter->EndCommitProcessCompleted, Executive, KernelMode, FALSE, NULL); output = (PVOLSNAP_NAMES) Irp->AssociatedIrp.SystemBuffer; VspAcquire(Filter->Root); output->MultiSzLength = sizeof(WCHAR); for (l = Filter->VolumeList.Flink; l != &Filter->VolumeList; l = l->Flink) { extension = CONTAINING_RECORD(l, VOLUME_EXTENSION, ListEntry); swprintf(buffer, L"\\Device\\HarddiskVolumeShadowCopy%d", extension->VolumeNumber); RtlInitUnicodeString(&name, buffer); output->MultiSzLength += name.Length + sizeof(WCHAR); } if (irpSp->Parameters.DeviceIoControl.OutputBufferLength < Irp->IoStatus.Information + output->MultiSzLength) { VspRelease(Filter->Root); return STATUS_BUFFER_OVERFLOW; } Irp->IoStatus.Information += output->MultiSzLength; buf = output->Names; for (l = Filter->VolumeList.Flink; l != &Filter->VolumeList; l = l->Flink) { extension = CONTAINING_RECORD(l, VOLUME_EXTENSION, ListEntry); swprintf(buf, L"\\Device\\HarddiskVolumeShadowCopy%d", extension->VolumeNumber); RtlInitUnicodeString(&name, buf); buf += name.Length/sizeof(WCHAR) + 1; } *buf = 0; VspRelease(Filter->Root); return STATUS_SUCCESS; } NTSTATUS VspClearDiffArea( IN PFILTER_EXTENSION Filter, IN PIRP Irp ) /*++ Routine Description: This routine clears the list of diff areas used by this filter. This call will fail if there are any snapshots in flight. Arguments: Filter - Supplies the filter extension. Irp - Supplies the I/O request packet. Return Value: NTSTATUS --*/ { PLIST_ENTRY l; PVSP_DIFF_AREA_VOLUME diffAreaVolume; VspAcquire(Filter->Root); if (Filter->SnapshotsPresent) { VspRelease(Filter->Root); return STATUS_INVALID_PARAMETER; } while (!IsListEmpty(&Filter->DiffAreaVolumes)) { l = RemoveHeadList(&Filter->DiffAreaVolumes); diffAreaVolume = CONTAINING_RECORD(l, VSP_DIFF_AREA_VOLUME, ListEntry); ExFreePool(diffAreaVolume); } VspRelease(Filter->Root); return STATUS_SUCCESS; } VOID VspAddVolumeToDiffAreaWorker( IN PDEVICE_OBJECT DeviceObject, IN PVOID Context ) /*++ Routine Description: This routine adds the given volume to the diff area for this volume. All snapshots get a new diff area file. Arguments: Filter - Supplies the filter extension. Irp - Supplies the I/O request packet. Return Value: NTSTATUS --*/ { PVSP_CONTEXT context = (PVSP_CONTEXT) Context; PFILTER_EXTENSION Filter = (PFILTER_EXTENSION) DeviceObject->DeviceExtension; PIRP Irp = context->Dispatch.Irp; PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation(Irp); PVOLSNAP_NAME input; UNICODE_STRING volumeName; PFILTER_EXTENSION filter; PVSP_DIFF_AREA_VOLUME diffAreaVolume; PLIST_ENTRY l, ll; PVOLUME_EXTENSION extension; LONGLONG newDiffAreaFileSize, diff; PVSP_DIFF_AREA_FILE diffAreaFile; NTSTATUS status; KIRQL irql; if (irpSp->Parameters.DeviceIoControl.InputBufferLength < sizeof(VOLSNAP_NAME)) { VspLogError(NULL, Filter, VS_FAILURE_ADDING_DIFF_AREA, STATUS_INVALID_PARAMETER, 3); Irp->IoStatus.Status = STATUS_INVALID_PARAMETER; goto Finish; } input = (PVOLSNAP_NAME) Irp->AssociatedIrp.SystemBuffer; if (irpSp->Parameters.DeviceIoControl.InputBufferLength < (ULONG) FIELD_OFFSET(VOLSNAP_NAME, Name) + input->NameLength) { VspLogError(NULL, Filter, VS_FAILURE_ADDING_DIFF_AREA, STATUS_INVALID_PARAMETER, 4); Irp->IoStatus.Status = STATUS_INVALID_PARAMETER; goto Finish; } volumeName.Length = volumeName.MaximumLength = input->NameLength; volumeName.Buffer = input->Name; VspAcquire(Filter->Root); filter = VspFindFilter(Filter->Root, Filter, &volumeName, NULL); if (!filter || (filter->TargetObject->Characteristics&FILE_REMOVABLE_MEDIA)) { VspRelease(Filter->Root); Irp->IoStatus.Status = STATUS_INVALID_PARAMETER; goto Finish; } for (l = Filter->DiffAreaVolumes.Flink; l != &Filter->DiffAreaVolumes; l = l->Flink) { diffAreaVolume = CONTAINING_RECORD(l, VSP_DIFF_AREA_VOLUME, ListEntry); if (filter == diffAreaVolume->Filter) { break; } } if (l != &Filter->DiffAreaVolumes) { VspRelease(Filter->Root); VspLogError(NULL, Filter, VS_FAILURE_ADDING_DIFF_AREA, STATUS_DUPLICATE_OBJECTID, 5); Irp->IoStatus.Status = STATUS_INVALID_PARAMETER; goto Finish; } diffAreaVolume = (PVSP_DIFF_AREA_VOLUME) ExAllocatePoolWithTag(PagedPool, sizeof(VSP_DIFF_AREA_VOLUME), VOLSNAP_TAG_DIFF_VOLUME); if (!diffAreaVolume) { VspRelease(Filter->Root); Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES; goto Finish; } diffAreaVolume->Filter = filter; InsertTailList(&Filter->DiffAreaVolumes, &diffAreaVolume->ListEntry); l = Filter->VolumeList.Blink; if (l == &Filter->VolumeList) { VspRelease(Filter->Root); Irp->IoStatus.Status = STATUS_SUCCESS; goto Finish; } VspRelease(Filter->Root); extension = CONTAINING_RECORD(l, VOLUME_EXTENSION, ListEntry); newDiffAreaFileSize = 2*extension->DiffAreaFileIncrease; VspAcquireNonPagedResource(extension, NULL); for (ll = extension->ListOfDiffAreaFiles.Flink; ll != &extension->ListOfDiffAreaFiles; ll = ll->Flink) { diffAreaFile = CONTAINING_RECORD(ll, VSP_DIFF_AREA_FILE, VolumeListEntry); diff = diffAreaFile->AllocatedFileSize - diffAreaFile->NextAvailable; if (diff > newDiffAreaFileSize) { newDiffAreaFileSize = diff; } } VspReleaseNonPagedResource(extension); diffAreaFile = (PVSP_DIFF_AREA_FILE) ExAllocatePoolWithTag(NonPagedPool, sizeof(VSP_DIFF_AREA_FILE), VOLSNAP_TAG_DIFF_FILE); if (!diffAreaFile) { Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES; goto Finish; } diffAreaFile->Extension = extension; diffAreaFile->Filter = filter; diffAreaFile->NextAvailable = 0; diffAreaFile->AllocatedFileSize = newDiffAreaFileSize; status = VspOpenDiffAreaFile(diffAreaFile); if (!NT_SUCCESS(status)) { ExFreePool(diffAreaFile); Irp->IoStatus.Status = status; goto Finish; } InitializeListHead(&diffAreaFile->UnusedAllocationList); status = VspMarkFileAllocationInBitmap(extension, diffAreaFile->FileHandle, diffAreaFile, TRUE, FALSE, NULL); if (!NT_SUCCESS(status)) { VspLogError(extension, diffAreaFile->Filter, VS_CANT_MAP_DIFF_AREA_FILE, status, 8); ZwClose(diffAreaFile->FileHandle); ExFreePool(diffAreaFile); Irp->IoStatus.Status = status; goto Finish; } KeAcquireSpinLock(&Filter->SpinLock, &irql); Filter->AllocatedVolumeSpace += diffAreaFile->AllocatedFileSize; KeReleaseSpinLock(&Filter->SpinLock, irql); VspAcquire(Filter->Root); diffAreaFile->FilterListEntryBeingUsed = TRUE; InsertTailList(&diffAreaFile->Filter->DiffAreaFilesOnThisFilter, &diffAreaFile->FilterListEntry); VspPauseSnapshotIo(extension); VspPauseVolumeIo(extension->Filter); VspAcquireNonPagedResource(extension, NULL); InsertTailList(&extension->ListOfDiffAreaFiles, &diffAreaFile->VolumeListEntry); VspReleaseNonPagedResource(extension); VspResumeVolumeIo(extension->Filter); VspResumeSnapshotIo(extension); VspRelease(Filter->Root); Finish: VspFreeContext(Filter->Root, context); IoFreeWorkItem(context->Dispatch.IoWorkItem); IoCompleteRequest(Irp, IO_NO_INCREMENT); } NTSTATUS VspAddVolumeToDiffArea( IN PFILTER_EXTENSION Filter, IN PIRP Irp ) /*++ Routine Description: This routine adds the given volume to the diff area for this volume. All snapshots get a new diff area file. Arguments: Filter - Supplies the filter extension. Irp - Supplies the I/O request packet. Return Value: NTSTATUS --*/ { PVSP_CONTEXT context; Irp->IoStatus.Status = STATUS_SUCCESS; Irp->IoStatus.Information = 0; context = VspAllocateContext(Filter->Root); if (!context) { return STATUS_INSUFFICIENT_RESOURCES; } context->Type = VSP_CONTEXT_TYPE_DISPATCH; context->Dispatch.IoWorkItem = IoAllocateWorkItem(Filter->DeviceObject); if (!context->Dispatch.IoWorkItem) { VspFreeContext(Filter->Root, context); return STATUS_INSUFFICIENT_RESOURCES; } IoMarkIrpPending(Irp); context->Dispatch.Irp = Irp; IoQueueWorkItem(context->Dispatch.IoWorkItem, VspAddVolumeToDiffAreaWorker, DelayedWorkQueue, context); return STATUS_PENDING; } NTSTATUS VspQueryDiffArea( IN PFILTER_EXTENSION Filter, IN PIRP Irp ) /*++ Routine Description: This routine the list of volumes that make up the diff area for this volume. Arguments: Filter - Supplies the filter extension. Irp - Supplies the I/O request packet. Return Value: NTSTATUS --*/ { PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation(Irp); PVOLSNAP_NAMES output; PLIST_ENTRY l; PFILTER_EXTENSION filter; KEVENT event; PMOUNTDEV_NAME name; CHAR buffer[512]; PIRP irp; IO_STATUS_BLOCK ioStatus; NTSTATUS status; PWCHAR buf; Irp->IoStatus.Information = FIELD_OFFSET(VOLSNAP_NAMES, Names); if (irpSp->Parameters.DeviceIoControl.OutputBufferLength < Irp->IoStatus.Information) { Irp->IoStatus.Information = 0; return STATUS_INVALID_PARAMETER; } output = (PVOLSNAP_NAMES) Irp->AssociatedIrp.SystemBuffer; VspAcquire(Filter->Root); output->MultiSzLength = sizeof(WCHAR); for (l = Filter->DiffAreaVolumes.Flink; l != &Filter->DiffAreaVolumes; l = l->Flink) { filter = CONTAINING_RECORD(l, VSP_DIFF_AREA_VOLUME, ListEntry)->Filter; KeInitializeEvent(&event, NotificationEvent, FALSE); name = (PMOUNTDEV_NAME) buffer; irp = IoBuildDeviceIoControlRequest(IOCTL_MOUNTDEV_QUERY_DEVICE_NAME, filter->TargetObject, NULL, 0, name, 512, FALSE, &event, &ioStatus); if (!irp) { VspRelease(Filter->Root); Irp->IoStatus.Information = 0; return STATUS_INSUFFICIENT_RESOURCES; } status = IoCallDriver(filter->TargetObject, irp); if (status == STATUS_PENDING) { KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL); status = ioStatus.Status; } if (!NT_SUCCESS(status)) { VspRelease(Filter->Root); Irp->IoStatus.Information = 0; return status; } output->MultiSzLength += name->NameLength + sizeof(WCHAR); } if (irpSp->Parameters.DeviceIoControl.OutputBufferLength < Irp->IoStatus.Information + output->MultiSzLength) { VspRelease(Filter->Root); return STATUS_BUFFER_OVERFLOW; } Irp->IoStatus.Information += output->MultiSzLength; buf = output->Names; for (l = Filter->DiffAreaVolumes.Flink; l != &Filter->DiffAreaVolumes; l = l->Flink) { filter = CONTAINING_RECORD(l, VSP_DIFF_AREA_VOLUME, ListEntry)->Filter; KeInitializeEvent(&event, NotificationEvent, FALSE); name = (PMOUNTDEV_NAME) buffer; irp = IoBuildDeviceIoControlRequest(IOCTL_MOUNTDEV_QUERY_DEVICE_NAME, filter->TargetObject, NULL, 0, name, 512, FALSE, &event, &ioStatus); if (!irp) { VspRelease(Filter->Root); Irp->IoStatus.Information = 0; return STATUS_INSUFFICIENT_RESOURCES; } status = IoCallDriver(filter->TargetObject, irp); if (status == STATUS_PENDING) { KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL); status = ioStatus.Status; } if (!NT_SUCCESS(status)) { VspRelease(Filter->Root); Irp->IoStatus.Information = 0; return status; } RtlCopyMemory(buf, name->Name, name->NameLength); buf += name->NameLength/sizeof(WCHAR); *buf++ = 0; } *buf = 0; VspRelease(Filter->Root); return STATUS_SUCCESS; } NTSTATUS VspQueryDiffAreaSize( IN PFILTER_EXTENSION Filter, IN PIRP Irp ) /*++ Routine Description: This routine returns the diff area sizes for this volume. Arguments: Filter - Supplies the filter extension. Irp - Supplies the I/O request packet. Return Value: NTSTATUS --*/ { PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation(Irp); PVOLSNAP_DIFF_AREA_SIZES output = (PVOLSNAP_DIFF_AREA_SIZES) Irp->AssociatedIrp.SystemBuffer; KIRQL irql; Irp->IoStatus.Information = sizeof(VOLSNAP_DIFF_AREA_SIZES); if (irpSp->Parameters.DeviceIoControl.OutputBufferLength < Irp->IoStatus.Information) { Irp->IoStatus.Information = 0; return STATUS_INVALID_PARAMETER; } KeAcquireSpinLock(&Filter->SpinLock, &irql); output->UsedVolumeSpace = Filter->UsedVolumeSpace; output->AllocatedVolumeSpace = Filter->AllocatedVolumeSpace; output->MaximumVolumeSpace = Filter->MaximumVolumeSpace; KeReleaseSpinLock(&Filter->SpinLock, irql); return STATUS_SUCCESS; } NTSTATUS VspQueryOriginalVolumeName( IN PVOLUME_EXTENSION Extension, IN PIRP Irp ) /*++ Routine Description: This routine returns the original volume name for the given volume snapshot. Arguments: Extension - Supplies the volume extension. Irp - Supplies the I/O request packet. Return Value: NTSTATUS --*/ { PFILTER_EXTENSION filter = Extension->Filter; PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation(Irp); PVOLSNAP_NAME output = (PVOLSNAP_NAME) Irp->AssociatedIrp.SystemBuffer; PMOUNTDEV_NAME name; CHAR buffer[512]; KEVENT event; PIRP irp; IO_STATUS_BLOCK ioStatus; NTSTATUS status; Irp->IoStatus.Information = FIELD_OFFSET(VOLSNAP_NAME, Name); if (irpSp->Parameters.DeviceIoControl.OutputBufferLength < Irp->IoStatus.Information) { Irp->IoStatus.Information = 0; return STATUS_INVALID_PARAMETER; } name = (PMOUNTDEV_NAME) buffer; KeInitializeEvent(&event, NotificationEvent, FALSE); irp = IoBuildDeviceIoControlRequest(IOCTL_MOUNTDEV_QUERY_DEVICE_NAME, filter->TargetObject, NULL, 0, name, 512, FALSE, &event, &ioStatus); if (!irp) { Irp->IoStatus.Information = 0; return STATUS_INSUFFICIENT_RESOURCES; } status = IoCallDriver(filter->TargetObject, irp); if (status == STATUS_PENDING) { KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL); status = ioStatus.Status; } if (!NT_SUCCESS(status)) { Irp->IoStatus.Information = 0; return status; } output->NameLength = name->NameLength; if (irpSp->Parameters.DeviceIoControl.OutputBufferLength < Irp->IoStatus.Information + output->NameLength) { return STATUS_BUFFER_OVERFLOW; } RtlCopyMemory(output->Name, name->Name, output->NameLength); Irp->IoStatus.Information += output->NameLength; return STATUS_SUCCESS; } NTSTATUS VspQueryConfigInfo( IN PVOLUME_EXTENSION Extension, IN PIRP Irp ) /*++ Routine Description: This routine returns the configuration information for this volume snapshot. Arguments: Extension - Supplies the volume extension. Irp - Supplies the I/O request packet. Return Value: NTSTATUS --*/ { PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation(Irp); PVOLSNAP_CONFIG_INFO output = (PVOLSNAP_CONFIG_INFO) Irp->AssociatedIrp.SystemBuffer; Irp->IoStatus.Information = sizeof(ULONG); if (irpSp->Parameters.DeviceIoControl.OutputBufferLength < Irp->IoStatus.Information) { return STATUS_INVALID_PARAMETER; } output->Attributes = 0; if (irpSp->Parameters.DeviceIoControl.OutputBufferLength >= sizeof(VOLSNAP_CONFIG_INFO)) { Irp->IoStatus.Information = sizeof(VOLSNAP_CONFIG_INFO); output->Reserved = 0; output->SnapshotCreationTime = Extension->CommitTimeStamp; } return STATUS_SUCCESS; } NTSTATUS VspSetApplicationInfo( IN PVOLUME_EXTENSION Extension, IN PIRP Irp ) /*++ Routine Description: This routine sets the application info. Arguments: Extension - Supplies the volume extension. Irp - Supplies the I/O request packet. Return Value: NTSTATUS --*/ { PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation(Irp); PVOLSNAP_APPLICATION_INFO input = (PVOLSNAP_APPLICATION_INFO) Irp->AssociatedIrp.SystemBuffer; PVOID newAppInfo, oldAppInfo; Irp->IoStatus.Information = 0; if (irpSp->Parameters.DeviceIoControl.InputBufferLength < sizeof(VOLSNAP_APPLICATION_INFO)) { return STATUS_INVALID_PARAMETER; } if (irpSp->Parameters.DeviceIoControl.InputBufferLength < (LONGLONG) FIELD_OFFSET(VOLSNAP_APPLICATION_INFO, Information) + input->InformationLength) { return STATUS_INVALID_PARAMETER; } newAppInfo = ExAllocatePoolWithQuotaTag((POOL_TYPE) (PagedPool | POOL_QUOTA_FAIL_INSTEAD_OF_RAISE), input->InformationLength, VOLSNAP_TAG_APP_INFO); if (!newAppInfo) { return STATUS_INSUFFICIENT_RESOURCES; } RtlCopyMemory(newAppInfo, input->Information, input->InformationLength); KeEnterCriticalRegion(); VspAcquirePagedResource(Extension, NULL); Extension->ApplicationInformationSize = input->InformationLength; oldAppInfo = Extension->ApplicationInformation; Extension->ApplicationInformation = newAppInfo; VspReleasePagedResource(Extension); KeLeaveCriticalRegion(); if (oldAppInfo) { ExFreePool(oldAppInfo); } return STATUS_SUCCESS; } NTSTATUS VspQueryApplicationInfo( IN PVOLUME_EXTENSION Extension, IN PIRP Irp ) /*++ Routine Description: This routine queries the application info. Arguments: Extension - Supplies the volume extension. Irp - Supplies the I/O request packet. Return Value: NTSTATUS --*/ { PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation(Irp); PVOLSNAP_APPLICATION_INFO output = (PVOLSNAP_APPLICATION_INFO) Irp->AssociatedIrp.SystemBuffer; PVOID appInfo; Irp->IoStatus.Information = FIELD_OFFSET(VOLSNAP_APPLICATION_INFO, Information); if (irpSp->Parameters.DeviceIoControl.OutputBufferLength < Irp->IoStatus.Information) { return STATUS_INVALID_PARAMETER; } VspAcquirePagedResource(Extension, NULL); output->InformationLength = Extension->ApplicationInformationSize; if (irpSp->Parameters.DeviceIoControl.OutputBufferLength < Irp->IoStatus.Information + output->InformationLength) { VspReleasePagedResource(Extension); return STATUS_BUFFER_OVERFLOW; } Irp->IoStatus.Information += output->InformationLength; RtlCopyMemory(output->Information, Extension->ApplicationInformation, output->InformationLength); VspReleasePagedResource(Extension); return STATUS_SUCCESS; } NTSTATUS VspCheckSecurity( IN PFILTER_EXTENSION Filter, 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( Filter->Pdo->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 VspAutoCleanup( IN PFILTER_EXTENSION Filter, IN PIRP Irp ) /*++ Routine Description: This routine remembers the given File Object so that when it is cleaned up, all snapshots will be cleaned up with it. Arguments: Filter - Supplies the filter extension. Irp - Supplies the I/O request packet. Return Value: NTSTATUS --*/ { PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation(Irp); NTSTATUS status; KIRQL irql; status = VspCheckSecurity(Filter, Irp); if (!NT_SUCCESS(status)) { return status; } IoAcquireCancelSpinLock(&irql); if (Filter->AutoCleanupFileObject) { IoReleaseCancelSpinLock(irql); return STATUS_INVALID_PARAMETER; } Filter->AutoCleanupFileObject = irpSp->FileObject; IoReleaseCancelSpinLock(irql); return STATUS_SUCCESS; } VOID VspDeleteSnapshotWorker( IN PDEVICE_OBJECT DeviceObject, IN PVOID Context ) { PFILTER_EXTENSION filter = (PFILTER_EXTENSION) DeviceObject->DeviceExtension; PVSP_CONTEXT context = (PVSP_CONTEXT) Context; PIRP irp = context->Dispatch.Irp; PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation(irp); PVOLUME_EXTENSION oldestExtension; PVOLSNAP_NAME name; WCHAR buffer[100]; UNICODE_STRING name1, name2; LIST_ENTRY listOfDiffAreaFileToClose; LIST_ENTRY listOfDeviceObjectsToDelete; NTSTATUS status; ASSERT(context->Type == VSP_CONTEXT_TYPE_DISPATCH); KeWaitForSingleObject(&filter->EndCommitProcessCompleted, Executive, KernelMode, FALSE, NULL); InitializeListHead(&listOfDiffAreaFileToClose); InitializeListHead(&listOfDeviceObjectsToDelete); VspAcquire(filter->Root); if (irpSp->Parameters.DeviceIoControl.IoControlCode == IOCTL_VOLSNAP_DELETE_SNAPSHOT) { if (IsListEmpty(&filter->VolumeList)) { status = STATUS_INVALID_PARAMETER; } else { oldestExtension = CONTAINING_RECORD(filter->VolumeList.Flink, VOLUME_EXTENSION, ListEntry); swprintf(buffer, L"\\Device\\HarddiskVolumeShadowCopy%d", oldestExtension->VolumeNumber); RtlInitUnicodeString(&name1, buffer); name = (PVOLSNAP_NAME) irp->AssociatedIrp.SystemBuffer; name2.Length = name2.MaximumLength = name->NameLength; name2.Buffer = name->Name; if (RtlEqualUnicodeString(&name1, &name2, TRUE)) { status = STATUS_SUCCESS; } else { status = STATUS_NOT_SUPPORTED; } } } else { status = STATUS_SUCCESS; } if (NT_SUCCESS(status)) { status = VspDeleteOldestSnapshot(filter, &listOfDiffAreaFileToClose, &listOfDeviceObjectsToDelete); } VspRelease(filter->Root); VspCloseDiffAreaFiles(&listOfDiffAreaFileToClose, &listOfDeviceObjectsToDelete); IoFreeWorkItem(context->Dispatch.IoWorkItem); VspFreeContext(filter->Root, context); irp->IoStatus.Status = status; IoCompleteRequest(irp, IO_NO_INCREMENT); } NTSTATUS VspDeleteSnapshotPost( IN PFILTER_EXTENSION Filter, IN PIRP Irp ) { PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation(Irp); PVSP_CONTEXT context; PVOLSNAP_NAME name; Irp->IoStatus.Information = 0; if (irpSp->Parameters.DeviceIoControl.IoControlCode == IOCTL_VOLSNAP_DELETE_SNAPSHOT) { if (irpSp->Parameters.DeviceIoControl.InputBufferLength < sizeof(VOLSNAP_NAME)) { return STATUS_INVALID_PARAMETER; } name = (PVOLSNAP_NAME) Irp->AssociatedIrp.SystemBuffer; if (irpSp->Parameters.DeviceIoControl.InputBufferLength < (ULONG) FIELD_OFFSET(VOLSNAP_NAME, Name) + name->NameLength) { return STATUS_INVALID_PARAMETER; } } context = VspAllocateContext(Filter->Root); if (!context) { return STATUS_INSUFFICIENT_RESOURCES; } context->Type = VSP_CONTEXT_TYPE_DISPATCH; context->Dispatch.IoWorkItem = IoAllocateWorkItem(Filter->DeviceObject); if (!context->Dispatch.IoWorkItem) { VspFreeContext(Filter->Root, context); return STATUS_INSUFFICIENT_RESOURCES; } IoMarkIrpPending(Irp); context->Dispatch.Irp = Irp; IoQueueWorkItem(context->Dispatch.IoWorkItem, VspDeleteSnapshotWorker, DelayedWorkQueue, context); return STATUS_PENDING; } VOID VspCheckCodeLocked( IN PDO_EXTENSION RootExtension ) { if (RootExtension->IsCodeLocked) { return; } VspAcquire(RootExtension); if (RootExtension->IsCodeLocked) { VspRelease(RootExtension); return; } MmLockPagableCodeSection(VspCheckCodeLocked); InterlockedExchange(&RootExtension->IsCodeLocked, TRUE); VspRelease(RootExtension); } NTSTATUS VspSetMaxDiffAreaSize( IN PFILTER_EXTENSION Filter, IN PIRP Irp ) { PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation(Irp); PVOLSNAP_DIFF_AREA_SIZES input = (PVOLSNAP_DIFF_AREA_SIZES) Irp->AssociatedIrp.SystemBuffer; KIRQL irql; if (irpSp->Parameters.DeviceIoControl.InputBufferLength < sizeof(VOLSNAP_DIFF_AREA_SIZES)) { return STATUS_INVALID_PARAMETER; } KeAcquireSpinLock(&Filter->SpinLock, &irql); Filter->MaximumVolumeSpace = input->MaximumVolumeSpace; KeReleaseSpinLock(&Filter->SpinLock, irql); return STATUS_SUCCESS; } NTSTATUS VolSnapDeviceControl( 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 --*/ { PFILTER_EXTENSION filter = (PFILTER_EXTENSION) DeviceObject->DeviceExtension; PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation(Irp); NTSTATUS status; PVOLUME_EXTENSION extension; if (filter->DeviceExtensionType == DEVICE_EXTENSION_FILTER) { if (filter->TargetObject->Characteristics&FILE_REMOVABLE_MEDIA) { IoSkipCurrentIrpStackLocation(Irp); return IoCallDriver(filter->TargetObject, Irp); } switch (irpSp->Parameters.DeviceIoControl.IoControlCode) { case IOCTL_VOLSNAP_FLUSH_AND_HOLD_WRITES: VspCheckCodeLocked(filter->Root); status = VspFlushAndHoldWrites(filter, Irp); break; case IOCTL_VOLSNAP_RELEASE_WRITES: VspCheckCodeLocked(filter->Root); status = VspReleaseWrites(filter); break; case IOCTL_VOLSNAP_PREPARE_FOR_SNAPSHOT: VspCheckCodeLocked(filter->Root); status = VspPrepareForSnapshot(filter, Irp); break; case IOCTL_VOLSNAP_ABORT_PREPARED_SNAPSHOT: VspCheckCodeLocked(filter->Root); status = VspAbortPreparedSnapshot(filter, TRUE); break; case IOCTL_VOLSNAP_COMMIT_SNAPSHOT: VspCheckCodeLocked(filter->Root); status = VspCommitSnapshot(filter, Irp); break; case IOCTL_VOLSNAP_END_COMMIT_SNAPSHOT: VspCheckCodeLocked(filter->Root); status = VspEndCommitSnapshot(filter, Irp); break; case IOCTL_VOLSNAP_QUERY_NAMES_OF_SNAPSHOTS: VspCheckCodeLocked(filter->Root); status = VspQueryNamesOfSnapshots(filter, Irp); break; case IOCTL_VOLSNAP_CLEAR_DIFF_AREA: VspCheckCodeLocked(filter->Root); status = VspClearDiffArea(filter, Irp); break; case IOCTL_VOLSNAP_ADD_VOLUME_TO_DIFF_AREA: VspCheckCodeLocked(filter->Root); status = VspAddVolumeToDiffArea(filter, Irp); break; case IOCTL_VOLSNAP_QUERY_DIFF_AREA: VspCheckCodeLocked(filter->Root); status = VspQueryDiffArea(filter, Irp); break; case IOCTL_VOLSNAP_SET_MAX_DIFF_AREA_SIZE: VspCheckCodeLocked(filter->Root); status = VspSetMaxDiffAreaSize(filter, Irp); break; case IOCTL_VOLSNAP_QUERY_DIFF_AREA_SIZES: VspCheckCodeLocked(filter->Root); status = VspQueryDiffAreaSize(filter, Irp); break; case IOCTL_VOLSNAP_DELETE_OLDEST_SNAPSHOT: case IOCTL_VOLSNAP_DELETE_SNAPSHOT: VspCheckCodeLocked(filter->Root); status = VspDeleteSnapshotPost(filter, Irp); break; case IOCTL_VOLSNAP_AUTO_CLEANUP: VspCheckCodeLocked(filter->Root); status = VspAutoCleanup(filter, Irp); break; default: IoSkipCurrentIrpStackLocation(Irp); return IoCallDriver(filter->TargetObject, Irp); } if (status == STATUS_PENDING) { return status; } Irp->IoStatus.Status = status; IoCompleteRequest(Irp, IO_NO_INCREMENT); return status; } ASSERT(filter->DeviceExtensionType == DEVICE_EXTENSION_VOLUME); extension = (PVOLUME_EXTENSION) filter; if (!extension->IsStarted) { Irp->IoStatus.Status = STATUS_NO_SUCH_DEVICE; Irp->IoStatus.Information = 0; IoCompleteRequest(Irp, IO_NO_INCREMENT); return STATUS_NO_SUCH_DEVICE; } status = VspIncrementVolumeRefCount(extension, Irp, NULL); if (!NT_SUCCESS(status)) { Irp->IoStatus.Status = status; Irp->IoStatus.Information = 0; IoCompleteRequest(Irp, IO_NO_INCREMENT); return status; } if (status == STATUS_PENDING) { return status; } switch (irpSp->Parameters.DeviceIoControl.IoControlCode) { case IOCTL_VOLSNAP_QUERY_ORIGINAL_VOLUME_NAME: status = VspQueryOriginalVolumeName(extension, Irp); break; case IOCTL_VOLSNAP_QUERY_CONFIG_INFO: status = VspQueryConfigInfo(extension, Irp); break; case IOCTL_VOLSNAP_SET_APPLICATION_INFO: status = VspSetApplicationInfo(extension, Irp); break; case IOCTL_VOLSNAP_QUERY_APPLICATION_INFO: status = VspQueryApplicationInfo(extension, Irp); break; case IOCTL_VOLUME_QUERY_VOLUME_NUMBER: status = VspQueryVolumeNumber(extension, Irp); break; case IOCTL_DISK_SET_PARTITION_INFO: status = STATUS_SUCCESS; break; case IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS: case IOCTL_DISK_VERIFY: case IOCTL_DISK_GET_PARTITION_INFO: case IOCTL_DISK_GET_PARTITION_INFO_EX: case IOCTL_DISK_GET_LENGTH_INFO: case IOCTL_DISK_GET_DRIVE_GEOMETRY: case IOCTL_DISK_CHECK_VERIFY: IoCopyCurrentIrpStackLocationToNext(Irp); IoSetCompletionRoutine(Irp, VspVolumeRefCountCompletionRoutine, extension, TRUE, TRUE, TRUE); IoMarkIrpPending(Irp); IoCallDriver(extension->Filter->TargetObject, Irp); return STATUS_PENDING; case IOCTL_DISK_IS_WRITABLE: status = STATUS_MEDIA_WRITE_PROTECTED; break; default: status = STATUS_INVALID_DEVICE_REQUEST; break; } VspDecrementVolumeRefCount(extension); Irp->IoStatus.Status = status; IoCompleteRequest(Irp, IO_NO_INCREMENT); return status; } NTSTATUS VspQueryBusRelations( IN PFILTER_EXTENSION Filter, IN PIRP Irp ) { ULONG numVolumes; PLIST_ENTRY l; NTSTATUS status; PDEVICE_RELATIONS deviceRelations, newRelations; ULONG size, i; PVOLUME_EXTENSION extension; numVolumes = 0; for (l = Filter->VolumeList.Flink; l != &Filter->VolumeList; l = l->Flink) { extension = CONTAINING_RECORD(l, VOLUME_EXTENSION, ListEntry); if (!extension->HasEndCommit) { continue; } InterlockedExchange(&extension->AliveToPnp, TRUE); numVolumes++; } status = Irp->IoStatus.Status; if (!numVolumes) { if (NT_SUCCESS(status)) { return status; } newRelations = (PDEVICE_RELATIONS) ExAllocatePoolWithTag(PagedPool, sizeof(DEVICE_RELATIONS), VOLSNAP_TAG_RELATIONS); if (!newRelations) { return STATUS_INSUFFICIENT_RESOURCES; } RtlZeroMemory(newRelations, sizeof(DEVICE_RELATIONS)); newRelations->Count = 0; Irp->IoStatus.Information = (ULONG_PTR) newRelations; while (!IsListEmpty(&Filter->DeadVolumeList)) { l = RemoveHeadList(&Filter->DeadVolumeList); extension = CONTAINING_RECORD(l, VOLUME_EXTENSION, ListEntry); InterlockedExchange(&extension->DeadToPnp, TRUE); } return STATUS_SUCCESS; } if (NT_SUCCESS(status)) { deviceRelations = (PDEVICE_RELATIONS) Irp->IoStatus.Information; size = FIELD_OFFSET(DEVICE_RELATIONS, Objects) + (numVolumes + deviceRelations->Count)*sizeof(PDEVICE_OBJECT); newRelations = (PDEVICE_RELATIONS) ExAllocatePoolWithTag(PagedPool, size, VOLSNAP_TAG_RELATIONS); if (!newRelations) { for (i = 0; i < deviceRelations->Count; i++) { ObDereferenceObject(deviceRelations->Objects[i]); } ExFreePool(deviceRelations); Irp->IoStatus.Information = 0; return STATUS_INSUFFICIENT_RESOURCES; } newRelations->Count = numVolumes + deviceRelations->Count; RtlCopyMemory(newRelations->Objects, deviceRelations->Objects, deviceRelations->Count*sizeof(PDEVICE_OBJECT)); i = deviceRelations->Count; ExFreePool(deviceRelations); } else { size = sizeof(DEVICE_RELATIONS) + numVolumes*sizeof(PDEVICE_OBJECT); newRelations = (PDEVICE_RELATIONS) ExAllocatePoolWithTag(PagedPool, size, VOLSNAP_TAG_RELATIONS); if (!newRelations) { return STATUS_INSUFFICIENT_RESOURCES; } newRelations->Count = numVolumes; i = 0; } numVolumes = 0; for (l = Filter->VolumeList.Flink; l != &Filter->VolumeList; l = l->Flink) { extension = CONTAINING_RECORD(l, VOLUME_EXTENSION, ListEntry); if (!extension->HasEndCommit) { continue; } newRelations->Objects[i + numVolumes++] = extension->DeviceObject; ObReferenceObject(extension->DeviceObject); } Irp->IoStatus.Information = (ULONG_PTR) newRelations; while (!IsListEmpty(&Filter->DeadVolumeList)) { l = RemoveHeadList(&Filter->DeadVolumeList); extension = CONTAINING_RECORD(l, VOLUME_EXTENSION, ListEntry); InterlockedExchange(&extension->DeadToPnp, TRUE); } return STATUS_SUCCESS; } NTSTATUS VspQueryId( IN PVOLUME_EXTENSION Extension, IN PIRP Irp ) { PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation(Irp); UNICODE_STRING string; NTSTATUS status; WCHAR buffer[100]; PWSTR id; switch (irpSp->Parameters.QueryId.IdType) { case BusQueryDeviceID: RtlInitUnicodeString(&string, L"STORAGE\\VolumeSnapshot"); break; case BusQueryHardwareIDs: RtlInitUnicodeString(&string, L"STORAGE\\VolumeSnapshot"); break; case BusQueryInstanceID: swprintf(buffer, L"HarddiskVolumeSnapshot%d", Extension->VolumeNumber); RtlInitUnicodeString(&string, buffer); break; default: return STATUS_NOT_SUPPORTED; } id = (PWSTR) ExAllocatePoolWithTag(PagedPool, string.Length + 2*sizeof(WCHAR), VOLSNAP_TAG_PNP_ID); 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; } VOID VspDeleteDiffAreaFilesWorker( IN PDEVICE_OBJECT DeviceObject, IN PVOID WorkItem ) { NTSTATUS status; UNICODE_STRING name, fileName; OBJECT_ATTRIBUTES oa; HANDLE h, fileHandle; IO_STATUS_BLOCK ioStatus; PFILE_NAMES_INFORMATION fileNamesInfo; CHAR buffer[200]; FILE_DISPOSITION_INFORMATION dispInfo; BOOLEAN restartScan; LARGE_INTEGER timeout; status = VspCreateDiffAreaFileName(DeviceObject, (ULONG) -1, &name); if (!NT_SUCCESS(status)) { IoFreeWorkItem((PIO_WORKITEM) WorkItem); return; } name.Length -= 39*sizeof(WCHAR); InitializeObjectAttributes(&oa, &name, OBJ_CASE_INSENSITIVE, NULL, NULL); status = ZwOpenFile(&h, FILE_LIST_DIRECTORY | SYNCHRONIZE, &oa, &ioStatus, FILE_SHARE_READ | FILE_SHARE_WRITE, FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT); if (!NT_SUCCESS(status)) { ExFreePool(name.Buffer); IoFreeWorkItem((PIO_WORKITEM) WorkItem); return; } fileName.Buffer = &name.Buffer[name.Length/sizeof(WCHAR)]; fileName.Length = 39*sizeof(WCHAR); fileName.MaximumLength = fileName.Length + sizeof(WCHAR); fileNamesInfo = (PFILE_NAMES_INFORMATION) buffer; dispInfo.DeleteFile = TRUE; restartScan = TRUE; for (;;) { status = ZwQueryDirectoryFile(h, NULL, NULL, NULL, &ioStatus, fileNamesInfo, 200, FileNamesInformation, TRUE, restartScan ? &fileName : NULL, restartScan); if (!NT_SUCCESS(status)) { break; } fileName.Length = fileName.MaximumLength = (USHORT) fileNamesInfo->FileNameLength; fileName.Buffer = fileNamesInfo->FileName; InitializeObjectAttributes(&oa, &fileName, OBJ_CASE_INSENSITIVE, h, NULL); status = ZwOpenFile(&fileHandle, DELETE, &oa, &ioStatus, FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE, FILE_NON_DIRECTORY_FILE); if (!NT_SUCCESS(status)) { continue; } ZwSetInformationFile(fileHandle, &ioStatus, &dispInfo, sizeof(dispInfo), FileDispositionInformation); ZwClose(fileHandle); restartScan = FALSE; } ZwClose(h); ExFreePool(name.Buffer); IoFreeWorkItem((PIO_WORKITEM) WorkItem); } NTSTATUS VolSnapPnp( 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 --*/ { PFILTER_EXTENSION filter = (PFILTER_EXTENSION) DeviceObject->DeviceExtension; PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation(Irp); PDEVICE_OBJECT targetObject; KEVENT event; NTSTATUS status; PVOLUME_EXTENSION extension; BOOLEAN deletePdo; PDEVICE_RELATIONS deviceRelations; PDEVICE_CAPABILITIES capabilities; KIRQL irql; PIRP irp; DEVICE_INSTALL_STATE deviceInstallState; ULONG bytes; PVSP_CONTEXT context; if (filter->DeviceExtensionType == DEVICE_EXTENSION_FILTER) { switch (irpSp->MinorFunction) { case IRP_MN_REMOVE_DEVICE: case IRP_MN_SURPRISE_REMOVAL: VspCleanupFilter(filter); targetObject = filter->TargetObject; if (irpSp->MinorFunction == IRP_MN_REMOVE_DEVICE) { IoDetachDevice(targetObject); IoDeleteDevice(filter->DeviceObject); } IoSkipCurrentIrpStackLocation(Irp); return IoCallDriver(targetObject, Irp); case IRP_MN_QUERY_DEVICE_RELATIONS: switch (irpSp->Parameters.QueryDeviceRelations.Type) { case BusRelations: break; default: IoSkipCurrentIrpStackLocation(Irp); return IoCallDriver(filter->TargetObject, Irp); } KeInitializeEvent(&event, NotificationEvent, FALSE); IoCopyCurrentIrpStackLocationToNext(Irp); IoSetCompletionRoutine(Irp, VspSignalCompletion, &event, TRUE, TRUE, TRUE); IoCallDriver(filter->TargetObject, Irp); KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL); VspAcquire(filter->Root); switch (irpSp->Parameters.QueryDeviceRelations.Type) { case BusRelations: status = VspQueryBusRelations(filter, Irp); break; } VspRelease(filter->Root); break; default: IoSkipCurrentIrpStackLocation(Irp); return IoCallDriver(filter->TargetObject, Irp); } Irp->IoStatus.Status = status; IoCompleteRequest(Irp, IO_NO_INCREMENT); return status; } ASSERT(filter->DeviceExtensionType == DEVICE_EXTENSION_VOLUME); extension = (PVOLUME_EXTENSION) filter; switch (irpSp->MinorFunction) { case IRP_MN_START_DEVICE: filter = extension->Filter; if (extension->IsDead) { status = STATUS_INVALID_PARAMETER; break; } InterlockedExchange(&extension->IsStarted, TRUE); status = IoGetDeviceProperty(extension->DeviceObject, DevicePropertyInstallState, sizeof(deviceInstallState), &deviceInstallState, &bytes); if (!NT_SUCCESS(status) || deviceInstallState != InstallStateInstalled) { status = STATUS_SUCCESS; break; } VspAcquire(extension->Root); extension->IsInstalled = TRUE; if (extension->ListEntry.Flink != &filter->VolumeList) { KeAcquireSpinLock(&extension->SpinLock, &irql); if (extension->IgnorableProduct) { ExFreePool(extension->IgnorableProduct->Buffer); ExFreePool(extension->IgnorableProduct); extension->IgnorableProduct = NULL; } KeReleaseSpinLock(&extension->SpinLock, irql); VspRelease(extension->Root); break; } if (!KeCancelTimer(&filter->EndCommitTimer)) { VspRelease(extension->Root); break; } VspRelease(extension->Root); context = VspAllocateContext(filter->Root); if (!context) { KeSetEvent(&filter->EndCommitProcessCompleted, IO_NO_INCREMENT, FALSE); ObDereferenceObject(filter->DeviceObject); status = STATUS_INSUFFICIENT_RESOURCES; break; } ObReferenceObject(extension->DeviceObject); context->Type = VSP_CONTEXT_TYPE_EXTENSION; context->Extension.Extension = extension; context->Extension.Irp = NULL; ExInitializeWorkItem(&context->WorkItem, VspSetIgnorableBlocksInBitmapWorker, context); VspQueueWorkItem(filter->Root, &context->WorkItem, 0); break; case IRP_MN_QUERY_REMOVE_DEVICE: case IRP_MN_CANCEL_REMOVE_DEVICE: 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: InterlockedExchange(&extension->IsStarted, FALSE); if (irpSp->MinorFunction == IRP_MN_REMOVE_DEVICE) { if (extension->DeadToPnp && !extension->DeviceDeleted) { InterlockedExchange(&extension->DeviceDeleted, TRUE); deletePdo = TRUE; } else { deletePdo = FALSE; } } else { deletePdo = FALSE; } 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) ExAllocatePoolWithTag(PagedPool, sizeof(DEVICE_RELATIONS), VOLSNAP_TAG_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_CAPABILITIES: capabilities = irpSp->Parameters.DeviceCapabilities.Capabilities; capabilities->SilentInstall = 1; capabilities->SurpriseRemovalOK = 1; capabilities->RawDeviceOK = 1; capabilities->Address = extension->VolumeNumber; status = STATUS_SUCCESS; break; case IRP_MN_QUERY_ID: status = VspQueryId(extension, Irp); break; case IRP_MN_QUERY_PNP_DEVICE_STATE: Irp->IoStatus.Information = PNP_DEVICE_DONT_DISPLAY_IN_UI; status = STATUS_SUCCESS; break; case IRP_MN_DEVICE_USAGE_NOTIFICATION: status = STATUS_INVALID_DEVICE_REQUEST; break; default: status = STATUS_NOT_SUPPORTED; break; } if (status == STATUS_NOT_SUPPORTED) { status = Irp->IoStatus.Status; } else { Irp->IoStatus.Status = status; } IoCompleteRequest(Irp, IO_NO_INCREMENT); return status; } VOID VspWorkerThread( IN PVOID Context ) /*++ Routine Description: This is a worker thread to process work queue items. Arguments: RootExtension - Supplies the root device extension. Return Value: None. --*/ { PVSP_CONTEXT context = (PVSP_CONTEXT) Context; PDO_EXTENSION rootExtension = context->ThreadCreation.RootExtension; ULONG queueNumber = context->ThreadCreation.QueueNumber; KIRQL irql; PLIST_ENTRY l; PWORK_QUEUE_ITEM queueItem; ASSERT(queueNumber < NUMBER_OF_THREAD_POOLS); ASSERT(context->Type == VSP_CONTEXT_TYPE_THREAD_CREATION); VspFreeContext(rootExtension, context); if (!queueNumber) { KeSetPriorityThread(KeGetCurrentThread(), 20); } for (;;) { KeWaitForSingleObject(&rootExtension->WorkerSemaphore[queueNumber], Executive, KernelMode, FALSE, NULL); KeAcquireSpinLock(&rootExtension->SpinLock[queueNumber], &irql); if (IsListEmpty(&rootExtension->WorkerQueue[queueNumber])) { KeReleaseSpinLock(&rootExtension->SpinLock[queueNumber], irql); ASSERT(!rootExtension->ThreadsRefCount); PsTerminateSystemThread(STATUS_SUCCESS); return; } l = RemoveHeadList(&rootExtension->WorkerQueue[queueNumber]); KeReleaseSpinLock(&rootExtension->SpinLock[queueNumber], irql); queueItem = CONTAINING_RECORD(l, WORK_QUEUE_ITEM, List); queueItem->WorkerRoutine(queueItem->Parameter); } } NTSTATUS VolSnapTargetDeviceNotification( IN PVOID NotificationStructure, IN PVOID Filter ) { PTARGET_DEVICE_REMOVAL_NOTIFICATION notification = (PTARGET_DEVICE_REMOVAL_NOTIFICATION) NotificationStructure; PFILTER_EXTENSION filter = (PFILTER_EXTENSION) Filter; PLIST_ENTRY l; PVSP_DIFF_AREA_FILE diffAreaFile; PFILTER_EXTENSION f; LIST_ENTRY listOfDiffAreaFilesToClose; LIST_ENTRY listOfDeviceObjectsToDelete; if (IsEqualGUID(notification->Event, GUID_TARGET_DEVICE_REMOVE_COMPLETE)) { if (filter->TargetDeviceNotificationEntry) { IoUnregisterPlugPlayNotification( filter->TargetDeviceNotificationEntry); filter->TargetDeviceNotificationEntry = NULL; } return STATUS_SUCCESS; } if (!IsEqualGUID(notification->Event, GUID_IO_VOLUME_DISMOUNT)) { return STATUS_SUCCESS; } InitializeListHead(&listOfDiffAreaFilesToClose); InitializeListHead(&listOfDeviceObjectsToDelete); VspAcquire(filter->Root); while (!IsListEmpty(&filter->DiffAreaFilesOnThisFilter)) { l = filter->DiffAreaFilesOnThisFilter.Flink; diffAreaFile = CONTAINING_RECORD(l, VSP_DIFF_AREA_FILE, FilterListEntry); f = diffAreaFile->Extension->Filter; VspLogError(diffAreaFile->Extension, diffAreaFile->Filter, VS_ABORT_SNAPSHOTS_DISMOUNT, STATUS_SUCCESS, 0); VspAbortPreparedSnapshot(f, FALSE); while (!IsListEmpty(&f->VolumeList)) { VspDeleteOldestSnapshot(f, &listOfDiffAreaFilesToClose, &listOfDeviceObjectsToDelete); } } VspRelease(filter->Root); VspCloseDiffAreaFiles(&listOfDiffAreaFilesToClose, &listOfDeviceObjectsToDelete); return STATUS_SUCCESS; } NTSTATUS VolSnapVolumeDeviceNotification( IN PVOID NotificationStructure, IN PVOID RootExtension ) /*++ Routine Description: This routine is called whenever a volume comes or goes. Arguments: NotificationStructure - Supplies the notification structure. RootExtension - Supplies the root extension. Return Value: NTSTATUS --*/ { PDEVICE_INTERFACE_CHANGE_NOTIFICATION notification = (PDEVICE_INTERFACE_CHANGE_NOTIFICATION) NotificationStructure; PDO_EXTENSION root = (PDO_EXTENSION) RootExtension; BOOLEAN errorMode; NTSTATUS status; PFILE_OBJECT fileObject; PDEVICE_OBJECT deviceObject; PIO_WORKITEM workItem; PFILTER_EXTENSION filter; if (!IsEqualGUID(notification->Event, GUID_DEVICE_INTERFACE_ARRIVAL)) { return STATUS_SUCCESS; } errorMode = PsGetThreadHardErrorsAreDisabled(PsGetCurrentThread()); PsSetThreadHardErrorsAreDisabled(PsGetCurrentThread(), TRUE); status = IoGetDeviceObjectPointer(notification->SymbolicLinkName, FILE_READ_ATTRIBUTES, &fileObject, &deviceObject); if (!NT_SUCCESS(status)) { PsSetThreadHardErrorsAreDisabled(PsGetCurrentThread(), errorMode); return STATUS_SUCCESS; } if (fileObject->DeviceObject->Characteristics&FILE_REMOVABLE_MEDIA) { ObDereferenceObject(fileObject); PsSetThreadHardErrorsAreDisabled(PsGetCurrentThread(), errorMode); return STATUS_SUCCESS; } VspAcquire(root); filter = VspFindFilter(root, NULL, NULL, fileObject); if (!filter || filter->TargetDeviceNotificationEntry) { ObDereferenceObject(fileObject); PsSetThreadHardErrorsAreDisabled(PsGetCurrentThread(), errorMode); VspRelease(root); return STATUS_SUCCESS; } ObReferenceObject(filter->DeviceObject); VspRelease(root); status = IoRegisterPlugPlayNotification( EventCategoryTargetDeviceChange, 0, fileObject, root->DriverObject, VolSnapTargetDeviceNotification, filter, &filter->TargetDeviceNotificationEntry); ObDereferenceObject(filter->DeviceObject); if (!NT_SUCCESS(status)) { ObDereferenceObject(fileObject); PsSetThreadHardErrorsAreDisabled(PsGetCurrentThread(), errorMode); return STATUS_SUCCESS; } workItem = IoAllocateWorkItem(deviceObject); if (workItem) { IoQueueWorkItem(workItem, VspDeleteDiffAreaFilesWorker, DelayedWorkQueue, workItem); } ObDereferenceObject(fileObject); PsSetThreadHardErrorsAreDisabled(PsGetCurrentThread(), errorMode); return STATUS_SUCCESS; } VOID VspWaitToRegisterWorker( IN PVOID Context ) { PVSP_CONTEXT context = (PVSP_CONTEXT) Context; PDO_EXTENSION rootExtension = context->RootExtension.RootExtension; UNICODE_STRING volumeSafeEventName; OBJECT_ATTRIBUTES oa; KEVENT event; LARGE_INTEGER timeout; ULONG i; NTSTATUS status; HANDLE volumeSafeEvent; ASSERT(context->Type == VSP_CONTEXT_TYPE_ROOT_EXTENSION); VspFreeContext(rootExtension, context); RtlInitUnicodeString(&volumeSafeEventName, L"\\Device\\VolumesSafeForWriteAccess"); InitializeObjectAttributes(&oa, &volumeSafeEventName, OBJ_CASE_INSENSITIVE, NULL, NULL); KeInitializeEvent(&event, NotificationEvent, FALSE); timeout.QuadPart = -10*1000*1000; // 1 second for (i = 0; i < 1000; i++) { status = ZwOpenEvent(&volumeSafeEvent, EVENT_ALL_ACCESS, &oa); if (NT_SUCCESS(status)) { break; } KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, &timeout); } if (i == 1000) { return; } ZwWaitForSingleObject(volumeSafeEvent, FALSE, NULL); ZwClose(volumeSafeEvent); if (rootExtension->NotificationEntry) { return; } IoRegisterPlugPlayNotification( EventCategoryDeviceInterfaceChange, PNPNOTIFY_DEVICE_INTERFACE_INCLUDE_EXISTING_INTERFACES, (PVOID) &GUID_IO_VOLUME_DEVICE_INTERFACE, rootExtension->DriverObject, VolSnapVolumeDeviceNotification, rootExtension, &rootExtension->NotificationEntry); } VOID VspDriverReinit( 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. --*/ { PDO_EXTENSION rootExtension = (PDO_EXTENSION) RootExtension; PVSP_CONTEXT context; context = VspAllocateContext(rootExtension); if (!context) { return; } context->Type = VSP_CONTEXT_TYPE_ROOT_EXTENSION; context->RootExtension.RootExtension = rootExtension; ExInitializeWorkItem(&context->WorkItem, VspWaitToRegisterWorker, context); ExQueueWorkItem(&context->WorkItem, DelayedWorkQueue); } #ifdef ALLOC_PRAGMA #pragma code_seg() #endif #if DBG #define NUMBER_OF_TRACE_ENTRIES (0x100) VSP_TRACE_STRUCTURE TraceStructures[NUMBER_OF_TRACE_ENTRIES]; LONG CurrentTraceStructure; PVSP_TRACE_STRUCTURE VspAllocateTraceStructure( ) { LONG next; next = InterlockedIncrement(&CurrentTraceStructure); return &TraceStructures[next&0xFF]; } #endif // DBG NTSTATUS VspSignalCompletion( IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Event ) { KeSetEvent((PKEVENT) Event, IO_NO_INCREMENT, FALSE); return STATUS_MORE_PROCESSING_REQUIRED; } NTSTATUS VspReleaseWrites( IN PFILTER_EXTENSION Filter ) /*++ Routine Description: This routine releases previously queued writes. If the writes have already been dequeued by a timeout of have never actually been queued for some other reason then this routine fails. Arguments: Filter - Supplies the filter extension. Irp - Supplies the I/O request packet. Return Value: NTSTATUS --*/ { KIRQL irql; LIST_ENTRY q; PLIST_ENTRY l; PIRP irp; BOOLEAN emptyQueue; KeAcquireSpinLock(&Filter->SpinLock, &irql); if (!Filter->HoldIncomingWrites || !Filter->TimerIsSet) { KeReleaseSpinLock(&Filter->SpinLock, irql); return STATUS_INVALID_PARAMETER; } if (!KeCancelTimer(&Filter->HoldWritesTimer)) { KeReleaseSpinLock(&Filter->SpinLock, irql); return STATUS_INVALID_PARAMETER; } IoStopTimer(Filter->DeviceObject); InterlockedIncrement(&Filter->RefCount); InterlockedExchange(&Filter->TimerIsSet, FALSE); InterlockedExchange(&Filter->HoldIncomingWrites, FALSE); if (IsListEmpty(&Filter->HoldQueue)) { emptyQueue = FALSE; } else { emptyQueue = TRUE; q = Filter->HoldQueue; InitializeListHead(&Filter->HoldQueue); } KeReleaseSpinLock(&Filter->SpinLock, irql); if (emptyQueue) { q.Blink->Flink = &q; q.Flink->Blink = &q; VspEmptyIrpQueue(Filter->Root->DriverObject, &q); } return STATUS_SUCCESS; } VOID VspDecrementRefCount( IN PFILTER_EXTENSION Filter ) { KIRQL irql; ZERO_REF_CALLBACK callback; if (InterlockedDecrement(&Filter->RefCount)) { return; } KeAcquireSpinLock(&Filter->SpinLock, &irql); callback = Filter->ZeroRefCallback; Filter->ZeroRefCallback = NULL; KeReleaseSpinLock(&Filter->SpinLock, irql); if (callback) { callback(Filter); } } VOID VspCleanupFilter( IN PFILTER_EXTENSION Filter ) /*++ Routine Description: This routine cleans up filter extension data because of an IRP_MN_REMOVE. Arguments: Filter - Supplies the filter extension. Return Value: None. --*/ { KIRQL irql; PIRP irp; PVOLUME_EXTENSION extension; PLIST_ENTRY l, ll; PVSP_DIFF_AREA_FILE diffAreaFile; PVSP_DIFF_AREA_VOLUME diffAreaVolume; PFILTER_EXTENSION f; LIST_ENTRY listOfDiffAreaFilesToClose; LIST_ENTRY listOfDeviceObjectsToDelete; PVSP_CONTEXT context; IoAcquireCancelSpinLock(&irql); irp = Filter->FlushAndHoldIrp; if (irp) { irp->CancelIrql = irql; IoSetCancelRoutine(irp, NULL); VspCancelRoutine(Filter->DeviceObject, irp); } else { IoReleaseCancelSpinLock(irql); } VspReleaseWrites(Filter); VspAcquire(Filter->Root); KeAcquireSpinLock(&Filter->SpinLock, &irql); extension = Filter->PreparedSnapshot; Filter->PreparedSnapshot = NULL; KeReleaseSpinLock(&Filter->SpinLock, irql); VspRelease(Filter->Root); if (extension) { VspCleanupInitialSnapshot(extension, TRUE); } KeWaitForSingleObject(&Filter->Root->ThreadsRefCountSemaphore, Executive, KernelMode, FALSE, NULL); if (Filter->Root->ThreadsRefCount) { if (Filter->SnapshotsPresent) { context = VspAllocateContext(Filter->Root); if (context) { context->Type = VSP_CONTEXT_TYPE_ERROR_LOG; context->ErrorLog.Extension = NULL; context->ErrorLog.DiffAreaFilter = Filter; context->ErrorLog.SpecificIoStatus = VS_ABORT_SNAPSHOT_VOLUME_REMOVED; context->ErrorLog.FinalStatus = STATUS_SUCCESS; context->ErrorLog.UniqueErrorValue = 0; ObReferenceObject(Filter->DeviceObject); VspLogErrorWorker(context); } } VspDestroyAllSnapshots(Filter, NULL); } KeReleaseSemaphore(&Filter->Root->ThreadsRefCountSemaphore, IO_NO_INCREMENT, 1, FALSE); InitializeListHead(&listOfDiffAreaFilesToClose); InitializeListHead(&listOfDeviceObjectsToDelete); VspAcquire(Filter->Root); if (!Filter->NotInFilterList) { RemoveEntryList(&Filter->ListEntry); Filter->NotInFilterList = TRUE; } while (!IsListEmpty(&Filter->DiffAreaVolumes)) { l = RemoveHeadList(&Filter->DiffAreaVolumes); diffAreaVolume = CONTAINING_RECORD(l, VSP_DIFF_AREA_VOLUME, ListEntry); ExFreePool(diffAreaVolume); } for (l = Filter->Root->FilterList.Flink; l != &Filter->Root->FilterList; l = l->Flink) { f = CONTAINING_RECORD(l, FILTER_EXTENSION, ListEntry); for (ll = f->DiffAreaVolumes.Flink; ll != &f->DiffAreaVolumes; ll = ll->Flink) { diffAreaVolume = CONTAINING_RECORD(ll, VSP_DIFF_AREA_VOLUME, ListEntry); if (diffAreaVolume->Filter == Filter) { RemoveEntryList(ll); ExFreePool(diffAreaVolume); break; } } } while (!IsListEmpty(&Filter->DiffAreaFilesOnThisFilter)) { l = Filter->DiffAreaFilesOnThisFilter.Flink; diffAreaFile = CONTAINING_RECORD(l, VSP_DIFF_AREA_FILE, FilterListEntry); f = diffAreaFile->Extension->Filter; VspLogError(diffAreaFile->Extension, diffAreaFile->Filter, VS_ABORT_SNAPSHOTS_DISMOUNT, STATUS_SUCCESS, 0); VspAbortPreparedSnapshot(f, FALSE); while (!IsListEmpty(&f->VolumeList)) { VspDeleteOldestSnapshot(f, &listOfDiffAreaFilesToClose, &listOfDeviceObjectsToDelete); } } VspRelease(Filter->Root); VspCloseDiffAreaFiles(&listOfDiffAreaFilesToClose, &listOfDeviceObjectsToDelete); } NTSTATUS VolSnapPower( IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp ) /*++ Routine Description: This routine is the dispatch for IRP_MJ_POWER. Arguments: DeviceObject - Supplies the device object. Irp - Supplies the IO request packet. Return Value: NTSTATUS --*/ { PFILTER_EXTENSION filter = (PFILTER_EXTENSION) DeviceObject->DeviceExtension; PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation(Irp); NTSTATUS status; if (filter->DeviceExtensionType == DEVICE_EXTENSION_FILTER) { PoStartNextPowerIrp(Irp); IoSkipCurrentIrpStackLocation(Irp); return PoCallDriver(filter->TargetObject, Irp); } ASSERT(filter->DeviceExtensionType == DEVICE_EXTENSION_VOLUME); 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; } NTSTATUS VolSnapRead( IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp ) /*++ Routine Description: This routine is the dispatch for IRP_MJ_READ. Arguments: DeviceObject - Supplies the device object. Irp - Supplies the IO request packet. Return Value: NTSTATUS --*/ { PFILTER_EXTENSION filter = (PFILTER_EXTENSION) DeviceObject->DeviceExtension; NTSTATUS status; PVOLUME_EXTENSION extension; KIRQL irql; if (filter->DeviceExtensionType == DEVICE_EXTENSION_FILTER) { IoSkipCurrentIrpStackLocation(Irp); return IoCallDriver(filter->TargetObject, Irp); } ASSERT(filter->DeviceExtensionType == DEVICE_EXTENSION_VOLUME); extension = (PVOLUME_EXTENSION) filter; filter = extension->Filter; if (!extension->IsStarted) { Irp->IoStatus.Status = STATUS_NO_SUCH_DEVICE; Irp->IoStatus.Information = 0; IoCompleteRequest(Irp, IO_NO_INCREMENT); return STATUS_NO_SUCH_DEVICE; } status = VspIncrementVolumeRefCount(extension, Irp, NULL); if (!NT_SUCCESS(status)) { Irp->IoStatus.Status = status; Irp->IoStatus.Information = 0; IoCompleteRequest(Irp, IO_NO_INCREMENT); return status; } if (status == STATUS_PENDING) { return status; } IoMarkIrpPending(Irp); KeAcquireSpinLock(&extension->SpinLock, &irql); if (VspAreBitsSet(extension, Irp)) { KeReleaseSpinLock(&extension->SpinLock, irql); Irp->IoStatus.Status = STATUS_SUCCESS; Irp->IoStatus.Information = IoGetCurrentIrpStackLocation(Irp)-> Parameters.Read.Length; VspReadCompletionForReadSnapshot(DeviceObject, Irp, extension); return STATUS_PENDING; } KeReleaseSpinLock(&extension->SpinLock, irql); IoCopyCurrentIrpStackLocationToNext(Irp); IoSetCompletionRoutine(Irp, VspReadCompletionForReadSnapshot, extension, TRUE, TRUE, TRUE); IoCallDriver(filter->TargetObject, Irp); return STATUS_PENDING; } NTSTATUS VspIncrementRefCount( IN PFILTER_EXTENSION Filter, IN PIRP Irp ) { KIRQL irql; InterlockedIncrement(&Filter->RefCount); if (!Filter->HoldIncomingWrites) { return STATUS_SUCCESS; } VspDecrementRefCount(Filter); KeAcquireSpinLock(&Filter->SpinLock, &irql); if (!Filter->HoldIncomingWrites) { InterlockedIncrement(&Filter->RefCount); KeReleaseSpinLock(&Filter->SpinLock, irql); return STATUS_SUCCESS; } IoMarkIrpPending(Irp); InsertTailList(&Filter->HoldQueue, &Irp->Tail.Overlay.ListEntry); KeReleaseSpinLock(&Filter->SpinLock, irql); return STATUS_PENDING; } NTSTATUS VspRefCountCompletionRoutine( IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Filter ) { VspDecrementRefCount((PFILTER_EXTENSION) Filter); return STATUS_SUCCESS; } NTSTATUS VolSnapWrite( IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp ) /*++ Routine Description: This routine is the dispatch for IRP_MJ_WRITE. Arguments: DeviceObject - Supplies the device object. Irp - Supplies the IO request packet. Return Value: NTSTATUS --*/ { PFILTER_EXTENSION filter = (PFILTER_EXTENSION) DeviceObject->DeviceExtension; NTSTATUS status; PVOLUME_EXTENSION extension; KIRQL irql; PLIST_ENTRY l, ll; PVSP_DIFF_AREA_FILE diffAreaFile; PIO_STACK_LOCATION nextSp; PVSP_CONTEXT context; PDO_EXTENSION rootExtension; if (filter->DeviceExtensionType == DEVICE_EXTENSION_VOLUME) { Irp->IoStatus.Status = STATUS_INVALID_DEVICE_REQUEST; Irp->IoStatus.Information = 0; IoCompleteRequest(Irp, IO_NO_INCREMENT); return STATUS_INVALID_DEVICE_REQUEST; } ASSERT(filter->DeviceExtensionType == DEVICE_EXTENSION_FILTER); IoMarkIrpPending(Irp); status = VspIncrementRefCount(filter, Irp); if (status == STATUS_PENDING) { return status; } if (!filter->SnapshotsPresent) { IoCopyCurrentIrpStackLocationToNext(Irp); IoSetCompletionRoutine(Irp, VspRefCountCompletionRoutine, filter, TRUE, TRUE, TRUE); IoCallDriver(filter->TargetObject, Irp); return STATUS_PENDING; } extension = CONTAINING_RECORD(filter->VolumeList.Blink, VOLUME_EXTENSION, ListEntry); KeAcquireSpinLock(&extension->SpinLock, &irql); if (VspAreBitsSet(extension, Irp)) { KeReleaseSpinLock(&extension->SpinLock, irql); IoCopyCurrentIrpStackLocationToNext(Irp); IoSetCompletionRoutine(Irp, VspRefCountCompletionRoutine, filter, TRUE, TRUE, TRUE); IoCallDriver(filter->TargetObject, Irp); return STATUS_PENDING; } KeReleaseSpinLock(&extension->SpinLock, irql); context = VspAllocateContext(extension->Root); if (!context) { rootExtension = extension->Root; KeAcquireSpinLock(&rootExtension->ESpinLock, &irql); if (rootExtension->EmergencyContextInUse) { InsertTailList(&rootExtension->IrpWaitingList, &Irp->Tail.Overlay.ListEntry); if (!rootExtension->IrpWaitingListNeedsChecking) { InterlockedExchange( &rootExtension->IrpWaitingListNeedsChecking, TRUE); } KeReleaseSpinLock(&rootExtension->ESpinLock, irql); VspDecrementRefCount(filter); return STATUS_PENDING; } rootExtension->EmergencyContextInUse = TRUE; KeReleaseSpinLock(&rootExtension->ESpinLock, irql); context = rootExtension->EmergencyContext; } for (l = extension->ListOfDiffAreaFiles.Flink; l != &extension->ListOfDiffAreaFiles; l = l->Flink) { diffAreaFile = CONTAINING_RECORD(l, VSP_DIFF_AREA_FILE, VolumeListEntry); status = VspIncrementRefCount(diffAreaFile->Filter, Irp); if (status == STATUS_PENDING) { break; } } if (l != &extension->ListOfDiffAreaFiles) { for (ll = extension->ListOfDiffAreaFiles.Flink; ll != l; ll = ll->Flink) { diffAreaFile = CONTAINING_RECORD(ll, VSP_DIFF_AREA_FILE, VolumeListEntry); VspDecrementRefCount(diffAreaFile->Filter); } VspFreeContext(extension->Root, context); VspDecrementRefCount(filter); return STATUS_PENDING; } nextSp = IoGetNextIrpStackLocation(Irp); nextSp->Parameters.Write.Length = 1; // Use this for a ref count. context->Type = VSP_CONTEXT_TYPE_WRITE_VOLUME; context->WriteVolume.Extension = extension; context->WriteVolume.Irp = Irp; context->WriteVolume.RoundedStart = 0; ExInitializeWorkItem(&context->WorkItem, VspWriteVolume, context); VspAcquireNonPagedResource(extension, &context->WorkItem); return STATUS_PENDING; } NTSTATUS VolSnapCleanup( IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp ) /*++ Routine Description: This routine is the dispatch for IRP_MJ_CLEANUP. Arguments: DeviceObject - Supplies the device object. Irp - Supplies the IO request packet. Return Value: NTSTATUS --*/ { PFILTER_EXTENSION filter = (PFILTER_EXTENSION) DeviceObject->DeviceExtension; PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation(Irp); KEVENT event; KIRQL irql; PIRP irp; PVSP_CONTEXT context; if (filter->DeviceExtensionType == DEVICE_EXTENSION_VOLUME) { Irp->IoStatus.Status = STATUS_INVALID_DEVICE_REQUEST; Irp->IoStatus.Information = 0; IoCompleteRequest(Irp, IO_NO_INCREMENT); return STATUS_INVALID_DEVICE_REQUEST; } ASSERT(filter->DeviceExtensionType == DEVICE_EXTENSION_FILTER); KeInitializeEvent(&event, NotificationEvent, FALSE); IoCopyCurrentIrpStackLocationToNext(Irp); IoSetCompletionRoutine(Irp, VspSignalCompletion, &event, TRUE, TRUE, TRUE); IoCallDriver(filter->TargetObject, Irp); KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL); IoAcquireCancelSpinLock(&irql); if (filter->FlushAndHoldIrp) { irp = filter->FlushAndHoldIrp; if (IoGetCurrentIrpStackLocation(irp)->FileObject == irpSp->FileObject) { irp->CancelIrql = irql; IoSetCancelRoutine(irp, NULL); VspCancelRoutine(DeviceObject, irp); } else { IoReleaseCancelSpinLock(irql); } } else { IoReleaseCancelSpinLock(irql); } IoAcquireCancelSpinLock(&irql); if (filter->AutoCleanupFileObject == irpSp->FileObject) { filter->AutoCleanupFileObject = NULL; IoReleaseCancelSpinLock(irql); if (!InterlockedExchange(&filter->DestroyAllSnapshotsPending, TRUE)) { context = &filter->DestroyContext; context->Type = VSP_CONTEXT_TYPE_FILTER; context->Filter.Filter = filter; ObReferenceObject(filter->DeviceObject); ExInitializeWorkItem(&context->WorkItem, VspDestroyAllSnapshotsWorker, context); ExQueueWorkItem(&context->WorkItem, DelayedWorkQueue); } } else { 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 --*/ { ULONG i; PDEVICE_OBJECT deviceObject; NTSTATUS status; PDO_EXTENSION rootExtension; for (i = 0; i <= IRP_MJ_MAXIMUM_FUNCTION; i++) { DriverObject->MajorFunction[i] = VolSnapDefaultDispatch; } DriverObject->DriverExtension->AddDevice = VolSnapAddDevice; DriverObject->MajorFunction[IRP_MJ_CREATE] = VolSnapCreate; DriverObject->MajorFunction[IRP_MJ_READ] = VolSnapRead; DriverObject->MajorFunction[IRP_MJ_WRITE] = VolSnapWrite; DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = VolSnapDeviceControl; DriverObject->MajorFunction[IRP_MJ_CLEANUP] = VolSnapCleanup; DriverObject->MajorFunction[IRP_MJ_PNP] = VolSnapPnp; DriverObject->MajorFunction[IRP_MJ_POWER] = VolSnapPower; status = IoAllocateDriverObjectExtension(DriverObject, VolSnapAddDevice, sizeof(DO_EXTENSION), (PVOID*) &rootExtension); if (!NT_SUCCESS(status)) { return status; } RtlZeroMemory(rootExtension, sizeof(DO_EXTENSION)); rootExtension->DriverObject = DriverObject; InitializeListHead(&rootExtension->FilterList); InitializeListHead(&rootExtension->HoldIrps); KeInitializeTimer(&rootExtension->HoldTimer); KeInitializeDpc(&rootExtension->HoldTimerDpc, VspFsTimerDpc, rootExtension); KeInitializeSemaphore(&rootExtension->Semaphore, 1, 1); for (i = 0; i < NUMBER_OF_THREAD_POOLS; i++) { InitializeListHead(&rootExtension->WorkerQueue[i]); KeInitializeSemaphore(&rootExtension->WorkerSemaphore[i], 0, MAXLONG); KeInitializeSpinLock(&rootExtension->SpinLock[i]); } KeInitializeSemaphore(&rootExtension->ThreadsRefCountSemaphore, 1, 1); IoRegisterDriverReinitialization(DriverObject, VspDriverReinit, rootExtension); ExInitializeNPagedLookasideList(&rootExtension->ContextLookasideList, NULL, NULL, 0, sizeof(VSP_CONTEXT), VOLSNAP_TAG_CONTEXT, 32); rootExtension->EmergencyContext = VspAllocateContext(rootExtension); if (!rootExtension->EmergencyContext) { ExDeleteNPagedLookasideList(&rootExtension->ContextLookasideList); return STATUS_INSUFFICIENT_RESOURCES; } InitializeListHead(&rootExtension->IrpWaitingList); KeInitializeSpinLock(&rootExtension->ESpinLock); ExInitializeNPagedLookasideList(&rootExtension->TempTableEntryLookasideList, NULL, NULL, 0, sizeof(RTL_BALANCED_LINKS) + sizeof(TEMP_TRANSLATION_TABLE_ENTRY), VOLSNAP_TAG_TEMP_TABLE, 32); rootExtension->EmergencyTableEntry = VspAllocateTempTableEntry(rootExtension); if (!rootExtension->EmergencyTableEntry) { ExFreeToNPagedLookasideList(&rootExtension->ContextLookasideList, rootExtension->EmergencyContext); ExDeleteNPagedLookasideList( &rootExtension->TempTableEntryLookasideList); ExDeleteNPagedLookasideList(&rootExtension->ContextLookasideList); return STATUS_INSUFFICIENT_RESOURCES; } InitializeListHead(&rootExtension->WorkItemWaitingList); rootExtension->RegistryPath.Length = RegistryPath->Length; rootExtension->RegistryPath.MaximumLength = rootExtension->RegistryPath.Length + sizeof(WCHAR); rootExtension->RegistryPath.Buffer = (PWSTR) ExAllocatePoolWithTag(PagedPool, rootExtension->RegistryPath.MaximumLength, VOLSNAP_TAG_SHORT_TERM); if (rootExtension->RegistryPath.Buffer) { RtlCopyMemory(rootExtension->RegistryPath.Buffer, RegistryPath->Buffer, RegistryPath->Length); rootExtension->RegistryPath.Buffer[RegistryPath->Length/ sizeof(WCHAR)] = 0; } InitializeListHead(&rootExtension->AdjustBitmapQueue); return STATUS_SUCCESS; }