cache.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	CACHE_BLOCK
struct	CACHE_DRIVE

Macros
#define	TAG_CACHE_DATA   'DcaC'
#define	TAG_CACHE_BLOCK   'BcaC'

Typedefs
typedef struct CACHE_BLOCK *	PCACHE_BLOCK
typedef struct CACHE_DRIVE *	PCACHE_DRIVE

Functions
PCACHE_BLOCK	CacheInternalGetBlockPointer (PCACHE_DRIVE CacheDrive, ULONG BlockNumber)
PCACHE_BLOCK	CacheInternalFindBlock (PCACHE_DRIVE CacheDrive, ULONG BlockNumber)
PCACHE_BLOCK	CacheInternalAddBlockToCache (PCACHE_DRIVE CacheDrive, ULONG BlockNumber)
BOOLEAN	CacheInternalFreeBlock (PCACHE_DRIVE CacheDrive)
VOID	CacheInternalCheckCacheSizeLimits (PCACHE_DRIVE CacheDrive)
VOID	CacheInternalDumpBlockList (PCACHE_DRIVE CacheDrive)
VOID	CacheInternalOptimizeBlockList (PCACHE_DRIVE CacheDrive, PCACHE_BLOCK CacheBlock)
BOOLEAN	CacheInitializeDrive (UCHAR DriveNumber)
VOID	CacheInvalidateCacheData (VOID)
BOOLEAN	CacheReadDiskSectors (UCHAR DiskNumber, ULONGLONG StartSector, ULONG SectorCount, PVOID Buffer)
BOOLEAN	CacheForceDiskSectorsIntoCache (UCHAR DiskNumber, ULONGLONG StartSector, ULONG SectorCount)
BOOLEAN	CacheReleaseMemory (ULONG MinimumAmountToRelease)

Variables
CACHE_DRIVE	CacheManagerDrive
BOOLEAN	CacheManagerInitialized
ULONG	CacheBlockCount
SIZE_T	CacheSizeLimit
SIZE_T	CacheSizeCurrent

Macro Definition Documentation

TAG_CACHE_BLOCK

#define TAG_CACHE_BLOCK   'BcaC'

Definition at line 24 of file cache.h.

TAG_CACHE_DATA

#define TAG_CACHE_DATA   'DcaC'

Definition at line 23 of file cache.h.

Typedef Documentation

PCACHE_BLOCK

typedef struct CACHE_BLOCK * PCACHE_BLOCK

PCACHE_DRIVE

typedef struct CACHE_DRIVE * PCACHE_DRIVE

Function Documentation

CacheForceDiskSectorsIntoCache()

BOOLEAN CacheForceDiskSectorsIntoCache	(	UCHAR	DiskNumber,
		ULONGLONG	StartSector,
		ULONG	SectorCount
	)

CacheInitializeDrive()

BOOLEAN CacheInitializeDrive

(

UCHAR

DriveNumber

)

Definition at line 37 of file cache.c.

