ReactOS 0.4.15-dev-8339-g4028de8
cache.c File Reference
#include <freeldr.h>
#include <debug.h>
Include dependency graph for cache.c:

Go to the source code of this file.

Functions

 DBG_DEFAULT_CHANNEL (CACHE)
 
BOOLEAN CacheInitializeDrive (UCHAR DriveNumber)
 
VOID CacheInvalidateCacheData (VOID)
 
BOOLEAN CacheReadDiskSectors (UCHAR DiskNumber, ULONGLONG StartSector, ULONG SectorCount, PVOID Buffer)
 
BOOLEAN CacheReleaseMemory (ULONG MinimumAmountToRelease)
 

Variables

CACHE_DRIVE CacheManagerDrive
 
BOOLEAN CacheManagerInitialized = FALSE
 
BOOLEAN CacheManagerDataInvalid = FALSE
 
ULONG CacheBlockCount = 0
 
SIZE_T CacheSizeLimit = 0
 
SIZE_T CacheSizeCurrent = 0
 

Function Documentation

◆ CacheInitializeDrive()

BOOLEAN CacheInitializeDrive ( UCHAR  DriveNumber)

Definition at line 37 of file cache.c.

38{
39 PCACHE_BLOCK NextCacheBlock;
40 GEOMETRY DriveGeometry;
41
42 // If we already have a cache for this drive then
43 // by all means lets keep it, unless it is a removable
44 // drive, in which case we'll invalidate the cache
46 (DriveNumber == CacheManagerDrive.DriveNumber) &&
47 (DriveNumber >= 0x80) &&
49 {
50 return TRUE;
51 }
52
54
55 //
56 // If we have already been initialized then free
57 // the old data
58 //
60 {
62
63 TRACE("CacheBlockCount: %d\n", CacheBlockCount);
64 TRACE("CacheSizeLimit: %d\n", CacheSizeLimit);
65 TRACE("CacheSizeCurrent: %d\n", CacheSizeCurrent);
66 //
67 // Loop through and free the cache blocks
68 //
70 {
73 ListEntry);
74
75 FrLdrTempFree(NextCacheBlock->BlockData, TAG_CACHE_DATA);
76 FrLdrTempFree(NextCacheBlock, TAG_CACHE_BLOCK);
77 }
78 }
79
80 // Initialize the structure
83 CacheManagerDrive.DriveNumber = DriveNumber;
84 if (!MachDiskGetDriveGeometry(DriveNumber, &DriveGeometry))
85 {
86 return FALSE;
87 }
89
90 // Get the number of sectors in each cache block
92
95 CacheSizeLimit = TotalPagesInLookupTable / 8 * MM_PAGE_SIZE;
97
99
100 TRACE("Initializing BIOS drive 0x%x.\n", DriveNumber);
101 TRACE("BytesPerSector: %d.\n", CacheManagerDrive.BytesPerSector);
102 TRACE("BlockSize: %d.\n", CacheManagerDrive.BlockSize);
103 TRACE("CacheSizeLimit: %d.\n", CacheSizeLimit);
104
105 return TRUE;
106}
#define TAG_CACHE_DATA
Definition: cache.h:23
#define TAG_CACHE_BLOCK
Definition: cache.h:24
#define MachDiskGetDriveGeometry(Drive, Geom)
Definition: machine.h:128
#define MachDiskGetCacheableBlockCount(Drive)
Definition: machine.h:130
PFN_NUMBER TotalPagesInLookupTable
Definition: meminit.c:27
FORCEINLINE VOID FrLdrTempFree(PVOID Allocation, ULONG Tag)
Definition: mm.h:197
#define TEMP_HEAP_SIZE
Definition: mm.h:134
SIZE_T CacheSizeLimit
Definition: cache.c:34
BOOLEAN CacheManagerDataInvalid
Definition: cache.c:32
CACHE_DRIVE CacheManagerDrive
Definition: cache.c:30
BOOLEAN CacheManagerInitialized
Definition: cache.c:31
ULONG CacheBlockCount
Definition: cache.c:33
SIZE_T CacheSizeCurrent
Definition: cache.c:35
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define IsListEmpty(ListHead)
Definition: env_spec_w32.h:954
#define RemoveHeadList(ListHead)
Definition: env_spec_w32.h:964
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
#define min(a, b)
Definition: monoChain.cc:55
#define TRACE(s)
Definition: solgame.cpp:4
PVOID BlockData
Definition: cache.h:43
ULONG BytesPerSector
Definition: cache.h:57
LIST_ENTRY CacheBlockHead
Definition: cache.h:60
ULONG BlockSize
Definition: cache.h:59
UCHAR DriveNumber
Definition: cache.h:56
Definition: disk.h:25
ULONG BytesPerSector
Definition: disk.h:29
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260

