Ros-diffs

ros-diffs@reactos.org

81390 discussions

03/03: [NTOSKRNL] Drop the iSharedCacheMapLock in favor of the master lock
by Pierre Schweitzer 09 Feb '18

09 Feb '18

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=0518444217452c18d6c8c… commit 0518444217452c18d6c8c369852e7b0c17990d63 Author: Pierre Schweitzer <pierre(a)reactos.org> AuthorDate: Fri Feb 9 11:13:53 2018 +0100 Commit: Pierre Schweitzer <pierre(a)reactos.org> CommitDate: Fri Feb 9 11:13:53 2018 +0100 [NTOSKRNL] Drop the iSharedCacheMapLock in favor of the master lock --- ntoskrnl/cc/view.c | 18 ++++++------------ 1 file changed, 6 insertions(+), 12 deletions(-) diff --git a/ntoskrnl/cc/view.c b/ntoskrnl/cc/view.c index cb6991b19c..23bc5076e1 100644 --- a/ntoskrnl/cc/view.c +++ b/ntoskrnl/cc/view.c @@ -64,11 +64,6 @@ LIST_ENTRY CcDeferredWrites; KSPIN_LOCK CcDeferredWriteSpinLock; LIST_ENTRY CcCleanSharedCacheMapList; -/* Internal vars (ROS): - * - Lock for the CcCleanSharedCacheMapList list - */ -KSPIN_LOCK iSharedCacheMapLock; - #if DBG static void CcRosVacbIncRefCount_(PROS_VACB vacb, const char* file, int line) { @@ -1100,9 +1095,9 @@ CcRosDeleteFileCache ( CcRosInternalFreeVacb(current); } - KeAcquireSpinLock(&iSharedCacheMapLock, &OldIrql); + OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock); RemoveEntryList(&SharedCacheMap->SharedCacheMapLinks); - KeReleaseSpinLock(&iSharedCacheMapLock, OldIrql); + KeReleaseQueuedSpinLock(LockQueueMasterLock, OldIrql); ExFreeToNPagedLookasideList(&SharedCacheMapLookasideList, SharedCacheMap); KeAcquireGuardedMutex(&ViewLock); @@ -1267,9 +1262,9 @@ CcRosInitializeFileCache ( InitializeListHead(&SharedCacheMap->CacheMapVacbListHead); FileObject->SectionObjectPointer->SharedCacheMap = SharedCacheMap; - KeAcquireSpinLock(&iSharedCacheMapLock, &OldIrql); + OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock); InsertTailList(&CcCleanSharedCacheMapList, &SharedCacheMap->SharedCacheMapLinks); - KeReleaseSpinLock(&iSharedCacheMapLock, OldIrql); + KeReleaseQueuedSpinLock(LockQueueMasterLock, OldIrql); } if (FileObject->PrivateCacheMap == NULL) { @@ -1282,9 +1277,9 @@ CcRosInitializeFileCache ( /* If we also allocated the shared cache map for this file, kill it */ if (Allocated) { - KeAcquireSpinLock(&iSharedCacheMapLock, &OldIrql); + OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock); RemoveEntryList(&SharedCacheMap->SharedCacheMapLinks); - KeReleaseSpinLock(&iSharedCacheMapLock, OldIrql); + KeReleaseQueuedSpinLock(LockQueueMasterLock, OldIrql); FileObject->SectionObjectPointer->SharedCacheMap = NULL; ObDereferenceObject(FileObject); @@ -1349,7 +1344,6 @@ CcInitView ( InitializeListHead(&CcDeferredWrites); InitializeListHead(&CcCleanSharedCacheMapList); KeInitializeSpinLock(&CcDeferredWriteSpinLock); - KeInitializeSpinLock(&iSharedCacheMapLock); KeInitializeGuardedMutex(&ViewLock); ExInitializeNPagedLookasideList(&iBcbLookasideList, NULL,

1 0

02/03: [NTOSKRNL] Silence lazy writer now we know it works
by Pierre Schweitzer 09 Feb '18

09 Feb '18

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=8119e0ad2bfb765167c6c… commit 8119e0ad2bfb765167c6cc608f4b0fd1ce8584e1 Author: Pierre Schweitzer <pierre(a)reactos.org> AuthorDate: Fri Feb 9 11:05:44 2018 +0100 Commit: Pierre Schweitzer <pierre(a)reactos.org> CommitDate: Fri Feb 9 11:05:44 2018 +0100 [NTOSKRNL] Silence lazy writer now we know it works --- ntoskrnl/cc/lazywrite.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ntoskrnl/cc/lazywrite.c b/ntoskrnl/cc/lazywrite.c index 261fcf363e..adb9fb09d7 100644 --- a/ntoskrnl/cc/lazywrite.c +++ b/ntoskrnl/cc/lazywrite.c @@ -143,13 +143,13 @@ CcLazyWriteScan(VOID) if (Target != 0) { /* Flush! */ - DPRINT1("Lazy writer starting (%d)\n", Target); + DPRINT("Lazy writer starting (%d)\n", Target); CcRosFlushDirtyPages(Target, &Count, FALSE, TRUE); /* And update stats */ CcLazyWritePages += Count; ++CcLazyWriteIos; - DPRINT1("Lazy writer done (%d)\n", Count); + DPRINT("Lazy writer done (%d)\n", Count); } /* If we have deferred writes, try them now! */