{
    PCACHE_BLOCK    NextCacheBlock;
    GEOMETRY    DriveGeometry;
 
    // If we already have a cache for this drive then
    // by all means lets keep it, unless it is a removable
    // drive, in which case we'll invalidate the cache
    if ((CacheManagerInitialized) &&
        (DriveNumber == CacheManagerDrive.DriveNumber) &&
        (DriveNumber >= 0x80) &&
        (!CacheManagerDataInvalid))
    {
        return TRUE;
    }
 
    CacheManagerDataInvalid = FALSE;
 
    //
    // If we have already been initialized then free
    // the old data
    //
    if (CacheManagerInitialized)
    {
        CacheManagerInitialized = FALSE;
 
        TRACE("CacheBlockCount: %d\n", CacheBlockCount);
        TRACE("CacheSizeLimit: %d\n", CacheSizeLimit);
        TRACE("CacheSizeCurrent: %d\n", CacheSizeCurrent);
        //
        // Loop through and free the cache blocks
        //
        while (!IsListEmpty(&CacheManagerDrive.CacheBlockHead))
        {
            NextCacheBlock = CONTAINING_RECORD(RemoveHeadList(&CacheManagerDrive.CacheBlockHead),
                                               CACHE_BLOCK,
                                               ListEntry);
 
            FrLdrTempFree(NextCacheBlock->BlockData, TAG_CACHE_DATA);
            FrLdrTempFree(NextCacheBlock, TAG_CACHE_BLOCK);
        }
    }
 
    // Initialize the structure
    RtlZeroMemory(&CacheManagerDrive, sizeof(CACHE_DRIVE));
    InitializeListHead(&CacheManagerDrive.CacheBlockHead);
    CacheManagerDrive.DriveNumber = DriveNumber;
    if (!MachDiskGetDriveGeometry(DriveNumber, &DriveGeometry))
    {
        return FALSE;
    }
    CacheManagerDrive.BytesPerSector = DriveGeometry.BytesPerSector;
 
    // Get the number of sectors in each cache block
    CacheManagerDrive.BlockSize = MachDiskGetCacheableBlockCount(DriveNumber);
 
    CacheBlockCount = 0;
    CacheSizeCurrent = 0;
    CacheSizeLimit = TotalPagesInLookupTable / 8 * MM_PAGE_SIZE;
    CacheSizeLimit = min(CacheSizeLimit, TEMP_HEAP_SIZE - (128 * 1024));
 
    CacheManagerInitialized = TRUE;
 
    TRACE("Initializing BIOS drive 0x%x.\n", DriveNumber);
    TRACE("BytesPerSector: %d.\n", CacheManagerDrive.BytesPerSector);
    TRACE("BlockSize: %d.\n", CacheManagerDrive.BlockSize);
    TRACE("CacheSizeLimit: %d.\n", CacheSizeLimit);
 
    return TRUE;
}

Referenced by ExtOpenVolume().

CacheInternalAddBlockToCache()

PCACHE_BLOCK CacheInternalAddBlockToCache	(	PCACHE_DRIVE	CacheDrive,
		ULONG	BlockNumber
	)

Definition at line 91 of file blocklist.c.

{
    PCACHE_BLOCK    CacheBlock = NULL;
 
    TRACE("CacheInternalAddBlockToCache() BlockNumber = %d\n", BlockNumber);
 
    // Check the size of the cache so we don't exceed our limits
    CacheInternalCheckCacheSizeLimits(CacheDrive);
 
    // We will need to add the block to the
    // drive's list of cached blocks. So allocate
    // the block memory.
    CacheBlock = FrLdrTempAlloc(sizeof(CACHE_BLOCK), TAG_CACHE_BLOCK);
    if (CacheBlock == NULL)
    {
        return NULL;
    }
 
    // Now initialize the structure and
    // allocate room for the block data
    RtlZeroMemory(CacheBlock, sizeof(CACHE_BLOCK));
    CacheBlock->BlockNumber = BlockNumber;
    CacheBlock->BlockData = FrLdrTempAlloc(CacheDrive->BlockSize * CacheDrive->BytesPerSector,
                                           TAG_CACHE_DATA);
    if (CacheBlock->BlockData ==NULL)
    {
        FrLdrTempFree(CacheBlock, TAG_CACHE_BLOCK);
        return NULL;
    }
 
    // Now try to read in the block
    if (!MachDiskReadLogicalSectors(CacheDrive->DriveNumber, (BlockNumber * CacheDrive->BlockSize), CacheDrive->BlockSize, DiskReadBuffer))
    {
        FrLdrTempFree(CacheBlock->BlockData, TAG_CACHE_DATA);
        FrLdrTempFree(CacheBlock, TAG_CACHE_BLOCK);
        return NULL;
    }
    RtlCopyMemory(CacheBlock->BlockData, DiskReadBuffer, CacheDrive->BlockSize * CacheDrive->BytesPerSector);
 
    // Add it to our list of blocks managed by the cache
    InsertTailList(&CacheDrive->CacheBlockHead, &CacheBlock->ListEntry);
 
    // Update the cache data
    CacheBlockCount++;
    CacheSizeCurrent = CacheBlockCount * (CacheDrive->BlockSize * CacheDrive->BytesPerSector);
 
    CacheInternalDumpBlockList(CacheDrive);
 
    return CacheBlock;
}

