PROS_VACB current;
BOOLEAN Locked;
NTSTATUS Status;
- LARGE_INTEGER ZeroTimeout;
DPRINT("CcRosFlushDirtyPages(Target %lu)\n", Target);
(*Count) = 0;
- ZeroTimeout.QuadPart = 0;
KeEnterCriticalRegion();
KeAcquireGuardedMutex(&ViewLock);
continue;
}
- Status = KeWaitForSingleObject(¤t->Mutex,
- Executive,
- KernelMode,
- FALSE,
- Wait ? NULL : &ZeroTimeout);
- if (Status != STATUS_SUCCESS)
+ Locked = ExAcquireResourceExclusiveLite(¤t->Lock, Wait);
+ if (!Locked)
{
current->SharedCacheMap->Callbacks->ReleaseFromLazyWrite(
current->SharedCacheMap->LazyWriteContext);
/* One reference is added above */
if (current->ReferenceCount > 2)
{
- KeReleaseMutex(¤t->Mutex, FALSE);
+ ExReleaseResourceLite(¤t->Lock);
current->SharedCacheMap->Callbacks->ReleaseFromLazyWrite(
current->SharedCacheMap->LazyWriteContext);
CcRosVacbDecRefCount(current);
Status = CcRosFlushVacb(current);
- KeReleaseMutex(¤t->Mutex, FALSE);
+ ExReleaseResourceLite(¤t->Lock);
current->SharedCacheMap->Callbacks->ReleaseFromLazyWrite(
current->SharedCacheMap->LazyWriteContext);
KeAcquireGuardedMutex(&ViewLock);
CcRosVacbDecRefCount(current);
- if (!NT_SUCCESS(Status) && (Status != STATUS_END_OF_FILE))
+ if (!NT_SUCCESS(Status) && (Status != STATUS_END_OF_FILE) &&
+ (Status != STATUS_MEDIA_WRITE_PROTECTED))
{
DPRINT1("CC: Failed to flush VACB.\n");
}
KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldIrql);
KeReleaseGuardedMutex(&ViewLock);
- KeReleaseMutex(&Vacb->Mutex, FALSE);
+ ExReleaseResourceLite(&Vacb->Lock);
return STATUS_SUCCESS;
}
CcRosVacbIncRefCount(current);
KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldIrql);
KeReleaseGuardedMutex(&ViewLock);
- KeWaitForSingleObject(¤t->Mutex,
- Executive,
- KernelMode,
- FALSE,
- NULL);
+ ExAcquireResourceExclusiveLite(¤t->Lock, TRUE);
return current;
}
if (current->FileOffset.QuadPart > FileOffset)
KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldIrql);
KeReleaseGuardedMutex(&ViewLock);
- KeReleaseMutex(&Vacb->Mutex, FALSE);
+ ExReleaseResourceLite(&Vacb->Lock);
return STATUS_SUCCESS;
}
KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldIrql);
KeReleaseGuardedMutex(&ViewLock);
- KeReleaseMutex(&Vacb->Mutex, FALSE);
+ ExReleaseResourceLite(&Vacb->Lock);
return STATUS_SUCCESS;
}
static
-VOID
-CcRosMapVacb(PVOID BaseAddress,
- SIZE_T Length,
- ULONG Consumer,
- ULONG Protection)
+NTSTATUS
+CcRosMapVacb(
+ PROS_VACB Vacb)
{
ULONG i;
NTSTATUS Status;
+ ULONG_PTR NumberOfPages;
+
+ /* Create a memory area. */
+ MmLockAddressSpace(MmGetKernelAddressSpace());
+ Status = MmCreateMemoryArea(MmGetKernelAddressSpace(),
+ 0, // nothing checks for VACB mareas, so set to 0
+ &Vacb->BaseAddress,
+ VACB_MAPPING_GRANULARITY,
+ PAGE_READWRITE,
+ (PMEMORY_AREA*)&Vacb->MemoryArea,
+ 0,
+ PAGE_SIZE);
+ MmUnlockAddressSpace(MmGetKernelAddressSpace());
+ if (!NT_SUCCESS(Status))
+ {
+ KeBugCheck(CACHE_MANAGER);
+ }
- ASSERT(((ULONG_PTR)BaseAddress % PAGE_SIZE) == 0);
+ ASSERT(((ULONG_PTR)Vacb->BaseAddress % PAGE_SIZE) == 0);
+ ASSERT((ULONG_PTR)Vacb->BaseAddress > (ULONG_PTR)MmSystemRangeStart);
- for (i = 0; i < PAGE_ROUND_UP(Length) / PAGE_SIZE; i++)
+ /* Create a virtual mapping for this memory area */
+ NumberOfPages = BYTES_TO_PAGES(VACB_MAPPING_GRANULARITY);
+ for (i = 0; i < NumberOfPages; i++)
{
- PFN_NUMBER Page;
+ PFN_NUMBER PageFrameNumber;
- Status = MmRequestPageMemoryConsumer(Consumer, TRUE, &Page);
- if (!NT_SUCCESS(Status))
+ Status = MmRequestPageMemoryConsumer(MC_CACHE, TRUE, &PageFrameNumber);
+ if (PageFrameNumber == 0)
{
DPRINT1("Unable to allocate page\n");
KeBugCheck(MEMORY_MANAGEMENT);
}
- Status = MmCreateVirtualMapping (NULL,
- (PVOID)((ULONG_PTR)BaseAddress + (i * PAGE_SIZE)),
- Protection,
- &Page,
- 1);
+
+ Status = MmCreateVirtualMapping(NULL,
+ (PVOID)((ULONG_PTR)Vacb->BaseAddress + (i * PAGE_SIZE)),
+ PAGE_READWRITE,
+ &PageFrameNumber,
+ 1);
if (!NT_SUCCESS(Status))
{
DPRINT1("Unable to create virtual mapping\n");
KeBugCheck(MEMORY_MANAGEMENT);
}
}
+
+ return STATUS_SUCCESS;
}
static
}
current = ExAllocateFromNPagedLookasideList(&VacbLookasideList);
+ current->BaseAddress = NULL;
current->Valid = FALSE;
current->Dirty = FALSE;
current->PageOut = FALSE;
current->DirtyVacbListEntry.Flink = NULL;
current->DirtyVacbListEntry.Blink = NULL;
current->ReferenceCount = 1;
- KeInitializeMutex(¤t->Mutex, 0);
- KeWaitForSingleObject(¤t->Mutex,
- Executive,
- KernelMode,
- FALSE,
- NULL);
+ ExInitializeResourceLite(¤t->Lock);
+ ExAcquireResourceExclusiveLite(¤t->Lock, TRUE);
KeAcquireGuardedMutex(&ViewLock);
*Vacb = current;
current);
}
#endif
- KeReleaseMutex(&(*Vacb)->Mutex, FALSE);
+ ExReleaseResourceLite(&(*Vacb)->Lock);
KeReleaseGuardedMutex(&ViewLock);
ExFreeToNPagedLookasideList(&VacbLookasideList, *Vacb);
*Vacb = current;
- KeWaitForSingleObject(¤t->Mutex,
- Executive,
- KernelMode,
- FALSE,
- NULL);
+ ExAcquireResourceExclusiveLite(¤t->Lock, TRUE);
return STATUS_SUCCESS;
}
if (current->FileOffset.QuadPart < FileOffset)
InsertTailList(&VacbLruListHead, ¤t->VacbLruListEntry);
KeReleaseGuardedMutex(&ViewLock);
- MmLockAddressSpace(MmGetKernelAddressSpace());
- current->BaseAddress = NULL;
- Status = MmCreateMemoryArea(MmGetKernelAddressSpace(),
- 0, // nothing checks for VACB mareas, so set to 0
- ¤t->BaseAddress,
- VACB_MAPPING_GRANULARITY,
- PAGE_READWRITE,
- (PMEMORY_AREA*)¤t->MemoryArea,
- FALSE,
- 0,
- PAGE_SIZE);
- MmUnlockAddressSpace(MmGetKernelAddressSpace());
- if (!NT_SUCCESS(Status))
- {
- KeBugCheck(CACHE_MANAGER);
- }
-
- /* Create a virtual mapping for this memory area */
MI_SET_USAGE(MI_USAGE_CACHE);
#if MI_TRACE_PFNS
if ((SharedCacheMap->FileObject) && (SharedCacheMap->FileObject->FileName.Buffer))
}
#endif
- CcRosMapVacb(current->BaseAddress, VACB_MAPPING_GRANULARITY,
- MC_CACHE, PAGE_READWRITE);
+ Status = CcRosMapVacb(current);
- return STATUS_SUCCESS;
+ return Status;
}
NTSTATUS
CcFreeCachePage,
NULL);
MmUnlockAddressSpace(MmGetKernelAddressSpace());
+ ExDeleteResourceLite(&Vacb->Lock);
ExFreeToNPagedLookasideList(&VacbLookasideList, Vacb);
return STATUS_SUCCESS;
NTSTATUS Status;
KIRQL oldIrql;
+ CCTRACE(CC_API_DEBUG, "SectionObjectPointers=%p FileOffset=%p Length=%lu\n",
+ SectionObjectPointers, FileOffset, Length);
+
DPRINT("CcFlushCache(SectionObjectPointers 0x%p, FileOffset 0x%p, Length %lu, IoStatus 0x%p)\n",
SectionObjectPointers, FileOffset, Length, IoStatus);
IoStatus->Status = Status;
}
}
- KeReleaseMutex(¤t->Mutex, FALSE);
+ ExReleaseResourceLite(¤t->Lock);
KeAcquireGuardedMutex(&ViewLock);
KeAcquireSpinLock(&SharedCacheMap->CacheMapLock, &oldIrql);
if (SharedCacheMap == NULL)
{
KeReleaseGuardedMutex(&ViewLock);
- return STATUS_UNSUCCESSFUL;
+ return STATUS_INSUFFICIENT_RESOURCES;
}
RtlZeroMemory(SharedCacheMap, sizeof(*SharedCacheMap));
ObReferenceObjectByPointer(FileObject,
IN PSECTION_OBJECT_POINTERS SectionObjectPointers)
{
PROS_SHARED_CACHE_MAP SharedCacheMap;
+
+ CCTRACE(CC_API_DEBUG, "SectionObjectPointers=%p\n", SectionObjectPointers);
+
if (SectionObjectPointers && SectionObjectPointers->SharedCacheMap)
{
SharedCacheMap = SectionObjectPointers->SharedCacheMap;