1 0

01/03: [NTOSKRNL] Use better locking for private cache map in CcRosReleaseFileCache(). Suggested by Thomas
by Pierre Schweitzer 09 Feb '18

09 Feb '18

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=fc4744da5f9cf16f5559e… commit fc4744da5f9cf16f5559e78981702158066ce626 Author: Pierre Schweitzer <pierre(a)reactos.org> AuthorDate: Fri Feb 9 11:05:15 2018 +0100 Commit: Pierre Schweitzer <pierre(a)reactos.org> CommitDate: Fri Feb 9 11:05:15 2018 +0100 [NTOSKRNL] Use better locking for private cache map in CcRosReleaseFileCache(). Suggested by Thomas --- ntoskrnl/cc/view.c | 28 ++++++++++++++-------------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/ntoskrnl/cc/view.c b/ntoskrnl/cc/view.c index 377c1ef84d..cb6991b19c 100644 --- a/ntoskrnl/cc/view.c +++ b/ntoskrnl/cc/view.c @@ -1171,6 +1171,8 @@ CcRosReleaseFileCache ( * has been closed. */ { + KIRQL OldIrql; + PPRIVATE_CACHE_MAP PrivateMap; PROS_SHARED_CACHE_MAP SharedCacheMap; KeAcquireGuardedMutex(&ViewLock); @@ -1178,27 +1180,25 @@ CcRosReleaseFileCache ( if (FileObject->SectionObjectPointer->SharedCacheMap != NULL) { SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap; - if (FileObject->PrivateCacheMap != NULL) - { - KIRQL OldIrql; - PPRIVATE_CACHE_MAP PrivateMap; - /* Closing the handle, so kill the private cache map */ - PrivateMap = FileObject->PrivateCacheMap; + /* Closing the handle, so kill the private cache map + * Before you event try to remove it from FO, always + * lock the master lock, to be sure not to race + * with a potential read ahead ongoing! + */ + OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock); + PrivateMap = FileObject->PrivateCacheMap; + FileObject->PrivateCacheMap = NULL; + KeReleaseQueuedSpinLock(LockQueueMasterLock, OldIrql); + if (PrivateMap != NULL) + { /* Remove it from the file */ KeAcquireSpinLock(&SharedCacheMap->CacheMapLock, &OldIrql); RemoveEntryList(&PrivateMap->PrivateLinks); KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, OldIrql); - /* And free it. - * Before you event try to remove it from FO, always - * lock the master lock, to be sure not to race - * with a potential read ahead ongoing! - */ - OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock); - FileObject->PrivateCacheMap = NULL; - KeReleaseQueuedSpinLock(LockQueueMasterLock, OldIrql); + /* And free it. */ ExFreePoolWithTag(PrivateMap, TAG_PRIVATE_CACHE_MAP); if (SharedCacheMap->OpenCount > 0)

1 0

01/01: [NTOSKRNL] Bring an initial (and not perfect ; -)) implementation of read ahead to our Cc!
by Pierre Schweitzer 09 Feb '18

09 Feb '18

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=c5139563db15f3b854157… commit c5139563db15f3b8541573a6e59e27ff0059a1a1 Author: Pierre Schweitzer <pierre(a)reactos.org> AuthorDate: Fri Feb 9 10:06:17 2018 +0100 Commit: Pierre Schweitzer <pierre(a)reactos.org> CommitDate: Fri Feb 9 10:14:11 2018 +0100 [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 --- ntoskrnl/cc/cacheman.c | 95 ++++++++++++++++++++++- ntoskrnl/cc/copy.c | 168 +++++++++++++++++++++++++++++++++++++++++ ntoskrnl/cc/lazywrite.c | 38 ++++++---- ntoskrnl/cc/view.c | 8 +- ntoskrnl/include/internal/cc.h | 18 +++++ sdk/include/ndk/cctypes.h | 6 +- 6 files changed, 314 insertions(+), 19 deletions(-) diff --git a/ntoskrnl/cc/cacheman.c b/ntoskrnl/cc/cacheman.c index abfb5e425c..99abf84e5d 100644 --- a/ntoskrnl/cc/cacheman.c +++ b/ntoskrnl/cc/cacheman.c @@ -51,6 +51,7 @@ CcInitializeCacheManager(VOID) /* Initialize lazy-writer lists */ InitializeListHead(&CcIdleWorkerThreadList); + InitializeListHead(&CcExpressWorkQueue); InitializeListHead(&CcRegularWorkQueue); InitializeListHead(&CcPostTickWorkQueue); @@ -160,7 +161,99 @@ CcScheduleReadAhead ( IN ULONG Length ) { - UNIMPLEMENTED; + KIRQL OldIrql; + LARGE_INTEGER NewOffset; + PROS_SHARED_CACHE_MAP SharedCacheMap; + PPRIVATE_CACHE_MAP PrivateCacheMap; + + SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap; + PrivateCacheMap = FileObject->PrivateCacheMap; + + /* If file isn't cached, or if read ahead is disabled, this is no op */ + if (SharedCacheMap == NULL || PrivateCacheMap == NULL || + BooleanFlagOn(SharedCacheMap->Flags, READAHEAD_DISABLED)) + { + return; + } + + /* Round read length with read ahead mask */ + Length = ROUND_UP(Length, PrivateCacheMap->ReadAheadMask + 1); + /* Compute the offset we'll reach */ + NewOffset.QuadPart = FileOffset->QuadPart + Length; + + /* Lock read ahead spin lock */ + KeAcquireSpinLock(&PrivateCacheMap->ReadAheadSpinLock, &OldIrql); + /* Easy case: the file is sequentially read */ + if (BooleanFlagOn(FileObject->Flags, FO_SEQUENTIAL_ONLY)) + { + /* If we went backward, this is no go! */ + if (NewOffset.QuadPart < PrivateCacheMap->ReadAheadOffset[1].QuadPart) + { + KeReleaseSpinLock(&PrivateCacheMap->ReadAheadSpinLock, OldIrql); + return; + } + + /* FIXME: hackish, but will do the job for now */ + PrivateCacheMap->ReadAheadOffset[1].QuadPart = NewOffset.QuadPart; + PrivateCacheMap->ReadAheadLength[1] = Length; + } + /* Other cases: try to find some logic in that mess... */ + else + { + /* Let's check if we always read the same way (like going down in the file) + * and pretend it's enough for now + */ + if (PrivateCacheMap->FileOffset2.QuadPart >= PrivateCacheMap->FileOffset1.QuadPart && + FileOffset->QuadPart >= PrivateCacheMap->FileOffset2.QuadPart) + { + /* FIXME: hackish, but will do the job for now */ + PrivateCacheMap->ReadAheadOffset[1].QuadPart = NewOffset.QuadPart; + PrivateCacheMap->ReadAheadLength[1] = Length; + } + else + { + /* FIXME: handle the other cases */ + KeReleaseSpinLock(&PrivateCacheMap->ReadAheadSpinLock, OldIrql); + UNIMPLEMENTED; + return; + } + } + + /* If read ahead isn't active yet */ + if (!PrivateCacheMap->Flags.ReadAheadActive) + { + PWORK_QUEUE_ENTRY WorkItem; + + /* It's active now! + * Be careful with the mask, you don't want to mess with node code + */ + InterlockedOr((volatile long *)&PrivateCacheMap->UlongFlags, 0x10000); + KeReleaseSpinLock(&PrivateCacheMap->ReadAheadSpinLock, OldIrql); + + /* Get a work item */ + WorkItem = ExAllocateFromNPagedLookasideList(&CcTwilightLookasideList); + if (WorkItem != NULL) + { + /* Reference our FO so that it doesn't go in between */ + ObReferenceObject(FileObject); + + /* We want to do read ahead! */ + WorkItem->Function = ReadAhead; + WorkItem->Parameters.Read.FileObject = FileObject; + + /* Queue in the read ahead dedicated queue */ + CcPostWorkQueue(WorkItem, &CcExpressWorkQueue); + + return; + } + + /* Fail path: lock again, and revert read ahead active */ + KeAcquireSpinLock(&PrivateCacheMap->ReadAheadSpinLock, &OldIrql); + InterlockedAnd((volatile long *)&PrivateCacheMap->UlongFlags, 0xFFFEFFFF); + } + + /* Done (fail) */ + KeReleaseSpinLock(&PrivateCacheMap->ReadAheadSpinLock, OldIrql); } /* diff --git a/ntoskrnl/cc/copy.c b/ntoskrnl/cc/copy.c index 521d90b48e..63ad5aeb11 100644 --- a/ntoskrnl/cc/copy.c +++ b/ntoskrnl/cc/copy.c @@ -248,8 +248,10 @@ CcCopyData ( ULONG PartialLength; PVOID BaseAddress; BOOLEAN Valid; + PPRIVATE_CACHE_MAP PrivateCacheMap; SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap; + PrivateCacheMap = FileObject->PrivateCacheMap; CurrentOffset = FileOffset; BytesCopied = 0; @@ -356,6 +358,23 @@ CcCopyData ( if (Operation != CcOperationZero) Buffer = (PVOID)((ULONG_PTR)Buffer + PartialLength); } + + /* If that was a successful sync read operation, let's handle read ahead */ + if (Operation == CcOperationRead && Length == 0 && Wait) + { + /* If file isn't random access, schedule next read */ + if (!BooleanFlagOn(FileObject->Flags, FO_RANDOM_ACCESS)) + { + CcScheduleReadAhead(FileObject, (PLARGE_INTEGER)&FileOffset, BytesCopied); + } + + /* And update read history in private cache map */ + PrivateCacheMap->FileOffset1.QuadPart = PrivateCacheMap->FileOffset2.QuadPart; + PrivateCacheMap->BeyondLastByte1.QuadPart = PrivateCacheMap->BeyondLastByte2.QuadPart; + PrivateCacheMap->FileOffset2.QuadPart = FileOffset; + PrivateCacheMap->BeyondLastByte2.QuadPart = FileOffset + BytesCopied; + } + IoStatus->Status = STATUS_SUCCESS; IoStatus->Information = BytesCopied; return TRUE; @@ -435,6 +454,155 @@ CcPostDeferredWrites(VOID) } } +VOID +CcPerformReadAhead( + IN PFILE_OBJECT FileObject) +{ + NTSTATUS Status; + LONGLONG CurrentOffset; + KIRQL OldIrql; + PROS_SHARED_CACHE_MAP SharedCacheMap; + PROS_VACB Vacb; + ULONG PartialLength; + PVOID BaseAddress; + BOOLEAN Valid; + ULONG Length; + PPRIVATE_CACHE_MAP PrivateCacheMap; + BOOLEAN Locked; + + SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap; + + /* Critical: + * PrivateCacheMap might disappear in-between if the handle + * to the file is closed (private is attached to the handle not to + * the file), so we need to lock the master lock while we deal with + * it. It won't disappear without attempting to lock such lock. + */ + OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock); + PrivateCacheMap = FileObject->PrivateCacheMap; + /* If the handle was closed since the read ahead was scheduled, just quit */ + if (PrivateCacheMap == NULL) + { + KeReleaseQueuedSpinLock(LockQueueMasterLock, OldIrql); + ObDereferenceObject(FileObject); + return; + } + /* Otherwise, extract read offset and length and release private map */ + else + { + KeAcquireSpinLockAtDpcLevel(&PrivateCacheMap->ReadAheadSpinLock); + CurrentOffset = PrivateCacheMap->ReadAheadOffset[1].QuadPart; + Length = PrivateCacheMap->ReadAheadLength[1]; + KeReleaseSpinLockFromDpcLevel(&PrivateCacheMap->ReadAheadSpinLock); + } + KeReleaseQueuedSpinLock(LockQueueMasterLock, OldIrql); + + /* Time to go! */ + DPRINT("Doing ReadAhead for %p\n", FileObject); + /* Lock the file, first */ + if (!SharedCacheMap->Callbacks->AcquireForReadAhead(SharedCacheMap->LazyWriteContext, FALSE)) + { + Locked = FALSE; + goto Clear; + } + + /* Remember it's locked */ + Locked = TRUE; + + /* Next of the algorithm will lock like CcCopyData with the slight + * difference that we don't copy data back to an user-backed buffer + * We just bring data into Cc + */ + PartialLength = CurrentOffset % VACB_MAPPING_GRANULARITY; + if (PartialLength != 0) + { + PartialLength = min(Length, VACB_MAPPING_GRANULARITY - PartialLength); + Status = CcRosRequestVacb(SharedCacheMap, + ROUND_DOWN(CurrentOffset, + VACB_MAPPING_GRANULARITY), + &BaseAddress, + &Valid, + &Vacb); + if (!NT_SUCCESS(Status)) + { + DPRINT1("Failed to request VACB: %lx!\n", Status); + goto Clear; + } + + if (!Valid) + { + Status = CcReadVirtualAddress(Vacb); + if (!NT_SUCCESS(Status)) + { + CcRosReleaseVacb(SharedCacheMap, Vacb, FALSE, FALSE, FALSE); + DPRINT1("Failed to read data: %lx!\n", Status); + goto Clear; + } + } + + CcRosReleaseVacb(SharedCacheMap, Vacb, TRUE, FALSE, FALSE); + + Length -= PartialLength; + CurrentOffset += PartialLength; + } + + while (Length > 0) + { + ASSERT(CurrentOffset % VACB_MAPPING_GRANULARITY == 0); + PartialLength = min(VACB_MAPPING_GRANULARITY, Length); + Status = CcRosRequestVacb(SharedCacheMap, + CurrentOffset, + &BaseAddress, + &Valid, + &Vacb); + if (!NT_SUCCESS(Status)) + { + DPRINT1("Failed to request VACB: %lx!\n", Status); + goto Clear; + } + + if (!Valid) + { + Status = CcReadVirtualAddress(Vacb); + if (!NT_SUCCESS(Status)) + { + CcRosReleaseVacb(SharedCacheMap, Vacb, FALSE, FALSE, FALSE); + DPRINT1("Failed to read data: %lx!\n", Status); + goto Clear; + } + } + + CcRosReleaseVacb(SharedCacheMap, Vacb, TRUE, FALSE, FALSE); + + Length -= PartialLength; + CurrentOffset += PartialLength; + } + +Clear: + /* See previous comment about private cache map */ + OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock); + PrivateCacheMap = FileObject->PrivateCacheMap; + if (PrivateCacheMap != NULL) + { + /* Mark read ahead as unactive */ + KeAcquireSpinLockAtDpcLevel(&PrivateCacheMap->ReadAheadSpinLock); + InterlockedAnd((volatile long *)&PrivateCacheMap->UlongFlags, 0xFFFEFFFF); + KeReleaseSpinLockFromDpcLevel(&PrivateCacheMap->ReadAheadSpinLock); + } + KeReleaseSpinLock(&PrivateCacheMap->ReadAheadSpinLock, OldIrql); + + /* If file was locked, release it */ + if (Locked) + { + SharedCacheMap->Callbacks->ReleaseFromReadAhead(SharedCacheMap->LazyWriteContext); + } + + /* And drop our extra reference (See: CcScheduleReadAhead) */ + ObDereferenceObject(FileObject); + + return; +} + /* * @unimplemented */ diff --git a/ntoskrnl/cc/lazywrite.c b/ntoskrnl/cc/lazywrite.c index 292266d191..261fcf363e 100644 --- a/ntoskrnl/cc/lazywrite.c +++ b/ntoskrnl/cc/lazywrite.c @@ -13,14 +13,6 @@ #define NDEBUG #include <debug.h> -typedef enum _WORK_QUEUE_FUNCTIONS -{ - ReadAhead = 1, - WriteBehind = 2, - LazyWrite = 3, - SetDone = 4, -} WORK_QUEUE_FUNCTIONS, *PWORK_QUEUE_FUNCTIONS; - /* Counters: * - Amount of pages flushed by lazy writer * - Number of times lazy writer ran @@ -31,6 +23,7 @@ ULONG CcLazyWriteIos = 0; /* Internal vars (MS): * - Lazy writer status structure * - Lookaside list where to allocate work items + * - Queue for high priority work items (read ahead) * - Queue for regular work items * - Available worker threads * - Queue for stuff to be queued after lazy writer is done @@ -43,6 +36,7 @@ ULONG CcLazyWriteIos = 0; */ LAZY_WRITER LazyWriter; NPAGED_LOOKASIDE_LIST CcTwilightLookasideList; +LIST_ENTRY CcExpressWorkQueue; LIST_ENTRY CcRegularWorkQueue; LIST_ENTRY CcIdleWorkerThreadList; LIST_ENTRY CcPostTickWorkQueue; @@ -231,10 +225,22 @@ CcWorkerThread( DropThrottle = FALSE; } - /* If no work to do, we're done */ - if (IsListEmpty(&CcRegularWorkQueue)) + /* Check first if we have read ahead to do */ + if (IsListEmpty(&CcExpressWorkQueue)) { - break; + /* 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); } /* Get our work item, if someone is waiting for us to finish @@ -242,7 +248,6 @@ CcWorkerThread( * then, quit running to let the others do * and throttle so that noone starts till current activity is over */ - WorkItem = CONTAINING_RECORD(CcRegularWorkQueue.Flink, WORK_QUEUE_ENTRY, WorkQueueLinks); if (WorkItem->Function == SetDone && CcNumberActiveWorkerThreads > 1) { CcQueueThrottle = TRUE; @@ -256,7 +261,10 @@ CcWorkerThread( /* And handle it */ switch (WorkItem->Function) { - /* We only support lazy write now */ + case ReadAhead: + CcPerformReadAhead(WorkItem->Parameters.Read.FileObject); + break; + case LazyWrite: CcLazyWriteScan(); break; @@ -265,6 +273,10 @@ CcWorkerThread( KeSetEvent(WorkItem->Parameters.Event.Event, IO_NO_INCREMENT, FALSE); DropThrottle = TRUE; break; + + default: + DPRINT1("Ignored item: %p (%d)\n", WorkItem, WorkItem->Function); + break; } /* And release the item */ diff --git a/ntoskrnl/cc/view.c b/ntoskrnl/cc/view.c index 4823d04268..377c1ef84d 100644 --- a/ntoskrnl/cc/view.c +++ b/ntoskrnl/cc/view.c @@ -1191,8 +1191,14 @@ CcRosReleaseFileCache ( RemoveEntryList(&PrivateMap->PrivateLinks); KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, OldIrql); - /* And free it */ + /* And free it. + * Before you event try to remove it from FO, always + * lock the master lock, to be sure not to race + * with a potential read ahead ongoing! + */ + OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock); FileObject->PrivateCacheMap = NULL; + KeReleaseQueuedSpinLock(LockQueueMasterLock, OldIrql); ExFreePoolWithTag(PrivateMap, TAG_PRIVATE_CACHE_MAP); if (SharedCacheMap->OpenCount > 0) diff --git a/ntoskrnl/include/internal/cc.h b/ntoskrnl/include/internal/cc.h index 51dea091e3..d34360a7e3 100644 --- a/ntoskrnl/include/internal/cc.h +++ b/ntoskrnl/include/internal/cc.h @@ -47,6 +47,7 @@ extern LIST_ENTRY CcDeferredWrites; extern KSPIN_LOCK CcDeferredWriteSpinLock; extern ULONG CcNumberWorkerThreads; extern LIST_ENTRY CcIdleWorkerThreadList; +extern LIST_ENTRY CcExpressWorkQueue; extern LIST_ENTRY CcRegularWorkQueue; extern LIST_ENTRY CcPostTickWorkQueue; extern NPAGED_LOOKASIDE_LIST CcTwilightLookasideList; @@ -261,6 +262,14 @@ typedef struct _WORK_QUEUE_ENTRY unsigned char Function; } WORK_QUEUE_ENTRY, *PWORK_QUEUE_ENTRY; +typedef enum _WORK_QUEUE_FUNCTIONS +{ + ReadAhead = 1, + WriteBehind = 2, + LazyWrite = 3, + SetDone = 4, +} WORK_QUEUE_FUNCTIONS, *PWORK_QUEUE_FUNCTIONS; + extern LAZY_WRITER LazyWriter; #define NODE_TYPE_DEFERRED_WRITE 0x02FC @@ -439,6 +448,15 @@ CcScheduleLazyWriteScan(BOOLEAN NoDelay); VOID CcPostDeferredWrites(VOID); +VOID +CcPostWorkQueue( + IN PWORK_QUEUE_ENTRY WorkItem, + IN PLIST_ENTRY WorkQueue); + +VOID +CcPerformReadAhead( + IN PFILE_OBJECT FileObject); + FORCEINLINE NTSTATUS CcRosAcquireVacbLock( diff --git a/sdk/include/ndk/cctypes.h b/sdk/include/ndk/cctypes.h index c49a748923..c07e96732a 100644 --- a/sdk/include/ndk/cctypes.h +++ b/sdk/include/ndk/cctypes.h @@ -75,10 +75,8 @@ typedef struct _PRIVATE_CACHE_MAP LARGE_INTEGER BeyondLastByte1; LARGE_INTEGER FileOffset2; LARGE_INTEGER BeyondLastByte2; - ULONG SequentialReadCount; - ULONG ReadAheadLength; - LARGE_INTEGER ReadAheadOffset; - LARGE_INTEGER ReadAheadBeyondLastByte; + LARGE_INTEGER ReadAheadOffset[2]; + ULONG ReadAheadLength[2]; KSPIN_LOCK ReadAheadSpinLock; LIST_ENTRY PrivateLinks; PVOID ReadAheadWorkItem;