Referenced by CacheInternalGetBlockPointer().

CacheInternalCheckCacheSizeLimits()

VOID CacheInternalCheckCacheSizeLimits

(

PCACHE_DRIVE

CacheDrive

)

Definition at line 177 of file blocklist.c.

{
    SIZE_T        NewCacheSize;
 
    TRACE("CacheInternalCheckCacheSizeLimits()\n");
 
    // Calculate the size of the cache if we added a block
    NewCacheSize = (CacheBlockCount + 1) * (CacheDrive->BlockSize * CacheDrive->BytesPerSector);
 
    // Check the new size against the cache size limit
    if (NewCacheSize > CacheSizeLimit)
    {
        CacheInternalFreeBlock(CacheDrive);
        CacheInternalDumpBlockList(CacheDrive);
    }
}

Referenced by CacheInternalAddBlockToCache().

CacheInternalDumpBlockList()

VOID CacheInternalDumpBlockList

(

PCACHE_DRIVE

CacheDrive

)

Definition at line 194 of file blocklist.c.

{
    PCACHE_BLOCK    CacheBlock;
 
    TRACE("Dumping block list for BIOS drive 0x%x.\n", CacheDrive->DriveNumber);
    TRACE("BytesPerSector: %d.\n", CacheDrive->BytesPerSector);
    TRACE("BlockSize: %d.\n", CacheDrive->BlockSize);
    TRACE("CacheSizeLimit: %d.\n", CacheSizeLimit);
    TRACE("CacheSizeCurrent: %d.\n", CacheSizeCurrent);
    TRACE("CacheBlockCount: %d.\n", CacheBlockCount);
 
    CacheBlock = CONTAINING_RECORD(CacheDrive->CacheBlockHead.Flink, CACHE_BLOCK, ListEntry);
    while (&CacheBlock->ListEntry != &CacheDrive->CacheBlockHead)
    {
        TRACE("Cache Block: CacheBlock: 0x%x\n", CacheBlock);
        TRACE("Cache Block: Block Number: %d\n", CacheBlock->BlockNumber);
        TRACE("Cache Block: Access Count: %d\n", CacheBlock->AccessCount);
        TRACE("Cache Block: Block Data: 0x%x\n", CacheBlock->BlockData);
        TRACE("Cache Block: Locked In Cache: %d\n", CacheBlock->LockedInCache);
 
        if (CacheBlock->BlockData == NULL)
        {
            BugCheck("CacheBlock->BlockData == NULL\n");
        }
 
        CacheBlock = CONTAINING_RECORD(CacheBlock->ListEntry.Flink, CACHE_BLOCK, ListEntry);
    }
}

Referenced by CacheInternalAddBlockToCache(), and CacheInternalCheckCacheSizeLimits().

CacheInternalFindBlock()

PCACHE_BLOCK CacheInternalFindBlock	(	PCACHE_DRIVE	CacheDrive,
		ULONG	BlockNumber
	)

Definition at line 53 of file blocklist.c.

{
    PCACHE_BLOCK    CacheBlock = NULL;
 
    TRACE("CacheInternalFindBlock() BlockNumber = %d\n", BlockNumber);
 
    //
    // Make sure the block list has entries before I start searching it.
    //
    if (!IsListEmpty(&CacheDrive->CacheBlockHead))
    {
        //
        // Search the list and find the BIOS drive number
        //
        CacheBlock = CONTAINING_RECORD(CacheDrive->CacheBlockHead.Flink, CACHE_BLOCK, ListEntry);
 
        while (&CacheBlock->ListEntry != &CacheDrive->CacheBlockHead)
        {
            //
            // We found the block, so return it
            //
            if (CacheBlock->BlockNumber == BlockNumber)
            {
                //
                // Increment the blocks access count
                //
                CacheBlock->AccessCount++;
 
                return CacheBlock;
            }
 
            CacheBlock = CONTAINING_RECORD(CacheBlock->ListEntry.Flink, CACHE_BLOCK, ListEntry);
        }
    }
 
    return NULL;
}

