/*++ Copyright (c) 1992 Microsoft Corporation Module Name: Cc.c Abstract: WinDbg Extension Api for examining cache manager data structures Author: Keith Kaplan [KeithKa] 17-Apr-97 Environment: User Mode. Revision History: --*/ #include "precomp.h" #undef CREATE_NEW #undef OPEN_EXISTING #undef FlagOn #undef WordAlign #undef LongAlign #undef QuadAlign #pragma hdrstop // // DUMP_WITH_OFFSET -- for dumping values contained in structures. // #define DUMP_WITH_OFFSET(type, ptr, element, label) \ dprintf( "\n(%03x) %08x %s ", \ FIELD_OFFSET(type, element), \ ptr.element, \ label ) // // DUMP_LL_W_OFFSET -- for dumping longlongs contained in structures. // #define DUMP_LL_W_OFFSET(type, ptr, element, label) \ dprintf( "\n(%03x) %I64x %s ", \ FIELD_OFFSET(type, element), \ ptr.element, \ label ) // // DUMP_EMBW_OFFSET -- for dumping addresses of values embedded in structures. // #define DUMP_EMBW_OFFSET(type, ptr, element, label) \ dprintf( "\n(%03x) %08x %s ", \ FIELD_OFFSET(type, element), \ ptr + FIELD_OFFSET(type, element), \ label ) #define RM( Addr, Obj, pObj, Type, Result, label ) \ (pObj) = (Type) (Addr); \ if ( !ReadMemory( (DWORD) (pObj), &(Obj), sizeof( Obj ), &(Result)) ) { \ if (label) { \ dprintf( "Unable to read memory at %p (%s)\n", (pObj), (label) );\ } else { \ dprintf( "Unable to read memory at %p\n", (pObj) ); \ } \ return; \ } // // The help strings printed out // static LPSTR Extensions[] = { "Cache Manager Debugger Extensions:\n", "bcb [addr] Dump Buffer Control Block", "scm [addr] Dump Shared Cache Map", "finddata [FileObject Offset] Find cached data at given offset in file object", "defwrites Dump deferred write queue", 0 }; typedef PVOID (*STRUCT_DUMP_ROUTINE)( IN ULONG64 Address, IN LONG Options, USHORT Processor, HANDLE hCurrentThread ); VOID DumpBcb ( IN ULONG64 Address, IN LONG Options, USHORT Processor, HANDLE hCurrentThread ); VOID DumpPcm ( IN ULONG64 Address, IN LONG Options, USHORT Processor, HANDLE hCurrentThread ); VOID DumpScm ( IN ULONG64 Address, IN LONG Options, USHORT Processor, HANDLE hCurrentThread ); typedef struct { CSHORT TypeCode; char *Text; } MY_NODE_TYPE; static MY_NODE_TYPE NodeTypeCodes[] = { { CACHE_NTC_SHARED_CACHE_MAP, "Shared Cache Map" }, { CACHE_NTC_PRIVATE_CACHE_MAP, "Private Cache Map" }, { CACHE_NTC_BCB, "Bcb" }, { CACHE_NTC_DEFERRED_WRITE, "Deferred Write" }, { CACHE_NTC_MBCB, "Mbcb" }, { CACHE_NTC_OBCB, "Obcb" }, { CACHE_NTC_MBCB_GRANDE, "Mcb Grande" }, { 0, "Unknown" } }; static const char * TypeCodeGuess ( IN CSHORT TypeCode ) /*++ Routine Description: Guess at a structure's type code Arguments: TypeCode - Type code from the data structure Return Value: None --*/ { int i = 0; while (NodeTypeCodes[i].TypeCode != 0 && NodeTypeCodes[i].TypeCode != TypeCode) { i++; } return NodeTypeCodes[i].Text; } VOID DumpBcb ( IN ULONG64 Address, IN LONG Options, USHORT Processor, HANDLE hCurrentThread ) /*++ Routine Description: Dump a specific bcb. Arguments: Address - Gives the address of the bcb to dump Return Value: None --*/ { ULONG Result, NodeTypeCode; UNREFERENCED_PARAMETER( Options ); UNREFERENCED_PARAMETER( Processor ); UNREFERENCED_PARAMETER( hCurrentThread ); dprintf( "\n Bcb: %08p", Address ); if (GetFieldValue(Address, "BCB", "NodeTypeCode", NodeTypeCode) ) { dprintf("Unable to read BCB at %p.\n", Address); return; } // // Type of a bcb must be CACHE_NTC_BCB. // if (NodeTypeCode != CACHE_NTC_BCB) { dprintf( "\nBCB signature does not match, type code is %s", TypeCodeGuess((CSHORT) NodeTypeCode )); return; } else { dprintf("Use 'dt -n BCB %p' to dump BCB", Address); return; } #if 0 RM( Address, Bcb, pBcb, PBCB, Result, "Bcb" ); // // Before we get into too much trouble, make sure this looks like a bcb. // // // Type of a bcb must be CACHE_NTC_BCB. // if (Bcb.NodeTypeCode != CACHE_NTC_BCB) { dprintf( "\nBCB signature does not match, type code is %s", TypeCodeGuess( Bcb.NodeTypeCode )); return; } // // Having established that this looks like a bcb, let's dump the // interesting parts. // DUMP_WITH_OFFSET( BCB, Bcb, PinCount, "PinCount " ); DUMP_WITH_OFFSET( BCB, Bcb, ByteLength, "ByteLength " ); DUMP_LL_W_OFFSET( BCB, Bcb, FileOffset, "FileOffset " ); DUMP_LL_W_OFFSET( BCB, Bcb, BeyondLastByte, "BeyondLastByte " ); DUMP_LL_W_OFFSET( BCB, Bcb, OldestLsn, "OldestLsn " ); DUMP_LL_W_OFFSET( BCB, Bcb, NewestLsn, "NewestLsn " ); DUMP_WITH_OFFSET( BCB, Bcb, Vacb, "Vacb " ); DUMP_EMBW_OFFSET( BCB, Address, Resource, "Resource " ); DUMP_WITH_OFFSET( BCB, Bcb, SharedCacheMap, "SharedCacheMap " ); DUMP_WITH_OFFSET( BCB, Bcb, BaseAddress, "BaseAddress " ); if (Bcb.Dirty) { dprintf( "\n Dirty" ); } else { dprintf( "\n Not dirty" ); } dprintf( "\n" ); return; #endif } VOID DumpFindData ( IN ULONG64 FileObjectAddress, IN LONG ffset, USHORT Processor, HANDLE hCurrentThread ) /*++ Routine Description: Dump the cache contents for a given file object at the given offset. Arguments: FileObjectAddress - Gives the address of the file object to dump Offset - Gives the offset within the file to dump Return Value: None --*/ { ULONG Result; ULONG64 pFileObject; ULONG64 pScm; ULONG64 pSop; ULONG64 VacbAddr; // the address of the vacb ULONG64 *pVacbAddr; ULONG64 VacbAddrAddr; // the address of the address of the vacb ULONG64 pVacb; ULONG VacbNumber; ULONG OffsetWithinVacb; ULONG Level; ULONG Shift; ULONG OffsetForLevel; LONGLONG Offset = ffset; LONGLONG OriginalOffset = Offset; LONGLONG LevelMask; ULONG PtrSize = DBG_PTR_SIZE; ULONG Type, InVacbsOffset; ULONG64 SectionObjectPointer, SharedCacheMap, Vacbs, SectionSize_Quad; UNREFERENCED_PARAMETER( Processor ); UNREFERENCED_PARAMETER( hCurrentThread ); // // Before we get into too much trouble, make sure this looks like a FileObject or SCM. // if (GetFieldValue(FileObjectAddress, "FILE_OBJECT", "Type", Type)) { dprintf("Unable to read FILE_OBJECT at %p\n", FileObjectAddress); return; } // // Type must be IO_TYPE_FILE or a CACHE_NTC_SHARED_CACHE_MAP // if (Type != CACHE_NTC_SHARED_CACHE_MAP) { dprintf( "\n FindData for FileObject %08p", FileObjectAddress ); if (Type != IO_TYPE_FILE) { dprintf( "\nFILE_OBJECT type signature does not match, type code is %s", TypeCodeGuess((USHORT) Type )); return; } GetFieldValue(FileObjectAddress, "FILE_OBJECT", "SectionObjectPointer", SectionObjectPointer); dprintf( " Section Object Pointers: %08p", SectionObjectPointer ); if (GetFieldValue(SectionObjectPointer, "SECTION_OBJECT_POINTERS", "SharedCacheMap", SharedCacheMap)) { dprintf("Unable to read SECTION_OBJECT_POINTERS at %p\n", SectionObjectPointer); return; } dprintf( "\n Shared Cache Map: %08p", SharedCacheMap ); } else { dprintf( "\n FindData for SharedCacheMap %08p", FileObjectAddress ); SharedCacheMap = FileObjectAddress; } if (GetFieldValue(SharedCacheMap, "SHARED_CACHE_MAP", "Vacbs", Vacbs)) { dprintf("Unable to read SHARED_CACHE_MAP at %p\n", SharedCacheMap); return; } GetFieldValue(SharedCacheMap, "SHARED_CACHE_MAP", "SectionSize.QuadPart", SectionSize_Quad); OffsetWithinVacb = (((ULONG) Offset) & (VACB_MAPPING_GRANULARITY - 1)); GetFieldOffset("SHARED_CACHE_MAP", "InitialVacbs", &InVacbsOffset); dprintf( " File Offset: %I64x ", Offset ); if (Vacbs == (SharedCacheMap + InVacbsOffset)) { CHAR Buff[50]; // // Small file case -- we're using one of the Vacbs in the Shared Cache Map's // embedded array. // VacbNumber = (ULONG) (Offset >> VACB_OFFSET_SHIFT); if (VacbNumber >= PREALLOCATED_VACBS) { dprintf( "\nInvalid VacbNumber for resident Vacb" ); return; } sprintf(Buff, "InitialVacbs[%d]", VacbNumber); GetFieldValue(SharedCacheMap, "SHARED_CACHE_MAP", Buff, VacbAddr); dprintf( "in VACB number %x", VacbNumber ); } else if (SectionSize_Quad <= VACB_SIZE_OF_FIRST_LEVEL) { // // Medium file case -- we're using a single level (linear) structure to // store the Vacbs. // VacbNumber = (ULONG) (Offset >> VACB_OFFSET_SHIFT); VacbAddrAddr = Vacbs + (VacbNumber * PtrSize); if (!ReadPointer(VacbAddrAddr, &VacbAddr)) { dprintf("Unable to read at %p\n", VacbAddrAddr); return; } // RM( VacbAddrAddr, VacbAddr, pVacbAddr, PVOID, Result, "VACB array" ); dprintf( "in VACB number %x", VacbNumber ); } else { // // Large file case -- multilevel Vacb storage. // Level = 0; Shift = VACB_OFFSET_SHIFT + VACB_LEVEL_SHIFT; // // Loop to calculate how many levels we have and how much we have to // shift to index into the first level. // do { Level += 1; Shift += VACB_LEVEL_SHIFT; } while (SectionSize_Quad > ((ULONG64)1 << Shift)); // // Now descend the tree to the bottom level to get the caller's Vacb. // Shift -= VACB_LEVEL_SHIFT; // dprintf( "Shift: 0x%x\n", Shift ); OffsetForLevel = (ULONG) (Offset >> Shift); VacbAddrAddr = Vacbs + (OffsetForLevel * PtrSize); if (!ReadPointer(VacbAddrAddr, &VacbAddr)) { dprintf("Unable to read at %p\n", VacbAddrAddr); return; } while ((VacbAddr != 0) && (Level != 0)) { Level -= 1; Offset &= ((LONGLONG)1 << Shift) - 1; Shift -= VACB_LEVEL_SHIFT; // dprintf( "Shift: 0x%x\n", Shift ); OffsetForLevel = (ULONG) (Offset >> Shift); VacbAddrAddr = VacbAddr + (OffsetForLevel * PtrSize); if (!ReadPointer(VacbAddrAddr, &VacbAddr)) { dprintf("Unable to read at %p\n", VacbAddrAddr); return; } } } if (VacbAddr != 0) { ULONG64 Base; dprintf( "\n Vacb: %08p", VacbAddr ); if (GetFieldValue(VacbAddr, "VACB", "BaseAddress", Base)) { dprintf("Unable to read VACB at %p.", VacbAddr); return; } dprintf( "\n Your data is at: %08p", (Base + OffsetWithinVacb) ); } else { dprintf( "\n Data at offset %I64x not mapped", OriginalOffset ); } dprintf( "\n" ); return; } VOID DumpPcm ( IN ULONG64 Address, IN LONG Options, USHORT Processor, HANDLE hCurrentThread ) /*++ Routine Description: Dump a specific private cache map. Arguments: Address - Gives the address of the private cache map to dump Return Value: None --*/ { ULONG Result, NodeTypeCode; ULONG64 pPcm; UNREFERENCED_PARAMETER( Options ); UNREFERENCED_PARAMETER( Processor ); UNREFERENCED_PARAMETER( hCurrentThread ); dprintf( "\n Private cache map: %08p", Address ); if (GetFieldValue(Address, "PRIVATE_CACHE_MAP", "NodeTypeCode", NodeTypeCode)) { dprintf("Unable to read PRIVATE_CACHE_MAP at %p\n", Address); return; } // RM( Address, Pcm, pPcm, PPRIVATE_CACHE_MAP, Result, "PrivateCacheMap" ); // // Before we get into too much trouble, make sure this looks like a private cache map. // // // Type of a private cache map must be CACHE_NTC_PRIVATE_CACHE_MAP. // if (NodeTypeCode != CACHE_NTC_PRIVATE_CACHE_MAP) { dprintf( "\nPrivate cache map signature does not match, type code is %s", TypeCodeGuess( (USHORT) NodeTypeCode )); return; } else { dprintf("Use 'dt PRIVATE_CACHE_MAP %p' to dump PCM\n", Address); return; } #if 0 DUMP_WITH_OFFSET( PRIVATE_CACHE_MAP, Pcm, FileObject, "FileObject " ); DUMP_LL_W_OFFSET( PRIVATE_CACHE_MAP, Pcm, FileOffset1, "FileOffset1 " ); DUMP_LL_W_OFFSET( PRIVATE_CACHE_MAP, Pcm, BeyondLastByte1, "BeyondLastByte1 " ); DUMP_LL_W_OFFSET( PRIVATE_CACHE_MAP, Pcm, FileOffset2, "FileOffset2 " ); DUMP_LL_W_OFFSET( PRIVATE_CACHE_MAP, Pcm, BeyondLastByte2, "BeyondLastByte2 " ); DUMP_EMBW_OFFSET( PRIVATE_CACHE_MAP, Address, ReadAheadSpinLock, "ReadAheadSpinLock " ); DUMP_WITH_OFFSET( PRIVATE_CACHE_MAP, Pcm, ReadAheadMask, "ReadAheadMask " ); dprintf( "\n ReadAhead -- " ); if (Pcm.ReadAheadActive) { dprintf( "Active, " ); } else { dprintf( "Not active, " ); } if (Pcm.ReadAheadEnabled) { dprintf( "Enabled" ); } else { dprintf( "Not enabled" ); } dprintf( "\n" ); #endif return; } VOID DumpScm ( IN ULONG64 Address, IN LONG Options, USHORT Processor, HANDLE hCurrentThread ) /*++ Routine Description: Dump a specific shared cache map. Arguments: Address - Gives the address of the shared cache map to dump Return Value: None --*/ { ULONG Result, NodeTypeCode; ULONG64 pScm; UNREFERENCED_PARAMETER( Options ); UNREFERENCED_PARAMETER( Processor ); UNREFERENCED_PARAMETER( hCurrentThread ); dprintf( "\n Shared cache map: %08p", Address ); if (GetFieldValue(Address, "SHARED_CACHE_MAP", "NodeTypeCode", NodeTypeCode)) { dprintf("Unable to read SHARED_CACHE_MAP at %p\n", Address); return; } // RM( Address, Scm, pScm, PSHARED_CACHE_MAP, Result, "SharedCacheMap" ); // // Before we get into too much trouble, make sure this looks like a shared cache map. // // // Type of a shared cache map must be CACHE_NTC_SHARED_CACHE_MAP. // if (NodeTypeCode != CACHE_NTC_SHARED_CACHE_MAP) { dprintf( "\nShared cache map signature does not match, type code is %s", TypeCodeGuess( (USHORT) NodeTypeCode )); return; } else { dprintf("Use 'dt SHARED_CACHE_MAP %p' to dump PCM\n", Address); return; } #if 0 DUMP_WITH_OFFSET( SHARED_CACHE_MAP, Scm, OpenCount, "OpenCount " ); DUMP_LL_W_OFFSET( SHARED_CACHE_MAP, Scm, FileSize, "FileSize " ); DUMP_LL_W_OFFSET( SHARED_CACHE_MAP, Scm, SectionSize, "SectionSize " ); DUMP_LL_W_OFFSET( SHARED_CACHE_MAP, Scm, ValidDataLength, "ValidDataLength " ); DUMP_LL_W_OFFSET( SHARED_CACHE_MAP, Scm, ValidDataGoal, "ValidDataGoal " ); DUMP_WITH_OFFSET( SHARED_CACHE_MAP, Scm, FileObject, "FileObject " ); DUMP_WITH_OFFSET( SHARED_CACHE_MAP, Scm, ActiveVacb, "ActiveVacb " ); DUMP_WITH_OFFSET( SHARED_CACHE_MAP, Scm, ActivePage, "ActivePage " ); DUMP_WITH_OFFSET( SHARED_CACHE_MAP, Scm, NeedToZero, "NeedToZero " ); DUMP_WITH_OFFSET( SHARED_CACHE_MAP, Scm, NeedToZeroPage, "NeedToZeroPage " ); DUMP_EMBW_OFFSET( SHARED_CACHE_MAP, Address, ActiveVacbSpinLock, "ActiveVacbSpinLock " ); DUMP_WITH_OFFSET( SHARED_CACHE_MAP, Scm, VacbActiveCount, "VacbActiveCount " ); DUMP_WITH_OFFSET( SHARED_CACHE_MAP, Scm, Mbcb, "Mbcb " ); DUMP_WITH_OFFSET( SHARED_CACHE_MAP, Scm, DirtyPages, "DirtyPages " ); DUMP_WITH_OFFSET( SHARED_CACHE_MAP, Scm, Section, "Section " ); DUMP_WITH_OFFSET( SHARED_CACHE_MAP, Scm, Status, "Status " ); DUMP_WITH_OFFSET( SHARED_CACHE_MAP, Scm, CreateEvent, "CreateEvent " ); DUMP_WITH_OFFSET( SHARED_CACHE_MAP, Scm, WaitOnActiveCount, "WaitOnActiveCount " ); DUMP_WITH_OFFSET( SHARED_CACHE_MAP, Scm, PagesToWrite, "PagesToWrite " ); DUMP_LL_W_OFFSET( SHARED_CACHE_MAP, Scm, BeyondLastFlush, "BeyondLastFlush " ); DUMP_WITH_OFFSET( SHARED_CACHE_MAP, Scm, Callbacks, "Callbacks " ); DUMP_WITH_OFFSET( SHARED_CACHE_MAP, Scm, LazyWriteContext, "LazyWriteContext " ); DUMP_WITH_OFFSET( SHARED_CACHE_MAP, Scm, LogHandle, "LogHandle " ); DUMP_WITH_OFFSET( SHARED_CACHE_MAP, Scm, FlushToLsnRoutine, "FlushToLsnRoutine " ); DUMP_WITH_OFFSET( SHARED_CACHE_MAP, Scm, DirtyPageThreshold, "DirtyPageThreshold " ); DUMP_WITH_OFFSET( SHARED_CACHE_MAP, Scm, LazyWritePassCount, "LazyWritePassCount " ); DUMP_WITH_OFFSET( SHARED_CACHE_MAP, Scm, UninitializeEvent, "UninitializeEvent " ); DUMP_WITH_OFFSET( SHARED_CACHE_MAP, Scm, NeedToZeroVacb, "NeedToZeroVacb " ); DUMP_EMBW_OFFSET( SHARED_CACHE_MAP, Address, BcbSpinLock, "BcbSpinLock " ); DUMP_EMBW_OFFSET( SHARED_CACHE_MAP, Address, Event, "Event " ); DUMP_EMBW_OFFSET( SHARED_CACHE_MAP, Address, PrivateCacheMap, "PrivateCacheMap " ); dprintf( "\n" ); #endif return; } VOID DumpDeferredWrites ( IN ULONG64 Address, IN LONG Options, USHORT Processor, HANDLE hCurrentThread ) /*++ Routine Description: Dump a specific shared cache map. Arguments: Address - Gives the address of the shared cache map to dump Return Value: None --*/ { ULONG64 ListHeadAddr; ULONG Result; ULONG Temp; ULONG64 GlobalAddress; ULONG Value; ULONG64 CcTotalDirtyPages=0; ULONG64 CcDirtyPageThreshold=0; ULONG64 MmAvailablePages=0; ULONG64 MmThrottleTop=0; ULONG64 MmThrottleBottom=0; ULONG64 CcSingleDirtySourceDominant=0; ULONG64 CcDirtyPageHysteresisThreshold=0; ULONG64 Total; ULONG Offset; ULONG64 Flink; BOOLEAN CheckLazyWriter = FALSE; BOOLEAN CheckMappedPageWriter = FALSE; BOOLEAN CheckModifiedPageWriter = FALSE; UNREFERENCED_PARAMETER( Options ); UNREFERENCED_PARAMETER( Processor ); UNREFERENCED_PARAMETER( hCurrentThread ); UNREFERENCED_PARAMETER( Address ); dprintf( "*** Cache Write Throttle Analysis ***\n\n" ); CcTotalDirtyPages = GetUlongFromAddress( GlobalAddress = GetExpression( "nt!CcTotalDirtyPages" )); CcDirtyPageThreshold = GetUlongFromAddress( GlobalAddress = GetExpression( "nt!CcDirtyPageThreshold" )); if (GlobalAddress = GetExpression( "nt!CcDirtyPageHysteresisThreshold" )) { CcDirtyPageHysteresisThreshold = GetUlongFromAddress( GlobalAddress ); } else { // // Write hysteresis is new to Whistler. Assume that if the symbol or read fails // that we're dealing with a downlevel OS. // CcDirtyPageHysteresisThreshold = 0; } MmAvailablePages = GetUlongFromAddress( GlobalAddress = GetExpression( "nt!MmAvailablePages" )); MmThrottleTop = GetUlongFromAddress( GlobalAddress = GetExpression( "nt!MmThrottleTop" )); MmThrottleBottom = GetUlongFromAddress( GlobalAddress = GetExpression( "nt!MmThrottleBottom" )); if (GetFieldValue( GlobalAddress = GetExpression( "nt!MmModifiedPageListHead" ), "nt!_MMPFNLIST", "Total", Total)) { dprintf("Unable to read nt!_MMPFNLIST at %p\n", GlobalAddress); return; } if (!ReadPointer( GlobalAddress = GetExpression( "nt!CcSingleDirtySourceDominant" ), &CcSingleDirtySourceDominant)) { // // CcSingleDirtySourceDominant is present in newer builds only // if (GlobalAddress) { dprintf("Unable to read nt!CcSingleDirtySourceDominant at %p\n", GlobalAddress); return; } else { CcSingleDirtySourceDominant = 0; } } dprintf("\tCcTotalDirtyPages: %8u (%8u Kb)\n" "\tCcDirtyPageThreshold: %8u (%8u Kb)\n", (ULONG) CcTotalDirtyPages, (ULONG) CcTotalDirtyPages*_KB, (ULONG) CcDirtyPageThreshold, (ULONG) CcDirtyPageThreshold*_KB); if (CcDirtyPageHysteresisThreshold) { dprintf("\tCcDirtyPageHysteresisThreshold: %8u (%8u Kb)\n", (ULONG) CcDirtyPageHysteresisThreshold, (ULONG) CcDirtyPageHysteresisThreshold*_KB); } dprintf("\tMmAvailablePages: %8u (%8u Kb)\n" "\tMmThrottleTop: %8u (%8u Kb)\n" "\tMmThrottleBottom: %8u (%8u Kb)\n" "\tMmModifiedPageListHead.Total: %8u (%8u Kb)\n\n", (ULONG) MmAvailablePages, (ULONG) MmAvailablePages*_KB, (ULONG) MmThrottleTop, (ULONG) MmThrottleTop*_KB, (ULONG) MmThrottleBottom, (ULONG) MmThrottleBottom*_KB, (ULONG) Total, (ULONG) Total*_KB ); // // Cc element of the throttle. // if (CcDirtyPageHysteresisThreshold) { if (CcSingleDirtySourceDominant) { dprintf("Active write hysteresis with CcSingleDirtySourceDominant (%p)\n", CcSingleDirtySourceDominant); // // Split this up in the rare case where the transition is occuring. // if (CcTotalDirtyPages > CcDirtyPageHysteresisThreshold) { dprintf("CcTotalDirtyPages > CcDirtyPageHysteresisThreshold, writes may be throttled\n"); CheckLazyWriter = TRUE; } } } if (CcTotalDirtyPages < CcDirtyPageThreshold) { // From cc.h #define WRITE_CHARGE_THRESHOLD (64 * PageSize) if (CcTotalDirtyPages + (WRITE_CHARGE_THRESHOLD/PageSize) >= CcDirtyPageThreshold) { // // Fortunately, this is in pages, not bytes. The target's page size could be different. // dprintf("CcTotalDirtyPages within %u (max charge) pages of the threshold, writes\n" " may be throttled\n", (WRITE_CHARGE_THRESHOLD/PageSize)); CheckLazyWriter = TRUE; } } else { dprintf("CcTotalDirtyPages >= CcDirtyPageThreshold, writes throttled\n"); CheckLazyWriter = TRUE; } // // Mm element of the throttle. // if (MmAvailablePages <= MmThrottleTop) { if (MmAvailablePages <= MmThrottleBottom) { dprintf("MmAvailablePages <= MmThrottleTop,\n "); dprintf("and MmAvailablePages <= MmThrottleBottom, writes throttled\n "); CheckMappedPageWriter = TRUE; } if (Total >= 1000) { if (!CheckMappedPageWriter) { dprintf("MmAvailablePages <= MmThrottleTop,\n "); } dprintf("and modified page list >= 1000, writes throttled\n "); CheckModifiedPageWriter = TRUE; } } // // Suggest useful things. // if (CheckMappedPageWriter || CheckModifiedPageWriter || CheckLazyWriter) { dprintf("\nCheck these thread(s): "); if (CheckMappedPageWriter) { dprintf("MiMappedPageWriter "); } if (CheckModifiedPageWriter) { dprintf("MiModifiedPageWriter "); } if (CheckLazyWriter) { dprintf("CcWriteBehind(LazyWriter)"); } dprintf("\n"); if (CheckModifiedPageWriter || CheckMappedPageWriter) { dprintf("Check system process for the Mm page writers, !vm 3\n"); } if (CheckLazyWriter) { dprintf("Check critical workqueue for the lazy writer, !exqueue 16\n"); } } else { dprintf("Write throttles not engaged\n"); } ListHeadAddr = GetExpression( "nt!CcDeferredWrites" ); if (!ListHeadAddr) { dprintf( "Unable to get address of CcDeferredWrites\n" ); return; } GetFieldOffset("nt!_DEFERRED_WRITE", "DeferredWriteLinks", &Offset); if (GetFieldValue( ListHeadAddr - Offset, "nt!_DEFERRED_WRITE", "DeferredWriteLinks.Flink", Flink)) { dprintf( "Cannot read nt!_DEFERRED_WRITE at %p\n", ListHeadAddr - Offset); return; } if (Flink != ListHeadAddr) { ULONG64 Next, Event; dprintf("Cc Deferred Write list: (CcDeferredWrites)\n"); do { if (GetFieldValue( Flink - Offset, "nt!_DEFERRED_WRITE", "DeferredWriteLinks.Flink", Next)) { dprintf( "Cannot read nt!_DEFERRED_WRITE at %p\n", Flink - Offset); return; } InitTypeRead((Flink - Offset), nt!_DEFERRED_WRITE); dprintf( " File: %p ", ReadField(FileObject) ); if (Event = ReadField(Event)) { dprintf("Event: %p\n", Event ); } else { UCHAR Name[0x100]; ULONG64 Displacement, PostRoutine; GetSymbol( (PostRoutine = ReadField(PostRoutine)), Name, &Displacement ); dprintf("CallBack: %s (%p) ", Name, PostRoutine ); dprintf("Context1: %p ", ReadField(Context1) ); dprintf("Context2: %p\n", ReadField(Context2) ); } if (CheckControlC()) { break; } } while ( (Flink = Next) != ListHeadAddr ); dprintf( "\n" ); } return; } ULONG DumpBcbList ( IN PFIELD_INFO ListElement, IN PVOID Context ) /*++ Routine Description: Enumeration callback function for the bcblist Arguments: ListElement - Pointer to the containing record Context - Opaque context passed from the origination function Return Value: TRUE to discontinue the enumeration FALSE to continue the enumeration --*/ { ULONG Signature; ULONG PinCount = 0; ULONG Dirty = 0; LONGLONG Offset = 0; LONG Options = (LONG)(ULONG_PTR) Context; if (GetFieldValue( ListElement->address, "BCB", "NodeTypeCode", Signature )) { dprintf( "Unable to read bcb at 0x%I64x\n", ListElement->address ); } else { if (Signature == CACHE_NTC_BCB) { GetFieldValue( ListElement->address, "BCB", "PinCount", PinCount ); GetFieldValue( ListElement->address, "BCB", "Dirty", Dirty ); GetFieldValue( ListElement->address, "BCB", "FileOffset.QuadPart", Offset ); if ((Options != 0) || (PinCount != 0)) { dprintf( " Bcb: %p @ 0x%I64x PinCount: 0x%x Dirty: %x\n", ListElement->address, Offset, PinCount, Dirty ); } } } return FALSE; } VOID DumpLevel( ULONG64 Address, ULONG64 MaxSize, ULONG64 Offset, ULONG Options, ULONG Level, ULONG *Count, ULONG *CountActive ) /*++ Routine Description: Dump a vacb level recursively. Arguments: Address - Gives the address of the vacb level to dump MaxSize - the total section size Offset - Current offset within the section being dumped. Should be 0 for 1st caller Options - if non zero dump everything otherwise only dump referenced vacbs Level - how many levels of vacbs there are Count, CountActive - accumulators for counts of VACBs and active VACBs Return Value: None --*/ { int Index; ULONG PtrSize; ULONG64 SubAddress; ULONG64 Overlay = 0; ULONG64 Limit; ULONG64 Increment; USHORT ActiveCount; Limit = (MaxSize - Offset) >> VACB_OFFSET_SHIFT; if (Limit > (1< ((ULONG64)1 << Shift)) { Level += 1; Shift += VACB_LEVEL_SHIFT; } dprintf( "Levels %d\n", Level ); if (GetFieldValue( Address, "SHARED_CACHE_MAP", "VacbActiveCount", ActiveCount )) { dprintf( "Unable to read ActiveVacbCount at 0x%I64x\n", Address ); return; } dprintf("VacbActiveCount %u\n\n", ActiveCount ); // // Now spit out all of the Vacbs. // Count = ActiveCount = 0; DumpLevel( Vacbs, SectionSize, 0, Options, Level, &Count, &ActiveCount ); dprintf( "\n" ); dprintf( "Total VACBs %u Active %u\n", Count, ActiveCount ); if (GetFieldValue( Address, "SHARED_CACHE_MAP", "BcbList.Flink", FirstBcb )) { dprintf( "Unable to read bcblist at 0x%I64x\n", Address ); return; } ListType( "SHARED_CACHE_MAP", FirstBcb, 1, "BcbList.Flink", (PVOID)(ULONG_PTR) Options, DumpBcbList ); return; } // // Entry points, parameter parsers, etc. below // static VOID ParseAndDump ( IN PCHAR args, IN STRUCT_DUMP_ROUTINE DumpFunction, USHORT Processor, HANDLE hCurrentThread ) /*++ Routine Description: Parse command line arguments and dump an ntfs structure. Arguments: Args - String of arguments to parse. DumpFunction - Function to call with parsed arguments. Return Value: %u None --*/ { ULONG64 StructToDump; LONG Options; LPSTR arg2 = args; // // If the caller specified an address then that's the item we dump // StructToDump = 0; Options = 0; if (GetExpressionEx(args,&StructToDump, &args )) { Options = (ULONG)GetExpression( args ); } #ifdef CDAVIS_DEBUG if (!StructToDump){ dprintf("unable to get expression %s\n",arg2); return; } #endif (*DumpFunction) ( StructToDump, Options, Processor, hCurrentThread ); dprintf( "\n" ); return; } static VOID PrintHelp ( VOID ) /*++ Routine Description: Dump out one line of help for each DECLARE_API Arguments: None Return Value: None --*/ { int i; for( i=0; Extensions[i]; i++ ) dprintf( " %s\n", Extensions[i] ); } DECLARE_API( bcb ) /*++ Routine Description: Dump bcb struct Arguments: arg - [Address] [options] Return Value: None --*/ { ULONG dwProcessor; HANDLE hCurrentThread; if (!GetCurrentProcessor(Client, &dwProcessor, &hCurrentThread)) { dwProcessor = 0; hCurrentThread = 0; } ParseAndDump( (PCHAR) args, (STRUCT_DUMP_ROUTINE) DumpBcb, (USHORT)dwProcessor, hCurrentThread ); return S_OK; } DECLARE_API( cchelp ) /*++ Routine Description: Dump help message Arguments: None Return Value: None --*/ { PrintHelp(); return S_OK; } DECLARE_API( finddata ) /*++ Routine Description: Dump bcb struct Arguments: arg - [Address] [options] Return Value: None --*/ { ULONG dwProcessor; HANDLE hCurrentThread; if (!GetCurrentProcessor(Client, &dwProcessor, &hCurrentThread)) { dwProcessor = 0; hCurrentThread = 0; } ParseAndDump( (PCHAR) args, (STRUCT_DUMP_ROUTINE) DumpFindData, (USHORT)dwProcessor, hCurrentThread ); return S_OK; } DECLARE_API( pcm ) /*++ Routine Description: Dump private cache map struct Arguments: arg - [Address] [options] Return Value: None --*/ { ULONG dwProcessor; HANDLE hCurrentThread; if (!GetCurrentProcessor(Client, &dwProcessor, &hCurrentThread)) { dwProcessor = 0; hCurrentThread = 0; } ParseAndDump( (PCHAR) args, (STRUCT_DUMP_ROUTINE) DumpPcm, (USHORT)dwProcessor, hCurrentThread ); return S_OK; } DECLARE_API( scm ) /*++ Routine Description: Dump shared cache map struct Arguments: arg - [Address] [options] Return Value: None --*/ { ULONG dwProcessor; HANDLE hCurrentThread; if (!GetCurrentProcessor(Client, &dwProcessor, &hCurrentThread)) { dwProcessor = 0; hCurrentThread = 0; } ParseAndDump( (PCHAR) args, (STRUCT_DUMP_ROUTINE) DumpScm, (USHORT)dwProcessor, hCurrentThread ); return S_OK; } DECLARE_API( defwrites ) /*++ Routine Description: Dump deferred write queue Arguments: arg - [Address] [options] Return Value: None --*/ { ULONG dwProcessor; HANDLE hCurrentThread; if (!GetCurrentProcessor(Client, &dwProcessor, &hCurrentThread)) { dwProcessor = 0; hCurrentThread = 0; } ParseAndDump( (PCHAR) args, (STRUCT_DUMP_ROUTINE) DumpDeferredWrites, (USHORT)dwProcessor, hCurrentThread ); return S_OK; } DECLARE_API( openmaps ) /*++ Routine Description: Find referenced bcbs and vacbs in a cache map Arguments: arg - [Shared cache map address] Return Value: None --*/ { ULONG dwProcessor; HANDLE hCurrentThread; if (!GetCurrentProcessor(Client, &dwProcessor, &hCurrentThread)) { dwProcessor = 0; hCurrentThread = 0; } ParseAndDump( (PCHAR) args, (STRUCT_DUMP_ROUTINE) DumpOpenMaps, (USHORT)dwProcessor, hCurrentThread ); return S_OK; }