Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-11-07 15:10:53 +00:00
Code Issues Projects Releases Packages Wiki Activity
reactos/ntoskrnl/cc/lazywrite.c

405 lines
11 KiB
C
Raw Normal View History

[NTOSKRNL] Drop the always running thread for lazy writer. Instead move to a threading model like the Windows one. We'll queue several work items to be executed in a system thread (Cc worker) when there are VACB that have been marked as dirty. Furthermore, some delay will be observed before action to avoid killing the system with IOs. This new threading model opens way for read ahead and write behind implementation. Also, moved the initialization of the lazy writer to CcInitializeCacheManager() it has nothing to do with views and shouldn't be initialized there. Also, moved the lazy writer implementation to its own file. Modified CcDeferWrite() and CcRosMarkDirtyVacb() to take into account the new threading model. Introduced new functions: - CcPostWorkQueue(): post an item to be handled by Cc worker and spawn a worker if required - CcScanDpc(): called after some time (not to have lazy writer always running) to queue a lazy scan - CcLazyWriteScan(): the lazy writer we used to have - CcScheduleLazyWriteScan(): function to call when you want to start a lazy writer run. It will make a DPC after some time and queue execution - CcWorkerThread(): the worker thread that will handle lazy write, read ahead, and so on
2018-02-07 17:10:59 +00:00
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* FILE: ntoskrnl/cc/lazywrite.c
* PURPOSE: Cache manager
*
* PROGRAMMERS: Pierre Schweitzer (pierre@reactos.org)
*/
/* INCLUDES *****************************************************************/
#include <ntoskrnl.h>
#define NDEBUG
#include <debug.h>
/* Counters:
* - Amount of pages flushed by lazy writer
* - Number of times lazy writer ran
*/
ULONG CcLazyWritePages = 0;
ULONG CcLazyWriteIos = 0;
/* Internal vars (MS):
* - Lazy writer status structure
* - Lookaside list where to allocate work items
[NTOSKRNL] Bring an initial (and not perfect ;-)) implementation of read ahead to our Cc! This halfplements CcScheduleReadAhead() which is responsible for finding the next reads to perform given last read and previous reads. I made it very basic for now, at least to test the whole process. This also introduces the CcExpressWorkQueue in the lazy writer which is responsible for dealing with read ahead items and which is dealt with before the regular queue. In CcCopyData(), if read was fine, schedule read ahead so that it can happen in background without the FSD to notice it! Also, update the read history so that scheduling as a bit of data. Implement (à la "old Cc" ;-)) CcPerformReadAhead() which is responsible for performing the read. It's only to be called by the worker thread. Side note on the modifications done in CcRosReleaseFileCache(). Private cache map is tied to a handle. If it goes away, private cache map gets deleted. Read ahead can run after the handle was closed (and thus, private cache map deleted), so it is mandatory to always lock the master lock before accessing the structure in read ahead or before deleting it in CcRosReleaseFileCache(). Otherwise, you'll just break everything. You've been warned! This commit also partly reverts f8b5d27. CORE-14312
2018-02-09 09:06:17 +00:00
* - Queue for high priority work items (read ahead)
[NTOSKRNL] Drop the always running thread for lazy writer. Instead move to a threading model like the Windows one. We'll queue several work items to be executed in a system thread (Cc worker) when there are VACB that have been marked as dirty. Furthermore, some delay will be observed before action to avoid killing the system with IOs. This new threading model opens way for read ahead and write behind implementation. Also, moved the initialization of the lazy writer to CcInitializeCacheManager() it has nothing to do with views and shouldn't be initialized there. Also, moved the lazy writer implementation to its own file. Modified CcDeferWrite() and CcRosMarkDirtyVacb() to take into account the new threading model. Introduced new functions: - CcPostWorkQueue(): post an item to be handled by Cc worker and spawn a worker if required - CcScanDpc(): called after some time (not to have lazy writer always running) to queue a lazy scan - CcLazyWriteScan(): the lazy writer we used to have - CcScheduleLazyWriteScan(): function to call when you want to start a lazy writer run. It will make a DPC after some time and queue execution - CcWorkerThread(): the worker thread that will handle lazy write, read ahead, and so on
2018-02-07 17:10:59 +00:00
* - Queue for regular work items
* - Available worker threads
[NTOSKRNL] Properly implement lazy writer activity watching. We get rid of the old iLazyWriterNotify event in favor of work items that contain an event that lazy writer will set once its done. To implement this, we rely on the newly introduced CcPostTickWorkQueue work queue that will contain work items that are to be queued once lazy writer is done. Move the CcWaitForCurrentLazyWriterActivity() implementation to the lazy writer file, and reimplemented it using the new support mechanisms
2018-02-07 17:56:13 +00:00
* - Queue for stuff to be queued after lazy writer is done
[NTOSKRNL] Drop the always running thread for lazy writer. Instead move to a threading model like the Windows one. We'll queue several work items to be executed in a system thread (Cc worker) when there are VACB that have been marked as dirty. Furthermore, some delay will be observed before action to avoid killing the system with IOs. This new threading model opens way for read ahead and write behind implementation. Also, moved the initialization of the lazy writer to CcInitializeCacheManager() it has nothing to do with views and shouldn't be initialized there. Also, moved the lazy writer implementation to its own file. Modified CcDeferWrite() and CcRosMarkDirtyVacb() to take into account the new threading model. Introduced new functions: - CcPostWorkQueue(): post an item to be handled by Cc worker and spawn a worker if required - CcScanDpc(): called after some time (not to have lazy writer always running) to queue a lazy scan - CcLazyWriteScan(): the lazy writer we used to have - CcScheduleLazyWriteScan(): function to call when you want to start a lazy writer run. It will make a DPC after some time and queue execution - CcWorkerThread(): the worker thread that will handle lazy write, read ahead, and so on
2018-02-07 17:10:59 +00:00
* - Marker for throttling queues
* - Number of ongoing workers
* - Three seconds delay for lazy writer
* - One second delay for lazy writer
* - Zero delay for lazy writer
* - Number of worker threads
*/
LAZY_WRITER LazyWriter;
NPAGED_LOOKASIDE_LIST CcTwilightLookasideList;
[NTOSKRNL] Bring an initial (and not perfect ;-)) implementation of read ahead to our Cc! This halfplements CcScheduleReadAhead() which is responsible for finding the next reads to perform given last read and previous reads. I made it very basic for now, at least to test the whole process. This also introduces the CcExpressWorkQueue in the lazy writer which is responsible for dealing with read ahead items and which is dealt with before the regular queue. In CcCopyData(), if read was fine, schedule read ahead so that it can happen in background without the FSD to notice it! Also, update the read history so that scheduling as a bit of data. Implement (à la "old Cc" ;-)) CcPerformReadAhead() which is responsible for performing the read. It's only to be called by the worker thread. Side note on the modifications done in CcRosReleaseFileCache(). Private cache map is tied to a handle. If it goes away, private cache map gets deleted. Read ahead can run after the handle was closed (and thus, private cache map deleted), so it is mandatory to always lock the master lock before accessing the structure in read ahead or before deleting it in CcRosReleaseFileCache(). Otherwise, you'll just break everything. You've been warned! This commit also partly reverts f8b5d27. CORE-14312
2018-02-09 09:06:17 +00:00
LIST_ENTRY CcExpressWorkQueue;
[NTOSKRNL] Drop the always running thread for lazy writer. Instead move to a threading model like the Windows one. We'll queue several work items to be executed in a system thread (Cc worker) when there are VACB that have been marked as dirty. Furthermore, some delay will be observed before action to avoid killing the system with IOs. This new threading model opens way for read ahead and write behind implementation. Also, moved the initialization of the lazy writer to CcInitializeCacheManager() it has nothing to do with views and shouldn't be initialized there. Also, moved the lazy writer implementation to its own file. Modified CcDeferWrite() and CcRosMarkDirtyVacb() to take into account the new threading model. Introduced new functions: - CcPostWorkQueue(): post an item to be handled by Cc worker and spawn a worker if required - CcScanDpc(): called after some time (not to have lazy writer always running) to queue a lazy scan - CcLazyWriteScan(): the lazy writer we used to have - CcScheduleLazyWriteScan(): function to call when you want to start a lazy writer run. It will make a DPC after some time and queue execution - CcWorkerThread(): the worker thread that will handle lazy write, read ahead, and so on
2018-02-07 17:10:59 +00:00
LIST_ENTRY CcRegularWorkQueue;
LIST_ENTRY CcIdleWorkerThreadList;
[NTOSKRNL] Properly implement lazy writer activity watching. We get rid of the old iLazyWriterNotify event in favor of work items that contain an event that lazy writer will set once its done. To implement this, we rely on the newly introduced CcPostTickWorkQueue work queue that will contain work items that are to be queued once lazy writer is done. Move the CcWaitForCurrentLazyWriterActivity() implementation to the lazy writer file, and reimplemented it using the new support mechanisms
2018-02-07 17:56:13 +00:00
LIST_ENTRY CcPostTickWorkQueue;
[NTOSKRNL] Drop the always running thread for lazy writer. Instead move to a threading model like the Windows one. We'll queue several work items to be executed in a system thread (Cc worker) when there are VACB that have been marked as dirty. Furthermore, some delay will be observed before action to avoid killing the system with IOs. This new threading model opens way for read ahead and write behind implementation. Also, moved the initialization of the lazy writer to CcInitializeCacheManager() it has nothing to do with views and shouldn't be initialized there. Also, moved the lazy writer implementation to its own file. Modified CcDeferWrite() and CcRosMarkDirtyVacb() to take into account the new threading model. Introduced new functions: - CcPostWorkQueue(): post an item to be handled by Cc worker and spawn a worker if required - CcScanDpc(): called after some time (not to have lazy writer always running) to queue a lazy scan - CcLazyWriteScan(): the lazy writer we used to have - CcScheduleLazyWriteScan(): function to call when you want to start a lazy writer run. It will make a DPC after some time and queue execution - CcWorkerThread(): the worker thread that will handle lazy write, read ahead, and so on
2018-02-07 17:10:59 +00:00
BOOLEAN CcQueueThrottle = FALSE;
ULONG CcNumberActiveWorkerThreads = 0;
LARGE_INTEGER CcFirstDelay = RTL_CONSTANT_LARGE_INTEGER((LONGLONG)-1*3000*1000*10);
LARGE_INTEGER CcIdleDelay = RTL_CONSTANT_LARGE_INTEGER((LONGLONG)-1*1000*1000*10);
LARGE_INTEGER CcNoDelay = RTL_CONSTANT_LARGE_INTEGER((LONGLONG)0);
ULONG CcNumberWorkerThreads;
/* FUNCTIONS *****************************************************************/
VOID
CcPostWorkQueue(
IN PWORK_QUEUE_ENTRY WorkItem,
IN PLIST_ENTRY WorkQueue)
{
KIRQL OldIrql;
PWORK_QUEUE_ITEM ThreadToSpawn;
/* First of all, insert the item in the queue */
OldIrql = KeAcquireQueuedSpinLock(LockQueueWorkQueueLock);
InsertTailList(WorkQueue, &WorkItem->WorkQueueLinks);
/* Now, define whether we have to spawn a new work thread
* We will spawn a new one if:
* - There's no throttle in action
* - There's still at least one idle thread
*/
ThreadToSpawn = NULL;
if (!CcQueueThrottle && !IsListEmpty(&CcIdleWorkerThreadList))
{
PLIST_ENTRY ListEntry;
/* Get the idle thread */
ListEntry = RemoveHeadList(&CcIdleWorkerThreadList);
ThreadToSpawn = CONTAINING_RECORD(ListEntry, WORK_QUEUE_ITEM, List);
/* We're going to have one more! */
CcNumberActiveWorkerThreads += 1;
}
KeReleaseQueuedSpinLock(LockQueueWorkQueueLock, OldIrql);
/* If we have a thread to spawn, do it! */
if (ThreadToSpawn != NULL)
{
/* We NULLify it to be consistent with initialization */
ThreadToSpawn->List.Flink = NULL;
ExQueueWorkItem(ThreadToSpawn, CriticalWorkQueue);
}
}
VOID
NTAPI
CcScanDpc(
IN PKDPC Dpc,
IN PVOID DeferredContext,
IN PVOID SystemArgument1,
IN PVOID SystemArgument2)
{
PWORK_QUEUE_ENTRY WorkItem;
/* Allocate a work item */
WorkItem = ExAllocateFromNPagedLookasideList(&CcTwilightLookasideList);
if (WorkItem == NULL)
{
LazyWriter.ScanActive = FALSE;
return;
}
/* And post it, it will be for lazy write */
[NTOSKRNL] Implement write behind in Cc For now, this is just a split between scan and flush that were both done during lazy scan previously. Lazy scan shouldn't perform any write operation, but only queue a write behind operation. Our implementation is far from the original, as it seems our lazy scan should queue a write behind operation per shared cache map. Right now, we only perform global operation.
2018-12-23 13:43:17 +00:00
WorkItem->Function = LazyScan;
[NTOSKRNL] Drop the always running thread for lazy writer. Instead move to a threading model like the Windows one. We'll queue several work items to be executed in a system thread (Cc worker) when there are VACB that have been marked as dirty. Furthermore, some delay will be observed before action to avoid killing the system with IOs. This new threading model opens way for read ahead and write behind implementation. Also, moved the initialization of the lazy writer to CcInitializeCacheManager() it has nothing to do with views and shouldn't be initialized there. Also, moved the lazy writer implementation to its own file. Modified CcDeferWrite() and CcRosMarkDirtyVacb() to take into account the new threading model. Introduced new functions: - CcPostWorkQueue(): post an item to be handled by Cc worker and spawn a worker if required - CcScanDpc(): called after some time (not to have lazy writer always running) to queue a lazy scan - CcLazyWriteScan(): the lazy writer we used to have - CcScheduleLazyWriteScan(): function to call when you want to start a lazy writer run. It will make a DPC after some time and queue execution - CcWorkerThread(): the worker thread that will handle lazy write, read ahead, and so on
2018-02-07 17:10:59 +00:00
CcPostWorkQueue(WorkItem, &CcRegularWorkQueue);
}
[NTOSKRNL] Implement write behind in Cc For now, this is just a split between scan and flush that were both done during lazy scan previously. Lazy scan shouldn't perform any write operation, but only queue a write behind operation. Our implementation is far from the original, as it seems our lazy scan should queue a write behind operation per shared cache map. Right now, we only perform global operation.
2018-12-23 13:43:17 +00:00
VOID
CcWriteBehind(VOID)
{
ULONG Target, Count;
Target = CcTotalDirtyPages / 8;
if (Target != 0)
{
/* Flush! */
DPRINT("Lazy writer starting (%d)\n", Target);
CcRosFlushDirtyPages(Target, &Count, FALSE, TRUE);
/* And update stats */
CcLazyWritePages += Count;
++CcLazyWriteIos;
DPRINT("Lazy writer done (%d)\n", Count);
}
}
[NTOSKRNL] Drop the always running thread for lazy writer. Instead move to a threading model like the Windows one. We'll queue several work items to be executed in a system thread (Cc worker) when there are VACB that have been marked as dirty. Furthermore, some delay will be observed before action to avoid killing the system with IOs. This new threading model opens way for read ahead and write behind implementation. Also, moved the initialization of the lazy writer to CcInitializeCacheManager() it has nothing to do with views and shouldn't be initialized there. Also, moved the lazy writer implementation to its own file. Modified CcDeferWrite() and CcRosMarkDirtyVacb() to take into account the new threading model. Introduced new functions: - CcPostWorkQueue(): post an item to be handled by Cc worker and spawn a worker if required - CcScanDpc(): called after some time (not to have lazy writer always running) to queue a lazy scan - CcLazyWriteScan(): the lazy writer we used to have - CcScheduleLazyWriteScan(): function to call when you want to start a lazy writer run. It will make a DPC after some time and queue execution - CcWorkerThread(): the worker thread that will handle lazy write, read ahead, and so on
2018-02-07 17:10:59 +00:00
VOID
CcLazyWriteScan(VOID)
{
ULONG Target;
[NTOSKRNL] Properly implement lazy writer activity watching. We get rid of the old iLazyWriterNotify event in favor of work items that contain an event that lazy writer will set once its done. To implement this, we rely on the newly introduced CcPostTickWorkQueue work queue that will contain work items that are to be queued once lazy writer is done. Move the CcWaitForCurrentLazyWriterActivity() implementation to the lazy writer file, and reimplemented it using the new support mechanisms
2018-02-07 17:56:13 +00:00
KIRQL OldIrql;
[NTOSKRNL] Drop the always running thread for lazy writer. Instead move to a threading model like the Windows one. We'll queue several work items to be executed in a system thread (Cc worker) when there are VACB that have been marked as dirty. Furthermore, some delay will be observed before action to avoid killing the system with IOs. This new threading model opens way for read ahead and write behind implementation. Also, moved the initialization of the lazy writer to CcInitializeCacheManager() it has nothing to do with views and shouldn't be initialized there. Also, moved the lazy writer implementation to its own file. Modified CcDeferWrite() and CcRosMarkDirtyVacb() to take into account the new threading model. Introduced new functions: - CcPostWorkQueue(): post an item to be handled by Cc worker and spawn a worker if required - CcScanDpc(): called after some time (not to have lazy writer always running) to queue a lazy scan - CcLazyWriteScan(): the lazy writer we used to have - CcScheduleLazyWriteScan(): function to call when you want to start a lazy writer run. It will make a DPC after some time and queue execution - CcWorkerThread(): the worker thread that will handle lazy write, read ahead, and so on
2018-02-07 17:10:59 +00:00
PLIST_ENTRY ListEntry;
[NTOSKRNL] Properly implement lazy writer activity watching. We get rid of the old iLazyWriterNotify event in favor of work items that contain an event that lazy writer will set once its done. To implement this, we rely on the newly introduced CcPostTickWorkQueue work queue that will contain work items that are to be queued once lazy writer is done. Move the CcWaitForCurrentLazyWriterActivity() implementation to the lazy writer file, and reimplemented it using the new support mechanisms
2018-02-07 17:56:13 +00:00
LIST_ENTRY ToPost;
PWORK_QUEUE_ENTRY WorkItem;
[NTOSKRNL] Drop the always running thread for lazy writer. Instead move to a threading model like the Windows one. We'll queue several work items to be executed in a system thread (Cc worker) when there are VACB that have been marked as dirty. Furthermore, some delay will be observed before action to avoid killing the system with IOs. This new threading model opens way for read ahead and write behind implementation. Also, moved the initialization of the lazy writer to CcInitializeCacheManager() it has nothing to do with views and shouldn't be initialized there. Also, moved the lazy writer implementation to its own file. Modified CcDeferWrite() and CcRosMarkDirtyVacb() to take into account the new threading model. Introduced new functions: - CcPostWorkQueue(): post an item to be handled by Cc worker and spawn a worker if required - CcScanDpc(): called after some time (not to have lazy writer always running) to queue a lazy scan - CcLazyWriteScan(): the lazy writer we used to have - CcScheduleLazyWriteScan(): function to call when you want to start a lazy writer run. It will make a DPC after some time and queue execution - CcWorkerThread(): the worker thread that will handle lazy write, read ahead, and so on
2018-02-07 17:10:59 +00:00
[NTOSKRNL] Properly implement lazy writer activity watching. We get rid of the old iLazyWriterNotify event in favor of work items that contain an event that lazy writer will set once its done. To implement this, we rely on the newly introduced CcPostTickWorkQueue work queue that will contain work items that are to be queued once lazy writer is done. Move the CcWaitForCurrentLazyWriterActivity() implementation to the lazy writer file, and reimplemented it using the new support mechanisms
2018-02-07 17:56:13 +00:00
/* Do we have entries to queue after we're done? */
InitializeListHead(&ToPost);
OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
if (LazyWriter.OtherWork)
{
while (!IsListEmpty(&CcPostTickWorkQueue))
{
ListEntry = RemoveHeadList(&CcPostTickWorkQueue);
WorkItem = CONTAINING_RECORD(ListEntry, WORK_QUEUE_ENTRY, WorkQueueLinks);
InsertTailList(&ToPost, &WorkItem->WorkQueueLinks);
}
LazyWriter.OtherWork = FALSE;
}
KeReleaseQueuedSpinLock(LockQueueMasterLock, OldIrql);
[NTOSKRNL] Drop the always running thread for lazy writer. Instead move to a threading model like the Windows one. We'll queue several work items to be executed in a system thread (Cc worker) when there are VACB that have been marked as dirty. Furthermore, some delay will be observed before action to avoid killing the system with IOs. This new threading model opens way for read ahead and write behind implementation. Also, moved the initialization of the lazy writer to CcInitializeCacheManager() it has nothing to do with views and shouldn't be initialized there. Also, moved the lazy writer implementation to its own file. Modified CcDeferWrite() and CcRosMarkDirtyVacb() to take into account the new threading model. Introduced new functions: - CcPostWorkQueue(): post an item to be handled by Cc worker and spawn a worker if required - CcScanDpc(): called after some time (not to have lazy writer always running) to queue a lazy scan - CcLazyWriteScan(): the lazy writer we used to have - CcScheduleLazyWriteScan(): function to call when you want to start a lazy writer run. It will make a DPC after some time and queue execution - CcWorkerThread(): the worker thread that will handle lazy write, read ahead, and so on
2018-02-07 17:10:59 +00:00
/* Our target is one-eighth of the dirty pages */
Target = CcTotalDirtyPages / 8;
if (Target != 0)
{
[NTOSKRNL] Implement write behind in Cc For now, this is just a split between scan and flush that were both done during lazy scan previously. Lazy scan shouldn't perform any write operation, but only queue a write behind operation. Our implementation is far from the original, as it seems our lazy scan should queue a write behind operation per shared cache map. Right now, we only perform global operation.
2018-12-23 13:43:17 +00:00
/* There is stuff to flush, schedule a write-behind operation */
[NTOSKRNL] Drop the always running thread for lazy writer. Instead move to a threading model like the Windows one. We'll queue several work items to be executed in a system thread (Cc worker) when there are VACB that have been marked as dirty. Furthermore, some delay will be observed before action to avoid killing the system with IOs. This new threading model opens way for read ahead and write behind implementation. Also, moved the initialization of the lazy writer to CcInitializeCacheManager() it has nothing to do with views and shouldn't be initialized there. Also, moved the lazy writer implementation to its own file. Modified CcDeferWrite() and CcRosMarkDirtyVacb() to take into account the new threading model. Introduced new functions: - CcPostWorkQueue(): post an item to be handled by Cc worker and spawn a worker if required - CcScanDpc(): called after some time (not to have lazy writer always running) to queue a lazy scan - CcLazyWriteScan(): the lazy writer we used to have - CcScheduleLazyWriteScan(): function to call when you want to start a lazy writer run. It will make a DPC after some time and queue execution - CcWorkerThread(): the worker thread that will handle lazy write, read ahead, and so on
2018-02-07 17:10:59 +00:00
[NTOSKRNL] Implement write behind in Cc For now, this is just a split between scan and flush that were both done during lazy scan previously. Lazy scan shouldn't perform any write operation, but only queue a write behind operation. Our implementation is far from the original, as it seems our lazy scan should queue a write behind operation per shared cache map. Right now, we only perform global operation.
2018-12-23 13:43:17 +00:00
/* Allocate a work item */
WorkItem = ExAllocateFromNPagedLookasideList(&CcTwilightLookasideList);
if (WorkItem != NULL)
{
WorkItem->Function = WriteBehind;
CcPostWorkQueue(WorkItem, &CcRegularWorkQueue);
}
[NTOSKRNL] Drop the always running thread for lazy writer. Instead move to a threading model like the Windows one. We'll queue several work items to be executed in a system thread (Cc worker) when there are VACB that have been marked as dirty. Furthermore, some delay will be observed before action to avoid killing the system with IOs. This new threading model opens way for read ahead and write behind implementation. Also, moved the initialization of the lazy writer to CcInitializeCacheManager() it has nothing to do with views and shouldn't be initialized there. Also, moved the lazy writer implementation to its own file. Modified CcDeferWrite() and CcRosMarkDirtyVacb() to take into account the new threading model. Introduced new functions: - CcPostWorkQueue(): post an item to be handled by Cc worker and spawn a worker if required - CcScanDpc(): called after some time (not to have lazy writer always running) to queue a lazy scan - CcLazyWriteScan(): the lazy writer we used to have - CcScheduleLazyWriteScan(): function to call when you want to start a lazy writer run. It will make a DPC after some time and queue execution - CcWorkerThread(): the worker thread that will handle lazy write, read ahead, and so on
2018-02-07 17:10:59 +00:00
}
[NTOSKRNL] Use the LockQueueMasterLock where appropriate
2018-02-07 20:35:22 +00:00
/* Post items that were due for end of run */
[NTOSKRNL] Properly implement lazy writer activity watching. We get rid of the old iLazyWriterNotify event in favor of work items that contain an event that lazy writer will set once its done. To implement this, we rely on the newly introduced CcPostTickWorkQueue work queue that will contain work items that are to be queued once lazy writer is done. Move the CcWaitForCurrentLazyWriterActivity() implementation to the lazy writer file, and reimplemented it using the new support mechanisms
2018-02-07 17:56:13 +00:00
while (!IsListEmpty(&ToPost))
{
ListEntry = RemoveHeadList(&ToPost);
WorkItem = CONTAINING_RECORD(ListEntry, WORK_QUEUE_ENTRY, WorkQueueLinks);
CcPostWorkQueue(WorkItem, &CcRegularWorkQueue);
}
[NTOSKRNL] Optimize a bit deferred writes. In the lazy writer run, first post items that are queued for this. Only then, start executing deferred writes if any. If there were any, reschedule immediately a lazy writer run, to keep Cc warm and to make it unqueue write faster in case of high IOs situation. To make second lazy writer run happen faster, we keep our state active to use short delay (1s) instead of standard idle (3s).
2018-05-02 21:30:10 +00:00
/* If we have deferred writes, try them now! */
if (!IsListEmpty(&CcDeferredWrites))
{
CcPostDeferredWrites();
/* Reschedule immediately a lazy writer run
* Keep us active to have short idle delay
*/
CcScheduleLazyWriteScan(FALSE);
}
else
{
/* We're no longer active */
OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
LazyWriter.ScanActive = FALSE;
KeReleaseQueuedSpinLock(LockQueueMasterLock, OldIrql);
}
[NTOSKRNL] Drop the always running thread for lazy writer. Instead move to a threading model like the Windows one. We'll queue several work items to be executed in a system thread (Cc worker) when there are VACB that have been marked as dirty. Furthermore, some delay will be observed before action to avoid killing the system with IOs. This new threading model opens way for read ahead and write behind implementation. Also, moved the initialization of the lazy writer to CcInitializeCacheManager() it has nothing to do with views and shouldn't be initialized there. Also, moved the lazy writer implementation to its own file. Modified CcDeferWrite() and CcRosMarkDirtyVacb() to take into account the new threading model. Introduced new functions: - CcPostWorkQueue(): post an item to be handled by Cc worker and spawn a worker if required - CcScanDpc(): called after some time (not to have lazy writer always running) to queue a lazy scan - CcLazyWriteScan(): the lazy writer we used to have - CcScheduleLazyWriteScan(): function to call when you want to start a lazy writer run. It will make a DPC after some time and queue execution - CcWorkerThread(): the worker thread that will handle lazy write, read ahead, and so on
2018-02-07 17:10:59 +00:00
}
VOID CcScheduleLazyWriteScan(
IN BOOLEAN NoDelay)
{
/* If no delay, immediately start lazy writer,
* no matter it was already started
*/
if (NoDelay)
{
LazyWriter.ScanActive = TRUE;
KeSetTimer(&LazyWriter.ScanTimer, CcNoDelay, &LazyWriter.ScanDpc);
}
/* Otherwise, if it's not running, just wait three seconds to start it */
else if (!LazyWriter.ScanActive)
{
LazyWriter.ScanActive = TRUE;
KeSetTimer(&LazyWriter.ScanTimer, CcFirstDelay, &LazyWriter.ScanDpc);
}
/* Finally, already running, so queue for the next second */
else
{
KeSetTimer(&LazyWriter.ScanTimer, CcIdleDelay, &LazyWriter.ScanDpc);
}
}
VOID
NTAPI
CcWorkerThread(
IN PVOID Parameter)
{
KIRQL OldIrql;
[NTOSKRNL] Implement write behind in Cc For now, this is just a split between scan and flush that were both done during lazy scan previously. Lazy scan shouldn't perform any write operation, but only queue a write behind operation. Our implementation is far from the original, as it seems our lazy scan should queue a write behind operation per shared cache map. Right now, we only perform global operation.
2018-12-23 13:43:17 +00:00
BOOLEAN DropThrottle, WritePerformed;
[NTOSKRNL] Drop the always running thread for lazy writer. Instead move to a threading model like the Windows one. We'll queue several work items to be executed in a system thread (Cc worker) when there are VACB that have been marked as dirty. Furthermore, some delay will be observed before action to avoid killing the system with IOs. This new threading model opens way for read ahead and write behind implementation. Also, moved the initialization of the lazy writer to CcInitializeCacheManager() it has nothing to do with views and shouldn't be initialized there. Also, moved the lazy writer implementation to its own file. Modified CcDeferWrite() and CcRosMarkDirtyVacb() to take into account the new threading model. Introduced new functions: - CcPostWorkQueue(): post an item to be handled by Cc worker and spawn a worker if required - CcScanDpc(): called after some time (not to have lazy writer always running) to queue a lazy scan - CcLazyWriteScan(): the lazy writer we used to have - CcScheduleLazyWriteScan(): function to call when you want to start a lazy writer run. It will make a DPC after some time and queue execution - CcWorkerThread(): the worker thread that will handle lazy write, read ahead, and so on
2018-02-07 17:10:59 +00:00
PWORK_QUEUE_ITEM Item;
[NTOSKRNL] In debug builds, print more information about the top level IRP in the Cc worker thread CORE-14315
2018-02-10 22:49:33 +00:00
#if DBG
PIRP TopLevel;
#endif
[NTOSKRNL] Drop the always running thread for lazy writer. Instead move to a threading model like the Windows one. We'll queue several work items to be executed in a system thread (Cc worker) when there are VACB that have been marked as dirty. Furthermore, some delay will be observed before action to avoid killing the system with IOs. This new threading model opens way for read ahead and write behind implementation. Also, moved the initialization of the lazy writer to CcInitializeCacheManager() it has nothing to do with views and shouldn't be initialized there. Also, moved the lazy writer implementation to its own file. Modified CcDeferWrite() and CcRosMarkDirtyVacb() to take into account the new threading model. Introduced new functions: - CcPostWorkQueue(): post an item to be handled by Cc worker and spawn a worker if required - CcScanDpc(): called after some time (not to have lazy writer always running) to queue a lazy scan - CcLazyWriteScan(): the lazy writer we used to have - CcScheduleLazyWriteScan(): function to call when you want to start a lazy writer run. It will make a DPC after some time and queue execution - CcWorkerThread(): the worker thread that will handle lazy write, read ahead, and so on
2018-02-07 17:10:59 +00:00
/* Get back our thread item */
Item = Parameter;
/* And by default, don't touch throttle */
DropThrottle = FALSE;
[NTOSKRNL] Implement write behind in Cc For now, this is just a split between scan and flush that were both done during lazy scan previously. Lazy scan shouldn't perform any write operation, but only queue a write behind operation. Our implementation is far from the original, as it seems our lazy scan should queue a write behind operation per shared cache map. Right now, we only perform global operation.
2018-12-23 13:43:17 +00:00
/* No write performed */
WritePerformed = FALSE;
[NTOSKRNL] Drop the always running thread for lazy writer. Instead move to a threading model like the Windows one. We'll queue several work items to be executed in a system thread (Cc worker) when there are VACB that have been marked as dirty. Furthermore, some delay will be observed before action to avoid killing the system with IOs. This new threading model opens way for read ahead and write behind implementation. Also, moved the initialization of the lazy writer to CcInitializeCacheManager() it has nothing to do with views and shouldn't be initialized there. Also, moved the lazy writer implementation to its own file. Modified CcDeferWrite() and CcRosMarkDirtyVacb() to take into account the new threading model. Introduced new functions: - CcPostWorkQueue(): post an item to be handled by Cc worker and spawn a worker if required - CcScanDpc(): called after some time (not to have lazy writer always running) to queue a lazy scan - CcLazyWriteScan(): the lazy writer we used to have - CcScheduleLazyWriteScan(): function to call when you want to start a lazy writer run. It will make a DPC after some time and queue execution - CcWorkerThread(): the worker thread that will handle lazy write, read ahead, and so on
2018-02-07 17:10:59 +00:00
[NTOSKRNL] In debug builds, print more information about the top level IRP in the Cc worker thread CORE-14315
2018-02-10 22:49:33 +00:00
#if DBG
/* Top level IRP should be clean when started
* Save it to catch buggy drivers (or bugs!)
*/
TopLevel = IoGetTopLevelIrp();
if (TopLevel != NULL)
{
DPRINT1("(%p) TopLevel IRP for this thread: %p\n", PsGetCurrentThread(), TopLevel);
}
#endif
[NTOSKRNL] Drop the always running thread for lazy writer. Instead move to a threading model like the Windows one. We'll queue several work items to be executed in a system thread (Cc worker) when there are VACB that have been marked as dirty. Furthermore, some delay will be observed before action to avoid killing the system with IOs. This new threading model opens way for read ahead and write behind implementation. Also, moved the initialization of the lazy writer to CcInitializeCacheManager() it has nothing to do with views and shouldn't be initialized there. Also, moved the lazy writer implementation to its own file. Modified CcDeferWrite() and CcRosMarkDirtyVacb() to take into account the new threading model. Introduced new functions: - CcPostWorkQueue(): post an item to be handled by Cc worker and spawn a worker if required - CcScanDpc(): called after some time (not to have lazy writer always running) to queue a lazy scan - CcLazyWriteScan(): the lazy writer we used to have - CcScheduleLazyWriteScan(): function to call when you want to start a lazy writer run. It will make a DPC after some time and queue execution - CcWorkerThread(): the worker thread that will handle lazy write, read ahead, and so on
2018-02-07 17:10:59 +00:00
/* Loop till we have jobs */
while (TRUE)
{
PWORK_QUEUE_ENTRY WorkItem;
/* Lock queues */
OldIrql = KeAcquireQueuedSpinLock(LockQueueWorkQueueLock);
/* If we have to touch throttle, reset it now! */
if (DropThrottle)
{
CcQueueThrottle = FALSE;
DropThrottle = FALSE;
}
[NTOSKRNL] Bring an initial (and not perfect ;-)) implementation of read ahead to our Cc! This halfplements CcScheduleReadAhead() which is responsible for finding the next reads to perform given last read and previous reads. I made it very basic for now, at least to test the whole process. This also introduces the CcExpressWorkQueue in the lazy writer which is responsible for dealing with read ahead items and which is dealt with before the regular queue. In CcCopyData(), if read was fine, schedule read ahead so that it can happen in background without the FSD to notice it! Also, update the read history so that scheduling as a bit of data. Implement (à la "old Cc" ;-)) CcPerformReadAhead() which is responsible for performing the read. It's only to be called by the worker thread. Side note on the modifications done in CcRosReleaseFileCache(). Private cache map is tied to a handle. If it goes away, private cache map gets deleted. Read ahead can run after the handle was closed (and thus, private cache map deleted), so it is mandatory to always lock the master lock before accessing the structure in read ahead or before deleting it in CcRosReleaseFileCache(). Otherwise, you'll just break everything. You've been warned! This commit also partly reverts f8b5d27. CORE-14312
2018-02-09 09:06:17 +00:00
/* Check first if we have read ahead to do */
if (IsListEmpty(&CcExpressWorkQueue))
[NTOSKRNL] Drop the always running thread for lazy writer. Instead move to a threading model like the Windows one. We'll queue several work items to be executed in a system thread (Cc worker) when there are VACB that have been marked as dirty. Furthermore, some delay will be observed before action to avoid killing the system with IOs. This new threading model opens way for read ahead and write behind implementation. Also, moved the initialization of the lazy writer to CcInitializeCacheManager() it has nothing to do with views and shouldn't be initialized there. Also, moved the lazy writer implementation to its own file. Modified CcDeferWrite() and CcRosMarkDirtyVacb() to take into account the new threading model. Introduced new functions: - CcPostWorkQueue(): post an item to be handled by Cc worker and spawn a worker if required - CcScanDpc(): called after some time (not to have lazy writer always running) to queue a lazy scan - CcLazyWriteScan(): the lazy writer we used to have - CcScheduleLazyWriteScan(): function to call when you want to start a lazy writer run. It will make a DPC after some time and queue execution - CcWorkerThread(): the worker thread that will handle lazy write, read ahead, and so on
2018-02-07 17:10:59 +00:00
{
[NTOSKRNL] Bring an initial (and not perfect ;-)) implementation of read ahead to our Cc! This halfplements CcScheduleReadAhead() which is responsible for finding the next reads to perform given last read and previous reads. I made it very basic for now, at least to test the whole process. This also introduces the CcExpressWorkQueue in the lazy writer which is responsible for dealing with read ahead items and which is dealt with before the regular queue. In CcCopyData(), if read was fine, schedule read ahead so that it can happen in background without the FSD to notice it! Also, update the read history so that scheduling as a bit of data. Implement (à la "old Cc" ;-)) CcPerformReadAhead() which is responsible for performing the read. It's only to be called by the worker thread. Side note on the modifications done in CcRosReleaseFileCache(). Private cache map is tied to a handle. If it goes away, private cache map gets deleted. Read ahead can run after the handle was closed (and thus, private cache map deleted), so it is mandatory to always lock the master lock before accessing the structure in read ahead or before deleting it in CcRosReleaseFileCache(). Otherwise, you'll just break everything. You've been warned! This commit also partly reverts f8b5d27. CORE-14312
2018-02-09 09:06:17 +00:00
/* If not, check regular queue */
if (IsListEmpty(&CcRegularWorkQueue))
{
break;
}
else
{
WorkItem = CONTAINING_RECORD(CcRegularWorkQueue.Flink, WORK_QUEUE_ENTRY, WorkQueueLinks);
}
}
else
{
WorkItem = CONTAINING_RECORD(CcExpressWorkQueue.Flink, WORK_QUEUE_ENTRY, WorkQueueLinks);
[NTOSKRNL] Drop the always running thread for lazy writer. Instead move to a threading model like the Windows one. We'll queue several work items to be executed in a system thread (Cc worker) when there are VACB that have been marked as dirty. Furthermore, some delay will be observed before action to avoid killing the system with IOs. This new threading model opens way for read ahead and write behind implementation. Also, moved the initialization of the lazy writer to CcInitializeCacheManager() it has nothing to do with views and shouldn't be initialized there. Also, moved the lazy writer implementation to its own file. Modified CcDeferWrite() and CcRosMarkDirtyVacb() to take into account the new threading model. Introduced new functions: - CcPostWorkQueue(): post an item to be handled by Cc worker and spawn a worker if required - CcScanDpc(): called after some time (not to have lazy writer always running) to queue a lazy scan - CcLazyWriteScan(): the lazy writer we used to have - CcScheduleLazyWriteScan(): function to call when you want to start a lazy writer run. It will make a DPC after some time and queue execution - CcWorkerThread(): the worker thread that will handle lazy write, read ahead, and so on
2018-02-07 17:10:59 +00:00
}
/* Get our work item, if someone is waiting for us to finish
* and we're not the only thread in queue
* then, quit running to let the others do
* and throttle so that noone starts till current activity is over
*/
if (WorkItem->Function == SetDone && CcNumberActiveWorkerThreads > 1)
{
CcQueueThrottle = TRUE;
break;
}
/* Otherwise, remove current entry */
RemoveEntryList(&WorkItem->WorkQueueLinks);
KeReleaseQueuedSpinLock(LockQueueWorkQueueLock, OldIrql);
/* And handle it */
switch (WorkItem->Function)
{
[NTOSKRNL] Bring an initial (and not perfect ;-)) implementation of read ahead to our Cc! This halfplements CcScheduleReadAhead() which is responsible for finding the next reads to perform given last read and previous reads. I made it very basic for now, at least to test the whole process. This also introduces the CcExpressWorkQueue in the lazy writer which is responsible for dealing with read ahead items and which is dealt with before the regular queue. In CcCopyData(), if read was fine, schedule read ahead so that it can happen in background without the FSD to notice it! Also, update the read history so that scheduling as a bit of data. Implement (à la "old Cc" ;-)) CcPerformReadAhead() which is responsible for performing the read. It's only to be called by the worker thread. Side note on the modifications done in CcRosReleaseFileCache(). Private cache map is tied to a handle. If it goes away, private cache map gets deleted. Read ahead can run after the handle was closed (and thus, private cache map deleted), so it is mandatory to always lock the master lock before accessing the structure in read ahead or before deleting it in CcRosReleaseFileCache(). Otherwise, you'll just break everything. You've been warned! This commit also partly reverts f8b5d27. CORE-14312
2018-02-09 09:06:17 +00:00
case ReadAhead:
CcPerformReadAhead(WorkItem->Parameters.Read.FileObject);
break;
[NTOSKRNL] Implement write behind in Cc For now, this is just a split between scan and flush that were both done during lazy scan previously. Lazy scan shouldn't perform any write operation, but only queue a write behind operation. Our implementation is far from the original, as it seems our lazy scan should queue a write behind operation per shared cache map. Right now, we only perform global operation.
2018-12-23 13:43:17 +00:00
case WriteBehind:
[NTOSKRNL] Set the MemoryMaker flag when executing write behind
2018-12-23 13:59:42 +00:00
PsGetCurrentThread()->MemoryMaker = 1;
[NTOSKRNL] Implement write behind in Cc For now, this is just a split between scan and flush that were both done during lazy scan previously. Lazy scan shouldn't perform any write operation, but only queue a write behind operation. Our implementation is far from the original, as it seems our lazy scan should queue a write behind operation per shared cache map. Right now, we only perform global operation.
2018-12-23 13:43:17 +00:00
CcWriteBehind();
[NTOSKRNL] Set the MemoryMaker flag when executing write behind
2018-12-23 13:59:42 +00:00
PsGetCurrentThread()->MemoryMaker = 0;
[NTOSKRNL] Implement write behind in Cc For now, this is just a split between scan and flush that were both done during lazy scan previously. Lazy scan shouldn't perform any write operation, but only queue a write behind operation. Our implementation is far from the original, as it seems our lazy scan should queue a write behind operation per shared cache map. Right now, we only perform global operation.
2018-12-23 13:43:17 +00:00
WritePerformed = TRUE;
break;
case LazyScan:
[NTOSKRNL] Drop the always running thread for lazy writer. Instead move to a threading model like the Windows one. We'll queue several work items to be executed in a system thread (Cc worker) when there are VACB that have been marked as dirty. Furthermore, some delay will be observed before action to avoid killing the system with IOs. This new threading model opens way for read ahead and write behind implementation. Also, moved the initialization of the lazy writer to CcInitializeCacheManager() it has nothing to do with views and shouldn't be initialized there. Also, moved the lazy writer implementation to its own file. Modified CcDeferWrite() and CcRosMarkDirtyVacb() to take into account the new threading model. Introduced new functions: - CcPostWorkQueue(): post an item to be handled by Cc worker and spawn a worker if required - CcScanDpc(): called after some time (not to have lazy writer always running) to queue a lazy scan - CcLazyWriteScan(): the lazy writer we used to have - CcScheduleLazyWriteScan(): function to call when you want to start a lazy writer run. It will make a DPC after some time and queue execution - CcWorkerThread(): the worker thread that will handle lazy write, read ahead, and so on
2018-02-07 17:10:59 +00:00
CcLazyWriteScan();
break;
case SetDone:
KeSetEvent(WorkItem->Parameters.Event.Event, IO_NO_INCREMENT, FALSE);
DropThrottle = TRUE;
break;
[NTOSKRNL] Bring an initial (and not perfect ;-)) implementation of read ahead to our Cc! This halfplements CcScheduleReadAhead() which is responsible for finding the next reads to perform given last read and previous reads. I made it very basic for now, at least to test the whole process. This also introduces the CcExpressWorkQueue in the lazy writer which is responsible for dealing with read ahead items and which is dealt with before the regular queue. In CcCopyData(), if read was fine, schedule read ahead so that it can happen in background without the FSD to notice it! Also, update the read history so that scheduling as a bit of data. Implement (à la "old Cc" ;-)) CcPerformReadAhead() which is responsible for performing the read. It's only to be called by the worker thread. Side note on the modifications done in CcRosReleaseFileCache(). Private cache map is tied to a handle. If it goes away, private cache map gets deleted. Read ahead can run after the handle was closed (and thus, private cache map deleted), so it is mandatory to always lock the master lock before accessing the structure in read ahead or before deleting it in CcRosReleaseFileCache(). Otherwise, you'll just break everything. You've been warned! This commit also partly reverts f8b5d27. CORE-14312
2018-02-09 09:06:17 +00:00
default:
DPRINT1("Ignored item: %p (%d)\n", WorkItem, WorkItem->Function);
break;
[NTOSKRNL] Drop the always running thread for lazy writer. Instead move to a threading model like the Windows one. We'll queue several work items to be executed in a system thread (Cc worker) when there are VACB that have been marked as dirty. Furthermore, some delay will be observed before action to avoid killing the system with IOs. This new threading model opens way for read ahead and write behind implementation. Also, moved the initialization of the lazy writer to CcInitializeCacheManager() it has nothing to do with views and shouldn't be initialized there. Also, moved the lazy writer implementation to its own file. Modified CcDeferWrite() and CcRosMarkDirtyVacb() to take into account the new threading model. Introduced new functions: - CcPostWorkQueue(): post an item to be handled by Cc worker and spawn a worker if required - CcScanDpc(): called after some time (not to have lazy writer always running) to queue a lazy scan - CcLazyWriteScan(): the lazy writer we used to have - CcScheduleLazyWriteScan(): function to call when you want to start a lazy writer run. It will make a DPC after some time and queue execution - CcWorkerThread(): the worker thread that will handle lazy write, read ahead, and so on
2018-02-07 17:10:59 +00:00
}
/* And release the item */
ExFreeToNPagedLookasideList(&CcTwilightLookasideList, WorkItem);
}
/* Our thread is available again */
InsertTailList(&CcIdleWorkerThreadList, &Item->List);
/* One less worker */
--CcNumberActiveWorkerThreads;
KeReleaseQueuedSpinLock(LockQueueWorkQueueLock, OldIrql);
[NTOSKRNL] In debug builds, print more information about the top level IRP in the Cc worker thread CORE-14315
2018-02-10 22:49:33 +00:00
[NTOSKRNL] Implement write behind in Cc For now, this is just a split between scan and flush that were both done during lazy scan previously. Lazy scan shouldn't perform any write operation, but only queue a write behind operation. Our implementation is far from the original, as it seems our lazy scan should queue a write behind operation per shared cache map. Right now, we only perform global operation.
2018-12-23 13:43:17 +00:00
/* If there are pending write openations and we have at least 20 dirty pages */
if (!IsListEmpty(&CcDeferredWrites) && CcTotalDirtyPages >= 20)
{
/* And if we performed a write operation previously, then
* stress the system a bit and reschedule a scan to find
* stuff to write
*/
if (WritePerformed)
{
CcLazyWriteScan();
}
}
[NTOSKRNL] In debug builds, print more information about the top level IRP in the Cc worker thread CORE-14315
2018-02-10 22:49:33 +00:00
#if DBG
/* Top level shouldn't have changed */
if (TopLevel != IoGetTopLevelIrp())
{
DPRINT1("(%p) Mismatching TopLevel: %p, %p\n", PsGetCurrentThread(), TopLevel, IoGetTopLevelIrp());
}
#endif
[NTOSKRNL] Drop the always running thread for lazy writer. Instead move to a threading model like the Windows one. We'll queue several work items to be executed in a system thread (Cc worker) when there are VACB that have been marked as dirty. Furthermore, some delay will be observed before action to avoid killing the system with IOs. This new threading model opens way for read ahead and write behind implementation. Also, moved the initialization of the lazy writer to CcInitializeCacheManager() it has nothing to do with views and shouldn't be initialized there. Also, moved the lazy writer implementation to its own file. Modified CcDeferWrite() and CcRosMarkDirtyVacb() to take into account the new threading model. Introduced new functions: - CcPostWorkQueue(): post an item to be handled by Cc worker and spawn a worker if required - CcScanDpc(): called after some time (not to have lazy writer always running) to queue a lazy scan - CcLazyWriteScan(): the lazy writer we used to have - CcScheduleLazyWriteScan(): function to call when you want to start a lazy writer run. It will make a DPC after some time and queue execution - CcWorkerThread(): the worker thread that will handle lazy write, read ahead, and so on
2018-02-07 17:10:59 +00:00
}
[NTOSKRNL] Properly implement lazy writer activity watching. We get rid of the old iLazyWriterNotify event in favor of work items that contain an event that lazy writer will set once its done. To implement this, we rely on the newly introduced CcPostTickWorkQueue work queue that will contain work items that are to be queued once lazy writer is done. Move the CcWaitForCurrentLazyWriterActivity() implementation to the lazy writer file, and reimplemented it using the new support mechanisms
2018-02-07 17:56:13 +00:00
/*
* @implemented
*/
NTSTATUS
NTAPI
CcWaitForCurrentLazyWriterActivity (
VOID)
{
KIRQL OldIrql;
KEVENT WaitEvent;
PWORK_QUEUE_ENTRY WorkItem;
/* Allocate a work item */
WorkItem = ExAllocateFromNPagedLookasideList(&CcTwilightLookasideList);
if (WorkItem == NULL)
{
return STATUS_INSUFFICIENT_RESOURCES;
}
/* We want lazy writer to set our event */
WorkItem->Function = SetDone;
KeInitializeEvent(&WaitEvent, NotificationEvent, FALSE);
WorkItem->Parameters.Event.Event = &WaitEvent;
/* Use the post tick queue */
OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
InsertTailList(&CcPostTickWorkQueue, &WorkItem->WorkQueueLinks);
/* Inform the lazy writer it will have to handle the post tick queue */
LazyWriter.OtherWork = TRUE;
/* And if it's not running, queue a lazy writer run
* And start it NOW, we want the response now
*/
if (!LazyWriter.ScanActive)
{
CcScheduleLazyWriteScan(TRUE);
}
KeReleaseQueuedSpinLock(LockQueueMasterLock, OldIrql);
/* And now, wait until lazy writer replies */
return KeWaitForSingleObject(&WaitEvent, Executive, KernelMode, FALSE, NULL);
}
Reference in a new issue Copy permalink