* - Number of calls to CcMapData that couldn't wait
* - Number of calls to CcPinRead that could wait
* - Number of calls to CcPinRead that couldn't wait
+ * - Number of calls to CcPinMappedDataCount
*/
ULONG CcMapDataWait = 0;
ULONG CcMapDataNoWait = 0;
ULONG CcPinReadWait = 0;
ULONG CcPinReadNoWait = 0;
+ULONG CcPinMappedDataCount = 0;
/* FUNCTIONS *****************************************************************/
}
static
-BOOLEAN
-NTAPI
-CcpMapData(
+VOID
+CcpDereferenceBcb(
IN PROS_SHARED_CACHE_MAP SharedCacheMap,
- IN PLARGE_INTEGER FileOffset,
- IN ULONG Length,
- IN ULONG Flags,
- OUT PROS_VACB *pVacb,
- OUT PVOID *pBuffer)
+ IN PINTERNAL_BCB Bcb)
{
- LONGLONG ReadOffset;
- BOOLEAN Valid;
- PROS_VACB Vacb;
- NTSTATUS Status;
- LONGLONG ROffset;
-
- ReadOffset = FileOffset->QuadPart;
-
- DPRINT("SectionSize %I64x, FileSize %I64x\n",
- SharedCacheMap->SectionSize.QuadPart,
- SharedCacheMap->FileSize.QuadPart);
-
- if (ReadOffset % VACB_MAPPING_GRANULARITY + Length > VACB_MAPPING_GRANULARITY)
- {
- CCTRACE(CC_API_DEBUG, "FileObject=%p FileOffset=%p Length=%lu Flags=0x%lx -> FALSE\n",
- SharedCacheMap->FileObject, FileOffset, Length, Flags);
- return FALSE;
- }
+ ULONG RefCount;
+ KIRQL OldIrql;
- if (!BooleanFlagOn(Flags, MAP_NO_READ))
+ KeAcquireSpinLock(&SharedCacheMap->BcbSpinLock, &OldIrql);
+ RefCount = --Bcb->RefCount;
+ if (RefCount == 0)
{
- static int Warned = 0;
+ RemoveEntryList(&Bcb->BcbEntry);
+ KeReleaseSpinLock(&SharedCacheMap->BcbSpinLock, OldIrql);
- SetFlag(Flags, MAP_NO_READ);
- if (!Warned)
- {
- DPRINT1("Mapping/pinning with no read not implemented. Forcing read, might fail if wait not allowed\n");
- Warned++;
- }
- }
+ ASSERT(Bcb->PinCount == 0);
+ /*
+ * Don't mark dirty, if it was dirty,
+ * the VACB was already marked as such
+ * following the call to CcSetDirtyPinnedData
+ */
+ CcRosReleaseVacb(SharedCacheMap,
+ Bcb->Vacb,
+ FALSE,
+ FALSE);
- ROffset = ROUND_DOWN(ReadOffset, VACB_MAPPING_GRANULARITY);
- Status = CcRosRequestVacb(SharedCacheMap,
- ROffset,
- pBuffer,
- &Valid,
- &Vacb);
- if (!NT_SUCCESS(Status))
- {
- CCTRACE(CC_API_DEBUG, "FileObject=%p FileOffset=%p Length=%lu Flags=0x%lx -> FALSE\n",
- SharedCacheMap->FileObject, FileOffset, Length, Flags);
- ExRaiseStatus(Status);
- return FALSE;
+ ExDeleteResourceLite(&Bcb->Lock);
+ ExFreeToNPagedLookasideList(&iBcbLookasideList, Bcb);
}
-
- if (!Valid && BooleanFlagOn(Flags, MAP_NO_READ))
+ else
{
- if (!BooleanFlagOn(Flags, MAP_WAIT))
- {
- CcRosReleaseVacb(SharedCacheMap, Vacb, FALSE, FALSE, FALSE);
- CCTRACE(CC_API_DEBUG, "FileObject=%p FileOffset=%p Length=%lu Flags=0x%lx -> FALSE\n",
- SharedCacheMap->FileObject, FileOffset, Length, Flags);
- return FALSE;
- }
-
- Status = CcReadVirtualAddress(Vacb);
- if (!NT_SUCCESS(Status))
- {
- CcRosReleaseVacb(SharedCacheMap, Vacb, FALSE, FALSE, FALSE);
- CCTRACE(CC_API_DEBUG, "FileObject=%p FileOffset=%p Length=%lu Flags=0x%lx -> FALSE\n",
- SharedCacheMap->FileObject, FileOffset, Length, Flags);
- ExRaiseStatus(Status);
- return FALSE;
- }
+ KeReleaseSpinLock(&SharedCacheMap->BcbSpinLock, OldIrql);
}
-
- *pBuffer = (PUCHAR)*pBuffer + ReadOffset % VACB_MAPPING_GRANULARITY;
- *pVacb = Vacb;
-
- return TRUE;
}
static
iBcb = ExAllocateFromNPagedLookasideList(&iBcbLookasideList);
if (iBcb == NULL)
{
- CcRosReleaseVacb(SharedCacheMap, Vacb, TRUE, FALSE, FALSE);
+ CcRosReleaseVacb(SharedCacheMap, Vacb, FALSE, FALSE);
return NULL;
}
RtlZeroMemory(iBcb, sizeof(*iBcb));
- iBcb->PFCB.NodeTypeCode = 0xDE45; /* Undocumented (CAPTIVE_PUBLIC_BCB_NODETYPECODE) */
- iBcb->PFCB.NodeByteSize = sizeof(PUBLIC_BCB);
+ iBcb->PFCB.NodeTypeCode = 0x2FD; /* As per KMTests */
+ iBcb->PFCB.NodeByteSize = 0;
iBcb->PFCB.MappedLength = Length;
iBcb->PFCB.MappedFileOffset = *FileOffset;
iBcb->Vacb = Vacb;
- iBcb->Dirty = FALSE;
iBcb->PinCount = 0;
iBcb->RefCount = 1;
ExInitializeResourceLite(&iBcb->Lock);
/* Yes, and we've lost */
if (DupBcb != NULL)
{
+ /* We will return that BCB */
+ ++DupBcb->RefCount;
Result = TRUE;
+ KeReleaseSpinLock(&SharedCacheMap->BcbSpinLock, OldIrql);
if (ToPin)
{
- DupBcb->PinCount++;
-
if (BooleanFlagOn(PinFlags, PIN_EXCLUSIVE))
{
Result = ExAcquireResourceExclusiveLite(&iBcb->Lock, BooleanFlagOn(PinFlags, PIN_WAIT));
Result = ExAcquireSharedStarveExclusive(&iBcb->Lock, BooleanFlagOn(PinFlags, PIN_WAIT));
}
- if (!Result)
+ if (Result)
{
- DupBcb->PinCount--;
+ DupBcb->PinCount++;
+ }
+ else
+ {
+ CcpDereferenceBcb(SharedCacheMap, DupBcb);
DupBcb = NULL;
}
}
- if (Result)
+ if (DupBcb != NULL)
{
- /* We'll return that BCB */
- ++DupBcb->RefCount;
+ /* Delete the loser */
+ CcRosReleaseVacb(SharedCacheMap, Vacb, FALSE, FALSE);
+ ExDeleteResourceLite(&iBcb->Lock);
+ ExFreeToNPagedLookasideList(&iBcbLookasideList, iBcb);
}
- /* Delete the loser */
- CcRosReleaseVacb(SharedCacheMap, Vacb, TRUE, FALSE, FALSE);
- ExDeleteResourceLite(&iBcb->Lock);
- ExFreeToNPagedLookasideList(&iBcbLookasideList, iBcb);
-
/* Return the winner - no need to update buffer address, it's
* relative to the VACB, which is unchanged.
*/
}
InsertTailList(&SharedCacheMap->BcbList, &iBcb->BcbEntry);
+ KeReleaseSpinLock(&SharedCacheMap->BcbSpinLock, OldIrql);
}
- KeReleaseSpinLock(&SharedCacheMap->BcbSpinLock, OldIrql);
return iBcb;
}
OUT PVOID * Buffer)
{
PINTERNAL_BCB NewBcb;
- BOOLEAN Result;
- PROS_VACB Vacb;
KIRQL OldIrql;
+ ULONG VacbOffset;
+ NTSTATUS Status;
+ _SEH2_VOLATILE BOOLEAN Result;
+
+ VacbOffset = (ULONG)(FileOffset->QuadPart % VACB_MAPPING_GRANULARITY);
+
+ if ((VacbOffset + Length) > VACB_MAPPING_GRANULARITY)
+ {
+ /* Complain loudly, we shoud pin the whole range */
+ DPRINT1("TRUNCATING DATA PIN FROM %lu to %lu!\n", Length, VACB_MAPPING_GRANULARITY - VacbOffset);
+ Length = VACB_MAPPING_GRANULARITY - VacbOffset;
+ }
KeAcquireSpinLock(&SharedCacheMap->BcbSpinLock, &OldIrql);
NewBcb = CcpFindBcb(SharedCacheMap, FileOffset, Length, TRUE);
- KeReleaseSpinLock(&SharedCacheMap->BcbSpinLock, OldIrql);
if (NewBcb != NULL)
{
- NewBcb->PinCount++;
+ BOOLEAN Result;
+
+ ++NewBcb->RefCount;
+ KeReleaseSpinLock(&SharedCacheMap->BcbSpinLock, OldIrql);
if (BooleanFlagOn(Flags, PIN_EXCLUSIVE))
- {
Result = ExAcquireResourceExclusiveLite(&NewBcb->Lock, BooleanFlagOn(Flags, PIN_WAIT));
- }
else
- {
Result = ExAcquireSharedStarveExclusive(&NewBcb->Lock, BooleanFlagOn(Flags, PIN_WAIT));
- }
if (!Result)
{
- NewBcb->PinCount--;
- }
- else
- {
- NewBcb->RefCount++;
- *Bcb = NewBcb;
- *Buffer = (PUCHAR)NewBcb->Vacb->BaseAddress + FileOffset->QuadPart % VACB_MAPPING_GRANULARITY;
+ CcpDereferenceBcb(SharedCacheMap, NewBcb);
+ return FALSE;
}
- return Result;
+ NewBcb->PinCount++;
}
else
{
+ LONGLONG ROffset;
+ PROS_VACB Vacb;
+
+ KeReleaseSpinLock(&SharedCacheMap->BcbSpinLock, OldIrql);
+
if (BooleanFlagOn(Flags, PIN_IF_BCB))
{
return FALSE;
}
- Result = CcpMapData(SharedCacheMap, FileOffset, Length, Flags, &Vacb, Buffer);
- if (Result)
+ /* Properly round offset and call internal helper for getting a VACB */
+ ROffset = ROUND_DOWN(FileOffset->QuadPart, VACB_MAPPING_GRANULARITY);
+ Status = CcRosGetVacb(SharedCacheMap, ROffset, &Vacb);
+ if (!NT_SUCCESS(Status))
{
- NewBcb = CcpGetAppropriateBcb(SharedCacheMap, Vacb, FileOffset, Length, Flags, TRUE);
- if (NewBcb == NULL)
- {
- CcRosReleaseVacb(SharedCacheMap, Vacb, TRUE, FALSE, FALSE);
- Result = FALSE;
- }
- else
- {
- *Bcb = NewBcb;
- }
+ CCTRACE(CC_API_DEBUG, "FileObject=%p FileOffset=%p Length=%lu Flags=0x%lx -> FALSE\n",
+ SharedCacheMap->FileObject, FileOffset, Length, Flags);
+ ExRaiseStatus(Status);
+ return FALSE;
+ }
+
+ NewBcb = CcpGetAppropriateBcb(SharedCacheMap, Vacb, FileOffset, Length, Flags, TRUE);
+ if (NewBcb == NULL)
+ {
+ CcRosReleaseVacb(SharedCacheMap, Vacb, FALSE, FALSE);
+ return FALSE;
+ }
+ }
+
+ Result = FALSE;
+ _SEH2_TRY
+ {
+ /* Ensure the pages are resident */
+ Result = CcRosEnsureVacbResident(NewBcb->Vacb,
+ BooleanFlagOn(Flags, PIN_WAIT),
+ BooleanFlagOn(Flags, PIN_NO_READ),
+ VacbOffset, Length);
+ }
+ _SEH2_FINALLY
+ {
+ if (!Result)
+ {
+ CCTRACE(CC_API_DEBUG, "FileObject=%p FileOffset=%p Length=%lu Flags=0x%lx -> FALSE\n",
+ SharedCacheMap->FileObject, FileOffset, Length, Flags);
+ CcUnpinData(&NewBcb->PFCB);
+ *Bcb = NULL;
+ *Buffer = NULL;
}
}
+ _SEH2_END;
+
+ if (Result)
+ {
+ *Bcb = &NewBcb->PFCB;
+ *Buffer = (PVOID)((ULONG_PTR)NewBcb->Vacb->BaseAddress + VacbOffset);
+ }
return Result;
}
OUT PVOID *pBcb,
OUT PVOID *pBuffer)
{
- BOOLEAN Ret;
KIRQL OldIrql;
PINTERNAL_BCB iBcb;
PROS_VACB Vacb;
PROS_SHARED_CACHE_MAP SharedCacheMap;
+ ULONG VacbOffset;
+ NTSTATUS Status;
+ _SEH2_VOLATILE BOOLEAN Result;
- DPRINT("CcMapData(FileObject 0x%p, FileOffset %I64x, Length %lu, Flags 0x%lx,"
+ CCTRACE(CC_API_DEBUG, "CcMapData(FileObject 0x%p, FileOffset 0x%I64x, Length %lu, Flags 0x%lx,"
" pBcb 0x%p, pBuffer 0x%p)\n", FileObject, FileOffset->QuadPart,
Length, Flags, pBcb, pBuffer);
++CcMapDataNoWait;
}
+ VacbOffset = (ULONG)(FileOffset->QuadPart % VACB_MAPPING_GRANULARITY);
+ /* KMTests seem to show that it is allowed to call accross mapping granularity */
+ if ((VacbOffset + Length) > VACB_MAPPING_GRANULARITY)
+ {
+ DPRINT1("TRUNCATING DATA MAP FROM %lu to %lu!\n", Length, VACB_MAPPING_GRANULARITY - VacbOffset);
+ Length = VACB_MAPPING_GRANULARITY - VacbOffset;
+ }
+
KeAcquireSpinLock(&SharedCacheMap->BcbSpinLock, &OldIrql);
iBcb = CcpFindBcb(SharedCacheMap, FileOffset, Length, FALSE);
- KeReleaseSpinLock(&SharedCacheMap->BcbSpinLock, OldIrql);
if (iBcb == NULL)
{
- Ret = CcpMapData(SharedCacheMap, FileOffset, Length, Flags, &Vacb, pBuffer);
- if (Ret)
+ KeReleaseSpinLock(&SharedCacheMap->BcbSpinLock, OldIrql);
+
+ /* Call internal helper for getting a VACB */
+ Status = CcRosGetVacb(SharedCacheMap, FileOffset->QuadPart, &Vacb);
+ if (!NT_SUCCESS(Status))
{
- iBcb = CcpGetAppropriateBcb(SharedCacheMap, Vacb, FileOffset, Length, 0, FALSE);
- if (iBcb == NULL)
- {
- CcRosReleaseVacb(SharedCacheMap, Vacb, TRUE, FALSE, FALSE);
- Ret = FALSE;
- }
- else
- {
- *pBcb = iBcb;
- }
+ CCTRACE(CC_API_DEBUG, "FileObject=%p FileOffset=%p Length=%lu Flags=0x%lx -> FALSE\n",
+ SharedCacheMap->FileObject, FileOffset, Length, Flags);
+ ExRaiseStatus(Status);
+ }
+
+ iBcb = CcpGetAppropriateBcb(SharedCacheMap, Vacb, FileOffset, Length, 0, FALSE);
+ if (iBcb == NULL)
+ {
+ CcRosReleaseVacb(SharedCacheMap, Vacb, FALSE, FALSE);
+ CCTRACE(CC_API_DEBUG, "FileObject=%p FileOffset=%p Length=%lu Flags=0x%lx -> FALSE\n",
+ SharedCacheMap->FileObject, FileOffset, Length, Flags);
+ *pBcb = NULL; // If you ever remove this for compat, make sure to review all callers for using an unititialized value
+ ExRaiseStatus(STATUS_INSUFFICIENT_RESOURCES);
}
}
else
{
++iBcb->RefCount;
- *pBcb = iBcb;
- *pBuffer = (PUCHAR)iBcb->Vacb->BaseAddress + FileOffset->QuadPart % VACB_MAPPING_GRANULARITY;
- Ret = TRUE;
+ KeReleaseSpinLock(&SharedCacheMap->BcbSpinLock, OldIrql);
}
- CCTRACE(CC_API_DEBUG, "FileObject=%p FileOffset=%p Length=%lu Flags=0x%lx -> %d Bcb=%p\n",
- FileObject, FileOffset, Length, Flags, Ret, *pBcb);
- return Ret;
+ _SEH2_TRY
+ {
+ Result = FALSE;
+ /* Ensure the pages are resident */
+ Result = CcRosEnsureVacbResident(iBcb->Vacb, BooleanFlagOn(Flags, MAP_WAIT),
+ BooleanFlagOn(Flags, MAP_NO_READ), VacbOffset, Length);
+ }
+ _SEH2_FINALLY
+ {
+ if (!Result)
+ {
+ CcpDereferenceBcb(SharedCacheMap, iBcb);
+ *pBcb = NULL;
+ *pBuffer = NULL;
+ }
+ }
+ _SEH2_END;
+
+ if (Result)
+ {
+ *pBcb = &iBcb->PFCB;
+ *pBuffer = (PVOID)((ULONG_PTR)iBcb->Vacb->BaseAddress + VacbOffset);
+ }
+
+ CCTRACE(CC_API_DEBUG, "FileObject=%p FileOffset=%p Length=%lu Flags=0x%lx -> TRUE Bcb=%p, Buffer %p\n",
+ FileObject, FileOffset, Length, Flags, *pBcb, *pBuffer);
+ return Result;
}
/*
return FALSE;
}
- iBcb = *Bcb;
+ iBcb = *Bcb ? CONTAINING_RECORD(*Bcb, INTERNAL_BCB, PFCB) : NULL;
+
+ ++CcPinMappedDataCount;
Result = CcpPinData(SharedCacheMap, FileOffset, Length, Flags, Bcb, &Buffer);
if (Result)
{
- CcUnpinData(iBcb);
+ CcUnpinData(&iBcb->PFCB);
}
return Result;
IN PVOID Bcb,
IN PLARGE_INTEGER Lsn)
{
- PINTERNAL_BCB iBcb = Bcb;
+ PINTERNAL_BCB iBcb = CONTAINING_RECORD(Bcb, INTERNAL_BCB, PFCB);
- CCTRACE(CC_API_DEBUG, "Bcb=%p Lsn=%p\n",
- Bcb, Lsn);
+ CCTRACE(CC_API_DEBUG, "Bcb=%p Lsn=%p\n", Bcb, Lsn);
+
+ /* Tell Mm */
+ MmMakePagesDirty(NULL,
+ Add2Ptr(iBcb->Vacb->BaseAddress, iBcb->PFCB.MappedFileOffset.QuadPart - iBcb->Vacb->FileOffset.QuadPart),
+ iBcb->PFCB.MappedLength);
- iBcb->Dirty = TRUE;
if (!iBcb->Vacb->Dirty)
{
CcRosMarkDirtyVacb(iBcb->Vacb);
IN PVOID Bcb,
IN ERESOURCE_THREAD ResourceThreadId)
{
- PINTERNAL_BCB iBcb = Bcb;
+ PINTERNAL_BCB iBcb = CONTAINING_RECORD(Bcb, INTERNAL_BCB, PFCB);
CCTRACE(CC_API_DEBUG, "Bcb=%p ResourceThreadId=%lu\n", Bcb, ResourceThreadId);
iBcb->PinCount--;
}
- if (--iBcb->RefCount == 0)
- {
- KIRQL OldIrql;
- PROS_SHARED_CACHE_MAP SharedCacheMap;
-
- ASSERT(iBcb->PinCount == 0);
- SharedCacheMap = iBcb->Vacb->SharedCacheMap;
- CcRosReleaseVacb(SharedCacheMap,
- iBcb->Vacb,
- TRUE,
- iBcb->Dirty,
- FALSE);
-
- KeAcquireSpinLock(&SharedCacheMap->BcbSpinLock, &OldIrql);
- if (!IsListEmpty(&iBcb->BcbEntry))
- {
- RemoveEntryList(&iBcb->BcbEntry);
- }
- KeReleaseSpinLock(&SharedCacheMap->BcbSpinLock, OldIrql);
-
- ExDeleteResourceLite(&iBcb->Lock);
- ExFreeToNPagedLookasideList(&iBcbLookasideList, iBcb);
- }
+ CcpDereferenceBcb(iBcb->Vacb->SharedCacheMap, iBcb);
}
/*
CcRepinBcb (
IN PVOID Bcb)
{
- PINTERNAL_BCB iBcb = Bcb;
+ PINTERNAL_BCB iBcb = CONTAINING_RECORD(Bcb, INTERNAL_BCB, PFCB);
CCTRACE(CC_API_DEBUG, "Bcb=%p\n", Bcb);
IN BOOLEAN WriteThrough,
IN PIO_STATUS_BLOCK IoStatus)
{
- PINTERNAL_BCB iBcb = Bcb;
+ PINTERNAL_BCB iBcb = CONTAINING_RECORD(Bcb, INTERNAL_BCB, PFCB);
KIRQL OldIrql;
PROS_SHARED_CACHE_MAP SharedCacheMap;
CCTRACE(CC_API_DEBUG, "Bcb=%p WriteThrough=%d\n", Bcb, WriteThrough);
+ SharedCacheMap = iBcb->Vacb->SharedCacheMap;
IoStatus->Status = STATUS_SUCCESS;
- if (--iBcb->RefCount == 0)
+
+ if (WriteThrough)
{
+ CcFlushCache(iBcb->Vacb->SharedCacheMap->FileObject->SectionObjectPointer,
+ &iBcb->PFCB.MappedFileOffset,
+ iBcb->PFCB.MappedLength,
+ IoStatus);
+ }
+ else
+ {
+ IoStatus->Status = STATUS_SUCCESS;
IoStatus->Information = 0;
- if (WriteThrough)
- {
- if (iBcb->Vacb->Dirty)
- {
- IoStatus->Status = CcRosFlushVacb(iBcb->Vacb);
- }
- else
- {
- IoStatus->Status = STATUS_SUCCESS;
- }
- }
- else
- {
- IoStatus->Status = STATUS_SUCCESS;
- }
+ }
+
+ KeAcquireSpinLock(&SharedCacheMap->BcbSpinLock, &OldIrql);
+ if (--iBcb->RefCount == 0)
+ {
+ RemoveEntryList(&iBcb->BcbEntry);
+ KeReleaseSpinLock(&SharedCacheMap->BcbSpinLock, OldIrql);
if (iBcb->PinCount != 0)
{
ASSERT(iBcb->PinCount == 0);
}
- SharedCacheMap = iBcb->Vacb->SharedCacheMap;
+ /*
+ * Don't mark dirty, if it was dirty,
+ * the VACB was already marked as such
+ * following the call to CcSetDirtyPinnedData
+ */
CcRosReleaseVacb(iBcb->Vacb->SharedCacheMap,
iBcb->Vacb,
- TRUE,
- iBcb->Dirty,
+ FALSE,
FALSE);
- KeAcquireSpinLock(&SharedCacheMap->BcbSpinLock, &OldIrql);
- if (!IsListEmpty(&iBcb->BcbEntry))
- {
- RemoveEntryList(&iBcb->BcbEntry);
- }
- KeReleaseSpinLock(&SharedCacheMap->BcbSpinLock, OldIrql);
-
ExDeleteResourceLite(&iBcb->Lock);
ExFreeToNPagedLookasideList(&iBcbLookasideList, iBcb);
}
+ else
+ {
+ KeReleaseSpinLock(&SharedCacheMap->BcbSpinLock, OldIrql);
+ }
}
projects / reactos.git / blobdiff