1 0

02/02: [RAPPS] Fix column sorting
by Alexander Shaposhnikov 08 Feb '18

08 Feb '18

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=f4fedb936eae60e7b9847… commit f4fedb936eae60e7b9847339080cfd2604d4cd82 Author: Alexander Shaposhnikov <sanchaez(a)reactos.org> AuthorDate: Fri Feb 9 00:53:31 2018 +0200 Commit: Alexander Shaposhnikov <sanchaez(a)reactos.org> CommitDate: Fri Feb 9 00:53:31 2018 +0200 [RAPPS] Fix column sorting CORE-13793 --- base/applications/rapps/gui.cpp | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/base/applications/rapps/gui.cpp b/base/applications/rapps/gui.cpp index c4e76b35d3..ed2c3b8264 100644 --- a/base/applications/rapps/gui.cpp +++ b/base/applications/rapps/gui.cpp @@ -539,12 +539,7 @@ public: GetItemText(Index, iSubItem, Item2.GetBuffer(MAX_STR_LEN), MAX_STR_LEN); Item2.ReleaseBuffer(); - if (bIsAscending) - return Item2 == Item1; - else - return Item1 == Item2; - - return 0; + return bIsAscending ? Item1.Compare(Item2) : Item2.Compare(Item1); } HWND Create(HWND hwndParent)