Referenced by CacheInternalGetBlockPointer().

CacheInternalFreeBlock()

BOOLEAN CacheInternalFreeBlock

(

PCACHE_DRIVE

CacheDrive

)

Definition at line 142 of file blocklist.c.

{
    PCACHE_BLOCK    CacheBlockToFree;
 
    TRACE("CacheInternalFreeBlock()\n");
 
    // Get a pointer to the last item in the block list
    // that isn't forced to be in the cache and remove
    // it from the list
    CacheBlockToFree = CONTAINING_RECORD(CacheDrive->CacheBlockHead.Blink, CACHE_BLOCK, ListEntry);
    while (&CacheBlockToFree->ListEntry != &CacheDrive->CacheBlockHead && CacheBlockToFree->LockedInCache)
    {
        CacheBlockToFree = CONTAINING_RECORD(CacheBlockToFree->ListEntry.Blink, CACHE_BLOCK, ListEntry);
    }
 
    // No blocks left in cache that can be freed
    // so just return
    if (IsListEmpty(&CacheDrive->CacheBlockHead))
    {
        return FALSE;
    }
 
    RemoveEntryList(&CacheBlockToFree->ListEntry);
 
    // Free the block memory and the block structure
    FrLdrTempFree(CacheBlockToFree->BlockData, TAG_CACHE_DATA);
    FrLdrTempFree(CacheBlockToFree, TAG_CACHE_BLOCK);
 
    // Update the cache data
    CacheBlockCount--;
    CacheSizeCurrent = CacheBlockCount * (CacheDrive->BlockSize * CacheDrive->BytesPerSector);
 
    return TRUE;
}

Referenced by CacheInternalCheckCacheSizeLimits(), and CacheReleaseMemory().

CacheInternalGetBlockPointer()

PCACHE_BLOCK CacheInternalGetBlockPointer	(	PCACHE_DRIVE	CacheDrive,
		ULONG	BlockNumber
	)

Definition at line 28 of file blocklist.c.

{
    PCACHE_BLOCK    CacheBlock = NULL;
 
    TRACE("CacheInternalGetBlockPointer() BlockNumber = %d\n", BlockNumber);
 
    CacheBlock = CacheInternalFindBlock(CacheDrive, BlockNumber);
 
    if (CacheBlock != NULL)
    {
        TRACE("Cache hit! BlockNumber: %d CacheBlock->BlockNumber: %d\n", BlockNumber, CacheBlock->BlockNumber);
 
        return CacheBlock;
    }
 
    TRACE("Cache miss! BlockNumber: %d\n", BlockNumber);
 
    CacheBlock = CacheInternalAddBlockToCache(CacheDrive, BlockNumber);
 
    // Optimize the block list so it has a LRU structure
    CacheInternalOptimizeBlockList(CacheDrive, CacheBlock);
 
    return CacheBlock;
}

Referenced by CacheReadDiskSectors().

CacheInternalOptimizeBlockList()

VOID CacheInternalOptimizeBlockList	(	PCACHE_DRIVE	CacheDrive,
		PCACHE_BLOCK	CacheBlock
	)

Definition at line 223 of file blocklist.c.

{
 
    TRACE("CacheInternalOptimizeBlockList()\n");
 
    // Don't do this if this block is already at the head of the list
    if (&CacheBlock->ListEntry != CacheDrive->CacheBlockHead.Flink)
    {
        // Remove this item from the block list
        RemoveEntryList(&CacheBlock->ListEntry);
 
        // Re-insert it at the head of the list
        InsertHeadList(&CacheDrive->CacheBlockHead, &CacheBlock->ListEntry);
    }
}

Referenced by CacheInternalGetBlockPointer().

CacheInvalidateCacheData()

VOID CacheInvalidateCacheData

(

VOID

)

Definition at line 108 of file cache.c.

{
    CacheManagerDataInvalid = TRUE;
}