Referenced by Ext2OpenVolume().

◆ CacheInvalidateCacheData()

VOID CacheInvalidateCacheData ( VOID  )

Definition at line 108 of file cache.c.

109{
111}

◆ CacheReadDiskSectors()

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

Definition at line 113 of file cache.c.

114{
115 PCACHE_BLOCK CacheBlock;
116 ULONG StartBlock;
117 ULONG SectorOffsetInStartBlock;
118 ULONG CopyLengthInStartBlock;
119 ULONG EndBlock;
120 ULONG SectorOffsetInEndBlock;
121 ULONG BlockCount;
122 ULONG Idx;
123
124 TRACE("CacheReadDiskSectors() DiskNumber: 0x%x StartSector: %I64d SectorCount: %d Buffer: 0x%x\n", DiskNumber, StartSector, SectorCount, Buffer);
125
126 // If we aren't initialized yet then they can't do this
128 {
129 return FALSE;
130 }
131
132 //
133 // Calculate which blocks we must cache
134 //
135 StartBlock = (ULONG)(StartSector / CacheManagerDrive.BlockSize);
136 SectorOffsetInStartBlock = (ULONG)(StartSector % CacheManagerDrive.BlockSize);
137 CopyLengthInStartBlock = (ULONG)((SectorCount > (CacheManagerDrive.BlockSize - SectorOffsetInStartBlock)) ? (CacheManagerDrive.BlockSize - SectorOffsetInStartBlock) : SectorCount);
138 EndBlock = (ULONG)((StartSector + (SectorCount - 1)) / CacheManagerDrive.BlockSize);
139 SectorOffsetInEndBlock = (ULONG)(1 + (StartSector + (SectorCount - 1)) % CacheManagerDrive.BlockSize);
140 BlockCount = (EndBlock - StartBlock) + 1;
141 TRACE("StartBlock: %d SectorOffsetInStartBlock: %d CopyLengthInStartBlock: %d EndBlock: %d SectorOffsetInEndBlock: %d BlockCount: %d\n", StartBlock, SectorOffsetInStartBlock, CopyLengthInStartBlock, EndBlock, SectorOffsetInEndBlock, BlockCount);
142
143 //
144 // Read the first block into the buffer
145 //
146 if (BlockCount > 0)
147 {
148 //
149 // Get cache block pointer (this forces the disk sectors into the cache memory)
150 //
151 CacheBlock = CacheInternalGetBlockPointer(&CacheManagerDrive, StartBlock);
152 if (CacheBlock == NULL)
153 {
154 return FALSE;
155 }
156
157 //
158 // Copy the portion requested into the buffer
159 //
161 (PVOID)((ULONG_PTR)CacheBlock->BlockData + (SectorOffsetInStartBlock * CacheManagerDrive.BytesPerSector)),
162 (CopyLengthInStartBlock * CacheManagerDrive.BytesPerSector));
163 TRACE("1 - RtlCopyMemory(0x%x, 0x%x, %d)\n", Buffer, ((ULONG_PTR)CacheBlock->BlockData + (SectorOffsetInStartBlock * CacheManagerDrive.BytesPerSector)), (CopyLengthInStartBlock * CacheManagerDrive.BytesPerSector));
164
165 //
166 // Update the buffer address
167 //
168 Buffer = (PVOID)((ULONG_PTR)Buffer + (CopyLengthInStartBlock * CacheManagerDrive.BytesPerSector));
169
170 //
171 // Update the block count
172 //
173 BlockCount--;
174 }
175
176 //
177 // Loop through the middle blocks and read them into the buffer
178 //
179 for (Idx=StartBlock+1; BlockCount>1; Idx++)
180 {
181 //
182 // Get cache block pointer (this forces the disk sectors into the cache memory)
183 //
185 if (CacheBlock == NULL)
186 {
187 return FALSE;
188 }
189
190 //
191 // Copy the portion requested into the buffer
192 //
194 CacheBlock->BlockData,
196 TRACE("2 - RtlCopyMemory(0x%x, 0x%x, %d)\n", Buffer, CacheBlock->BlockData, CacheManagerDrive.BlockSize * CacheManagerDrive.BytesPerSector);
197
198 //
199 // Update the buffer address
200 //
202
203 //
204 // Update the block count
205 //
206 BlockCount--;
207 }
208
209 //
210 // Read the last block into the buffer
211 //
212 if (BlockCount > 0)
213 {
214 //
215 // Get cache block pointer (this forces the disk sectors into the cache memory)
216 //
217 CacheBlock = CacheInternalGetBlockPointer(&CacheManagerDrive, EndBlock);
218 if (CacheBlock == NULL)
219 {
220 return FALSE;
221 }
222
223 //
224 // Copy the portion requested into the buffer
225 //
227 CacheBlock->BlockData,
228 SectorOffsetInEndBlock * CacheManagerDrive.BytesPerSector);
229 TRACE("3 - RtlCopyMemory(0x%x, 0x%x, %d)\n", Buffer, CacheBlock->BlockData, SectorOffsetInEndBlock * CacheManagerDrive.BytesPerSector);
230
231 //
232 // Update the buffer address
233 //
234 Buffer = (PVOID)((ULONG_PTR)Buffer + (SectorOffsetInEndBlock * CacheManagerDrive.BytesPerSector));
235
236 //
237 // Update the block count
238 //
239 BlockCount--;
240 }
241
242 return TRUE;
243}
PCACHE_BLOCK CacheInternalGetBlockPointer(PCACHE_DRIVE CacheDrive, ULONG BlockNumber)
Definition: blocklist.c:28
Definition: bufpool.h:45
#define NULL
Definition: types.h:112
ULONG SectorCount
Definition: part_xbox.c:31
void * PVOID
Definition: typedefs.h:50
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
uint32_t ULONG_PTR
Definition: typedefs.h:65
uint32_t ULONG
Definition: typedefs.h:59