1 0

01/02: [RAPPS] Set header style when sorting by column
by Alexander Shaposhnikov 08 Feb '18

08 Feb '18

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=b698067e35b795044057b… commit b698067e35b795044057ba4a54eb2473ad66150d Author: Alexander Shaposhnikov <sanchaez(a)reactos.org> AuthorDate: Fri Feb 9 00:41:55 2018 +0200 Commit: Alexander Shaposhnikov <sanchaez(a)reactos.org> CommitDate: Fri Feb 9 00:41:55 2018 +0200 [RAPPS] Set header style when sorting by column --- base/applications/rapps/gui.cpp | 44 +++++++++++++++++++++++++++++++++++------ 1 file changed, 38 insertions(+), 6 deletions(-) diff --git a/base/applications/rapps/gui.cpp b/base/applications/rapps/gui.cpp index 4ef3bd475c..c4e76b35d3 100644 --- a/base/applications/rapps/gui.cpp +++ b/base/applications/rapps/gui.cpp @@ -388,14 +388,17 @@ class CAppsListView : }; BOOL bHasAllChecked; - BOOL bAscending; + BOOL bIsAscending; BOOL bHasCheckboxes; + INT nLastHeaderID; + public: CAppsListView() : bHasAllChecked(FALSE), - bAscending(TRUE), - bHasCheckboxes(FALSE) + bIsAscending(TRUE), + bHasCheckboxes(FALSE), + nLastHeaderID(-1) { } @@ -415,11 +418,40 @@ public: VOID ColumnClick(LPNMLISTVIEW pnmv) { - SortContext ctx = {this, pnmv->iSubItem}; + HWND hHeader; + HDITEMW hColumn; + INT nHeaderID = pnmv->iSubItem; + + if ((GetWindowLongPtr(GWL_STYLE) & ~LVS_NOSORTHEADER) == 0) + return; + + hHeader = (HWND) SendMessage(LVM_GETHEADER, 0, 0); + ZeroMemory(&hColumn, sizeof(hColumn)); + + /* If the sorting column changed, remove the sorting style from the old column */ + if ((nLastHeaderID != -1) && (nLastHeaderID != nHeaderID)) + { + hColumn.mask = HDI_FORMAT; + Header_GetItem(hHeader, nLastHeaderID, &hColumn); + hColumn.fmt &= ~(HDF_SORTUP | HDF_SORTDOWN); + Header_SetItem(hHeader, nLastHeaderID, &hColumn); + } + + /* Set the sorting style to the new column */ + hColumn.mask = HDI_FORMAT; + Header_GetItem(hHeader, nHeaderID, &hColumn); + + hColumn.fmt &= (bIsAscending ? ~HDF_SORTDOWN : ~HDF_SORTUP); + hColumn.fmt |= (bIsAscending ? HDF_SORTUP : HDF_SORTDOWN); + Header_SetItem(hHeader, nHeaderID, &hColumn); + /* Sort the list, using the current values of nHeaderID and bIsAscending */ + SortContext ctx = {this, nHeaderID}; SortItems(s_CompareFunc, &ctx); - bAscending = !bAscending; + /* Save new values */ + nLastHeaderID = nHeaderID; + bIsAscending = !bIsAscending; } PVOID GetLParam(INT Index) @@ -507,7 +539,7 @@ public: GetItemText(Index, iSubItem, Item2.GetBuffer(MAX_STR_LEN), MAX_STR_LEN); Item2.ReleaseBuffer(); - if (bAscending) + if (bIsAscending) return Item2 == Item1; else return Item1 == Item2;