CacheReadDiskSectors()

BOOLEAN CacheReadDiskSectors	(	UCHAR	DiskNumber,
		ULONGLONG	StartSector,
		ULONG	SectorCount,
		PVOID	Buffer
	)

Definition at line 113 of file cache.c.

{
    PCACHE_BLOCK    CacheBlock;
    ULONG                StartBlock;
    ULONG                SectorOffsetInStartBlock;
    ULONG                CopyLengthInStartBlock;
    ULONG                EndBlock;
    ULONG                SectorOffsetInEndBlock;
    ULONG                BlockCount;
    ULONG                Idx;
 
    TRACE("CacheReadDiskSectors() DiskNumber: 0x%x StartSector: %I64u SectorCount: %u Buffer: 0x%x\n", DiskNumber, StartSector, SectorCount, Buffer);
 
    // If we aren't initialized yet then they can't do this
    if (CacheManagerInitialized == FALSE)
    {
        return FALSE;
    }
 
    //
    // Calculate which blocks we must cache
    //
    StartBlock = (ULONG)(StartSector / CacheManagerDrive.BlockSize);
    SectorOffsetInStartBlock = (ULONG)(StartSector % CacheManagerDrive.BlockSize);
    CopyLengthInStartBlock = (ULONG)((SectorCount > (CacheManagerDrive.BlockSize - SectorOffsetInStartBlock)) ? (CacheManagerDrive.BlockSize - SectorOffsetInStartBlock) : SectorCount);
    EndBlock = (ULONG)((StartSector + (SectorCount - 1)) / CacheManagerDrive.BlockSize);
    SectorOffsetInEndBlock = (ULONG)(1 + (StartSector + (SectorCount - 1)) % CacheManagerDrive.BlockSize);
    BlockCount = (EndBlock - StartBlock) + 1;
    TRACE("StartBlock: %d SectorOffsetInStartBlock: %d CopyLengthInStartBlock: %d EndBlock: %d SectorOffsetInEndBlock: %d BlockCount: %d\n", StartBlock, SectorOffsetInStartBlock, CopyLengthInStartBlock, EndBlock, SectorOffsetInEndBlock, BlockCount);
 
    //
    // Read the first block into the buffer
    //
    if (BlockCount > 0)
    {
        //
        // Get cache block pointer (this forces the disk sectors into the cache memory)
        //
        CacheBlock = CacheInternalGetBlockPointer(&CacheManagerDrive, StartBlock);
        if (CacheBlock == NULL)
        {
            return FALSE;
        }
 
        //
        // Copy the portion requested into the buffer
        //
        RtlCopyMemory(Buffer,
            (PVOID)((ULONG_PTR)CacheBlock->BlockData + (SectorOffsetInStartBlock * CacheManagerDrive.BytesPerSector)),
            (CopyLengthInStartBlock * CacheManagerDrive.BytesPerSector));
        TRACE("1 - RtlCopyMemory(0x%x, 0x%x, %d)\n", Buffer, ((ULONG_PTR)CacheBlock->BlockData + (SectorOffsetInStartBlock * CacheManagerDrive.BytesPerSector)), (CopyLengthInStartBlock * CacheManagerDrive.BytesPerSector));
 
        //
        // Update the buffer address
        //
        Buffer = (PVOID)((ULONG_PTR)Buffer + (CopyLengthInStartBlock * CacheManagerDrive.BytesPerSector));
 
        //
        // Update the block count
        //
        BlockCount--;
    }
 
    //
    // Loop through the middle blocks and read them into the buffer
    //
    for (Idx=StartBlock+1; BlockCount>1; Idx++)
    {
        //
        // Get cache block pointer (this forces the disk sectors into the cache memory)
        //
        CacheBlock = CacheInternalGetBlockPointer(&CacheManagerDrive, Idx);
        if (CacheBlock == NULL)
        {
            return FALSE;
        }
 
        //
        // Copy the portion requested into the buffer
        //
        RtlCopyMemory(Buffer,
            CacheBlock->BlockData,
            CacheManagerDrive.BlockSize * CacheManagerDrive.BytesPerSector);
        TRACE("2 - RtlCopyMemory(0x%x, 0x%x, %d)\n", Buffer, CacheBlock->BlockData, CacheManagerDrive.BlockSize * CacheManagerDrive.BytesPerSector);
 
        //
        // Update the buffer address
        //
        Buffer = (PVOID)((ULONG_PTR)Buffer + (CacheManagerDrive.BlockSize * CacheManagerDrive.BytesPerSector));
 
        //
        // Update the block count
        //
        BlockCount--;
    }
 
    //
    // Read the last block into the buffer
    //
    if (BlockCount > 0)
    {
        //
        // Get cache block pointer (this forces the disk sectors into the cache memory)
        //
        CacheBlock = CacheInternalGetBlockPointer(&CacheManagerDrive, EndBlock);
        if (CacheBlock == NULL)
        {
            return FALSE;
        }
 
        //
        // Copy the portion requested into the buffer
        //
        RtlCopyMemory(Buffer,
            CacheBlock->BlockData,
            SectorOffsetInEndBlock * CacheManagerDrive.BytesPerSector);
        TRACE("3 - RtlCopyMemory(0x%x, 0x%x, %d)\n", Buffer, CacheBlock->BlockData, SectorOffsetInEndBlock * CacheManagerDrive.BytesPerSector);
 
        //
        // Update the buffer address
        //
        Buffer = (PVOID)((ULONG_PTR)Buffer + (SectorOffsetInEndBlock * CacheManagerDrive.BytesPerSector));
 
        //
        // Update the block count
        //
        BlockCount--;
    }
 
    return TRUE;
}

