#define MAX_ZERO_LENGTH (256 * 1024)
#define MAX_RW_LENGTH (256 * 1024)
+C_ASSERT(MAX_RW_LENGTH <= VACB_MAPPING_GRANULARITY);
ULONG CcFastMdlReadWait;
ULONG CcFastMdlReadNotPossible;
if (current->Valid)
{
TempLength = min(VACB_MAPPING_GRANULARITY, Length);
- memcpy(Buffer, current->BaseAddress, TempLength);
+ RtlCopyMemory(Buffer, current->BaseAddress, TempLength);
Buffer = (PVOID)((ULONG_PTR)Buffer + TempLength);
while ((current2 != NULL) && !current2->Valid && (current_size < MAX_RW_LENGTH))
{
PVOID address = current2->BaseAddress;
- for (i = 0; i < (VACB_MAPPING_GRANULARITY / PAGE_SIZE); i++, address = RVA(address, PAGE_SIZE))
+ for (i = 0; i < VACB_MAPPING_GRANULARITY / PAGE_SIZE; i++, address = RVA(address, PAGE_SIZE))
{
*MdlPages++ = MmGetPfnForProcess(NULL, address);
}
previous = current;
current = current->NextInChain;
TempLength = min(VACB_MAPPING_GRANULARITY, Length);
- memcpy(Buffer, previous->BaseAddress, TempLength);
+ RtlCopyMemory(Buffer, previous->BaseAddress, TempLength);
Buffer = (PVOID)((ULONG_PTR)Buffer + TempLength);
return Status;
}
- if (VACB_MAPPING_GRANULARITY > Size)
+ if (Size < VACB_MAPPING_GRANULARITY)
{
RtlZeroMemory((char*)CacheSeg->BaseAddress + Size,
VACB_MAPPING_GRANULARITY - Size);
TempLength = ReadOffset % VACB_MAPPING_GRANULARITY;
if (TempLength != 0)
{
- TempLength = min (Length, VACB_MAPPING_GRANULARITY - TempLength);
+ TempLength = min(Length, VACB_MAPPING_GRANULARITY - TempLength);
Status = CcRosRequestCacheSegment(Bcb,
ROUND_DOWN(ReadOffset,
- VACB_MAPPING_GRANULARITY),
+ VACB_MAPPING_GRANULARITY),
&BaseAddress, &Valid, &CacheSeg);
if (!NT_SUCCESS(Status))
{
return FALSE;
}
}
- memcpy (Buffer, (char*)BaseAddress + ReadOffset % VACB_MAPPING_GRANULARITY,
- TempLength);
+ RtlCopyMemory(Buffer,
+ (char*)BaseAddress + ReadOffset % VACB_MAPPING_GRANULARITY,
+ TempLength);
CcRosReleaseCacheSegment(Bcb, CacheSeg, TRUE, FALSE, FALSE);
ReadLength += TempLength;
Length -= TempLength;
while (Length > 0)
{
- TempLength = min(max(VACB_MAPPING_GRANULARITY, MAX_RW_LENGTH), Length);
+ TempLength = min(VACB_MAPPING_GRANULARITY, Length);
Status = ReadCacheSegmentChain(Bcb, ReadOffset, TempLength, Buffer);
if (!NT_SUCCESS(Status))
{
{
ULONG ROffset;
ROffset = ROUND_DOWN(WriteOffset, VACB_MAPPING_GRANULARITY);
- TempLength = min (Length, VACB_MAPPING_GRANULARITY - TempLength);
+ TempLength = min(Length, VACB_MAPPING_GRANULARITY - TempLength);
Status = CcRosRequestCacheSegment(Bcb, ROffset,
&BaseAddress, &Valid, &CacheSeg);
if (!NT_SUCCESS(Status))
return FALSE;
}
}
- memcpy ((char*)BaseAddress + WriteOffset % VACB_MAPPING_GRANULARITY,
- Buffer, TempLength);
+ RtlCopyMemory((char*)BaseAddress + WriteOffset % VACB_MAPPING_GRANULARITY,
+ Buffer,
+ TempLength);
CcRosReleaseCacheSegment(Bcb, CacheSeg, TRUE, TRUE, FALSE);
Length -= TempLength;
while (Length > 0)
{
- TempLength = min (VACB_MAPPING_GRANULARITY, Length);
+ TempLength = min(VACB_MAPPING_GRANULARITY, Length);
Status = CcRosRequestCacheSegment(Bcb,
WriteOffset,
&BaseAddress,
return FALSE;
}
}
- memcpy (BaseAddress, Buffer, TempLength);
+ RtlCopyMemory(BaseAddress, Buffer, TempLength);
CcRosReleaseCacheSegment(Bcb, CacheSeg, TRUE, TRUE, FALSE);
Length -= TempLength;
WriteOffset += TempLength;
Status);
}
}
- TempLength = min (CurrentLength, VACB_MAPPING_GRANULARITY - Offset);
+ TempLength = min(CurrentLength, VACB_MAPPING_GRANULARITY - Offset);
}
else
{
TempLength = VACB_MAPPING_GRANULARITY;
}
- memset ((PUCHAR)current->BaseAddress + Offset, 0, TempLength);
+ RtlZeroMemory((PUCHAR)current->BaseAddress + Offset,
+ TempLength);
WriteOffset.QuadPart += TempLength;
CurrentLength -= TempLength;
static LIST_ENTRY CacheSegmentListHead;
static LIST_ENTRY CacheSegmentLRUListHead;
static LIST_ENTRY ClosedListHead;
-ULONG DirtyPageCount=0;
+ULONG DirtyPageCount = 0;
KGUARDED_MUTEX ViewLock;
KeReleaseGuardedMutex(&ViewLock);
}
- return(Status);
+ return Status;
}
NTSTATUS
KeLeaveCriticalRegion();
DPRINT("CcRosFlushDirtyPages() finished\n");
- return(STATUS_SUCCESS);
+ return STATUS_SUCCESS;
}
NTSTATUS
DPRINT("Evicted %lu cache pages\n", (*NrFreed));
- return(STATUS_SUCCESS);
+ return STATUS_SUCCESS;
}
NTSTATUS
KeReleaseGuardedMutex(&ViewLock);
KeReleaseMutex(&CacheSeg->Mutex, FALSE);
- return(STATUS_SUCCESS);
+ return STATUS_SUCCESS;
}
/* Returns with Cache Segment Lock Held! */
KeReleaseGuardedMutex(&ViewLock);
KeReleaseMutex(&CacheSeg->Mutex, FALSE);
- return(STATUS_SUCCESS);
+ return STATUS_SUCCESS;
}
NTSTATUS
CacheSeg = CcRosLookupCacheSegment(Bcb, FileOffset);
if (CacheSeg == NULL)
{
- return(STATUS_UNSUCCESSFUL);
+ return STATUS_UNSUCCESSFUL;
}
KeAcquireGuardedMutex(&ViewLock);
KeReleaseGuardedMutex(&ViewLock);
KeReleaseMutex(&CacheSeg->Mutex, FALSE);
- return(STATUS_SUCCESS);
+ return STATUS_SUCCESS;
}
static
#ifdef CACHE_BITMAP
KeAcquireSpinLock(&CiCacheSegMappingRegionLock, &oldIrql);
- StartingOffset = RtlFindClearBitsAndSet(&CiCacheSegMappingRegionAllocMap, VACB_MAPPING_GRANULARITY / PAGE_SIZE, CiCacheSegMappingRegionHint);
+ StartingOffset = RtlFindClearBitsAndSet(&CiCacheSegMappingRegionAllocMap,
+ VACB_MAPPING_GRANULARITY / PAGE_SIZE,
+ CiCacheSegMappingRegionHint);
if (StartingOffset == 0xffffffff)
{
MmMapMemoryArea(current->BaseAddress, VACB_MAPPING_GRANULARITY,
MC_CACHE, PAGE_READWRITE);
- return(STATUS_SUCCESS);
+ return STATUS_SUCCESS;
}
NTSTATUS
}
}
- for (i = 0; i < (Length / VACB_MAPPING_GRANULARITY); i++)
+ for (i = 0; i < Length / VACB_MAPPING_GRANULARITY; i++)
{
if (i == 0)
{
ASSERT(Previous);
Previous->NextInChain = NULL;
- return(STATUS_SUCCESS);
+ return STATUS_SUCCESS;
}
NTSTATUS
DPRINT("*BaseAddress %p\n", *BaseAddress);
*CacheSeg = current;
*BaseOffset = current->FileOffset;
- return(STATUS_SUCCESS);
+ return STATUS_SUCCESS;
}
NTSTATUS
ASSERT(Bcb);
- if ((FileOffset % VACB_MAPPING_GRANULARITY) != 0)
+ if (FileOffset % VACB_MAPPING_GRANULARITY != 0)
{
DPRINT1("Bad fileoffset %x should be multiple of %x",
FileOffset, VACB_MAPPING_GRANULARITY);
KeBugCheck(CACHE_MANAGER);
}
- return(CcRosGetCacheSegment(Bcb,
+ return CcRosGetCacheSegment(Bcb,
FileOffset,
&BaseOffset,
BaseAddress,
UptoDate,
- CacheSeg));
+ CacheSeg);
}
#ifdef CACHE_BITMAP
#else
RtlClearBits(&CiCacheSegMappingRegionAllocMap, Base, RegionSize);
- CiCacheSegMappingRegionHint = min (CiCacheSegMappingRegionHint, Base);
+ CiCacheSegMappingRegionHint = min(CiCacheSegMappingRegionHint, Base);
KeReleaseSpinLock(&CiCacheSegMappingRegionLock, oldIrql);
#else
MmUnlockAddressSpace(MmGetKernelAddressSpace());
#endif
ExFreeToNPagedLookasideList(&CacheSegLookasideList, CacheSeg);
- return(STATUS_SUCCESS);
+ return STATUS_SUCCESS;
}
/*
ExFreeToNPagedLookasideList(&BcbLookasideList, Bcb);
KeAcquireGuardedMutex(&ViewLock);
}
- return(STATUS_SUCCESS);
+ return STATUS_SUCCESS;
}
VOID
}
}
KeReleaseGuardedMutex(&ViewLock);
- return(STATUS_SUCCESS);
+ return STATUS_SUCCESS;
}
NTSTATUS
NTAPI
CcRosInitializeFileCache (
PFILE_OBJECT FileObject,
- ULONG CacheSegmentSize,
PCACHE_MANAGER_CALLBACKS CallBacks,
PVOID LazyWriterContext)
/*
PBCB Bcb;
Bcb = FileObject->SectionObjectPointer->SharedCacheMap;
- DPRINT("CcRosInitializeFileCache(FileObject 0x%p, Bcb 0x%p, CacheSegmentSize %lu)\n",
- FileObject, Bcb, CacheSegmentSize);
+ DPRINT("CcRosInitializeFileCache(FileObject 0x%p, Bcb 0x%p)\n",
+ FileObject, Bcb);
KeAcquireGuardedMutex(&ViewLock);
if (Bcb == NULL)
if (Bcb == NULL)
{
KeReleaseGuardedMutex(&ViewLock);
- return(STATUS_UNSUCCESSFUL);
+ return STATUS_UNSUCCESSFUL;
}
- memset(Bcb, 0, sizeof(BCB));
+ RtlZeroMemory(Bcb, sizeof(*Bcb));
ObReferenceObjectByPointer(FileObject,
FILE_ALL_ACCESS,
NULL,
KernelMode);
Bcb->FileObject = FileObject;
- Bcb->CacheSegmentSize = CacheSegmentSize;
Bcb->Callbacks = CallBacks;
Bcb->LazyWriteContext = LazyWriterContext;
if (FileObject->FsContext)
}
KeReleaseGuardedMutex(&ViewLock);
- return(STATUS_SUCCESS);
+ return STATUS_SUCCESS;
}
/*
KeBugCheck(CACHE_MANAGER);
}
- Buffer = ExAllocatePool(NonPagedPool, CI_CACHESEG_MAPPING_REGION_SIZE / (PAGE_SIZE * 8));
+ Buffer = ExAllocatePoolWithTag(NonPagedPool,
+ CI_CACHESEG_MAPPING_REGION_SIZE / (PAGE_SIZE * 8),
+ TAG_CC);
if (!Buffer)
{
KeBugCheck(CACHE_MANAGER);
}
- RtlInitializeBitMap(&CiCacheSegMappingRegionAllocMap, Buffer, CI_CACHESEG_MAPPING_REGION_SIZE / PAGE_SIZE);
+ RtlInitializeBitMap(&CiCacheSegMappingRegionAllocMap,
+ Buffer,
+ CI_CACHESEG_MAPPING_REGION_SIZE / PAGE_SIZE);
RtlClearAllBits(&CiCacheSegMappingRegionAllocMap);
KeInitializeSpinLock(&CiCacheSegMappingRegionLock);
}
/* EOF */
-
-
-
-
-
-
-
-