1 0

01/01: [NTOSKRNL] Fix a ****ing bug where private cache map was deleted in CcUninitializeCacheMap() before the call to CcRosReleaseFileCache() which expects to have it to properly clean the file. So, move deletion code to CcRosReleaseFileCache() so that he's the only one to handle private map. Should hopefully fix all the recent buildbots issues (and the universe perhaps, who knows?)
by Pierre Schweitzer 08 Feb '18

08 Feb '18

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=f0c7f862d4da673ea3e41… commit f0c7f862d4da673ea3e4120918924af7a03ed0df Author: Pierre Schweitzer <pierre(a)reactos.org> AuthorDate: Thu Feb 8 14:15:02 2018 +0100 Commit: Pierre Schweitzer <pierre(a)reactos.org> CommitDate: Thu Feb 8 14:15:02 2018 +0100 [NTOSKRNL] Fix a ****ing bug where private cache map was deleted in CcUninitializeCacheMap() before the call to CcRosReleaseFileCache() which expects to have it to properly clean the file. So, move deletion code to CcRosReleaseFileCache() so that he's the only one to handle private map. Should hopefully fix all the recent buildbots issues (and the universe perhaps, who knows?) --- ntoskrnl/cc/fs.c | 19 ------------------- ntoskrnl/cc/view.c | 14 ++++++++++++++ 2 files changed, 14 insertions(+), 19 deletions(-) diff --git a/ntoskrnl/cc/fs.c b/ntoskrnl/cc/fs.c index 7be40ae82b..38c9ae527c 100644 --- a/ntoskrnl/cc/fs.c +++ b/ntoskrnl/cc/fs.c @@ -346,25 +346,6 @@ CcUninitializeCacheMap ( FALSE); } - /* Closing the handle, so kill the private cache map */ - if (FileObject->SectionObjectPointer->SharedCacheMap != NULL && - FileObject->PrivateCacheMap != NULL) - { - PPRIVATE_CACHE_MAP PrivateMap; - - PrivateMap = FileObject->PrivateCacheMap; - SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap; - - /* Remove it from the file */ - KeAcquireSpinLock(&SharedCacheMap->CacheMapLock, &OldIrql); - RemoveEntryList(&PrivateMap->PrivateLinks); - KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, OldIrql); - - /* And free it */ - FileObject->PrivateCacheMap = NULL; - ExFreePoolWithTag(PrivateMap, TAG_PRIVATE_CACHE_MAP); - } - Status = CcRosReleaseFileCache(FileObject); if (UninitializeCompleteEvent) { diff --git a/ntoskrnl/cc/view.c b/ntoskrnl/cc/view.c index 18eaac50e8..4823d04268 100644 --- a/ntoskrnl/cc/view.c +++ b/ntoskrnl/cc/view.c @@ -1180,7 +1180,21 @@ CcRosReleaseFileCache ( SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap; if (FileObject->PrivateCacheMap != NULL) { + KIRQL OldIrql; + PPRIVATE_CACHE_MAP PrivateMap; + + /* Closing the handle, so kill the private cache map */ + PrivateMap = FileObject->PrivateCacheMap; + + /* Remove it from the file */ + KeAcquireSpinLock(&SharedCacheMap->CacheMapLock, &OldIrql); + RemoveEntryList(&PrivateMap->PrivateLinks); + KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, OldIrql); + + /* And free it */ FileObject->PrivateCacheMap = NULL; + ExFreePoolWithTag(PrivateMap, TAG_PRIVATE_CACHE_MAP); + if (SharedCacheMap->OpenCount > 0) { SharedCacheMap->OpenCount--;