Referenced by ExtReadVolumeSectors().

CacheReleaseMemory()

BOOLEAN CacheReleaseMemory

(

ULONG

MinimumAmountToRelease

)

Definition at line 293 of file cache.c.

{
    ULONG                AmountReleased;
 
    TRACE("CacheReleaseMemory() MinimumAmountToRelease = %d\n", MinimumAmountToRelease);
 
    // If we aren't initialized yet then they can't do this
    if (CacheManagerInitialized == FALSE)
    {
        return FALSE;
    }
 
    // Loop through and try to free the requested amount of memory
    for (AmountReleased=0; AmountReleased<MinimumAmountToRelease; )
    {
        // Try to free a block
        // If this fails then break out of the loop
        if (!CacheInternalFreeBlock(&CacheManagerDrive))
        {
            break;
        }
 
        // It succeeded so increment the amount of memory we have freed
        AmountReleased += CacheManagerDrive.BlockSize * CacheManagerDrive.BytesPerSector;
    }
 
    // Return status
    return (AmountReleased >= MinimumAmountToRelease);
}

Variable Documentation

CacheBlockCount

ULONG CacheBlockCount

extern

Definition at line 33 of file cache.c.

Referenced by CacheInitializeDrive(), CacheInternalAddBlockToCache(), CacheInternalCheckCacheSizeLimits(), CacheInternalDumpBlockList(), and CacheInternalFreeBlock().

CacheManagerDrive

CACHE_DRIVE CacheManagerDrive

extern

Definition at line 30 of file cache.c.

Referenced by CacheInitializeDrive(), CacheReadDiskSectors(), and CacheReleaseMemory().

CacheManagerInitialized

BOOLEAN CacheManagerInitialized

extern

Definition at line 31 of file cache.c.

Referenced by CacheInitializeDrive(), CacheReadDiskSectors(), and CacheReleaseMemory().

CacheSizeCurrent

SIZE_T CacheSizeCurrent

extern

Definition at line 35 of file cache.c.

Referenced by CacheInitializeDrive(), CacheInternalAddBlockToCache(), CacheInternalDumpBlockList(), and CacheInternalFreeBlock().

CacheSizeLimit

SIZE_T CacheSizeLimit

extern

Definition at line 34 of file cache.c.

Referenced by CacheInitializeDrive(), CacheInternalCheckCacheSizeLimits(), and CacheInternalDumpBlockList().