Ros-diffs February 2018

ros-diffs@reactos.org

24 participants
240 discussions

02/03: [NTOSKRNL] Define the throttling limits for Cc in Mm: MmThrottleTop, MmThrottleBottom. Modified !defwrites to reflect that change

by Pierre Schweitzer

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=6b0cb54fe578e81205ffc… commit 6b0cb54fe578e81205ffc3be6e53b246ce040d01 Author: Pierre Schweitzer <pierre(a)reactos.org> AuthorDate: Fri Feb 9 14:21:14 2018 +0100 Commit: Pierre Schweitzer <pierre(a)reactos.org> CommitDate: Fri Feb 9 14:21:14 2018 +0100 [NTOSKRNL] Define the throttling limits for Cc in Mm: MmThrottleTop, MmThrottleBottom. Modified !defwrites to reflect that change --- ntoskrnl/cc/view.c | 6 ++++++ ntoskrnl/include/internal/mm.h | 2 ++ ntoskrnl/mm/ARM3/mminit.c | 24 ++++++++++++++++++++++++ 3 files changed, 32 insertions(+) diff --git a/ntoskrnl/cc/view.c b/ntoskrnl/cc/view.c index cf2645591c..d69b195c10 100644 --- a/ntoskrnl/cc/view.c +++ b/ntoskrnl/cc/view.c @@ -1437,6 +1437,12 @@ ExpKdbgExtDefWrites(ULONG Argc, PCHAR Argv[]) (CcDirtyPageThreshold * PAGE_SIZE) / 1024); KdbpPrint("MmAvailablePages:\t%lu (%lu Kb)\n", MmAvailablePages, (MmAvailablePages * PAGE_SIZE) / 1024); + KdbpPrint("MmThrottleTop:\t\t%lu (%lu Kb)\n", MmThrottleTop, + (MmThrottleTop * PAGE_SIZE) / 1024); + KdbpPrint("MmThrottleBottom:\t%lu (%lu Kb)\n", MmThrottleBottom, + (MmThrottleBottom * PAGE_SIZE) / 1024); + KdbpPrint("MmModifiedPageListHead.Total:\t%lu (%lu Kb)\n", MmModifiedPageListHead.Total, + (MmModifiedPageListHead.Total * PAGE_SIZE) / 1024); if (CcTotalDirtyPages >= CcDirtyPageThreshold) { diff --git a/ntoskrnl/include/internal/mm.h b/ntoskrnl/include/internal/mm.h index 4489530ee2..d5094e0915 100644 --- a/ntoskrnl/include/internal/mm.h +++ b/ntoskrnl/include/internal/mm.h @@ -15,6 +15,8 @@ extern PFN_NUMBER MmLowestPhysicalPage; extern PFN_NUMBER MmHighestPhysicalPage; extern PFN_NUMBER MmAvailablePages; extern PFN_NUMBER MmResidentAvailablePages; +extern ULONG MmThrottleTop; +extern ULONG MmThrottleBottom; extern LIST_ENTRY MmLoadedUserImageList; diff --git a/ntoskrnl/mm/ARM3/mminit.c b/ntoskrnl/mm/ARM3/mminit.c index eb625fcecb..9b57931cbc 100644 --- a/ntoskrnl/mm/ARM3/mminit.c +++ b/ntoskrnl/mm/ARM3/mminit.c @@ -387,6 +387,15 @@ PFN_NUMBER MiNumberOfFreePages = 0; ULONG MmCritsectTimeoutSeconds = 150; // NT value: 720 * 60 * 60; (30 days) LARGE_INTEGER MmCriticalSectionTimeout; +// +// Throttling limits for Cc (in pages) +// Above top, we don't throttle +// Above bottom, we throttle depending on the amount of modified pages +// Otherwise, we throttle! +// +ULONG MmThrottleTop; +ULONG MmThrottleBottom; + /* PRIVATE FUNCTIONS **********************************************************/ VOID @@ -2074,6 +2083,13 @@ MmArmInitSystem(IN ULONG Phase, MiLowNonPagedPoolEvent = &MiTempEvent; MiHighNonPagedPoolEvent = &MiTempEvent; + // + // Default throttling limits for Cc + // May be ajusted later on depending on system type + // + MmThrottleTop = 450; + MmThrottleBottom = 127; + // // Define the basic user vs. kernel address space separation // @@ -2461,6 +2477,10 @@ MmArmInitSystem(IN ULONG Phase, /* Set Windows NT Workstation product type */ SharedUserData->NtProductType = NtProductWinNt; MmProductType = 0; + + /* For this product, we wait till the last moment to throttle */ + MmThrottleTop = 250; + MmThrottleBottom = 30; } else { @@ -2479,6 +2499,10 @@ MmArmInitSystem(IN ULONG Phase, /* Set the product type, and make the system more aggressive with low memory */ MmProductType = 1; MmMinimumFreePages = 81; + + /* We will throttle earlier to preserve memory */ + MmThrottleTop = 450; + MmThrottleBottom = 80; } /* Update working set tuning parameters */

6 years, 10 months

01/03: [NTOSKRNL] Rewrite CcCanIWrite() to make it more accurate and handle specific callers

by Pierre Schweitzer

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=945ff8ea2ee2abd48f5ec… commit 945ff8ea2ee2abd48f5ecbe707131446546e75a3 Author: Pierre Schweitzer <pierre(a)reactos.org> AuthorDate: Fri Feb 9 13:56:16 2018 +0100 Commit: Pierre Schweitzer <pierre(a)reactos.org> CommitDate: Fri Feb 9 13:56:16 2018 +0100 [NTOSKRNL] Rewrite CcCanIWrite() to make it more accurate and handle specific callers --- ntoskrnl/cc/copy.c | 99 ++++++++++++++++++++++++++++++++++++------------------ 1 file changed, 66 insertions(+), 33 deletions(-) diff --git a/ntoskrnl/cc/copy.c b/ntoskrnl/cc/copy.c index 4992ade290..40897028fc 100644 --- a/ntoskrnl/cc/copy.c +++ b/ntoskrnl/cc/copy.c @@ -27,6 +27,14 @@ typedef enum _CC_COPY_OPERATION CcOperationZero } CC_COPY_OPERATION; +typedef enum _CC_CAN_WRITE_RETRY +{ + FirstTry = 0, + RetryAllowRemote = 253, + RetryForceCheckPerFile = 254, + RetryMasterLocked = 255, +} CC_CAN_WRITE_RETRY; + ULONG CcRosTraceLevel = 0; ULONG CcFastMdlReadWait; ULONG CcFastMdlReadNotPossible; @@ -414,7 +422,7 @@ CcPostDeferredWrites(VOID) } /* Check we can write */ - if (CcCanIWrite(DeferredWrite->FileObject, WrittenBytes, FALSE, TRUE)) + if (CcCanIWrite(DeferredWrite->FileObject, WrittenBytes, FALSE, RetryForceCheckPerFile)) { /* We can, so remove it from the list and stop looking for entry */ RemoveEntryList(&DeferredWrite->DeferredWriteLinks); @@ -614,9 +622,13 @@ CcCanIWrite ( IN BOOLEAN Wait, IN BOOLEAN Retrying) { + KIRQL OldIrql; KEVENT WaitEvent; + ULONG Length, Pages; + BOOLEAN PerFileDefer; DEFERRED_WRITE Context; PFSRTL_COMMON_FCB_HEADER Fcb; + CC_CAN_WRITE_RETRY TryContext; PROS_SHARED_CACHE_MAP SharedCacheMap; CCTRACE(CC_API_DEBUG, "FileObject=%p BytesToWrite=%lu Wait=%d Retrying=%d\n", @@ -628,53 +640,74 @@ CcCanIWrite ( return TRUE; } - /* We cannot write if dirty pages count is above threshold */ - if (CcTotalDirtyPages > CcDirtyPageThreshold) + TryContext = Retrying; + /* Allow remote file if not from posted */ + if (IoIsFileOriginRemote(FileObject) && TryContext < RetryAllowRemote) { - /* Can the caller wait till it's possible to write? */ - goto CanIWait; + return TRUE; } - /* We cannot write if dirty pages count will bring use above - * XXX: Might not be accurate - */ - if (CcTotalDirtyPages + (BytesToWrite / PAGE_SIZE) > CcDirtyPageThreshold) + /* Don't exceed max tolerated size */ + Length = MAX_ZERO_LENGTH; + if (BytesToWrite < MAX_ZERO_LENGTH) { - /* Can the caller wait till it's possible to write? */ - goto CanIWait; + Length = BytesToWrite; } - /* Is there a limit per file object? */ + /* Convert it to pages count */ + Pages = (Length + PAGE_SIZE - 1) >> PAGE_SHIFT; + + /* By default, assume limits per file won't be hit */ + PerFileDefer = FALSE; Fcb = FileObject->FsContext; - SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap; - if (!BooleanFlagOn(Fcb->Flags, FSRTL_FLAG_LIMIT_MODIFIED_PAGES) || - SharedCacheMap->DirtyPageThreshold == 0) + /* Do we have to check for limits per file? */ + if (TryContext >= RetryForceCheckPerFile || + BooleanFlagOn(Fcb->Flags, FSRTL_FLAG_LIMIT_MODIFIED_PAGES)) { - /* Nope, so that's fine, allow write operation */ - return TRUE; - } + /* If master is not locked, lock it now */ + if (TryContext != RetryMasterLocked) + { + OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock); + } - /* Is dirty page count above local threshold? */ - if (SharedCacheMap->DirtyPages > SharedCacheMap->DirtyPageThreshold) - { - /* Can the caller wait till it's possible to write? */ - goto CanIWait; + /* Let's not assume the file is cached... */ + if (FileObject->SectionObjectPointer != NULL && + FileObject->SectionObjectPointer->SharedCacheMap != NULL) + { + SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap; + /* Do we have limits per file set? */ + if (SharedCacheMap->DirtyPageThreshold != 0 && + SharedCacheMap->DirtyPages != 0) + { + /* Yes, check whether they are blocking */ + if (Pages + SharedCacheMap->DirtyPages > SharedCacheMap->DirtyPageThreshold) + { + PerFileDefer = TRUE; + } + } + } + + /* And don't forget to release master */ + if (TryContext != RetryMasterLocked) + { + KeReleaseQueuedSpinLock(LockQueueMasterLock, OldIrql); + } } - /* We cannot write if dirty pages count will bring use above - * XXX: Might not be accurate + /* So, now allow write if: + * - Not the first try or we have no throttling yet + * AND: + * - We don't execeed threshold! */ - if (SharedCacheMap->DirtyPages + (BytesToWrite / PAGE_SIZE) > SharedCacheMap->DirtyPageThreshold) + if ((TryContext != FirstTry || IsListEmpty(&CcDeferredWrites)) && + CcTotalDirtyPages + Pages < CcDirtyPageThreshold && + !PerFileDefer) { - /* Can the caller wait till it's possible to write? */ - goto CanIWait; + return TRUE; } - return TRUE; - -CanIWait: - /* If we reached that point, it means caller cannot write - * If he cannot wait, then fail and deny write + /* If we can wait, we'll start the wait loop for waiting till we can + * write for real */ if (!Wait) {

6 years, 10 months

01/01: [NTOSKRNL] Don't defer write through write operations

by Pierre Schweitzer

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=f51b74ca6111a93ea0835… commit f51b74ca6111a93ea08356fec0cbbd4bb7542e5a Author: Pierre Schweitzer <pierre(a)reactos.org> AuthorDate: Fri Feb 9 12:25:58 2018 +0100 Commit: Pierre Schweitzer <pierre(a)reactos.org> CommitDate: Fri Feb 9 12:25:58 2018 +0100 [NTOSKRNL] Don't defer write through write operations --- ntoskrnl/cc/copy.c | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/ntoskrnl/cc/copy.c b/ntoskrnl/cc/copy.c index 63ad5aeb11..4992ade290 100644 --- a/ntoskrnl/cc/copy.c +++ b/ntoskrnl/cc/copy.c @@ -622,6 +622,12 @@ CcCanIWrite ( CCTRACE(CC_API_DEBUG, "FileObject=%p BytesToWrite=%lu Wait=%d Retrying=%d\n", FileObject, BytesToWrite, Wait, Retrying); + /* Write through is always OK */ + if (BooleanFlagOn(FileObject->Flags, FO_WRITE_THROUGH)) + { + return TRUE; + } + /* We cannot write if dirty pages count is above threshold */ if (CcTotalDirtyPages > CcDirtyPageThreshold) {

6 years, 10 months

01/01: [NTOSKRNL] Quickly implement the !defwrites in KDBG

by Pierre Schweitzer

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=d35243d4e0bffb0edc071… commit d35243d4e0bffb0edc07150c550ff903ba4427d8 Author: Pierre Schweitzer <pierre(a)reactos.org> AuthorDate: Fri Feb 9 12:16:29 2018 +0100 Commit: Pierre Schweitzer <pierre(a)reactos.org> CommitDate: Fri Feb 9 12:16:29 2018 +0100 [NTOSKRNL] Quickly implement the !defwrites in KDBG --- ntoskrnl/cc/view.c | 26 ++++++++++++++++++++++++++ ntoskrnl/kdbg/kdb_cli.c | 2 ++ 2 files changed, 28 insertions(+) diff --git a/ntoskrnl/cc/view.c b/ntoskrnl/cc/view.c index 23bc5076e1..cf2645591c 100644 --- a/ntoskrnl/cc/view.c +++ b/ntoskrnl/cc/view.c @@ -1427,6 +1427,32 @@ ExpKdbgExtFileCache(ULONG Argc, PCHAR Argv[]) return TRUE; } + +BOOLEAN +ExpKdbgExtDefWrites(ULONG Argc, PCHAR Argv[]) +{ + KdbpPrint("CcTotalDirtyPages:\t%lu (%lu Kb)\n", CcTotalDirtyPages, + (CcTotalDirtyPages * PAGE_SIZE) / 1024); + KdbpPrint("CcDirtyPageThreshold:\t%lu (%lu Kb)\n", CcDirtyPageThreshold, + (CcDirtyPageThreshold * PAGE_SIZE) / 1024); + KdbpPrint("MmAvailablePages:\t%lu (%lu Kb)\n", MmAvailablePages, + (MmAvailablePages * PAGE_SIZE) / 1024); + + if (CcTotalDirtyPages >= CcDirtyPageThreshold) + { + KdbpPrint("CcTotalDirtyPages above the threshold, writes should be throttled\n"); + } + else if (CcTotalDirtyPages + 64 >= CcDirtyPageThreshold) + { + KdbpPrint("CcTotalDirtyPages within 64 (max charge) pages of the threshold, writes may be throttled\n"); + } + else + { + KdbpPrint("CcTotalDirtyPages below the threshold, writes should not be throttled\n"); + } + + return TRUE; +} #endif /* EOF */ diff --git a/ntoskrnl/kdbg/kdb_cli.c b/ntoskrnl/kdbg/kdb_cli.c index dfb01f4960..3fce1977d9 100644 --- a/ntoskrnl/kdbg/kdb_cli.c +++ b/ntoskrnl/kdbg/kdb_cli.c @@ -94,6 +94,7 @@ static BOOLEAN KdbpCmdDmesg(ULONG Argc, PCHAR Argv[]); BOOLEAN ExpKdbgExtPool(ULONG Argc, PCHAR Argv[]); BOOLEAN ExpKdbgExtPoolUsed(ULONG Argc, PCHAR Argv[]); BOOLEAN ExpKdbgExtFileCache(ULONG Argc, PCHAR Argv[]); +BOOLEAN ExpKdbgExtDefWrites(ULONG Argc, PCHAR Argv[]); #ifdef __ROS_DWARF__ static BOOLEAN KdbpCmdPrintStruct(ULONG Argc, PCHAR Argv[]); @@ -188,6 +189,7 @@ static const struct { "!pool", "!pool [Address [Flags]]", "Display information about pool allocations.", ExpKdbgExtPool }, { "!poolused", "!poolused [Flags [Tag]]", "Display pool usage.", ExpKdbgExtPoolUsed }, { "!filecache", "!filecache", "Display cache usage.", ExpKdbgExtFileCache }, + { "!defwrites", "!defwrites", "Display cache write values.", ExpKdbgExtDefWrites }, }; /* FUNCTIONS *****************************************************************/

6 years, 10 months

03/03: [NTOSKRNL] Drop the iSharedCacheMapLock in favor of the master lock

by Pierre Schweitzer

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,

6 years, 10 months

02/03: [NTOSKRNL] Silence lazy writer now we know it works

by Pierre Schweitzer

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! */

6 years, 10 months

01/03: [NTOSKRNL] Use better locking for private cache map in CcRosReleaseFileCache(). Suggested by Thomas

by Pierre Schweitzer

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)

6 years, 10 months

01/01: [NTOSKRNL] Bring an initial (and not perfect ; -)) implementation of read ahead to our Cc!

by Pierre Schweitzer

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;

6 years, 10 months

02/02: [RAPPS] Fix column sorting

by Alexander Shaposhnikov

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)

6 years, 10 months

01/02: [RAPPS] Set header style when sorting by column

by Alexander Shaposhnikov

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;

6 years, 10 months

← Newer
1
...
13
14
15
16
17
18
19
...
24
Older →

Jump to page:

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Ros-diffs February 2018