1 0

01/01: [NDK] Update the PRIVATE_CACHE_MAP structure to match W2K3 one. Also update the spin lock on allocation.
by Pierre Schweitzer 08 Feb '18

08 Feb '18

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=f8b5d27807db025dba05a… commit f8b5d27807db025dba05a922a73432940e2af66e Author: Pierre Schweitzer <pierre(a)reactos.org> AuthorDate: Thu Feb 8 14:02:42 2018 +0100 Commit: Pierre Schweitzer <pierre(a)reactos.org> CommitDate: Thu Feb 8 14:02:42 2018 +0100 [NDK] Update the PRIVATE_CACHE_MAP structure to match W2K3 one. Also update the spin lock on allocation. --- ntoskrnl/cc/view.c | 1 + sdk/include/ndk/cctypes.h | 7 +++++-- 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/ntoskrnl/cc/view.c b/ntoskrnl/cc/view.c index 94fcff6b7a..18eaac50e8 100644 --- a/ntoskrnl/cc/view.c +++ b/ntoskrnl/cc/view.c @@ -1280,6 +1280,7 @@ CcRosInitializeFileCache ( PrivateMap->NodeTypeCode = NODE_TYPE_PRIVATE_MAP; PrivateMap->ReadAheadMask = PAGE_SIZE - 1; PrivateMap->FileObject = FileObject; + KeInitializeSpinLock(&PrivateMap->ReadAheadSpinLock); /* Link it to the file */ KeAcquireSpinLock(&SharedCacheMap->CacheMapLock, &OldIrql); diff --git a/sdk/include/ndk/cctypes.h b/sdk/include/ndk/cctypes.h index 5dd55689f5..c49a748923 100644 --- a/sdk/include/ndk/cctypes.h +++ b/sdk/include/ndk/cctypes.h @@ -75,10 +75,13 @@ typedef struct _PRIVATE_CACHE_MAP LARGE_INTEGER BeyondLastByte1; LARGE_INTEGER FileOffset2; LARGE_INTEGER BeyondLastByte2; - LARGE_INTEGER ReadAheadOffset[2]; - ULONG ReadAheadLength[2]; + ULONG SequentialReadCount; + ULONG ReadAheadLength; + LARGE_INTEGER ReadAheadOffset; + LARGE_INTEGER ReadAheadBeyondLastByte; KSPIN_LOCK ReadAheadSpinLock; LIST_ENTRY PrivateLinks; + PVOID ReadAheadWorkItem; } PRIVATE_CACHE_MAP, *PPRIVATE_CACHE_MAP; typedef struct _BITMAP_RANGE

