[NTOSKRNL:CC] Implementation of Lazy Writer
Implemented following function *CcPostWorkQueue *CcScheduleLazyWriteScanEx *CcScheduleLazyWriteScan *CcExceptionFilter *CcPerformReadAhead *CcPostDeferredWrites *CcSetValidData *CcWriteBehind *CcLazyWriteScan
This commit is contained in:
parent
189cf42f74
commit
3ff9824c8b
862
NTOSKRNL/CC/cclazywriter.cpp
Normal file
862
NTOSKRNL/CC/cclazywriter.cpp
Normal file
@ -0,0 +1,862 @@
|
||||
/*
|
||||
* PROJECT: Alcyone System Kernel
|
||||
* LICENSE: BSD Clause 3
|
||||
* PURPOSE: Cache Controller:: Lazy Writer
|
||||
* NT KERNEL: 5.11.9360
|
||||
* COPYRIGHT: 2023-2029 Dibymartanda Samanta <>
|
||||
*/
|
||||
#include <ntoskrnl.h>
|
||||
#define NTDEBUG
|
||||
#include <debug.h>
|
||||
#include "ccinternal.hpp"
|
||||
#include "cclazywriter.hpp"
|
||||
|
||||
extern "C"
|
||||
|
||||
/*Internal Function*/
|
||||
|
||||
VOID
|
||||
VECTORCALL
|
||||
CcPostWorkQueue(IN PWORK_QUEUE_ENTRY WorkItem,
|
||||
IN PLIST_ENTRY WorkQueue)
|
||||
{
|
||||
PWORK_QUEUE_ITEM ThreadToSpawn = nullptr;
|
||||
PLIST_ENTRY ListEntry = nullptr; // be aware.
|
||||
KIRQL CurrentIrql = NULL;
|
||||
|
||||
/* Aquire SpinLock & Insert the Worker in Queue*/
|
||||
CurrentIrql = KeAcquireQueuedSpinLock(LockQueueWorkQueueLock);
|
||||
InsertTailList(WorkQueue, &WorkItem->WorkQueueLinks);
|
||||
|
||||
/* CHeck if new thread to be spawnwed */
|
||||
if (!CcQueueThrottle && !IsListEmpty(&CcIdleWorkerThreadList))
|
||||
{
|
||||
|
||||
ListEntry = RemoveHeadList(&CcIdleWorkerThreadList);
|
||||
ThreadToSpawn = CONTAINING_RECORD(ListEntry, WORK_QUEUE_ITEM, List);
|
||||
|
||||
/* Update the number of Active Worker Thread */
|
||||
_InterlockedIncrement(&CcNumberActiveWorkerThreads);
|
||||
}
|
||||
|
||||
KeReleaseQueuedSpinLock(LockQueueWorkQueueLock, CurrentIrql);
|
||||
|
||||
/* Check if thread left to spawn, disable it now since Spinlock is released */
|
||||
if (ThreadToSpawn)
|
||||
{
|
||||
DBGPRINT(" CcPostWorkQueue: Thread Left to be spwaned even after release of Spinlock!\n");
|
||||
ThreadToSpawn->List.Flink = nullptr;
|
||||
ExQueueWorkItem(ThreadToSpawn, CriticalWorkQueue);
|
||||
}
|
||||
}
|
||||
VOID
|
||||
NTAPI
|
||||
CcScheduleLazyWriteScanEx(IN BOOLEAN Delay_Status, IN BOOLEAN Teardowmn_Status)
|
||||
{
|
||||
BOOLEAN Result;
|
||||
|
||||
/* If their no delay , Start Lazy Writer Scan Immidietely */
|
||||
if (Delay_Status)
|
||||
{
|
||||
LazyWriter.Active = True;
|
||||
/* Check if Teardown is Active */
|
||||
if (Teardowmn_Status)
|
||||
{
|
||||
LazyWriter.PendingTeardown = True;
|
||||
}
|
||||
result = KeSetTimer(&LazyWriter.ScanTimer, CcNoDelay, &LazyWriter.ScanDpc);
|
||||
}
|
||||
/* If It is not running , Start it */
|
||||
else if (LazyWriter.ScanActive)
|
||||
{
|
||||
result = KeSetTimer(&LazyWriter.ScanTimer, CcIdleDelay, &LazyWriter.ScanDpc);
|
||||
}
|
||||
/* If it is already running , Queue for it */
|
||||
else
|
||||
{
|
||||
result = KeSetTimer(&LazyWriter.ScanTimer, CcFirstDelay, &LazyWriter.ScanDpc);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
VOID
|
||||
NTAPI
|
||||
CcScheduleLazyWriteScan(IN BOOLEAN NoDelay)
|
||||
{
|
||||
return CcScheduleLazyWriteScanEx(NoDelay, False);
|
||||
}
|
||||
|
||||
LONG
|
||||
VECTORCALL
|
||||
CcExceptionFilter(IN NTSTATUS Status)
|
||||
{
|
||||
LONG Result;
|
||||
/* Get the Flag Status */
|
||||
BOOL NTSTATUS_FLAG = static_cast<BOOL>(FsRtlIsNtstatusExpected(Status));
|
||||
if (NTSTATUS_FLAG)
|
||||
Result = EXCEPTION_EXECUTE_HANDLER;
|
||||
else
|
||||
Result = EXCEPTION_CONTINUE_SEARCH;
|
||||
|
||||
DBGPRINT("CcExceptionFilter: Status %X\n", Status);
|
||||
return Result;
|
||||
}
|
||||
VOID
|
||||
VECTORCALL
|
||||
CcPerformReadAhead(IN PFILE_OBJECT FileObject)
|
||||
{
|
||||
PETHREAD CurrentThread = PsGetCurrentThread();
|
||||
PSHARED_CACHE_MAP SharedCachMap;
|
||||
PPRIVATE_CACHE_MAP PrivateCachMap;
|
||||
PVACB Vacb = nullptr;
|
||||
BOOLEAN LengthIsZero = false;
|
||||
BOOLEAN ReadAheasStatus = false;
|
||||
BOOLEAN ReadAheadStatus = false;
|
||||
BOOLEAN ReadAheadFinishStatus = false;
|
||||
ULONG_PTR VirtualAdress = nullptr;
|
||||
LARGE_INTEGER FileOffset = {0};
|
||||
LARGE_INTEGER readAheadOffset[2];
|
||||
ULONG readAheadLength[2];
|
||||
ULONG IsPageNotResident = {0};
|
||||
ULONG ReceivedLength = {0};
|
||||
ULONG NumberOfPages = {0};
|
||||
ULONG Length = {0};
|
||||
ULONG OldReadClusterSize = {0};
|
||||
UCHAR OldForwardClusterOnly = {0};
|
||||
KIRQL LastIRQL = {0};
|
||||
|
||||
/* GET Cluster History */
|
||||
OldForwardClusterOnly = CurrentThread->ForwardClusterOnly;
|
||||
OldReadClusterSize = CurrentThread->ReadClusterSize;
|
||||
|
||||
SharedCachMap = FileObject->SectionObjectPointer->SharedCacheMap;
|
||||
|
||||
_TRY
|
||||
{
|
||||
while (TRUE)
|
||||
{
|
||||
LastIRQL = KeAcquireQueuedSpinLock(LockQueueMasterLock);
|
||||
|
||||
PrivateCachMap = FileObject->VirtualAdress;
|
||||
|
||||
/* Check if it is a valid VirtualAdress Adress , if Not Reissue ReadAhead Offesets */
|
||||
if (PrivateCachMap != nullptr)
|
||||
{
|
||||
KeAcquireSpinLockAtDpcLevel(&PrivateCachMap->ReadAheadSpinLock);
|
||||
|
||||
LengthIsZero = (!(PrivateCachMap->ReadAheadLength[0] | PrivateCachMap->ReadAheadLength[1]));
|
||||
|
||||
readAheadOffset[0].QuadPart = PrivateCachMap->ReadAheadOffset[0].QuadPart;
|
||||
readAheadOffset[1].QuadPart = PrivateCachMap->ReadAheadOffset[1].QuadPart;
|
||||
|
||||
readAheadLength[0] = PrivateCachMap->ReadAheadLength[0];
|
||||
readAheadLength[1] = PrivateCachMap->ReadAheadLength[1];
|
||||
|
||||
PrivateCachMap->ReadAheadLength[0] = 0;
|
||||
PrivateCachMap->ReadAheadLength[1] = 0;
|
||||
|
||||
KeReleaseSpinLockFromDpcLevel(&PrivateCachMap->ReadAheadSpinLock);
|
||||
}
|
||||
|
||||
KeReleaseQueuedSpinLock(LockQueueMasterLock, LastIRQL);
|
||||
|
||||
ReadAheadStatus = (*SharedCachMap->Callbacks->AcquireForReadAhead)(SharedCachMap->LazyWriteContext, TRUE);
|
||||
|
||||
if (!PrivateCachMap || LengthIsZero || !ReadAheadStatus)
|
||||
break;
|
||||
|
||||
for (auto i = 0; i <= 1; i++)
|
||||
{
|
||||
FileOffset = readAheadOffset[i];
|
||||
Length = readAheadLength[i];
|
||||
/* Check if Cache Can be read Ahead */
|
||||
if (Length && FileOffset.QuadPart <= SharedCachMap->FileSize.QuadPart)
|
||||
{
|
||||
ReadAheasStatus = TRUE;
|
||||
|
||||
if (SharedCachMap->FileSize.QuadPart <= (FileOffset.QuadPart + (LONGLONG)Length))
|
||||
{
|
||||
Length = (SharedCachMap->FileSize.QuadPart - FileOffset.QuadPart);
|
||||
ReadAheadFinishStatus = TRUE;
|
||||
}
|
||||
|
||||
if (Length > 0x800000)
|
||||
Length = 0x800000; // Make a Define and move to header
|
||||
|
||||
while (Length != NULL)
|
||||
{
|
||||
VirtualAdress = CcGetVirtualAddress(SharedCachMap, FileOffset, &Vacb, &ReceivedLength);
|
||||
|
||||
if (ReceivedLength > Length)
|
||||
ReceivedLength = Length;
|
||||
|
||||
for (NumberOfPages = ADDRESS_AND_SIZE_TO_SPAN_PAGES(VirtualAdress, ReceivedLength);
|
||||
NumberOfPages; NumberOfPages--)
|
||||
{
|
||||
CurrentThread->ForwardClusterOnly = 1;
|
||||
|
||||
if (NumberOfPages > 0x10)
|
||||
CurrentThread->ReadClusterSize = 0xF;
|
||||
else
|
||||
CurrentThread->ReadClusterSize = (NumberOfPages - 1);
|
||||
|
||||
IsPageNotResident |= !MmCheckCachedPageState(VirtualAdress, FALSE);
|
||||
|
||||
VirtualAdress = static_cast<LONG *>(VirtualAdress + PAGE_SIZE);
|
||||
}
|
||||
/*Update History */
|
||||
FileOffset.QuadPart += ReceivedLength;
|
||||
Length -= ReceivedLength;
|
||||
|
||||
CcFreeVirtualAddress(Vacb);
|
||||
Vacb = nullptr;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
(*SharedCachMap->Callbacks->ReleaseFromReadAhead)(SharedCachMap->LazyWriteContext);
|
||||
|
||||
ReadAheadStatus = FALSE;
|
||||
}
|
||||
}
|
||||
_FINALLY
|
||||
{
|
||||
|
||||
/* Restore cluster variables */
|
||||
CurrentThread->ForwardClusterOnly = OldForwardClusterOnly;
|
||||
CurrentThread->ReadClusterSize = OldReadClusterSize;
|
||||
|
||||
if (Vacb)
|
||||
CcFreeVirtualAddress(Vacb);
|
||||
/* If ReadAheadStatus is False , Release it from Write Context */
|
||||
if (ReadAheadStatus)
|
||||
(*SharedCachMap->Callbacks->ReleaseFromReadAhead)(SharedCachMap->LazyWriteContext);
|
||||
|
||||
LastIRQL = KeAcquireQueuedSpinLock(LockQueueMasterLock);
|
||||
|
||||
PrivateCachMap = FileObject->VirtualAdress;
|
||||
if (PrivateCachMap)
|
||||
{
|
||||
KeAcquireSpinLockAtDpcLevel(&PrivateCachMap->ReadAheadSpinLock);
|
||||
|
||||
RtlInterlockedAndBits(&PrivateCachMap->UlongFlags, ~SHARE_FL_WAITING_TEARDOWN);
|
||||
|
||||
if (ReadAheadFinishStatus && (FileObject->Flags & FO_SEQUENTIAL_ONLY))
|
||||
PrivateCachMap->ReadAheadOffset[1].QuadPart = 0;
|
||||
|
||||
if (ReadAheasStatus && !IsPageNotResident)
|
||||
RtlInterlockedAndBits(&PrivateCachMap->UlongFlags, ~0x20000);
|
||||
|
||||
KeReleaseSpinLockFromDpcLevel(&PrivateCachMap->ReadAheadSpinLock);
|
||||
}
|
||||
|
||||
KeReleaseQueuedSpinLock(LockQueueMasterLock, LastIRQL);
|
||||
ObDereferenceObject(FileObject);
|
||||
LastIRQL = KeAcquireQueuedSpinLock(LockQueueMasterLock);
|
||||
|
||||
_InterlockedDecrement(SharedCachMap->OpenCount);
|
||||
SharedCachMap->Flags &= ~SHARE_FL_READ_AHEAD;
|
||||
|
||||
/* If a Invalid Cache Map */
|
||||
if (!SharedCachMap->OpenCount && !(SharedCachMap->Flags & SHARE_FL_WRITE_QUEUED) && !SharedCachMap->DirtyPages)
|
||||
{
|
||||
RemoveEntryList(&SharedCachMap->SharedCacheMapLinks);
|
||||
InsertTailList(&CcDirtySharedCacheMapList.SharedCacheMapLinks, &SharedCachMap->SharedCacheMapLinks);
|
||||
|
||||
LazyWriter.OtherWork = TRUE;
|
||||
|
||||
if (!LazyWriter.ScanActive)
|
||||
CcScheduleLazyWriteScan(FALSE);
|
||||
}
|
||||
|
||||
KeReleaseQueuedSpinLock(LockQueueMasterLock, LastIRQL);
|
||||
}
|
||||
}
|
||||
VOID
|
||||
NTAPI
|
||||
CcPostDeferredWrites(VOID)
|
||||
{
|
||||
PDEFERRED_WRITE DeferredWrites = nullptr;
|
||||
PLIST_ENTRY Entry = nullptr;
|
||||
ULONG BytesToWrite = {0};
|
||||
KIRQL OldIrql = {0};
|
||||
|
||||
while (TRUE)
|
||||
{
|
||||
|
||||
/* Acquire the spin lock to protect concurrent access to shared data structures */
|
||||
KeAcquireSpinLock(&CcDeferredWriteSpinLock, &OldIrql);
|
||||
|
||||
if (!IsListEmpty(&CcDeferredWrites))
|
||||
{
|
||||
Entry = CcDeferredWrites.Flink;
|
||||
while (true)
|
||||
{
|
||||
DeferredWrites = CONTAINING_RECORD(Entry, DEFERRED_WRITE, DeferredWriteLinks);
|
||||
|
||||
/* Calculate the total bytes to write */
|
||||
BytesToWrite += DeferredWrites->BytesToWrite;
|
||||
|
||||
/* BytesToWrite Must not overflow Defferwrite Limits */
|
||||
if (BytesToWrite < DeferredWrites->BytesToWrite)
|
||||
{
|
||||
DeferredWrites = nullptr;
|
||||
break;
|
||||
}
|
||||
|
||||
/* if writing to the file object is possible */
|
||||
if (CcCanIWrite(DeferredWrites->FileObject, BytesToWrite, FALSE, 0xFE))
|
||||
{
|
||||
/*Remove the entry from the deferred writes list if writing is possible */
|
||||
RemoveEntryList(&DeferredWrites->DeferredWriteLinks);
|
||||
break;
|
||||
}
|
||||
|
||||
/* Check if the limit of modified pages has been reached */
|
||||
if (!DeferredWrites->LimitModifiedPages)
|
||||
{
|
||||
DeferredWrites = nullptr;
|
||||
break;
|
||||
}
|
||||
|
||||
/* Decrement the bytes to write and reset DeferredWrites*/
|
||||
BytesToWrite -= DeferredWrites->BytesToWrite;
|
||||
DeferredWrites = nullptr;
|
||||
|
||||
/* Move to the next entry in the list */
|
||||
Entry = Entry->Flink;
|
||||
}
|
||||
|
||||
/* Release the spin lock */
|
||||
KeReleaseSpinLock(&CcDeferredWriteSpinLock, OldIrql);
|
||||
|
||||
/* If Defferwrite List is null get out of loop */
|
||||
if (!DeferredWrites)
|
||||
break;
|
||||
|
||||
if (DeferredWrites->Event)
|
||||
{
|
||||
KeSetEvent(DeferredWrites->Event, IO_NO_INCREMENT, FALSE);
|
||||
continue;
|
||||
}
|
||||
|
||||
/*execute the post routine, and free memory */
|
||||
|
||||
DeferredWrites->PostRoutine(DeferredWrites->Context1, DeferredWrites->Context2);
|
||||
ExFreePoolWithTag(DeferredWrites, 0);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
NTSTATUS
|
||||
NTAPI
|
||||
CcSetValidData(IN PFILE_OBJECT FileObject,
|
||||
IN PLARGE_INTEGER FileSize)
|
||||
{
|
||||
FILE_END_OF_FILE_INFORMATION FileInfo; // Structure to hold end-of-file information
|
||||
PDEVICE_OBJECT DeviceObject; // Pointer to the device object associated with the file
|
||||
PIO_STACK_LOCATION IoStack; // Pointer to an I/O stack location structure
|
||||
IO_STATUS_BLOCK IoStatus; // I/O status block structure
|
||||
KEVENT Event; // Kernel event object for synchronization
|
||||
PIRP Irp; // Pointer to an I/O request packet structure
|
||||
NTSTATUS Status; // Status of the operation
|
||||
|
||||
/*Initialize a kernel event object for synchronization */
|
||||
KeInitializeEvent(&Event, NotificationEvent, FALSE);
|
||||
|
||||
/* Retrieve the device object associated with the file*/
|
||||
DeviceObject = IoGetRelatedDeviceObject(FileObject);
|
||||
|
||||
/* Initialize FileInfo structure with the new file size */
|
||||
FileInfo.EndOfFile.QuadPart = FileSize->QuadPart;
|
||||
|
||||
/* Allocate an I/O request packet (IRP) */
|
||||
Irp = IoAllocateIrp(DeviceObject->StackSize, 0);
|
||||
if (!Irp)
|
||||
{
|
||||
return STATUS_INSUFFICIENT_RESOURCES;
|
||||
}
|
||||
|
||||
/* Set IRP parameters */
|
||||
Irp->AssociatedIrp.SystemBuffer = &FileInfo;
|
||||
Irp->UserIosb = &IoStatus;
|
||||
Irp->UserEvent = &Event;
|
||||
Irp->Flags = (IRP_SYNCHRONOUS_PAGING_IO | IRP_PAGING_IO);
|
||||
Irp->RequestorMode = KernelMode;
|
||||
Irp->Tail.Overlay.Thread = PsGetCurrentThread();
|
||||
Irp->Tail.Overlay.OriginalFileObject = FileObject;
|
||||
|
||||
/* Get the next IRP stack location and set up IRP parameters */
|
||||
IoStack = IoGetNextIrpStackLocation(Irp);
|
||||
IoStack->MajorFunction = IRP_MJ_SET_INFORMATION;
|
||||
IoStack->FileObject = FileObject;
|
||||
IoStack->DeviceObject = DeviceObject;
|
||||
IoStack->Parameters.SetFile.Length = sizeof(FILE_END_OF_FILE_INFORMATION);
|
||||
IoStack->Parameters.SetFile.FileInformationClass = FileEndOfFileInformation;
|
||||
IoStack->Parameters.SetFile.FileObject = nullptr;
|
||||
IoStack->Parameters.SetFile.AdvanceOnly = 1;
|
||||
|
||||
/* Call the device driver to handle the IRP */
|
||||
Status = IoCallDriver(DeviceObject, Irp);
|
||||
|
||||
/*If the operation is pending, wait for it to complete*/
|
||||
if (Status == STATUS_PENDING)
|
||||
KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, nullptr);
|
||||
|
||||
/* Handle completion and error handling */
|
||||
if (!NT_SUCCESS(Status))
|
||||
{
|
||||
IoStatus.Status = Status;
|
||||
}
|
||||
|
||||
/* Return the IOstatus of the operation */
|
||||
return IoStatus.Status;
|
||||
}
|
||||
VOID
|
||||
VECTORCALL
|
||||
CcWriteBehind(IN PSHARED_CACHE_MAP SharedMap,
|
||||
IN IO_STATUS_BLOCK * OutIoStatus)
|
||||
{
|
||||
KLOCK_QUEUE_HANDLE LockHandle;
|
||||
LARGE_INTEGER validDataLength = {0};
|
||||
ULONG ActivePage = {0};
|
||||
ULONG TargetPages = {0} ;
|
||||
KIRQL OldIrql = {0};
|
||||
BOOLEAN IsVacbLocked = false;
|
||||
BOOLEAN IsCancelWait = false;
|
||||
NTSTATUS Status;
|
||||
|
||||
PVACB ActiveVacb = nullptr;
|
||||
PUNICODE_STRING FileName = nullptr;
|
||||
|
||||
/*Acquire lazy writer's lock for lazy write*/
|
||||
if (!(*SharedMap->Callbacks->AcquireForLazyWrite)(SharedMap->LazyWriteContext, TRUE))
|
||||
{
|
||||
/* If acquisition fails, release LockQueueMasterLock and set STATUS_FILE_LOCK_CONFLICT */
|
||||
OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
|
||||
SharedMap->Flags &= ~0x20; // Clear the flag indicating wait for Lazy Writer
|
||||
KeReleaseQueuedSpinLock(LockQueueMasterLock, OldIrql);
|
||||
|
||||
OutIoStatus->Status = STATUS_FILE_LOCK_CONFLICT;
|
||||
return;
|
||||
}
|
||||
|
||||
/* Acquire BcbSpinLock and LockQueueMasterLock */
|
||||
KeAcquireInStackQueuedSpinLock(&SharedMap->BcbSpinLock, &LockHandle);
|
||||
KeAcquireQueuedSpinLockAtDpcLevel(&KeGetCurrentPrcb()->LockQueue[LockQueueMasterLock]);
|
||||
|
||||
/*Determine if there are few dirty pages or no open references */
|
||||
if (SharedMap->DirtyPages <= 1 || !SharedMap->OpenCount)
|
||||
{
|
||||
/*Acquire ActiveVacbSpinLock to handle ActiveVacb*/
|
||||
KeAcquireSpinLockAtDpcLevel(&SharedMap->ActiveVacbSpinLock);
|
||||
|
||||
/*Retrieve ActiveVacb and related information if it exists*/
|
||||
ActiveVacb = SharedMap->ActiveVacb;
|
||||
if (ActiveVacb)
|
||||
{
|
||||
ActivePage = SharedMap->ActivePage;
|
||||
SharedMap->ActiveVacb = 0;
|
||||
IsVacbLocked = ((SharedMap->Flags & SHARE_FL_VACB_LOCKED) != 0);
|
||||
}
|
||||
|
||||
/*Release ActiveVacbSpinLock*/
|
||||
KeReleaseSpinLockFromDpcLevel(&SharedMap->ActiveVacbSpinLock);
|
||||
}
|
||||
|
||||
/*Increment OpenCount*/
|
||||
_InterlockedIncrement(SharedMap->OpenCount);
|
||||
|
||||
/* Update Mbcb information if it exists*/
|
||||
if (SharedMap->Mbcb)
|
||||
{
|
||||
TargetPages = SharedMap->Mbcb->DirtyPages;
|
||||
|
||||
if (ActiveVacb)
|
||||
_InterlockedIncrement(TargetPages);
|
||||
|
||||
/*Determine PagesToWrite based on CcPagesYetToWrite and TargetPages*/
|
||||
if (TargetPages > CcPagesYetToWrite)
|
||||
SharedMap->Mbcb->PagesToWrite = CcPagesYetToWrite;
|
||||
else
|
||||
SharedMap->Mbcb->PagesToWrite = TargetPages;
|
||||
}
|
||||
|
||||
/*Release LockQueueMasterLock and BcbSpinLock*/
|
||||
KeReleaseQueuedSpinLockFromDpcLevel(&KeGetCurrentPrcb()->LockQueue[LockQueueMasterLock]);
|
||||
KeReleaseInStackQueuedSpinLock(&LockHandle);
|
||||
|
||||
/* Free ActiveVacb if it exists*/
|
||||
if (ActiveVacb)
|
||||
CcFreeActiveVacb(SharedMap, ActiveVacb, ActivePage, IsVacbLocked);
|
||||
|
||||
/* Flush cache to disk*/
|
||||
CcFlushCache(SharedMap->FileObject->SectionObjectPointer, &CcNoDelay, 1, OutIoStatus);
|
||||
|
||||
/*Release lazy writer's lock*/
|
||||
(*SharedMap->Callbacks->ReleaseFromLazyWrite)(SharedMap->LazyWriteContext);
|
||||
|
||||
/* Check if Status Verification Failed */
|
||||
if (!NT_SUCCESS(OutIoStatus->Status) && OutIoStatus->Status != STATUS_VERIFY_REQUIRED)
|
||||
IsCancelWait = TRUE;
|
||||
|
||||
if (!NT_SUCCESS(OutIoStatus->Status) && OutIoStatus->Status != STATUS_VERIFY_REQUIRED &&
|
||||
OutIoStatus->Status != STATUS_FILE_LOCK_CONFLICT &&
|
||||
OutIoStatus->Status != STATUS_ENCOUNTERED_WRITE_IN_PROGRESS)
|
||||
{
|
||||
/* Prepare for error notification and log*/
|
||||
POBJECT_NAME_INFORMATION FileNameInfo = nullptr;
|
||||
NTSTATUS status;
|
||||
|
||||
/*Retrieve IOSTATUS */
|
||||
status = IoQueryFileDosDeviceName(SharedMap->FileObject, &FileNameInfo);
|
||||
|
||||
if (status = STATUS_SUCCESS)
|
||||
{
|
||||
IoRaiseInformationalHardError(STATUS_LOST_WRITEBEHIND_DATA, &FileNameInfo->Name, nullptr);
|
||||
}
|
||||
else
|
||||
{
|
||||
FileName = &SharedMap->FileObject->FileName;
|
||||
|
||||
if (FileName->Length && FileName->MaximumLength && FileName->Buffer)
|
||||
IoRaiseInformationalHardError(STATUS_LOST_WRITEBEHIND_DATA, FileName, nullptr);
|
||||
}
|
||||
|
||||
if (FileNameInfo)
|
||||
ExFreePoolWithTag(FileNameInfo, 0);
|
||||
}
|
||||
else if (!IsListEmpty(&CcDeferredWrites))
|
||||
{
|
||||
/*If deferred writes exist, process them */
|
||||
CcPostDeferredWrites();
|
||||
}
|
||||
|
||||
/*Acquire BcbSpinLock */
|
||||
KeAcquireInStackQueuedSpinLock(&SharedMap->BcbSpinLock, &LockHandle);
|
||||
|
||||
/* Update ValidDataLength if necessary*/
|
||||
Status = STATUS_SUCCESS;
|
||||
|
||||
if (SharedMap->Flags & (0x400 | 0x8000))
|
||||
{
|
||||
if (SharedMap->ValidDataLength.QuadPart <= SharedMap->ValidDataGoal.QuadPart &&
|
||||
SharedMap->ValidDataLength.QuadPart != 0x7FFFFFFFFFFFFFFF && SharedMap->FileSize.QuadPart)
|
||||
{
|
||||
/* Get flushed valid data and set ValidDataLength if necessary */
|
||||
validDataLength = CcGetFlushedValidData(SharedMap->FileObject->SectionObjectPointer, TRUE);
|
||||
|
||||
if (validDataLength.QuadPart >= SharedMap->ValidDataLength.QuadPart)
|
||||
{
|
||||
KeReleaseInStackQueuedSpinLock(&LockHandle);
|
||||
Status = CcSetValidData(SharedMap->FileObject, &validDataLength);
|
||||
KeAcquireInStackQueuedSpinLock(&SharedMap->BcbSpinLock, &LockHandle);
|
||||
|
||||
if (NT_SUCCESS(Status))
|
||||
SharedMap->ValidDataLength = validDataLength;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Release BcbSpinLock*/
|
||||
KeReleaseInStackQueuedSpinLock(&LockHandle);
|
||||
|
||||
/* Perform cleanup tasks*/
|
||||
OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
|
||||
InterlockedDecrement(SharedMap->OpenCount);
|
||||
LockHandle.OldIrql = OldIrql;
|
||||
|
||||
/* Check if there are any remaining open references*/
|
||||
if (SharedMap->OpenCount)
|
||||
goto Exit;
|
||||
|
||||
/*Cleanup if no remaining open references*/
|
||||
if (NT_SUCCESS(Status) ||
|
||||
(Status != STATUS_INSUFFICIENT_RESOURCES && Status != STATUS_VERIFY_REQUIRED &&
|
||||
Status != STATUS_FILE_LOCK_CONFLICT && Status != STATUS_ENCOUNTERED_WRITE_IN_PROGRESS))
|
||||
{
|
||||
/* Release LockQueueMasterLock, acquire file object lock, and recheck open count*/
|
||||
KeReleaseQueuedSpinLock(LockQueueMasterLock, LockHandle.OldIrql);
|
||||
FsRtlAcquireFileExclusive(SharedMap->FileObject);
|
||||
|
||||
LockHandle.OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
|
||||
|
||||
/*Delete SharedCacheMap if no open references remain*/
|
||||
if (!SharedMap->OpenCount)
|
||||
{
|
||||
if (!SharedMap->DirtyPages ||
|
||||
(!SharedMap->FileSize.QuadPart && !(SharedMap->Flags & SHARE_FL_PIN_ACCESS)))
|
||||
{
|
||||
CcDeleteSharedCacheMap(SharedMap, LockHandle.OldIrql, TRUE);
|
||||
OutIoStatus->Information = 0;
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
/*Release LockQueueMasterLock and file object lock */
|
||||
KeReleaseQueuedSpinLock(LockQueueMasterLock, LockHandle.OldIrql);
|
||||
FsRtlReleaseFile(SharedMap->FileObject);
|
||||
LockHandle.OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
|
||||
}
|
||||
|
||||
Exit:
|
||||
|
||||
/*Clear SHARE_FL_WAITING_FLUSH flag if necessary*/
|
||||
if (OutIoStatus->Information != 0x8A5E)
|
||||
SharedMap->Flags &= ~0x20;
|
||||
|
||||
/* Release LockQueueMasterLock*/
|
||||
KeReleaseQueuedSpinLock(LockQueueMasterLock, LockHandle.OldIrql);
|
||||
}
|
||||
VOID
|
||||
NTAPI CcLazyWriteScan()
|
||||
{
|
||||
PSHARED_CACHE_MAP FirstMap = nullptr;
|
||||
PSHARED_CACHE_MAP SharedMap = nullptr;
|
||||
PGENERAL_LOOKASIDE LookasideList = nullptr;
|
||||
PWORK_QUEUE_ENTRY WorkItem = nullptr;
|
||||
PLIST_ENTRY ListEntry = nullptr;
|
||||
PLIST_ENTRY MapLinks = nullptr;
|
||||
PKPRCB Prcb = nullptr;
|
||||
LIST_ENTRY PostWorkList ={0};
|
||||
ULONG TargetPages ={0};
|
||||
ULONG NextTargetPages;
|
||||
ULONG DirtyPages;
|
||||
ULONG counter = 0;
|
||||
BOOLEAN IsNoPagesToWrite = FALSE;
|
||||
BOOLEAN IsDoubleScan = FALSE;
|
||||
KIRQL OldIrql;
|
||||
|
||||
OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
|
||||
|
||||
// Check if there is no dirty page and no other work pending
|
||||
if (!CcTotalDirtyPages && !LazyWriter.OtherWork)
|
||||
{
|
||||
// Check if there are deferred writes pending
|
||||
if (!IsListEmpty(&CcDeferredWrites))
|
||||
{
|
||||
KeReleaseQueuedSpinLock(LockQueueMasterLock, OldIrql);
|
||||
CcPostDeferredWrites();
|
||||
CcScheduleLazyWriteScan(FALSE);
|
||||
}
|
||||
else
|
||||
{
|
||||
// No deferred writes pending, mark lazy write scan as inactive
|
||||
LazyWriter.ScanActive = 0;
|
||||
KeReleaseQueuedSpinLock(LockQueueMasterLock, OldIrql);
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
InitializeListHead(&PostWorkList);
|
||||
|
||||
// Move items from tick work queue to post work list
|
||||
while (!IsListEmpty(&CcPostTickWorkQueue))
|
||||
{
|
||||
ListEntry = RemoveHeadList(&CcPostTickWorkQueue);
|
||||
InsertTailList(&PostWorkList, ListEntry);
|
||||
}
|
||||
|
||||
LazyWriter.OtherWork = FALSE;
|
||||
|
||||
// Calculate target pages based on dirty pages count
|
||||
if (CcTotalDirtyPages > 8)
|
||||
TargetPages = (CcTotalDirtyPages / 8);
|
||||
else
|
||||
TargetPages = CcTotalDirtyPages;
|
||||
|
||||
DirtyPages = (CcTotalDirtyPages + CcPagesWrittenLastTime);
|
||||
|
||||
// Calculate next target pages for scanning
|
||||
if (CcDirtyPagesLastScan < DirtyPages)
|
||||
NextTargetPages = (DirtyPages - CcDirtyPagesLastScan);
|
||||
else
|
||||
NextTargetPages = 0;
|
||||
|
||||
NextTargetPages += (CcTotalDirtyPages - TargetPages);
|
||||
|
||||
if (NextTargetPages > CcDirtyPageTarget)
|
||||
TargetPages += (NextTargetPages - CcDirtyPageTarget);
|
||||
|
||||
CcDirtyPagesLastScan = CcTotalDirtyPages;
|
||||
CcPagesWrittenLastTime = TargetPages;
|
||||
CcPagesYetToWrite = TargetPages;
|
||||
|
||||
// Get the first shared cache map to start the scan
|
||||
SharedMap =
|
||||
CONTAINING_RECORD(CcLazyWriterCursor.SharedCacheMapLinks.Flink, SHARED_CACHE_MAP, SharedCacheMapLinks);
|
||||
|
||||
while (SharedMap != FirstMap)
|
||||
{
|
||||
MapLinks = &SharedMap->SharedCacheMapLinks;
|
||||
|
||||
if (MapLinks == &CcLazyWriterCursor.SharedCacheMapLinks)
|
||||
break;
|
||||
|
||||
if (!FirstMap)
|
||||
FirstMap = SharedMap;
|
||||
|
||||
// Check if we need to skip to the next map
|
||||
if (IsGoToNextMap(SharedMap, TargetPages))
|
||||
{
|
||||
counter++;
|
||||
if (counter >= 20 && !(SharedMap->Flags & (0x20 | 0x800)))
|
||||
{
|
||||
SharedMap->DirtyPages++;
|
||||
SharedMap->Flags |= 0x20;
|
||||
KeReleaseQueuedSpinLock(LockQueueMasterLock, OldIrql);
|
||||
|
||||
counter = 0;
|
||||
|
||||
OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
|
||||
SharedMap->Flags &= ~0x20;
|
||||
SharedMap->DirtyPages--;
|
||||
}
|
||||
|
||||
goto NextMap;
|
||||
}
|
||||
|
||||
SharedMap->PagesToWrite = SharedMap->DirtyPages;
|
||||
|
||||
// Adjust pages to write based on certain conditions
|
||||
if ((SharedMap->Flags & SHARE_FL_MODIFIED_NO_WRITE) && SharedMap->DirtyPages >= 0x40 &&
|
||||
CcCapturedSystemSize != MmSmallSystem)
|
||||
{
|
||||
SharedMap->PagesToWrite /= 8;
|
||||
}
|
||||
|
||||
if (!IsNoPagesToWrite)
|
||||
{
|
||||
if (TargetPages > SharedMap->PagesToWrite)
|
||||
{
|
||||
TargetPages -= SharedMap->PagesToWrite;
|
||||
}
|
||||
else if ((SharedMap->Flags & SHARE_FL_MODIFIED_NO_WRITE) ||
|
||||
(FirstMap == SharedMap && !(SharedMap->LazyWritePassCount & 0xF)))
|
||||
{
|
||||
TargetPages = 0;
|
||||
IsNoPagesToWrite = TRUE;
|
||||
|
||||
IsDoubleScan = TRUE;
|
||||
}
|
||||
else
|
||||
{
|
||||
RemoveEntryList(&CcLazyWriterCursor.SharedCacheMapLinks);
|
||||
InsertTailList(MapLinks, &CcLazyWriterCursor.SharedCacheMapLinks);
|
||||
|
||||
TargetPages = 0;
|
||||
IsNoPagesToWrite = TRUE;
|
||||
}
|
||||
}
|
||||
|
||||
SharedMap->Flags |= 0x20;
|
||||
SharedMap->DirtyPages++;
|
||||
|
||||
KeReleaseQueuedSpinLock(LockQueueMasterLock, OldIrql);
|
||||
|
||||
// Acquire a work item for writing behind
|
||||
Prcb = KeGetCurrentPrcb();
|
||||
LookasideList = Prcb->PPLookasideList[5].P;
|
||||
LookasideList->TotalAllocates++;
|
||||
WorkItem = (PWORK_QUEUE_ENTRY)InterlockedPopEntrySList(&LookasideList->ListHead);
|
||||
|
||||
if (!WorkItem)
|
||||
{
|
||||
LookasideList->AllocateMisses++;
|
||||
LookasideList = Prcb->PPLookasideList[5].L;
|
||||
LookasideList->TotalAllocates++;
|
||||
WorkItem = (PWORK_QUEUE_ENTRY)InterlockedPopEntrySList(&LookasideList->ListHead);
|
||||
|
||||
if (!WorkItem)
|
||||
{
|
||||
LookasideList->AllocateMisses++;
|
||||
WorkItem = LookasideList->Allocate(LookasideList->Type, LookasideList->Size, LookasideList->Tag);
|
||||
}
|
||||
}
|
||||
|
||||
// Check if work item is available
|
||||
if (!WorkItem)
|
||||
{
|
||||
OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
|
||||
SharedMap->Flags &= ~0x20;
|
||||
SharedMap->DirtyPages--;
|
||||
break;
|
||||
}
|
||||
|
||||
// Initialize work item for write behind function
|
||||
WorkItem->Function = WriteBehind;
|
||||
WorkItem->Parameters.Write.SharedCacheMap = SharedMap;
|
||||
|
||||
OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
|
||||
|
||||
SharedMap->DirtyPages--;
|
||||
|
||||
// Post work item to appropriate queue
|
||||
if (SharedMap->Flags & SHARE_FL_WAITING_TEARDOWN)
|
||||
{
|
||||
SharedMap->WriteBehindWorkQueueEntry = (PVOID)((ULONG_PTR)WorkItem | 1);
|
||||
CcPostWorkQueue(WorkItem, &CcFastTeardownWorkQueue);
|
||||
}
|
||||
else
|
||||
{
|
||||
SharedMap->WriteBehindWorkQueueEntry = WorkItem;
|
||||
CcPostWorkQueue(WorkItem, &CcRegularWorkQueue);
|
||||
}
|
||||
|
||||
counter = 0;
|
||||
|
||||
NextMap:
|
||||
|
||||
SharedMap = CONTAINING_RECORD(MapLinks->Flink, SHARED_CACHE_MAP, SharedCacheMapLinks);
|
||||
|
||||
if (IsDoubleScan)
|
||||
{
|
||||
RemoveEntryList(&CcLazyWriterCursor.SharedCacheMapLinks);
|
||||
InsertHeadList(MapLinks, &CcLazyWriterCursor.SharedCacheMapLinks);
|
||||
|
||||
IsDoubleScan = FALSE;
|
||||
}
|
||||
}
|
||||
|
||||
// Post remaining work items to regular work queue
|
||||
while (!IsListEmpty(&PostWorkList))
|
||||
{
|
||||
PWORK_QUEUE_ENTRY workItem;
|
||||
PLIST_ENTRY entry;
|
||||
|
||||
entry = RemoveHeadList(&PostWorkList);
|
||||
workItem = CONTAINING_RECORD(entry, WORK_QUEUE_ENTRY, WorkQueueLinks);
|
||||
|
||||
CcPostWorkQueue(workItem, &CcRegularWorkQueue);
|
||||
}
|
||||
CcComputeNextScanTime(&OldestLWSTimeStamp, &NextScanDelay);
|
||||
|
||||
if (!IsListEmpty(&PostWorkList) || !IsListEmpty(&CcDeferredWrites) || MmRegistryStatus.ProductStatus ||
|
||||
NextScanDelay.QuadPart != 0x7FFFFFFFFFFFFFFF))
|
||||
{
|
||||
/* Schedule a lazy write scan */
|
||||
CcRescheduleLazyWriteScan(&NextScanDelay);
|
||||
/* If forced disable is set, clear it */
|
||||
if (CcForcedDisableLazywriteScan)
|
||||
{
|
||||
CcForcedDisableLazywriteScan = false;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Set forced disable and deactivate the scan */
|
||||
CcForcedDisableLazywriteScan = true;
|
||||
LazyWriter.ScanActive = false;
|
||||
}
|
||||
}
|
||||
|
||||
KeReleaseQueuedSpinLock(LockQueueMasterLock, OldIrql);
|
||||
|
||||
// Check if there are deferred writes pending
|
||||
if (!IsListEmpty(&CcDeferredWrites))
|
||||
{
|
||||
CcPostDeferredWrites();
|
||||
CcScheduleLazyWriteScan(FALSE);
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user