Referenced by Ext2ReadVolumeSectors().

◆ CacheReleaseMemory()

BOOLEAN CacheReleaseMemory ( ULONG  MinimumAmountToRelease)

Definition at line 293 of file cache.c.

294{
295 ULONG AmountReleased;
296
297 TRACE("CacheReleaseMemory() MinimumAmountToRelease = %d\n", MinimumAmountToRelease);
298
299 // If we aren't initialized yet then they can't do this
301 {
302 return FALSE;
303 }
304
305 // Loop through and try to free the requested amount of memory
306 for (AmountReleased=0; AmountReleased<MinimumAmountToRelease; )
307 {
308 // Try to free a block
309 // If this fails then break out of the loop
311 {
312 break;
313 }
314
315 // It succeeded so increment the amount of memory we have freed
317 }
318
319 // Return status
320 return (AmountReleased >= MinimumAmountToRelease);
321}
BOOLEAN CacheInternalFreeBlock(PCACHE_DRIVE CacheDrive)
Definition: blocklist.c:142

◆ DBG_DEFAULT_CHANNEL()

DBG_DEFAULT_CHANNEL ( CACHE  )

Variable Documentation

◆ CacheBlockCount

◆ CacheManagerDataInvalid

BOOLEAN CacheManagerDataInvalid = FALSE

Definition at line 32 of file cache.c.

Referenced by CacheInitializeDrive(), and CacheInvalidateCacheData().

◆ CacheManagerDrive

CACHE_DRIVE CacheManagerDrive

Definition at line 30 of file cache.c.

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

◆ CacheManagerInitialized

BOOLEAN CacheManagerInitialized = FALSE

Definition at line 31 of file cache.c.

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

◆ CacheSizeCurrent

◆ CacheSizeLimit

SIZE_T CacheSizeLimit = 0