1 0

01/01: [NTOSKRNL] Revert 2362e0f and 07e6e9c (partly) they seem to have caused high instability in Cc. This reverts BCB being lazy written when marked dirty.
by Pierre Schweitzer 08 Feb '18

08 Feb '18

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=de897cbe3d5e95d006fbe… commit de897cbe3d5e95d006fbeae3e8a8683b569bbd5c Author: Pierre Schweitzer <pierre(a)reactos.org> AuthorDate: Thu Feb 8 13:40:54 2018 +0100 Commit: Pierre Schweitzer <pierre(a)reactos.org> CommitDate: Thu Feb 8 13:40:54 2018 +0100 [NTOSKRNL] Revert 2362e0f and 07e6e9c (partly) they seem to have caused high instability in Cc. This reverts BCB being lazy written when marked dirty. We'll go back to this behavior when this part will have been reworked and stabilized. CORE-14263 CORE-14279 CORE-14285 --- ntoskrnl/cc/pin.c | 4 ---- ntoskrnl/cc/view.c | 3 +-- 2 files changed, 1 insertion(+), 6 deletions(-) diff --git a/ntoskrnl/cc/pin.c b/ntoskrnl/cc/pin.c index 955bbd0ca7..7b8d878731 100644 --- a/ntoskrnl/cc/pin.c +++ b/ntoskrnl/cc/pin.c @@ -247,10 +247,6 @@ CcSetDirtyPinnedData ( Bcb, Lsn); iBcb->Dirty = TRUE; - if (!iBcb->Vacb->Dirty) - { - CcRosMarkDirtyVacb(iBcb->Vacb); - } } diff --git a/ntoskrnl/cc/view.c b/ntoskrnl/cc/view.c index 0d6d51b2f8..94fcff6b7a 100644 --- a/ntoskrnl/cc/view.c +++ b/ntoskrnl/cc/view.c @@ -231,8 +231,7 @@ CcRosFlushDirtyPages ( ASSERT(current->Dirty); /* One reference is added above */ - if ((current->ReferenceCount > 2 && current->PinCount == 0) || - (current->ReferenceCount > 3 && current->PinCount > 1)) + if (current->ReferenceCount > 2) { CcRosReleaseVacbLock(current); current->SharedCacheMap->Callbacks->ReleaseFromLazyWrite(

