LIST_ENTRY DirtyVacbListHead;
static LIST_ENTRY VacbLruListHead;
-KGUARDED_MUTEX ViewLock;
-
NPAGED_LOOKASIDE_LIST iBcbLookasideList;
static NPAGED_LOOKASIDE_LIST SharedCacheMapLookasideList;
static NPAGED_LOOKASIDE_LIST VacbLookasideList;
{
DPRINT1("Enabling Tracing for CacheMap 0x%p:\n", SharedCacheMap);
- KeAcquireGuardedMutex(&ViewLock);
- KeAcquireSpinLock(&SharedCacheMap->CacheMapLock, &oldirql);
+ oldirql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
+ KeAcquireSpinLockAtDpcLevel(&SharedCacheMap->CacheMapLock);
current_entry = SharedCacheMap->CacheMapVacbListHead.Flink;
while (current_entry != &SharedCacheMap->CacheMapVacbListHead)
DPRINT1(" VACB 0x%p enabled, RefCount %lu, Dirty %u, PageOut %lu\n",
current, current->ReferenceCount, current->Dirty, current->PageOut );
}
- KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldirql);
- KeReleaseGuardedMutex(&ViewLock);
+
+ KeReleaseSpinLockFromDpcLevel(&SharedCacheMap->CacheMapLock);
+ KeReleaseQueuedSpinLock(LockQueueMasterLock, oldirql);
}
else
{
PROS_VACB current;
BOOLEAN Locked;
NTSTATUS Status;
+ KIRQL OldIrql;
DPRINT("CcRosFlushDirtyPages(Target %lu)\n", Target);
(*Count) = 0;
KeEnterCriticalRegion();
- KeAcquireGuardedMutex(&ViewLock);
+ OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
current_entry = DirtyVacbListHead.Flink;
if (current_entry == &DirtyVacbListHead)
continue;
}
- Locked = current->SharedCacheMap->Callbacks->AcquireForLazyWrite(
- current->SharedCacheMap->LazyWriteContext, Wait);
- if (!Locked)
+ /* Don't attempt to lazy write the files that asked not to */
+ if (CalledFromLazy &&
+ BooleanFlagOn(current->SharedCacheMap->Flags, WRITEBEHIND_DISABLED))
{
CcRosVacbDecRefCount(current);
continue;
ASSERT(current->Dirty);
- KeReleaseGuardedMutex(&ViewLock);
+ KeReleaseQueuedSpinLock(LockQueueMasterLock, OldIrql);
+
+ Locked = current->SharedCacheMap->Callbacks->AcquireForLazyWrite(
+ current->SharedCacheMap->LazyWriteContext, Wait);
+ if (!Locked)
+ {
+ OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
+ CcRosVacbDecRefCount(current);
+ continue;
+ }
Status = CcRosFlushVacb(current);
current->SharedCacheMap->Callbacks->ReleaseFromLazyWrite(
current->SharedCacheMap->LazyWriteContext);
- KeAcquireGuardedMutex(&ViewLock);
+ OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
CcRosVacbDecRefCount(current);
if (!NT_SUCCESS(Status) && (Status != STATUS_END_OF_FILE) &&
current_entry = DirtyVacbListHead.Flink;
}
- KeReleaseGuardedMutex(&ViewLock);
+ KeReleaseQueuedSpinLock(LockQueueMasterLock, OldIrql);
KeLeaveCriticalRegion();
DPRINT("CcRosFlushDirtyPages() finished\n");
*NrFreed = 0;
retry:
- KeAcquireGuardedMutex(&ViewLock);
+ oldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
current_entry = VacbLruListHead.Flink;
while (current_entry != &VacbLruListHead)
VacbLruListEntry);
current_entry = current_entry->Flink;
- KeAcquireSpinLock(¤t->SharedCacheMap->CacheMapLock, &oldIrql);
+ KeAcquireSpinLockAtDpcLevel(¤t->SharedCacheMap->CacheMapLock);
/* Reference the VACB */
CcRosVacbIncRefCount(current);
if (InterlockedCompareExchange((PLONG)¤t->MappedCount, 0, 0) > 0 && !current->Dirty)
{
/* We have to break these locks because Cc sucks */
- KeReleaseSpinLock(¤t->SharedCacheMap->CacheMapLock, oldIrql);
- KeReleaseGuardedMutex(&ViewLock);
+ KeReleaseSpinLockFromDpcLevel(¤t->SharedCacheMap->CacheMapLock);
+ KeReleaseQueuedSpinLock(LockQueueMasterLock, oldIrql);
/* Page out the VACB */
for (i = 0; i < VACB_MAPPING_GRANULARITY / PAGE_SIZE; i++)
}
/* Reacquire the locks */
- KeAcquireGuardedMutex(&ViewLock);
- KeAcquireSpinLock(¤t->SharedCacheMap->CacheMapLock, &oldIrql);
+ oldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
+ KeAcquireSpinLockAtDpcLevel(¤t->SharedCacheMap->CacheMapLock);
}
/* Dereference the VACB */
(*NrFreed) += PagesFreed;
}
- KeReleaseSpinLock(¤t->SharedCacheMap->CacheMapLock, oldIrql);
+ KeReleaseSpinLockFromDpcLevel(¤t->SharedCacheMap->CacheMapLock);
}
- KeReleaseGuardedMutex(&ViewLock);
+ KeReleaseQueuedSpinLock(LockQueueMasterLock, oldIrql);
/* Try flushing pages if we haven't met our target */
if ((Target > 0) && !FlushedPages)
DPRINT("CcRosLookupVacb(SharedCacheMap 0x%p, FileOffset %I64u)\n",
SharedCacheMap, FileOffset);
- KeAcquireGuardedMutex(&ViewLock);
- KeAcquireSpinLock(&SharedCacheMap->CacheMapLock, &oldIrql);
+ oldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
+ KeAcquireSpinLockAtDpcLevel(&SharedCacheMap->CacheMapLock);
current_entry = SharedCacheMap->CacheMapVacbListHead.Flink;
while (current_entry != &SharedCacheMap->CacheMapVacbListHead)
FileOffset))
{
CcRosVacbIncRefCount(current);
- KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldIrql);
- KeReleaseGuardedMutex(&ViewLock);
+ KeReleaseSpinLockFromDpcLevel(&SharedCacheMap->CacheMapLock);
+ KeReleaseQueuedSpinLock(LockQueueMasterLock, oldIrql);
return current;
}
if (current->FileOffset.QuadPart > FileOffset)
current_entry = current_entry->Flink;
}
- KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldIrql);
- KeReleaseGuardedMutex(&ViewLock);
+ KeReleaseSpinLockFromDpcLevel(&SharedCacheMap->CacheMapLock);
+ KeReleaseQueuedSpinLock(LockQueueMasterLock, oldIrql);
return NULL;
}
SharedCacheMap = Vacb->SharedCacheMap;
- KeAcquireGuardedMutex(&ViewLock);
- KeAcquireSpinLock(&SharedCacheMap->CacheMapLock, &oldIrql);
+ oldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
+ KeAcquireSpinLockAtDpcLevel(&SharedCacheMap->CacheMapLock);
ASSERT(!Vacb->Dirty);
Vacb->Dirty = TRUE;
- KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldIrql);
- KeReleaseGuardedMutex(&ViewLock);
+ KeReleaseSpinLockFromDpcLevel(&SharedCacheMap->CacheMapLock);
/* Schedule a lazy writer run to now that we have dirty VACB */
- oldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
if (!LazyWriter.ScanActive)
{
CcScheduleLazyWriteScan(FALSE);
if (LockViews)
{
- KeAcquireGuardedMutex(&ViewLock);
- KeAcquireSpinLock(&SharedCacheMap->CacheMapLock, &oldIrql);
+ oldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
+ KeAcquireSpinLockAtDpcLevel(&SharedCacheMap->CacheMapLock);
}
ASSERT(Vacb->Dirty);
if (LockViews)
{
- KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldIrql);
- KeReleaseGuardedMutex(&ViewLock);
+ KeReleaseSpinLockFromDpcLevel(&SharedCacheMap->CacheMapLock);
+ KeReleaseQueuedSpinLock(LockQueueMasterLock, oldIrql);
}
}
Freed = FALSE;
InitializeListHead(&FreeList);
- KeAcquireGuardedMutex(&ViewLock);
+ oldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
/* Browse all the available VACB */
current_entry = VacbLruListHead.Flink;
VacbLruListEntry);
current_entry = current_entry->Flink;
- KeAcquireSpinLock(¤t->SharedCacheMap->CacheMapLock, &oldIrql);
+ KeAcquireSpinLockAtDpcLevel(¤t->SharedCacheMap->CacheMapLock);
/* Only deal with unused VACB, we will free them */
Refs = CcRosVacbGetRefCount(current);
InsertHeadList(&FreeList, ¤t->CacheMapVacbListEntry);
}
- KeReleaseSpinLock(¤t->SharedCacheMap->CacheMapLock, oldIrql);
+ KeReleaseSpinLockFromDpcLevel(¤t->SharedCacheMap->CacheMapLock);
}
- KeReleaseGuardedMutex(&ViewLock);
+ KeReleaseQueuedSpinLock(LockQueueMasterLock, oldIrql);
/* And now, free any of the found VACB, that'll free memory! */
while (!IsListEmpty(&FreeList))
#endif
current->MappedCount = 0;
current->ReferenceCount = 0;
- current->PinCount = 0;
InitializeListHead(¤t->CacheMapVacbListEntry);
InitializeListHead(¤t->DirtyVacbListEntry);
InitializeListHead(¤t->VacbLruListEntry);
goto Retry;
}
- CcRosVacbDecRefCount(current);
ExFreeToNPagedLookasideList(&VacbLookasideList, current);
return Status;
}
- KeAcquireGuardedMutex(&ViewLock);
+ oldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
*Vacb = current;
/* There is window between the call to CcRosLookupVacb
* file offset exist. If there is a VACB, we release
* our newly created VACB and return the existing one.
*/
- KeAcquireSpinLock(&SharedCacheMap->CacheMapLock, &oldIrql);
+ KeAcquireSpinLockAtDpcLevel(&SharedCacheMap->CacheMapLock);
current_entry = SharedCacheMap->CacheMapVacbListHead.Flink;
previous = NULL;
while (current_entry != &SharedCacheMap->CacheMapVacbListHead)
FileOffset))
{
CcRosVacbIncRefCount(current);
- KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldIrql);
+ KeReleaseSpinLockFromDpcLevel(&SharedCacheMap->CacheMapLock);
#if DBG
if (SharedCacheMap->Trace)
{
current);
}
#endif
- KeReleaseGuardedMutex(&ViewLock);
+ KeReleaseQueuedSpinLock(LockQueueMasterLock, oldIrql);
Refs = CcRosVacbDecRefCount(*Vacb);
ASSERT(Refs == 0);
{
InsertHeadList(&SharedCacheMap->CacheMapVacbListHead, ¤t->CacheMapVacbListEntry);
}
- KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldIrql);
+ KeReleaseSpinLockFromDpcLevel(&SharedCacheMap->CacheMapLock);
InsertTailList(&VacbLruListHead, ¤t->VacbLruListEntry);
- KeReleaseGuardedMutex(&ViewLock);
+ KeReleaseQueuedSpinLock(LockQueueMasterLock, oldIrql);
MI_SET_USAGE(MI_USAGE_CACHE);
#if MI_TRACE_PFNS
PROS_VACB current;
NTSTATUS Status;
ULONG Refs;
+ KIRQL OldIrql;
ASSERT(SharedCacheMap);
Refs = CcRosVacbGetRefCount(current);
- KeAcquireGuardedMutex(&ViewLock);
+ OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
/* Move to the tail of the LRU list */
RemoveEntryList(¤t->VacbLruListEntry);
InsertTailList(&VacbLruListHead, ¤t->VacbLruListEntry);
- KeReleaseGuardedMutex(&ViewLock);
+ KeReleaseQueuedSpinLock(LockQueueMasterLock, OldIrql);
/*
* Return information about the VACB to the caller.
NULL);
MmUnlockAddressSpace(MmGetKernelAddressSpace());
- if (Vacb->PinCount != 0 || Vacb->ReferenceCount != 0)
+ if (Vacb->ReferenceCount != 0)
{
- DPRINT1("Invalid free: %ld, %ld\n", Vacb->ReferenceCount, Vacb->PinCount);
+ DPRINT1("Invalid free: %ld\n", Vacb->ReferenceCount);
if (Vacb->SharedCacheMap->FileObject && Vacb->SharedCacheMap->FileObject->FileName.Length)
{
DPRINT1("For file: %wZ\n", &Vacb->SharedCacheMap->FileObject->FileName);
}
}
- ASSERT(Vacb->PinCount == 0);
ASSERT(Vacb->ReferenceCount == 0);
ASSERT(IsListEmpty(&Vacb->CacheMapVacbListEntry));
ASSERT(IsListEmpty(&Vacb->DirtyVacbListEntry));
NTAPI
CcRosDeleteFileCache (
PFILE_OBJECT FileObject,
- PROS_SHARED_CACHE_MAP SharedCacheMap)
+ PROS_SHARED_CACHE_MAP SharedCacheMap,
+ PKIRQL OldIrql)
/*
* FUNCTION: Releases the shared cache map associated with a file object
*/
PLIST_ENTRY current_entry;
PROS_VACB current;
LIST_ENTRY FreeList;
- KIRQL oldIrql;
ASSERT(SharedCacheMap);
SharedCacheMap->OpenCount++;
- KeReleaseGuardedMutex(&ViewLock);
+ KeReleaseQueuedSpinLock(LockQueueMasterLock, *OldIrql);
CcFlushCache(FileObject->SectionObjectPointer, NULL, 0, NULL);
- KeAcquireGuardedMutex(&ViewLock);
+ *OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
SharedCacheMap->OpenCount--;
if (SharedCacheMap->OpenCount == 0)
{
- KIRQL OldIrql;
-
FileObject->SectionObjectPointer->SharedCacheMap = NULL;
/*
* Release all VACBs
*/
InitializeListHead(&FreeList);
- KeAcquireSpinLock(&SharedCacheMap->CacheMapLock, &oldIrql);
+ KeAcquireSpinLockAtDpcLevel(&SharedCacheMap->CacheMapLock);
while (!IsListEmpty(&SharedCacheMap->CacheMapVacbListHead))
{
current_entry = RemoveTailList(&SharedCacheMap->CacheMapVacbListHead);
- KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldIrql);
+ KeReleaseSpinLockFromDpcLevel(&SharedCacheMap->CacheMapLock);
current = CONTAINING_RECORD(current_entry, ROS_VACB, CacheMapVacbListEntry);
RemoveEntryList(¤t->VacbLruListEntry);
InitializeListHead(¤t->VacbLruListEntry);
if (current->Dirty)
{
- KeAcquireSpinLock(&SharedCacheMap->CacheMapLock, &oldIrql);
+ KeAcquireSpinLockAtDpcLevel(&SharedCacheMap->CacheMapLock);
CcRosUnmarkDirtyVacb(current, FALSE);
- KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldIrql);
+ KeReleaseSpinLockFromDpcLevel(&SharedCacheMap->CacheMapLock);
DPRINT1("Freeing dirty VACB\n");
}
if (current->MappedCount != 0)
}
InsertHeadList(&FreeList, ¤t->CacheMapVacbListEntry);
- KeAcquireSpinLock(&SharedCacheMap->CacheMapLock, &oldIrql);
+ KeAcquireSpinLockAtDpcLevel(&SharedCacheMap->CacheMapLock);
}
#if DBG
SharedCacheMap->Trace = FALSE;
#endif
- KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldIrql);
+ KeReleaseSpinLockFromDpcLevel(&SharedCacheMap->CacheMapLock);
- KeReleaseGuardedMutex(&ViewLock);
+ KeReleaseQueuedSpinLock(LockQueueMasterLock, *OldIrql);
ObDereferenceObject(SharedCacheMap->FileObject);
while (!IsListEmpty(&FreeList))
{
DPRINT1("Leaking VACB %p attached to %p (%I64d)\n", current, FileObject, current->FileOffset.QuadPart);
DPRINT1("There are: %d references left\n", Refs);
- DPRINT1("Pin: %d, Map: %d\n", current->PinCount, current->MappedCount);
+ DPRINT1("Map: %d\n", current->MappedCount);
DPRINT1("Dirty: %d\n", current->Dirty);
if (FileObject->FileName.Length != 0)
{
#endif
}
- OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
+ *OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
RemoveEntryList(&SharedCacheMap->SharedCacheMapLinks);
- KeReleaseQueuedSpinLock(LockQueueMasterLock, OldIrql);
+ KeReleaseQueuedSpinLock(LockQueueMasterLock, *OldIrql);
ExFreeToNPagedLookasideList(&SharedCacheMapLookasideList, SharedCacheMap);
- KeAcquireGuardedMutex(&ViewLock);
+ *OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
}
return STATUS_SUCCESS;
}
PFILE_OBJECT FileObject)
{
PROS_SHARED_CACHE_MAP SharedCacheMap;
- KeAcquireGuardedMutex(&ViewLock);
+ KIRQL OldIrql;
+
+ OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
ASSERT(SharedCacheMap);
ASSERT(SharedCacheMap->OpenCount != 0);
SharedCacheMap->OpenCount++;
- KeReleaseGuardedMutex(&ViewLock);
+ KeReleaseQueuedSpinLock(LockQueueMasterLock, OldIrql);
}
VOID
PSECTION_OBJECT_POINTERS SectionObjectPointer)
{
PROS_SHARED_CACHE_MAP SharedCacheMap;
+ KIRQL OldIrql;
+
DPRINT("CcRosRemoveIfClosed()\n");
- KeAcquireGuardedMutex(&ViewLock);
+ OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
SharedCacheMap = SectionObjectPointer->SharedCacheMap;
if (SharedCacheMap && SharedCacheMap->OpenCount == 0)
{
- CcRosDeleteFileCache(SharedCacheMap->FileObject, SharedCacheMap);
+ CcRosDeleteFileCache(SharedCacheMap->FileObject, SharedCacheMap, &OldIrql);
}
- KeReleaseGuardedMutex(&ViewLock);
+ KeReleaseQueuedSpinLock(LockQueueMasterLock, OldIrql);
}
PFILE_OBJECT FileObject)
{
PROS_SHARED_CACHE_MAP SharedCacheMap;
- KeAcquireGuardedMutex(&ViewLock);
+ KIRQL OldIrql;
+
+ OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
ASSERT(SharedCacheMap);
if (SharedCacheMap->OpenCount > 0)
SharedCacheMap->OpenCount--;
if (SharedCacheMap->OpenCount == 0)
{
+ KeReleaseQueuedSpinLock(LockQueueMasterLock, OldIrql);
MmFreeSectionSegments(SharedCacheMap->FileObject);
- CcRosDeleteFileCache(FileObject, SharedCacheMap);
+
+ OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
+ CcRosDeleteFileCache(FileObject, SharedCacheMap, &OldIrql);
+ KeReleaseQueuedSpinLock(LockQueueMasterLock, OldIrql);
+
+ return;
}
}
- KeReleaseGuardedMutex(&ViewLock);
+ KeReleaseQueuedSpinLock(LockQueueMasterLock, OldIrql);
}
NTSTATUS
PPRIVATE_CACHE_MAP PrivateMap;
PROS_SHARED_CACHE_MAP SharedCacheMap;
- KeAcquireGuardedMutex(&ViewLock);
+ OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
if (FileObject->SectionObjectPointer->SharedCacheMap != NULL)
{
* lock the master lock, to be sure not to race
* with a potential read ahead ongoing!
*/
- OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
PrivateMap = FileObject->PrivateCacheMap;
FileObject->PrivateCacheMap = NULL;
- KeReleaseQueuedSpinLock(LockQueueMasterLock, OldIrql);
if (PrivateMap != NULL)
{
/* Remove it from the file */
- KeAcquireSpinLock(&SharedCacheMap->CacheMapLock, &OldIrql);
+ KeAcquireSpinLockAtDpcLevel(&SharedCacheMap->CacheMapLock);
RemoveEntryList(&PrivateMap->PrivateLinks);
- KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, OldIrql);
+ KeReleaseSpinLockFromDpcLevel(&SharedCacheMap->CacheMapLock);
/* And free it. */
if (PrivateMap != &SharedCacheMap->PrivateCacheMap)
SharedCacheMap->OpenCount--;
if (SharedCacheMap->OpenCount == 0)
{
+ KeReleaseQueuedSpinLock(LockQueueMasterLock, OldIrql);
MmFreeSectionSegments(SharedCacheMap->FileObject);
- CcRosDeleteFileCache(FileObject, SharedCacheMap);
+
+ OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
+ CcRosDeleteFileCache(FileObject, SharedCacheMap, &OldIrql);
+ KeReleaseQueuedSpinLock(LockQueueMasterLock, OldIrql);
+
+ return STATUS_SUCCESS;
}
}
}
}
- KeReleaseGuardedMutex(&ViewLock);
+ KeReleaseQueuedSpinLock(LockQueueMasterLock, OldIrql);
return STATUS_SUCCESS;
}
InitializeListHead(&SharedCacheMap->BcbList);
}
- KeAcquireGuardedMutex(&ViewLock);
+ OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
if (Allocated)
{
if (FileObject->SectionObjectPointer->SharedCacheMap == NULL)
KernelMode);
FileObject->SectionObjectPointer->SharedCacheMap = SharedCacheMap;
- OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
InsertTailList(&CcCleanSharedCacheMapList, &SharedCacheMap->SharedCacheMapLinks);
- KeReleaseQueuedSpinLock(LockQueueMasterLock, OldIrql);
}
else
{
/* If we also allocated the shared cache map for this file, kill it */
if (Allocated)
{
- OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
RemoveEntryList(&SharedCacheMap->SharedCacheMapLinks);
- KeReleaseQueuedSpinLock(LockQueueMasterLock, OldIrql);
FileObject->SectionObjectPointer->SharedCacheMap = NULL;
ObDereferenceObject(FileObject);
ExFreeToNPagedLookasideList(&SharedCacheMapLookasideList, SharedCacheMap);
}
- KeReleaseGuardedMutex(&ViewLock);
+ KeReleaseQueuedSpinLock(LockQueueMasterLock, OldIrql);
return STATUS_INSUFFICIENT_RESOURCES;
}
KeInitializeSpinLock(&PrivateMap->ReadAheadSpinLock);
/* Link it to the file */
- KeAcquireSpinLock(&SharedCacheMap->CacheMapLock, &OldIrql);
+ KeAcquireSpinLockAtDpcLevel(&SharedCacheMap->CacheMapLock);
InsertTailList(&SharedCacheMap->PrivateList, &PrivateMap->PrivateLinks);
- KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, OldIrql);
+ KeReleaseSpinLockFromDpcLevel(&SharedCacheMap->CacheMapLock);
FileObject->PrivateCacheMap = PrivateMap;
SharedCacheMap->OpenCount++;
}
- KeReleaseGuardedMutex(&ViewLock);
+ KeReleaseQueuedSpinLock(LockQueueMasterLock, OldIrql);
return STATUS_SUCCESS;
}
InitializeListHead(&CcDeferredWrites);
InitializeListHead(&CcCleanSharedCacheMapList);
KeInitializeSpinLock(&CcDeferredWriteSpinLock);
- KeInitializeGuardedMutex(&ViewLock);
ExInitializeNPagedLookasideList(&iBcbLookasideList,
NULL,
NULL,