/*++

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 > (((ULONG64) 1) << VACB_LEVEL_SHIFT) ) {
        Limit = (((ULONG64) 1) << VACB_LEVEL_SHIFT);
    }

    Increment = ((ULONG64) 1) << ((VACB_LEVEL_SHIFT * (Level - 1)) + VACB_OFFSET_SHIFT );

    PtrSize = DBG_PTR_SIZE;

    for (Index=0; Index < Limit; Index++ ) {

        if (!ReadPointer( Address + PtrSize * Index, &SubAddress )) {
            dprintf( "Unable to read subaddress at 0x%I64x\n", Address + PtrSize * Index );
            return;
        }

        if (SubAddress != 0) {

            if (Level == 1) {

                *Count = *Count + 1;

                if (GetFieldValue(SubAddress, "VACB", "Overlay.FileOffset.QuadPart", Overlay)) {
                    dprintf( "Unable to read overlay at %p\n", SubAddress );
                    return;
                }

                //
                //  If verbose print all vacbs o.w. print any vacbs with reference count
                //

                ActiveCount = (USHORT) (Overlay & 0xFFFF);

                if (ActiveCount != 0) {

                    *CountActive = *CountActive + 1;
                }

                if (ActiveCount != 0 || Options != 0) {
                    dprintf( "%16I64x ActiveCount %u @ Vacb %p\n", (Overlay & ~(0xFFFF)), ActiveCount, SubAddress );
                }

            } else {

                DumpLevel( SubAddress, MaxSize, Offset + Increment * Index, Options, Level - 1, Count, CountActive );
            }
        }
    }
}



VOID
DumpOpenMaps (
    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 FirstBcb;
    ULONGLONG SectionSize;
    LONG Level;
    LONG Shift;
    ULONG64 Vacbs;
    ULONG ActiveCount = 0, Count = 0;

    UNREFERENCED_PARAMETER( Options );
    UNREFERENCED_PARAMETER( Processor );
    UNREFERENCED_PARAMETER( hCurrentThread );
    UNREFERENCED_PARAMETER( Address );

    dprintf( "SharedCacheMap  %p\n", Address );

    //
    //  First look for mapped vacbs
    //

    if (GetFieldValue( Address, "SHARED_CACHE_MAP", "SectionSize.QuadPart", SectionSize )) {
        dprintf( "Unable to read sectionsize at 0x%I64x\n", Address );
        return;
    }

    if (GetFieldValue( Address, "SHARED_CACHE_MAP", "Vacbs", Vacbs )) {
        dprintf( "Unable to read vacbs at 0x%I64x\n", Address );
        return;
    }

    dprintf( "Section Size    %I64x\n", SectionSize );

    //
    //  Large file case -- multilevel Vacb storage.
    //

    Level = 0;
    Shift = VACB_OFFSET_SHIFT;

    //
    //  Loop to calculate how many levels we have and how much we have to
    //  shift to index into the first level.
    //

    while (SectionSize > ((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;
}