1 0

02/02: [NTOSKRNL] Revert 6ece4e9fc22d664ea2485d04303e8ae10047f21f for third tools compatibility
by Pierre Schweitzer 08 Feb '18

08 Feb '18

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=e26e4445b39d7455e83e4… commit e26e4445b39d7455e83e45ac7272d21289cc5106 Author: Pierre Schweitzer <pierre(a)reactos.org> AuthorDate: Thu Feb 8 11:50:45 2018 +0100 Commit: Pierre Schweitzer <pierre(a)reactos.org> CommitDate: Thu Feb 8 11:50:45 2018 +0100 [NTOSKRNL] Revert 6ece4e9fc22d664ea2485d04303e8ae10047f21f for third tools compatibility --- ntoskrnl/ke/bug.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ntoskrnl/ke/bug.c b/ntoskrnl/ke/bug.c index 2127d7207c..a92acb1bab 100644 --- a/ntoskrnl/ke/bug.c +++ b/ntoskrnl/ke/bug.c @@ -1070,8 +1070,8 @@ KeBugCheckWithTf(IN ULONG BugCheckCode, if ((BugCheckCode != MANUALLY_INITIATED_CRASH) && (KdDebuggerEnabled)) { /* Crash on the debugger console */ - DbgPrint("\n*** BugCheck: 0x%08lx\n" - " (0x%p,0x%p,0x%p,0x%p)\n\n", + DbgPrint("\n*** Fatal System Error: 0x%08lx\n" + " (0x%p,0x%p,0x%p,0x%p)\n\n", KiBugCheckData[0], KiBugCheckData[1], KiBugCheckData[2],

1 0

Jump to page:

2026

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Ros-diffs