Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-06-20 07:36:05 +00:00
Code Issues Projects Releases Packages Wiki Activity

[FORMATTING]

Browse source 
* Addendum to r56262.

svn path=/trunk/; revision=56273
This commit is contained in:
Amine Khaldi 2012-03-29 12:14:58 +00:00
parent 4d61c55638
commit aabb4465a0
13 changed files with 1259 additions and 1151 deletions
Download patch file Download diff file Expand all files Collapse all files

405
reactos/ntoskrnl/cache/cachesub.c vendored
View file

@ -19,10 +19,10 @@
typedef struct _WORK_QUEUE_WITH_READ_AHEAD typedef struct _WORK_QUEUE_WITH_READ_AHEAD
{ {
WORK_QUEUE_ITEM WorkItem; WORK_QUEUE_ITEM WorkItem;
PFILE_OBJECT FileObject; PFILE_OBJECT FileObject;
LARGE_INTEGER FileOffset; LARGE_INTEGER FileOffset;
ULONG Length; ULONG Length;
} WORK_QUEUE_WITH_READ_AHEAD, *PWORK_QUEUE_WITH_READ_AHEAD; } WORK_QUEUE_WITH_READ_AHEAD, *PWORK_QUEUE_WITH_READ_AHEAD;
/* FUNCTIONS ******************************************************************/ /* FUNCTIONS ******************************************************************/
@ -37,52 +37,54 @@ CcSetReadAheadGranularity(IN PFILE_OBJECT FileObject,
IN ULONG Granularity) IN ULONG Granularity)
{ {
PNOCC_CACHE_MAP Map = (PNOCC_CACHE_MAP)FileObject->SectionObjectPointer->SharedCacheMap; PNOCC_CACHE_MAP Map = (PNOCC_CACHE_MAP)FileObject->SectionObjectPointer->SharedCacheMap;
if (Map) if (Map)
{ {
Map->ReadAheadGranularity = Granularity; Map->ReadAheadGranularity = Granularity;
} }
} }
VOID VOID
NTAPI NTAPI
CcpReadAhead(PVOID Context) CcpReadAhead(PVOID Context)
{ {
LARGE_INTEGER Offset; LARGE_INTEGER Offset;
PWORK_QUEUE_WITH_READ_AHEAD WorkItem = (PWORK_QUEUE_WITH_READ_AHEAD)Context; PWORK_QUEUE_WITH_READ_AHEAD WorkItem = (PWORK_QUEUE_WITH_READ_AHEAD)Context;
PNOCC_CACHE_MAP Map = (PNOCC_CACHE_MAP)WorkItem->FileObject->SectionObjectPointer->SharedCacheMap; PNOCC_CACHE_MAP Map = (PNOCC_CACHE_MAP)WorkItem->FileObject->SectionObjectPointer->SharedCacheMap;
DPRINT1("Reading ahead %08x%08x:%x %wZ\n",
WorkItem->FileOffset.HighPart, DPRINT1("Reading ahead %08x%08x:%x %wZ\n",
WorkItem->FileOffset.LowPart, WorkItem->FileOffset.HighPart,
WorkItem->Length, WorkItem->FileOffset.LowPart,
&WorkItem->FileObject->FileName); WorkItem->Length,
Offset.HighPart = WorkItem->FileOffset.HighPart; &WorkItem->FileObject->FileName);
Offset.LowPart = PAGE_ROUND_DOWN(WorkItem->FileOffset.LowPart);
if (Map) Offset.HighPart = WorkItem->FileOffset.HighPart;
{ Offset.LowPart = PAGE_ROUND_DOWN(WorkItem->FileOffset.LowPart);
PLIST_ENTRY ListEntry; if (Map)
volatile char *chptr; {
PNOCC_BCB Bcb; PLIST_ENTRY ListEntry;
for (ListEntry = Map->AssociatedBcb.Flink; volatile char *chptr;
ListEntry != &Map->AssociatedBcb; PNOCC_BCB Bcb;
ListEntry = ListEntry->Flink) for (ListEntry = Map->AssociatedBcb.Flink;
{ ListEntry != &Map->AssociatedBcb;
Bcb = CONTAINING_RECORD(ListEntry, NOCC_BCB, ThisFileList); ListEntry = ListEntry->Flink)
if ((Offset.QuadPart + WorkItem->Length < Bcb->FileOffset.QuadPart) || {
(Bcb->FileOffset.QuadPart + Bcb->Length < Offset.QuadPart)) Bcb = CONTAINING_RECORD(ListEntry, NOCC_BCB, ThisFileList);
continue; if ((Offset.QuadPart + WorkItem->Length < Bcb->FileOffset.QuadPart) ||
for (chptr = Bcb->BaseAddress, Offset = Bcb->FileOffset; (Bcb->FileOffset.QuadPart + Bcb->Length < Offset.QuadPart))
chptr < ((PCHAR)Bcb->BaseAddress) + Bcb->Length && continue;
Offset.QuadPart < for (chptr = Bcb->BaseAddress, Offset = Bcb->FileOffset;
WorkItem->FileOffset.QuadPart + WorkItem->Length; chptr < ((PCHAR)Bcb->BaseAddress) + Bcb->Length &&
chptr += PAGE_SIZE, Offset.QuadPart += PAGE_SIZE) Offset.QuadPart <
{ WorkItem->FileOffset.QuadPart + WorkItem->Length;
*chptr ^= 0; chptr += PAGE_SIZE, Offset.QuadPart += PAGE_SIZE)
} {
} *chptr ^= 0;
} }
ObDereferenceObject(WorkItem->FileObject); }
ExFreePool(WorkItem); }
DPRINT("Done\n"); ObDereferenceObject(WorkItem->FileObject);
ExFreePool(WorkItem);
DPRINT("Done\n");
} }
VOID VOID
@ -91,30 +93,36 @@ CcScheduleReadAhead(IN PFILE_OBJECT FileObject,
IN PLARGE_INTEGER FileOffset, IN PLARGE_INTEGER FileOffset,
IN ULONG Length) IN ULONG Length)
{ {
PWORK_QUEUE_WITH_READ_AHEAD WorkItem; PWORK_QUEUE_WITH_READ_AHEAD WorkItem;
DPRINT("Schedule read ahead %08x%08x:%x %wZ\n",
FileOffset->HighPart, DPRINT("Schedule read ahead %08x%08x:%x %wZ\n",
FileOffset->LowPart, FileOffset->HighPart,
Length, FileOffset->LowPart,
&FileObject->FileName); Length,
WorkItem = ExAllocatePool(NonPagedPool, sizeof(*WorkItem)); &FileObject->FileName);
if (!WorkItem) KeBugCheck(0);
ObReferenceObject(FileObject); WorkItem = ExAllocatePool(NonPagedPool, sizeof(*WorkItem));
WorkItem->FileObject = FileObject; if (!WorkItem) KeBugCheck(0);
WorkItem->FileOffset = *FileOffset; ObReferenceObject(FileObject);
WorkItem->Length = Length; WorkItem->FileObject = FileObject;
ExInitializeWorkItem(((PWORK_QUEUE_ITEM)WorkItem), (PWORKER_THREAD_ROUTINE)CcpReadAhead, WorkItem); WorkItem->FileOffset = *FileOffset;
ExQueueWorkItem((PWORK_QUEUE_ITEM)WorkItem, DelayedWorkQueue); WorkItem->Length = Length;
DPRINT("Done\n");
ExInitializeWorkItem(((PWORK_QUEUE_ITEM)WorkItem),
(PWORKER_THREAD_ROUTINE)CcpReadAhead,
WorkItem);
ExQueueWorkItem((PWORK_QUEUE_ITEM)WorkItem, DelayedWorkQueue);
DPRINT("Done\n");
} }
VOID VOID
NTAPI NTAPI
CcSetDirtyPinnedData(IN PVOID BcbVoid, CcSetDirtyPinnedData(IN PVOID BcbVoid,
IN OPTIONAL PLARGE_INTEGER Lsn) IN OPTIONAL PLARGE_INTEGER Lsn)
{ {
PNOCC_BCB Bcb = (PNOCC_BCB)BcbVoid; PNOCC_BCB Bcb = (PNOCC_BCB)BcbVoid;
Bcb->Dirty = TRUE; Bcb->Dirty = TRUE;
} }
LARGE_INTEGER LARGE_INTEGER
@ -128,80 +136,84 @@ CcGetFlushedValidData(IN PSECTION_OBJECT_POINTERS SectionObjectPointer,
return Result; return Result;
} }
VOID VOID
NTAPI NTAPI
_CcpFlushCache(IN PNOCC_CACHE_MAP Map, _CcpFlushCache(IN PNOCC_CACHE_MAP Map,
IN OPTIONAL PLARGE_INTEGER FileOffset, IN OPTIONAL PLARGE_INTEGER FileOffset,
IN ULONG Length, IN ULONG Length,
OUT OPTIONAL PIO_STATUS_BLOCK IoStatus, OUT OPTIONAL PIO_STATUS_BLOCK IoStatus,
BOOLEAN Delete, BOOLEAN Delete,
const char *File, const char *File,
int Line) int Line)
{ {
PNOCC_BCB Bcb = NULL; PNOCC_BCB Bcb = NULL;
LARGE_INTEGER LowerBound, UpperBound; LARGE_INTEGER LowerBound, UpperBound;
PLIST_ENTRY ListEntry; PLIST_ENTRY ListEntry;
IO_STATUS_BLOCK IOSB; IO_STATUS_BLOCK IOSB;
RtlZeroMemory(&IOSB, sizeof(IO_STATUS_BLOCK)); RtlZeroMemory(&IOSB, sizeof(IO_STATUS_BLOCK));
DPRINT("CcFlushCache (while file) (%s:%d)\n", File, Line); DPRINT("CcFlushCache (while file) (%s:%d)\n", File, Line);
if (FileOffset && Length) if (FileOffset && Length)
{ {
LowerBound.QuadPart = FileOffset->QuadPart; LowerBound.QuadPart = FileOffset->QuadPart;
UpperBound.QuadPart = LowerBound.QuadPart + Length; UpperBound.QuadPart = LowerBound.QuadPart + Length;
} }
else else
{ {
LowerBound.QuadPart = 0; LowerBound.QuadPart = 0;
UpperBound.QuadPart = 0x7fffffffffffffffull; UpperBound.QuadPart = 0x7fffffffffffffffull;
} }
CcpLock(); CcpLock();
ListEntry = Map->AssociatedBcb.Flink; ListEntry = Map->AssociatedBcb.Flink;
while (ListEntry != &Map->AssociatedBcb) while (ListEntry != &Map->AssociatedBcb)
{ {
Bcb = CONTAINING_RECORD(ListEntry, NOCC_BCB, ThisFileList); Bcb = CONTAINING_RECORD(ListEntry, NOCC_BCB, ThisFileList);
CcpReferenceCache((ULONG)(Bcb - CcCacheSections)); CcpReferenceCache((ULONG)(Bcb - CcCacheSections));
if (Bcb->FileOffset.QuadPart + Bcb->Length >= LowerBound.QuadPart && if (Bcb->FileOffset.QuadPart + Bcb->Length >= LowerBound.QuadPart &&
Bcb->FileOffset.QuadPart < UpperBound.QuadPart) Bcb->FileOffset.QuadPart < UpperBound.QuadPart)
{ {
DPRINT DPRINT("Bcb #%x (@%08x%08x)\n",
("Bcb #%x (@%08x%08x)\n", Bcb - CcCacheSections,
Bcb - CcCacheSections, Bcb->FileOffset.u.HighPart, Bcb->FileOffset.u.LowPart);
Bcb->FileOffset.u.HighPart, Bcb->FileOffset.u.LowPart);
Bcb->RefCount++; Bcb->RefCount++;
CcpUnlock(); CcpUnlock();
MiFlushMappedSection(Bcb->BaseAddress, &Bcb->FileOffset, &Map->FileSizes.FileSize, Bcb->Dirty); MiFlushMappedSection(Bcb->BaseAddress,
CcpLock(); &Bcb->FileOffset,
Bcb->RefCount--; &Map->FileSizes.FileSize,
Bcb->Dirty);
CcpLock();
Bcb->RefCount--;
Bcb->Dirty = FALSE; Bcb->Dirty = FALSE;
ListEntry = ListEntry->Flink; ListEntry = ListEntry->Flink;
if (Delete && Bcb->RefCount < 2) if (Delete && Bcb->RefCount < 2)
{ {
Bcb->RefCount = 1; Bcb->RefCount = 1;
CcpDereferenceCache((ULONG)(Bcb - CcCacheSections), FALSE); CcpDereferenceCache((ULONG)(Bcb - CcCacheSections), FALSE);
} }
else else
CcpUnpinData(Bcb, TRUE); {
} CcpUnpinData(Bcb, TRUE);
else }
{ }
ListEntry = ListEntry->Flink; else
CcpUnpinData(Bcb, TRUE); {
} ListEntry = ListEntry->Flink;
CcpUnpinData(Bcb, TRUE);
}
DPRINT("End loop\n"); DPRINT("End loop\n");
} }
CcpUnlock(); CcpUnlock();
if (IoStatus) *IoStatus = IOSB; if (IoStatus) *IoStatus = IOSB;
} }
@ -215,25 +227,24 @@ CcFlushCache(IN PSECTION_OBJECT_POINTERS SectionObjectPointer,
{ {
PNOCC_CACHE_MAP Map = (PNOCC_CACHE_MAP)SectionObjectPointer->SharedCacheMap; PNOCC_CACHE_MAP Map = (PNOCC_CACHE_MAP)SectionObjectPointer->SharedCacheMap;
// Not cached /* Not cached */
if (!Map) if (!Map)
{ {
if (IoStatus) if (IoStatus)
{ {
IoStatus->Status = STATUS_SUCCESS; IoStatus->Status = STATUS_SUCCESS;
IoStatus->Information = 0; IoStatus->Information = 0;
} }
return; return;
} }
CcpFlushCache(Map, FileOffset, Length, IoStatus, TRUE); CcpFlushCache(Map, FileOffset, Length, IoStatus, TRUE);
} }
BOOLEAN BOOLEAN
NTAPI NTAPI
CcFlushImageSection CcFlushImageSection(PSECTION_OBJECT_POINTERS SectionObjectPointer,
(PSECTION_OBJECT_POINTERS SectionObjectPointer, MMFLUSH_TYPE FlushType)
MMFLUSH_TYPE FlushType)
{ {
PNOCC_CACHE_MAP Map = (PNOCC_CACHE_MAP)SectionObjectPointer->SharedCacheMap; PNOCC_CACHE_MAP Map = (PNOCC_CACHE_MAP)SectionObjectPointer->SharedCacheMap;
PNOCC_BCB Bcb; PNOCC_BCB Bcb;
@ -241,93 +252,91 @@ CcFlushImageSection
IO_STATUS_BLOCK IOSB; IO_STATUS_BLOCK IOSB;
BOOLEAN Result = TRUE; BOOLEAN Result = TRUE;
if (!Map) return TRUE; if (!Map) return TRUE;
for (Entry = Map->AssociatedBcb.Flink; for (Entry = Map->AssociatedBcb.Flink;
Entry != &Map->AssociatedBcb; Entry != &Map->AssociatedBcb;
Entry = Entry->Flink) Entry = Entry->Flink)
{ {
Bcb = CONTAINING_RECORD(Entry, NOCC_BCB, ThisFileList); Bcb = CONTAINING_RECORD(Entry, NOCC_BCB, ThisFileList);
if (!Bcb->Dirty) continue; if (!Bcb->Dirty) continue;
switch (FlushType) switch (FlushType)
{ {
case MmFlushForDelete: case MmFlushForDelete:
CcPurgeCacheSection CcPurgeCacheSection(SectionObjectPointer,
(SectionObjectPointer, &Bcb->FileOffset,
&Bcb->FileOffset, Bcb->Length,
Bcb->Length, FALSE);
FALSE); break;
break; case MmFlushForWrite:
case MmFlushForWrite: CcFlushCache(SectionObjectPointer,
CcFlushCache &Bcb->FileOffset,
(SectionObjectPointer, Bcb->Length,
&Bcb->FileOffset, &IOSB);
Bcb->Length, break;
&IOSB); }
break;
}
} }
return Result; return Result;
} }
// Always succeeds for us /* Always succeeds for us */
PVOID PVOID
NTAPI NTAPI
CcRemapBcb(IN PVOID Bcb) CcRemapBcb(IN PVOID Bcb)
{ {
ULONG Number = (ULONG)(((PNOCC_BCB)Bcb) - CcCacheSections); ULONG Number = (ULONG)(((PNOCC_BCB)Bcb) - CcCacheSections);
CcpLock(); CcpLock();
ASSERT(RtlTestBit(CcCacheBitmap, Number)); ASSERT(RtlTestBit(CcCacheBitmap, Number));
CcpReferenceCache(Number); CcpReferenceCache(Number);
CcpUnlock(); CcpUnlock();
return Bcb; return Bcb;
} }
VOID VOID
NTAPI NTAPI
CcShutdownSystem() CcShutdownSystem(VOID)
{ {
ULONG i, Result; ULONG i, Result;
NTSTATUS Status; NTSTATUS Status;
DPRINT1("CC: Shutdown\n"); DPRINT1("CC: Shutdown\n");
for (i = 0; i < CACHE_NUM_SECTIONS; i++) for (i = 0; i < CACHE_NUM_SECTIONS; i++)
{ {
PNOCC_BCB Bcb = &CcCacheSections[i]; PNOCC_BCB Bcb = &CcCacheSections[i];
if (Bcb->SectionObject) if (Bcb->SectionObject)
{ {
DPRINT1 DPRINT1("Evicting #%02x %08x%08x %wZ\n",
("Evicting #%02x %08x%08x %wZ\n", i,
i, Bcb->FileOffset.u.HighPart,
Bcb->FileOffset.u.HighPart, Bcb->FileOffset.u.LowPart, Bcb->FileOffset.u.LowPart,
&MmGetFileObjectForSection &MmGetFileObjectForSection((PROS_SECTION_OBJECT)Bcb->SectionObject)->FileName);
((PROS_SECTION_OBJECT)Bcb->SectionObject)->FileName);
CcpFlushCache(Bcb->Map, NULL, 0, NULL, TRUE);
Bcb->Dirty = FALSE;
}
}
// Evict all section pages CcpFlushCache(Bcb->Map, NULL, 0, NULL, TRUE);
Status = MiRosTrimCache(~0, 0, &Result); Bcb->Dirty = FALSE;
}
}
DPRINT1("Done (Evicted %d, Status %x)\n", Result, Status); /* Evict all section pages */
Status = MiRosTrimCache(~0, 0, &Result);
DPRINT1("Done (Evicted %d, Status %x)\n", Result, Status);
} }
VOID VOID
NTAPI NTAPI
CcRepinBcb(IN PVOID Bcb) CcRepinBcb(IN PVOID Bcb)
{ {
ULONG Number = (ULONG)(((PNOCC_BCB)Bcb) - CcCacheSections); ULONG Number = (ULONG)(((PNOCC_BCB)Bcb) - CcCacheSections);
CcpLock(); CcpLock();
ASSERT(RtlTestBit(CcCacheBitmap, Number)); ASSERT(RtlTestBit(CcCacheBitmap, Number));
DPRINT("CcRepinBcb(#%x)\n", Number); DPRINT("CcRepinBcb(#%x)\n", Number);
CcpReferenceCache(Number); CcpReferenceCache(Number);
CcpUnlock(); CcpUnlock();
} }
VOID VOID
@ -340,13 +349,13 @@ CcUnpinRepinnedBcb(IN PVOID Bcb,
if (WriteThrough) if (WriteThrough)
{ {
DPRINT("BCB #%x\n", RealBcb - CcCacheSections); DPRINT("BCB #%x\n", RealBcb - CcCacheSections);
CcpFlushCache CcpFlushCache(RealBcb->Map,
(RealBcb->Map, &RealBcb->FileOffset,
&RealBcb->FileOffset, RealBcb->Length,
RealBcb->Length, IoStatus,
IoStatus, RealBcb->Dirty); RealBcb->Dirty);
} }
CcUnpinData(Bcb); CcUnpinData(Bcb);

180
reactos/ntoskrnl/cache/copysup.c vendored
View file

@ -53,53 +53,55 @@ CcCopyRead(IN PFILE_OBJECT FileObject,
PCHAR BufferTarget = (PCHAR)Buffer; PCHAR BufferTarget = (PCHAR)Buffer;
LARGE_INTEGER CacheOffset, EndOfExtent, NextOffset; LARGE_INTEGER CacheOffset, EndOfExtent, NextOffset;
DPRINT DPRINT("CcCopyRead(%x,%x,%d,%d,%x)\n",
("CcCopyRead(%x,%x,%d,%d,%x)\n", FileObject,
FileObject, FileOffset->LowPart,
FileOffset->LowPart, Length,
Length, Wait,
Wait, Buffer);
Buffer);
CacheOffset.QuadPart = FileOffset->QuadPart; CacheOffset.QuadPart = FileOffset->QuadPart;
EndOfExtent.QuadPart = FileOffset->QuadPart + Length; EndOfExtent.QuadPart = FileOffset->QuadPart + Length;
while (CacheOffset.QuadPart < EndOfExtent.QuadPart) while (CacheOffset.QuadPart < EndOfExtent.QuadPart)
{ {
NextOffset.QuadPart = CacheOffset.QuadPart; NextOffset.QuadPart = CacheOffset.QuadPart;
NextOffset.LowPart = (NextOffset.LowPart + CACHE_STRIPE) & ~(CACHE_STRIPE-1); NextOffset.LowPart = (NextOffset.LowPart + CACHE_STRIPE) & ~(CACHE_STRIPE-1);
ReadLen = EndOfExtent.QuadPart - CacheOffset.QuadPart; ReadLen = EndOfExtent.QuadPart - CacheOffset.QuadPart;
if (CacheOffset.QuadPart + ReadLen > NextOffset.QuadPart) if (CacheOffset.QuadPart + ReadLen > NextOffset.QuadPart)
{ {
ReadLen = NextOffset.QuadPart - CacheOffset.QuadPart; ReadLen = NextOffset.QuadPart - CacheOffset.QuadPart;
} }
DPRINT("Reading %d bytes in this go (at %08x%08x)\n", ReadLen, CacheOffset.HighPart, CacheOffset.LowPart); DPRINT("Reading %d bytes in this go (at %08x%08x)\n",
ReadLen,
CacheOffset.HighPart,
CacheOffset.LowPart);
if (!CcPinRead if (!CcPinRead(FileObject,
(FileObject, &CacheOffset,
&CacheOffset, ReadLen,
ReadLen, Wait ? PIN_WAIT : PIN_IF_BCB,
Wait ? PIN_WAIT : PIN_IF_BCB, &Bcb,
&Bcb, (PVOID*)&ReadBuffer))
(PVOID*)&ReadBuffer)) {
{ IoStatus->Status = STATUS_UNSUCCESSFUL;
IoStatus->Status = STATUS_UNSUCCESSFUL; IoStatus->Information = 0;
IoStatus->Information = 0; DPRINT("Failed CcCopyRead\n");
DPRINT("Failed CcCopyRead\n"); return FALSE;
return FALSE; }
}
DPRINT("Copying %d bytes at %08x%08x\n", ReadLen, CacheOffset.HighPart, CacheOffset.LowPart); DPRINT("Copying %d bytes at %08x%08x\n",
RtlCopyMemory ReadLen,
(BufferTarget, CacheOffset.HighPart,
ReadBuffer, CacheOffset.LowPart);
ReadLen);
BufferTarget += ReadLen; RtlCopyMemory(BufferTarget, ReadBuffer, ReadLen);
CacheOffset = NextOffset; BufferTarget += ReadLen;
CcUnpinData(Bcb);
CacheOffset = NextOffset;
CcUnpinData(Bcb);
} }
IoStatus->Status = STATUS_SUCCESS; IoStatus->Status = STATUS_SUCCESS;
@ -131,58 +133,72 @@ CcCopyWrite(IN PFILE_OBJECT FileObject,
IN BOOLEAN Wait, IN BOOLEAN Wait,
IN PVOID Buffer) IN PVOID Buffer)
{ {
INT Count = 0; INT Count = 0;
BOOLEAN Result; BOOLEAN Result;
PNOCC_BCB Bcb; PNOCC_BCB Bcb;
PVOID WriteBuf; PVOID WriteBuf;
ULONG WriteLen; ULONG WriteLen;
LARGE_INTEGER CurrentOffset = *FileOffset; LARGE_INTEGER CurrentOffset = *FileOffset;
LARGE_INTEGER EndOffset; LARGE_INTEGER EndOffset;
LARGE_INTEGER NextOffset; LARGE_INTEGER NextOffset;
EndOffset.QuadPart = CurrentOffset.QuadPart + Length; EndOffset.QuadPart = CurrentOffset.QuadPart + Length;
DPRINT DPRINT("CcCopyWrite(%x,%x,%d,%d,%x)\n",
("CcCopyWrite(%x,%x,%d,%d,%x)\n", FileObject,
FileObject, FileOffset->LowPart,
FileOffset->LowPart, Length,
Length, Wait,
Wait, Buffer);
Buffer);
while (CurrentOffset.QuadPart < EndOffset.QuadPart) while (CurrentOffset.QuadPart < EndOffset.QuadPart)
{ {
NextOffset.HighPart = CurrentOffset.HighPart; NextOffset.HighPart = CurrentOffset.HighPart;
NextOffset.LowPart = (CurrentOffset.LowPart + CACHE_STRIPE) & ~(CACHE_STRIPE - 1); NextOffset.LowPart = (CurrentOffset.LowPart + CACHE_STRIPE) & ~(CACHE_STRIPE - 1);
DPRINT("NextOffset %08x%08x\n", NextOffset.u.HighPart, NextOffset.u.LowPart); DPRINT("NextOffset %08x%08x\n", NextOffset.u.HighPart, NextOffset.u.LowPart);
WriteLen = MIN(NextOffset.QuadPart - CurrentOffset.QuadPart, Length); WriteLen = MIN(NextOffset.QuadPart - CurrentOffset.QuadPart, Length);
DPRINT("Copying %x bytes from %08x%08x\n",
WriteLen,
CurrentOffset.u.HighPart, CurrentOffset.u.LowPart);
DPRINT("CcPreparePinWrite\n");
Result = CcPreparePinWrite
(FileObject, &CurrentOffset, WriteLen, FALSE, Wait ? PIN_WAIT : PIN_IF_BCB,
(PVOID *)&Bcb, &WriteBuf);
DPRINT("Result %s %x %x\n", Result ? "TRUE" : "FALSE", Bcb, WriteBuf);
if (!Result)
{
DPRINT1("CcPreparePinWrite Failed?\n");
if (Wait) RtlRaiseStatus(STATUS_NOT_MAPPED_DATA); else return FALSE;
}
DPRINT("Copying actual memory to BCB#%x (@%x) (from buffer at %x)\n", Bcb - CcCacheSections, WriteBuf, Bcb->BaseAddress);
//MiZeroFillSection(WriteBuf, &CurrentOffset, WriteLen); DPRINT("Copying %x bytes from %08x%08x\n",
RtlCopyMemory(WriteBuf, ((PCHAR)Buffer) + Count, WriteLen); WriteLen,
Count += WriteLen; CurrentOffset.u.HighPart,
Length -= WriteLen; CurrentOffset.u.LowPart);
CurrentOffset = NextOffset;
Bcb->Dirty = TRUE;
CcUnpinData(Bcb);
}
DPRINT("Done with CcCopyWrite\n"); DPRINT("CcPreparePinWrite\n");
return TRUE; Result = CcPreparePinWrite(FileObject,
&CurrentOffset,
WriteLen,
FALSE,
Wait ? PIN_WAIT : PIN_IF_BCB,
(PVOID *)&Bcb, &WriteBuf);
DPRINT("Result %s %x %x\n", Result ? "TRUE" : "FALSE", Bcb, WriteBuf);
if (!Result)
{
DPRINT1("CcPreparePinWrite Failed?\n");
if (Wait)
RtlRaiseStatus(STATUS_NOT_MAPPED_DATA);
else
return FALSE;
}
DPRINT("Copying actual memory to BCB#%x (@%x) (from buffer at %x)\n",
Bcb - CcCacheSections,
WriteBuf,
Bcb->BaseAddress);
//MiZeroFillSection(WriteBuf, &CurrentOffset, WriteLen);
RtlCopyMemory(WriteBuf, ((PCHAR)Buffer) + Count, WriteLen);
Count += WriteLen;
Length -= WriteLen;
CurrentOffset = NextOffset;
Bcb->Dirty = TRUE;
CcUnpinData(Bcb);
}
DPRINT("Done with CcCopyWrite\n");
return TRUE;
} }
VOID VOID

609
reactos/ntoskrnl/cache/fssup.c vendored
View file

@ -68,9 +68,9 @@ what shared cache map it associates with.
*/ */
typedef struct _NOCC_PRIVATE_CACHE_MAP typedef struct _NOCC_PRIVATE_CACHE_MAP
{ {
LIST_ENTRY ListEntry; LIST_ENTRY ListEntry;
PFILE_OBJECT FileObject; PFILE_OBJECT FileObject;
PNOCC_CACHE_MAP Map; PNOCC_CACHE_MAP Map;
} NOCC_PRIVATE_CACHE_MAP, *PNOCC_PRIVATE_CACHE_MAP; } NOCC_PRIVATE_CACHE_MAP, *PNOCC_PRIVATE_CACHE_MAP;
LIST_ENTRY CcpAllSharedCacheMaps; LIST_ENTRY CcpAllSharedCacheMaps;
@ -81,25 +81,28 @@ BOOLEAN
NTAPI NTAPI
CcInitializeCacheManager(VOID) CcInitializeCacheManager(VOID)
{ {
int i; int i;
DPRINT("Initialize\n"); DPRINT("Initialize\n");
for (i = 0; i < CACHE_NUM_SECTIONS; i++) for (i = 0; i < CACHE_NUM_SECTIONS; i++)
{ {
KeInitializeEvent(&CcCacheSections[i].ExclusiveWait, SynchronizationEvent, FALSE); KeInitializeEvent(&CcCacheSections[i].ExclusiveWait,
InitializeListHead(&CcCacheSections[i].ThisFileList); SynchronizationEvent,
} FALSE);
InitializeListHead(&CcpAllSharedCacheMaps); InitializeListHead(&CcCacheSections[i].ThisFileList);
}
KeInitializeEvent(&CcDeleteEvent, SynchronizationEvent, FALSE); InitializeListHead(&CcpAllSharedCacheMaps);
KeInitializeEvent(&CcFinalizeEvent, SynchronizationEvent, FALSE);
KeInitializeEvent(&CcpLazyWriteEvent, SynchronizationEvent, FALSE);
CcCacheBitmap->Buffer = ((PULONG)&CcCacheBitmap[1]); KeInitializeEvent(&CcDeleteEvent, SynchronizationEvent, FALSE);
CcCacheBitmap->SizeOfBitMap = ROUND_UP(CACHE_NUM_SECTIONS, 32); KeInitializeEvent(&CcFinalizeEvent, SynchronizationEvent, FALSE);
DPRINT1("Cache has %d entries\n", CcCacheBitmap->SizeOfBitMap); KeInitializeEvent(&CcpLazyWriteEvent, SynchronizationEvent, FALSE);
ExInitializeFastMutex(&CcMutex);
CcCacheBitmap->Buffer = ((PULONG)&CcCacheBitmap[1]);
CcCacheBitmap->SizeOfBitMap = ROUND_UP(CACHE_NUM_SECTIONS, 32);
DPRINT1("Cache has %d entries\n", CcCacheBitmap->SizeOfBitMap);
ExInitializeFastMutex(&CcMutex);
return TRUE; return TRUE;
} }
@ -125,16 +128,16 @@ BOOLEAN
NTAPI NTAPI
CcpAcquireFileLock(PNOCC_CACHE_MAP Map) CcpAcquireFileLock(PNOCC_CACHE_MAP Map)
{ {
DPRINT("Calling AcquireForLazyWrite: %x\n", Map->LazyContext); DPRINT("Calling AcquireForLazyWrite: %x\n", Map->LazyContext);
return Map->Callbacks.AcquireForLazyWrite(Map->LazyContext, TRUE); return Map->Callbacks.AcquireForLazyWrite(Map->LazyContext, TRUE);
} }
VOID VOID
NTAPI NTAPI
CcpReleaseFileLock(PNOCC_CACHE_MAP Map) CcpReleaseFileLock(PNOCC_CACHE_MAP Map)
{ {
DPRINT("Releasing Lazy Write %x\n", Map->LazyContext); DPRINT("Releasing Lazy Write %x\n", Map->LazyContext);
Map->Callbacks.ReleaseFromLazyWrite(Map->LazyContext); Map->Callbacks.ReleaseFromLazyWrite(Map->LazyContext);
} }
/* /*
@ -150,37 +153,41 @@ a stream file object and a sibling file object in the file object struct
itself. itself.
*/ */
// Must have CcpLock()
/* Must have CcpLock() */
PFILE_OBJECT CcpFindOtherStreamFileObject(PFILE_OBJECT FileObject) PFILE_OBJECT CcpFindOtherStreamFileObject(PFILE_OBJECT FileObject)
{ {
PLIST_ENTRY Entry, Private; PLIST_ENTRY Entry, Private;
for (Entry = CcpAllSharedCacheMaps.Flink; for (Entry = CcpAllSharedCacheMaps.Flink;
Entry != &CcpAllSharedCacheMaps; Entry != &CcpAllSharedCacheMaps;
Entry = Entry->Flink) Entry = Entry->Flink)
{ {
// 'Identical' test for other stream file object /* 'Identical' test for other stream file object */
PNOCC_CACHE_MAP Map = CONTAINING_RECORD(Entry, NOCC_CACHE_MAP, Entry); PNOCC_CACHE_MAP Map = CONTAINING_RECORD(Entry, NOCC_CACHE_MAP, Entry);
for (Private = Map->PrivateCacheMaps.Flink; for (Private = Map->PrivateCacheMaps.Flink;
Private != &Map->PrivateCacheMaps; Private != &Map->PrivateCacheMaps;
Private = Private->Flink) Private = Private->Flink)
{ {
PNOCC_PRIVATE_CACHE_MAP PrivateMap = CONTAINING_RECORD(Private, NOCC_PRIVATE_CACHE_MAP, ListEntry); PNOCC_PRIVATE_CACHE_MAP PrivateMap = CONTAINING_RECORD(Private,
if (PrivateMap->FileObject->Flags & FO_STREAM_FILE && NOCC_PRIVATE_CACHE_MAP,
PrivateMap->FileObject->DeviceObject == FileObject->DeviceObject && ListEntry);
PrivateMap->FileObject->Vpb == FileObject->Vpb &&
PrivateMap->FileObject->FsContext == FileObject->FsContext && if (PrivateMap->FileObject->Flags & FO_STREAM_FILE &&
PrivateMap->FileObject->FsContext2 == FileObject->FsContext2 && PrivateMap->FileObject->DeviceObject == FileObject->DeviceObject &&
1) PrivateMap->FileObject->Vpb == FileObject->Vpb &&
{ PrivateMap->FileObject->FsContext == FileObject->FsContext &&
return PrivateMap->FileObject; PrivateMap->FileObject->FsContext2 == FileObject->FsContext2 &&
} 1)
} {
} return PrivateMap->FileObject;
return 0; }
}
}
return 0;
} }
// Thanks: http://windowsitpro.com/Windows/Articles/ArticleID/3864/pg/2/2.html /* Thanks: http://windowsitpro.com/Windows/Articles/ArticleID/3864/pg/2/2.html */
VOID VOID
NTAPI NTAPI
CcInitializeCacheMap(IN PFILE_OBJECT FileObject, CcInitializeCacheMap(IN PFILE_OBJECT FileObject,
@ -189,55 +196,64 @@ CcInitializeCacheMap(IN PFILE_OBJECT FileObject,
IN PCACHE_MANAGER_CALLBACKS Callbacks, IN PCACHE_MANAGER_CALLBACKS Callbacks,
IN PVOID LazyWriteContext) IN PVOID LazyWriteContext)
{ {
PNOCC_CACHE_MAP Map = FileObject->SectionObjectPointer->SharedCacheMap; PNOCC_CACHE_MAP Map = FileObject->SectionObjectPointer->SharedCacheMap;
PNOCC_PRIVATE_CACHE_MAP PrivateCacheMap = FileObject->PrivateCacheMap; PNOCC_PRIVATE_CACHE_MAP PrivateCacheMap = FileObject->PrivateCacheMap;
CcpLock(); CcpLock();
/* We don't have a shared cache map. First find out if we have a sibling /* We don't have a shared cache map. First find out if we have a sibling
stream file object we can take it from. */ stream file object we can take it from. */
if (!Map && FileObject->Flags & FO_STREAM_FILE) if (!Map && FileObject->Flags & FO_STREAM_FILE)
{ {
PFILE_OBJECT IdenticalStreamFileObject = PFILE_OBJECT IdenticalStreamFileObject = CcpFindOtherStreamFileObject(FileObject);
CcpFindOtherStreamFileObject(FileObject); if (IdenticalStreamFileObject)
if (IdenticalStreamFileObject) Map = IdenticalStreamFileObject->SectionObjectPointer->SharedCacheMap;
Map = IdenticalStreamFileObject->SectionObjectPointer->SharedCacheMap; if (Map)
if (Map) {
{ DPRINT1("Linking SFO %x to previous SFO %x through cache map %x #\n",
DPRINT1 FileObject,
("Linking SFO %x to previous SFO %x through cache map %x #\n", IdenticalStreamFileObject,
FileObject, IdenticalStreamFileObject, Map); Map);
} }
} }
/* We still don't have a shared cache map. We need to create one. */ /* We still don't have a shared cache map. We need to create one. */
if (!Map) if (!Map)
{ {
DPRINT("Initializing file object for (%p) %wZ\n", FileObject, &FileObject->FileName); DPRINT("Initializing file object for (%p) %wZ\n",
Map = ExAllocatePool(NonPagedPool, sizeof(NOCC_CACHE_MAP)); FileObject,
FileObject->SectionObjectPointer->SharedCacheMap = Map; &FileObject->FileName);
Map->FileSizes = *FileSizes;
Map->LazyContext = LazyWriteContext; Map = ExAllocatePool(NonPagedPool, sizeof(NOCC_CACHE_MAP));
Map->ReadAheadGranularity = PAGE_SIZE; FileObject->SectionObjectPointer->SharedCacheMap = Map;
RtlCopyMemory(&Map->Callbacks, Callbacks, sizeof(*Callbacks)); Map->FileSizes = *FileSizes;
// For now ... Map->LazyContext = LazyWriteContext;
DPRINT("FileSizes->ValidDataLength %08x%08x\n", FileSizes->ValidDataLength.HighPart, FileSizes->ValidDataLength.LowPart); Map->ReadAheadGranularity = PAGE_SIZE;
InitializeListHead(&Map->AssociatedBcb); RtlCopyMemory(&Map->Callbacks, Callbacks, sizeof(*Callbacks));
InitializeListHead(&Map->PrivateCacheMaps);
InsertTailList(&CcpAllSharedCacheMaps, &Map->Entry); /* For now ... */
DPRINT("New Map %x\n", Map); DPRINT("FileSizes->ValidDataLength %08x%08x\n",
FileSizes->ValidDataLength.HighPart,
FileSizes->ValidDataLength.LowPart);
InitializeListHead(&Map->AssociatedBcb);
InitializeListHead(&Map->PrivateCacheMaps);
InsertTailList(&CcpAllSharedCacheMaps, &Map->Entry);
DPRINT("New Map %x\n", Map);
} }
/* We don't have a private cache map. Link it with the shared cache map /* We don't have a private cache map. Link it with the shared cache map
to serve as a held reference. When the list in the shared cache map to serve as a held reference. When the list in the shared cache map
is empty, we know we can delete it. */ is empty, we know we can delete it. */
if (!PrivateCacheMap) if (!PrivateCacheMap)
{ {
PrivateCacheMap = ExAllocatePool(NonPagedPool, sizeof(*PrivateCacheMap)); PrivateCacheMap = ExAllocatePool(NonPagedPool,
FileObject->PrivateCacheMap = PrivateCacheMap; sizeof(*PrivateCacheMap));
PrivateCacheMap->FileObject = FileObject;
ObReferenceObject(PrivateCacheMap->FileObject);
}
PrivateCacheMap->Map = Map; FileObject->PrivateCacheMap = PrivateCacheMap;
InsertTailList(&Map->PrivateCacheMaps, &PrivateCacheMap->ListEntry); PrivateCacheMap->FileObject = FileObject;
ObReferenceObject(PrivateCacheMap->FileObject);
}
PrivateCacheMap->Map = Map;
InsertTailList(&Map->PrivateCacheMaps, &PrivateCacheMap->ListEntry);
CcpUnlock(); CcpUnlock();
} }
@ -254,12 +270,14 @@ ULONG
NTAPI NTAPI
CcpCountCacheSections(IN PNOCC_CACHE_MAP Map) CcpCountCacheSections(IN PNOCC_CACHE_MAP Map)
{ {
PLIST_ENTRY Entry; PLIST_ENTRY Entry;
ULONG Count; ULONG Count;
for (Count = 0, Entry = Map->AssociatedBcb.Flink; Entry != &Map->AssociatedBcb; Entry = Entry->Flink, Count++); for (Count = 0, Entry = Map->AssociatedBcb.Flink;
Entry != &Map->AssociatedBcb;
Entry = Entry->Flink, Count++);
return Count; return Count;
} }
BOOLEAN BOOLEAN
@ -268,58 +286,62 @@ CcUninitializeCacheMap(IN PFILE_OBJECT FileObject,
IN OPTIONAL PLARGE_INTEGER TruncateSize, IN OPTIONAL PLARGE_INTEGER TruncateSize,
IN OPTIONAL PCACHE_UNINITIALIZE_EVENT UninitializeEvent) IN OPTIONAL PCACHE_UNINITIALIZE_EVENT UninitializeEvent)
{ {
BOOLEAN LastMap = FALSE; BOOLEAN LastMap = FALSE;
PNOCC_CACHE_MAP Map = (PNOCC_CACHE_MAP)FileObject->SectionObjectPointer->SharedCacheMap; PNOCC_CACHE_MAP Map = (PNOCC_CACHE_MAP)FileObject->SectionObjectPointer->SharedCacheMap;
PNOCC_PRIVATE_CACHE_MAP PrivateCacheMap = FileObject->PrivateCacheMap; PNOCC_PRIVATE_CACHE_MAP PrivateCacheMap = FileObject->PrivateCacheMap;
DPRINT("Uninitializing file object for %wZ SectionObjectPointer %x\n", &FileObject->FileName, FileObject->SectionObjectPointer); DPRINT("Uninitializing file object for %wZ SectionObjectPointer %x\n",
&FileObject->FileName,
FileObject->SectionObjectPointer);
ASSERT(UninitializeEvent == NULL); ASSERT(UninitializeEvent == NULL);
/* It may not be strictly necessary to flush here, but we do just for /* It may not be strictly necessary to flush here, but we do just for
kicks. */ kicks. */
if (Map) if (Map)
CcpFlushCache(Map, NULL, 0, NULL, FALSE); CcpFlushCache(Map, NULL, 0, NULL, FALSE);
CcpLock(); CcpLock();
/* We have a private cache map, so we've been initialized and haven't been /* We have a private cache map, so we've been initialized and haven't been
* uninitialized. */ * uninitialized. */
if (PrivateCacheMap) if (PrivateCacheMap)
{ {
ASSERT(!Map || Map == PrivateCacheMap->Map); ASSERT(!Map || Map == PrivateCacheMap->Map);
ASSERT(PrivateCacheMap->FileObject == FileObject); ASSERT(PrivateCacheMap->FileObject == FileObject);
RemoveEntryList(&PrivateCacheMap->ListEntry); RemoveEntryList(&PrivateCacheMap->ListEntry);
/* That was the last private cache map. It's time to delete all /* That was the last private cache map. It's time to delete all
cache stripes and all aspects of caching on the file. */ cache stripes and all aspects of caching on the file. */
if (IsListEmpty(&PrivateCacheMap->Map->PrivateCacheMaps)) if (IsListEmpty(&PrivateCacheMap->Map->PrivateCacheMaps))
{ {
/* Get rid of all the cache stripes. */ /* Get rid of all the cache stripes. */
while (!IsListEmpty(&PrivateCacheMap->Map->AssociatedBcb)) while (!IsListEmpty(&PrivateCacheMap->Map->AssociatedBcb))
{ {
PNOCC_BCB Bcb = CONTAINING_RECORD(PrivateCacheMap->Map->AssociatedBcb.Flink, NOCC_BCB, ThisFileList); PNOCC_BCB Bcb = CONTAINING_RECORD(PrivateCacheMap->Map->AssociatedBcb.Flink,
DPRINT("Evicting cache stripe #%x\n", Bcb - CcCacheSections); NOCC_BCB,
Bcb->RefCount = 1; ThisFileList);
CcpDereferenceCache(Bcb - CcCacheSections, TRUE);
}
RemoveEntryList(&PrivateCacheMap->Map->Entry);
ExFreePool(PrivateCacheMap->Map);
FileObject->SectionObjectPointer->SharedCacheMap = NULL;
LastMap = TRUE;
}
ObDereferenceObject(PrivateCacheMap->FileObject);
FileObject->PrivateCacheMap = NULL;
ExFreePool(PrivateCacheMap);
}
CcpUnlock();
DPRINT("Uninit complete\n"); DPRINT("Evicting cache stripe #%x\n", Bcb - CcCacheSections);
Bcb->RefCount = 1;
CcpDereferenceCache(Bcb - CcCacheSections, TRUE);
}
RemoveEntryList(&PrivateCacheMap->Map->Entry);
ExFreePool(PrivateCacheMap->Map);
FileObject->SectionObjectPointer->SharedCacheMap = NULL;
LastMap = TRUE;
}
ObDereferenceObject(PrivateCacheMap->FileObject);
FileObject->PrivateCacheMap = NULL;
ExFreePool(PrivateCacheMap);
}
CcpUnlock();
/* The return from CcUninitializeCacheMap means that 'caching was stopped'. DPRINT("Uninit complete\n");
*/
/* The return from CcUninitializeCacheMap means that 'caching was stopped'. */
return LastMap; return LastMap;
} }
/* /*
CcSetFileSizes is used to tell the cache manager that the file changed CcSetFileSizes is used to tell the cache manager that the file changed
@ -338,20 +360,19 @@ CcSetFileSizes(IN PFILE_OBJECT FileObject,
if (!Map) return; if (!Map) return;
Map->FileSizes = *FileSizes; Map->FileSizes = *FileSizes;
Bcb = Map->AssociatedBcb.Flink == &Map->AssociatedBcb ? Bcb = Map->AssociatedBcb.Flink == &Map->AssociatedBcb ?
NULL : CONTAINING_RECORD(Map->AssociatedBcb.Flink, NOCC_BCB, ThisFileList); NULL : CONTAINING_RECORD(Map->AssociatedBcb.Flink, NOCC_BCB, ThisFileList);
if (!Bcb) return; if (!Bcb) return;
MmExtendCacheSection(Bcb->SectionObject, &FileSizes->FileSize, FALSE); MmExtendCacheSection(Bcb->SectionObject, &FileSizes->FileSize, FALSE);
DPRINT("FileSizes->FileSize %x\n", FileSizes->FileSize.LowPart); DPRINT("FileSizes->FileSize %x\n", FileSizes->FileSize.LowPart);
DPRINT("FileSizes->AllocationSize %x\n", FileSizes->AllocationSize.LowPart); DPRINT("FileSizes->AllocationSize %x\n", FileSizes->AllocationSize.LowPart);
DPRINT("FileSizes->ValidDataLength %x\n", FileSizes->ValidDataLength.LowPart); DPRINT("FileSizes->ValidDataLength %x\n", FileSizes->ValidDataLength.LowPart);
} }
BOOLEAN BOOLEAN
NTAPI NTAPI
CcGetFileSizes CcGetFileSizes(IN PFILE_OBJECT FileObject,
(IN PFILE_OBJECT FileObject, IN PCC_FILE_SIZES FileSizes)
IN PCC_FILE_SIZES FileSizes)
{ {
PNOCC_CACHE_MAP Map = (PNOCC_CACHE_MAP)FileObject->SectionObjectPointer->SharedCacheMap; PNOCC_CACHE_MAP Map = (PNOCC_CACHE_MAP)FileObject->SectionObjectPointer->SharedCacheMap;
if (!Map) return FALSE; if (!Map) return FALSE;
@ -366,10 +387,10 @@ CcPurgeCacheSection(IN PSECTION_OBJECT_POINTERS SectionObjectPointer,
IN ULONG Length, IN ULONG Length,
IN BOOLEAN UninitializeCacheMaps) IN BOOLEAN UninitializeCacheMaps)
{ {
PNOCC_CACHE_MAP Map = (PNOCC_CACHE_MAP)SectionObjectPointer->SharedCacheMap; PNOCC_CACHE_MAP Map = (PNOCC_CACHE_MAP)SectionObjectPointer->SharedCacheMap;
if (!Map) return TRUE; if (!Map) return TRUE;
CcpFlushCache(Map, NULL, 0, NULL, TRUE); CcpFlushCache(Map, NULL, 0, NULL, TRUE);
return TRUE; return TRUE;
} }
VOID VOID
@ -380,7 +401,7 @@ CcSetDirtyPageThreshold(IN PFILE_OBJECT FileObject,
UNIMPLEMENTED; UNIMPLEMENTED;
while (TRUE); while (TRUE);
} }
/* /*
This could be implemented much more intelligently by mapping instances This could be implemented much more intelligently by mapping instances
@ -396,156 +417,212 @@ CcZeroData(IN PFILE_OBJECT FileObject,
IN BOOLEAN Wait) IN BOOLEAN Wait)
{ {
PNOCC_BCB Bcb = NULL; PNOCC_BCB Bcb = NULL;
PLIST_ENTRY ListEntry = NULL; PLIST_ENTRY ListEntry = NULL;
LARGE_INTEGER LowerBound = *StartOffset; LARGE_INTEGER LowerBound = *StartOffset;
LARGE_INTEGER UpperBound = *EndOffset; LARGE_INTEGER UpperBound = *EndOffset;
LARGE_INTEGER Target, End; LARGE_INTEGER Target, End;
PVOID PinnedBcb, PinnedBuffer; PVOID PinnedBcb, PinnedBuffer;
PNOCC_CACHE_MAP Map = FileObject->SectionObjectPointer->SharedCacheMap; PNOCC_CACHE_MAP Map = FileObject->SectionObjectPointer->SharedCacheMap;
DPRINT DPRINT("S %08x%08x E %08x%08x\n",
("S %08x%08x E %08x%08x\n", StartOffset->u.HighPart,
StartOffset->u.HighPart, StartOffset->u.LowPart, StartOffset->u.LowPart,
EndOffset->u.HighPart, EndOffset->u.LowPart); EndOffset->u.HighPart,
EndOffset->u.LowPart);
if (!Map) if (!Map)
{ {
NTSTATUS Status; NTSTATUS Status;
IO_STATUS_BLOCK IOSB; IO_STATUS_BLOCK IOSB;
PCHAR ZeroBuf = ExAllocatePool(PagedPool, PAGE_SIZE); PCHAR ZeroBuf = ExAllocatePool(PagedPool, PAGE_SIZE);
ULONG ToWrite; ULONG ToWrite;
if (!ZeroBuf) RtlRaiseStatus(STATUS_INSUFFICIENT_RESOURCES); if (!ZeroBuf) RtlRaiseStatus(STATUS_INSUFFICIENT_RESOURCES);
DPRINT1("RtlZeroMemory(%x,%x)\n", ZeroBuf, PAGE_SIZE); DPRINT1("RtlZeroMemory(%x,%x)\n", ZeroBuf, PAGE_SIZE);
RtlZeroMemory(ZeroBuf, PAGE_SIZE); RtlZeroMemory(ZeroBuf, PAGE_SIZE);
Target.QuadPart = PAGE_ROUND_DOWN(LowerBound.QuadPart); Target.QuadPart = PAGE_ROUND_DOWN(LowerBound.QuadPart);
End.QuadPart = PAGE_ROUND_UP(UpperBound.QuadPart); End.QuadPart = PAGE_ROUND_UP(UpperBound.QuadPart);
// Handle leading page // Handle leading page
if (LowerBound.QuadPart != Target.QuadPart) if (LowerBound.QuadPart != Target.QuadPart)
{ {
ToWrite = MIN(UpperBound.QuadPart - LowerBound.QuadPart, (PAGE_SIZE - LowerBound.QuadPart) & (PAGE_SIZE - 1)); ToWrite = MIN(UpperBound.QuadPart - LowerBound.QuadPart,
DPRINT("Zero last half %08x%08x %x\n", Target.u.HighPart, Target.u.LowPart, ToWrite); (PAGE_SIZE - LowerBound.QuadPart) & (PAGE_SIZE - 1));
Status = MiSimpleRead(FileObject, &Target, ZeroBuf, PAGE_SIZE, TRUE, &IOSB);
if (!NT_SUCCESS(Status))
{
ExFreePool(ZeroBuf);
RtlRaiseStatus(Status);
}
DPRINT1("RtlZeroMemory(%x,%x)\n", ZeroBuf + LowerBound.QuadPart - Target.QuadPart, ToWrite);
RtlZeroMemory(ZeroBuf + LowerBound.QuadPart - Target.QuadPart, ToWrite);
Status = MiSimpleWrite(FileObject, &Target, ZeroBuf, MIN(PAGE_SIZE,UpperBound.QuadPart-Target.QuadPart), &IOSB);
if (!NT_SUCCESS(Status))
{
ExFreePool(ZeroBuf);
RtlRaiseStatus(Status);
}
Target.QuadPart += PAGE_SIZE;
}
DPRINT1("RtlZeroMemory(%x,%x)\n", ZeroBuf, PAGE_SIZE); DPRINT("Zero last half %08x%08x %x\n",
RtlZeroMemory(ZeroBuf, PAGE_SIZE); Target.u.HighPart,
Target.u.LowPart,
ToWrite);
while (UpperBound.QuadPart - Target.QuadPart > PAGE_SIZE) Status = MiSimpleRead(FileObject,
{ &Target,
DPRINT("Zero full page %08x%08x\n", Target.u.HighPart, Target.u.LowPart); ZeroBuf,
Status = MiSimpleWrite(FileObject, &Target, ZeroBuf, PAGE_SIZE, &IOSB); PAGE_SIZE,
if (!NT_SUCCESS(Status)) TRUE,
{ &IOSB);
ExFreePool(ZeroBuf);
RtlRaiseStatus(Status);
}
Target.QuadPart += PAGE_SIZE;
}
if (UpperBound.QuadPart > Target.QuadPart) if (!NT_SUCCESS(Status))
{ {
ToWrite = UpperBound.QuadPart - Target.QuadPart; ExFreePool(ZeroBuf);
DPRINT("Zero first half %08x%08x %x\n", Target.u.HighPart, Target.u.LowPart, ToWrite); RtlRaiseStatus(Status);
Status = MiSimpleRead(FileObject, &Target, ZeroBuf, PAGE_SIZE, TRUE, &IOSB); }
if (!NT_SUCCESS(Status))
{
ExFreePool(ZeroBuf);
RtlRaiseStatus(Status);
}
DPRINT1("RtlZeroMemory(%x,%x)\n", ZeroBuf, ToWrite);
RtlZeroMemory(ZeroBuf, ToWrite);
Status = MiSimpleWrite(FileObject, &Target, ZeroBuf, MIN(PAGE_SIZE, UpperBound.QuadPart-Target.QuadPart), &IOSB);
if (!NT_SUCCESS(Status))
{
ExFreePool(ZeroBuf);
RtlRaiseStatus(Status);
}
Target.QuadPart += PAGE_SIZE;
}
ExFreePool(ZeroBuf); DPRINT1("RtlZeroMemory(%x,%x)\n",
return TRUE; ZeroBuf + LowerBound.QuadPart - Target.QuadPart,
} ToWrite);
CcpLock(); RtlZeroMemory(ZeroBuf + LowerBound.QuadPart - Target.QuadPart,
ListEntry = Map->AssociatedBcb.Flink; ToWrite);
while (ListEntry != &Map->AssociatedBcb) Status = MiSimpleWrite(FileObject,
{ &Target,
Bcb = CONTAINING_RECORD(ListEntry, NOCC_BCB, ThisFileList); ZeroBuf,
CcpReferenceCache(Bcb - CcCacheSections); MIN(PAGE_SIZE,
UpperBound.QuadPart-Target.QuadPart),
&IOSB);
if (Bcb->FileOffset.QuadPart + Bcb->Length >= LowerBound.QuadPart && if (!NT_SUCCESS(Status))
Bcb->FileOffset.QuadPart < UpperBound.QuadPart) {
{ ExFreePool(ZeroBuf);
DPRINT RtlRaiseStatus(Status);
("Bcb #%x (@%08x%08x)\n", }
Bcb - CcCacheSections, Target.QuadPart += PAGE_SIZE;
Bcb->FileOffset.u.HighPart, Bcb->FileOffset.u.LowPart); }
Target.QuadPart = MAX(Bcb->FileOffset.QuadPart, LowerBound.QuadPart); DPRINT1("RtlZeroMemory(%x,%x)\n", ZeroBuf, PAGE_SIZE);
End.QuadPart = MIN(Map->FileSizes.ValidDataLength.QuadPart, UpperBound.QuadPart); RtlZeroMemory(ZeroBuf, PAGE_SIZE);
End.QuadPart = MIN(End.QuadPart, Bcb->FileOffset.QuadPart + Bcb->Length);
CcpUnlock();
if (!CcPreparePinWrite while (UpperBound.QuadPart - Target.QuadPart > PAGE_SIZE)
(FileObject, {
&Target, DPRINT("Zero full page %08x%08x\n",
End.QuadPart - Target.QuadPart, Target.u.HighPart,
TRUE, Target.u.LowPart);
Wait,
&PinnedBcb,
&PinnedBuffer))
{
return FALSE;
}
ASSERT(PinnedBcb == Bcb); Status = MiSimpleWrite(FileObject,
&Target,
ZeroBuf,
PAGE_SIZE,
&IOSB);
CcpLock(); if (!NT_SUCCESS(Status))
ListEntry = ListEntry->Flink; {
// Return from pin state ExFreePool(ZeroBuf);
CcpUnpinData(PinnedBcb, TRUE); RtlRaiseStatus(Status);
} }
Target.QuadPart += PAGE_SIZE;
}
CcpUnpinData(Bcb, TRUE); if (UpperBound.QuadPart > Target.QuadPart)
} {
ToWrite = UpperBound.QuadPart - Target.QuadPart;
DPRINT("Zero first half %08x%08x %x\n",
Target.u.HighPart,
Target.u.LowPart,
ToWrite);
CcpUnlock(); Status = MiSimpleRead(FileObject,
&Target,
ZeroBuf,
PAGE_SIZE,
TRUE,
&IOSB);
return TRUE; if (!NT_SUCCESS(Status))
{
ExFreePool(ZeroBuf);
RtlRaiseStatus(Status);
}
DPRINT1("RtlZeroMemory(%x,%x)\n", ZeroBuf, ToWrite);
RtlZeroMemory(ZeroBuf, ToWrite);
Status = MiSimpleWrite(FileObject,
&Target,
ZeroBuf,
MIN(PAGE_SIZE,
UpperBound.QuadPart-Target.QuadPart),
&IOSB);
if (!NT_SUCCESS(Status))
{
ExFreePool(ZeroBuf);
RtlRaiseStatus(Status);
}
Target.QuadPart += PAGE_SIZE;
}
ExFreePool(ZeroBuf);
return TRUE;
}
CcpLock();
ListEntry = Map->AssociatedBcb.Flink;
while (ListEntry != &Map->AssociatedBcb)
{
Bcb = CONTAINING_RECORD(ListEntry, NOCC_BCB, ThisFileList);
CcpReferenceCache(Bcb - CcCacheSections);
if (Bcb->FileOffset.QuadPart + Bcb->Length >= LowerBound.QuadPart &&
Bcb->FileOffset.QuadPart < UpperBound.QuadPart)
{
DPRINT("Bcb #%x (@%08x%08x)\n",
Bcb - CcCacheSections,
Bcb->FileOffset.u.HighPart,
Bcb->FileOffset.u.LowPart);
Target.QuadPart = MAX(Bcb->FileOffset.QuadPart,
LowerBound.QuadPart);
End.QuadPart = MIN(Map->FileSizes.ValidDataLength.QuadPart,
UpperBound.QuadPart);
End.QuadPart = MIN(End.QuadPart,
Bcb->FileOffset.QuadPart + Bcb->Length);
CcpUnlock();
if (!CcPreparePinWrite(FileObject,
&Target,
End.QuadPart - Target.QuadPart,
TRUE,
Wait,
&PinnedBcb,
&PinnedBuffer))
{
return FALSE;
}
ASSERT(PinnedBcb == Bcb);
CcpLock();
ListEntry = ListEntry->Flink;
/* Return from pin state */
CcpUnpinData(PinnedBcb, TRUE);
}
CcpUnpinData(Bcb, TRUE);
}
CcpUnlock();
return TRUE;
} }
PFILE_OBJECT PFILE_OBJECT
NTAPI NTAPI
CcGetFileObjectFromSectionPtrs(IN PSECTION_OBJECT_POINTERS SectionObjectPointer) CcGetFileObjectFromSectionPtrs(IN PSECTION_OBJECT_POINTERS SectionObjectPointer)
{ {
PFILE_OBJECT Result = NULL; PFILE_OBJECT Result = NULL;
PNOCC_CACHE_MAP Map = SectionObjectPointer->SharedCacheMap; PNOCC_CACHE_MAP Map = SectionObjectPointer->SharedCacheMap;
CcpLock(); CcpLock();
if (!IsListEmpty(&Map->AssociatedBcb)) if (!IsListEmpty(&Map->AssociatedBcb))
{ {
PNOCC_BCB Bcb = CONTAINING_RECORD(Map->AssociatedBcb.Flink, NOCC_BCB, ThisFileList); PNOCC_BCB Bcb = CONTAINING_RECORD(Map->AssociatedBcb.Flink,
Result = MmGetFileObjectForSection((PROS_SECTION_OBJECT)Bcb->SectionObject); NOCC_BCB,
} ThisFileList);
CcpUnlock();
Result = MmGetFileObjectForSection((PROS_SECTION_OBJECT)Bcb->SectionObject);
}
CcpUnlock();
return Result; return Result;
} }
@ -553,9 +630,9 @@ PFILE_OBJECT
NTAPI NTAPI
CcGetFileObjectFromBcb(PVOID Bcb) CcGetFileObjectFromBcb(PVOID Bcb)
{ {
PNOCC_BCB RealBcb = (PNOCC_BCB)Bcb; PNOCC_BCB RealBcb = (PNOCC_BCB)Bcb;
DPRINT("BCB #%x\n", RealBcb - CcCacheSections); DPRINT("BCB #%x\n", RealBcb - CcCacheSections);
return MmGetFileObjectForSection((PROS_SECTION_OBJECT)RealBcb->SectionObject); return MmGetFileObjectForSection((PROS_SECTION_OBJECT)RealBcb->SectionObject);
} }
/* EOF */ /* EOF */

2
reactos/ntoskrnl/cache/lazyrite.c vendored
View file

@ -22,7 +22,7 @@ KEVENT CcpLazyWriteEvent;
VOID NTAPI VOID NTAPI
CcpLazyWriteThread(PVOID Unused) CcpLazyWriteThread(PVOID Unused)
{ {
/* Not implemented */ /* Not implemented */
} }
NTSTATUS NTSTATUS

8
reactos/ntoskrnl/cache/logsup.c vendored
View file

@ -33,10 +33,10 @@ CcSetLogHandleForFile(IN PFILE_OBJECT FileObject,
IN PVOID LogHandle, IN PVOID LogHandle,
IN PFLUSH_TO_LSN FlushToLsnRoutine) IN PFLUSH_TO_LSN FlushToLsnRoutine)
{ {
PNOCC_CACHE_MAP Map = FileObject->SectionObjectPointer->SharedCacheMap; PNOCC_CACHE_MAP Map = FileObject->SectionObjectPointer->SharedCacheMap;
if (!Map) return; if (!Map) return;
Map->LogHandle = LogHandle; Map->LogHandle = LogHandle;
Map->FlushToLsn = FlushToLsnRoutine; Map->FlushToLsn = FlushToLsnRoutine;
} }
LARGE_INTEGER LARGE_INTEGER

98
reactos/ntoskrnl/cache/mdlsup.c vendored
View file

@ -16,55 +16,47 @@
/* GLOBALS ********************************************************************/ /* GLOBALS ********************************************************************/
/* FUNCTIONS ******************************************************************/ /* FUNCTIONS ******************************************************************/
PMDL PMDL
NTAPI NTAPI
CcpBuildCacheMdl CcpBuildCacheMdl(PFILE_OBJECT FileObject,
(PFILE_OBJECT FileObject, PLARGE_INTEGER FileOffset,
PLARGE_INTEGER FileOffset, ULONG Length,
ULONG Length, PIO_STATUS_BLOCK IOSB)
PIO_STATUS_BLOCK IOSB)
{ {
PMDL Mdl; PMDL Mdl;
PVOID Bcb, Buffer; PVOID Bcb, Buffer;
BOOLEAN Result = CcMapData BOOLEAN Result = CcMapData(FileObject,
(FileObject, FileOffset,
FileOffset, Length,
Length, PIN_WAIT,
PIN_WAIT, &Bcb,
&Bcb, &Buffer);
&Buffer);
if (!Result) if (!Result)
{ {
IOSB->Information = 0; IOSB->Information = 0;
IOSB->Status = STATUS_UNSUCCESSFUL; IOSB->Status = STATUS_UNSUCCESSFUL;
return NULL; return NULL;
} }
IOSB->Information = Length; IOSB->Information = Length;
IOSB->Status = STATUS_SUCCESS; IOSB->Status = STATUS_SUCCESS;
Mdl = IoAllocateMdl Mdl = IoAllocateMdl(Buffer, Length, FALSE, FALSE, NULL);
(Buffer,
Length,
FALSE,
FALSE,
NULL);
if (!Mdl) if (!Mdl)
{ {
IOSB->Information = 0; IOSB->Information = 0;
IOSB->Status = STATUS_NO_MEMORY; IOSB->Status = STATUS_NO_MEMORY;
return NULL; return NULL;
} }
IOSB->Information = Length; IOSB->Information = Length;
IOSB->Status = STATUS_SUCCESS; IOSB->Status = STATUS_SUCCESS;
return Mdl; return Mdl;
} }
VOID VOID
@ -75,29 +67,25 @@ CcMdlRead(IN PFILE_OBJECT FileObject,
OUT PMDL *MdlChain, OUT PMDL *MdlChain,
OUT PIO_STATUS_BLOCK IoStatus) OUT PIO_STATUS_BLOCK IoStatus)
{ {
*MdlChain = CcpBuildCacheMdl *MdlChain = CcpBuildCacheMdl(FileObject, FileOffset, Length, IoStatus);
(FileObject,
FileOffset,
Length,
IoStatus);
} }
VOID VOID
NTAPI NTAPI
CcMdlReadComplete(IN PFILE_OBJECT FileObject, CcMdlReadComplete(IN PFILE_OBJECT FileObject,
IN PMDL MdlChain) IN PMDL MdlChain)
{ {
IoFreeMdl(MdlChain); IoFreeMdl(MdlChain);
} }
VOID VOID
NTAPI NTAPI
CcMdlReadComplete2(IN PMDL MdlChain, CcMdlReadComplete2(IN PMDL MdlChain,
IN PFILE_OBJECT FileObject) IN PFILE_OBJECT FileObject)
{ {
UNIMPLEMENTED UNIMPLEMENTED
} }
VOID VOID
NTAPI NTAPI
CcPrepareMdlWrite(IN PFILE_OBJECT FileObject, CcPrepareMdlWrite(IN PFILE_OBJECT FileObject,
@ -106,11 +94,7 @@ CcPrepareMdlWrite(IN PFILE_OBJECT FileObject,
OUT PMDL *MdlChain, OUT PMDL *MdlChain,
OUT PIO_STATUS_BLOCK IoStatus) OUT PIO_STATUS_BLOCK IoStatus)
{ {
*MdlChain = CcpBuildCacheMdl *MdlChain = CcpBuildCacheMdl(FileObject, FileOffset, Length, IoStatus);
(FileObject,
FileOffset,
Length,
IoStatus);
} }
VOID VOID
@ -119,7 +103,7 @@ CcMdlWriteComplete(IN PFILE_OBJECT FileObject,
IN PLARGE_INTEGER FileOffset, IN PLARGE_INTEGER FileOffset,
IN PMDL MdlChain) IN PMDL MdlChain)
{ {
IoFreeMdl(MdlChain); IoFreeMdl(MdlChain);
} }
VOID VOID
@ -128,7 +112,7 @@ CcMdlWriteComplete2(IN PFILE_OBJECT FileObject,
IN PLARGE_INTEGER FileOffset, IN PLARGE_INTEGER FileOffset,
IN PMDL MdlChain) IN PMDL MdlChain)
{ {
UNIMPLEMENTED UNIMPLEMENTED
} }
VOID VOID
@ -136,8 +120,8 @@ NTAPI
CcMdlWriteAbort(IN PFILE_OBJECT FileObject, CcMdlWriteAbort(IN PFILE_OBJECT FileObject,
IN PMDL MdlChain) IN PMDL MdlChain)
{ {
ASSERT(FALSE); ASSERT(FALSE);
IoFreeMdl(MdlChain); IoFreeMdl(MdlChain);
} }
/* EOF */ /* EOF */

94
reactos/ntoskrnl/cache/newcc.h vendored
View file

@ -5,7 +5,7 @@ typedef struct _NOCC_BCB
/* Public part */ /* Public part */
PUBLIC_BCB Bcb; PUBLIC_BCB Bcb;
struct _NOCC_CACHE_MAP *Map; struct _NOCC_CACHE_MAP *Map;
PROS_SECTION_OBJECT SectionObject; PROS_SECTION_OBJECT SectionObject;
LARGE_INTEGER FileOffset; LARGE_INTEGER FileOffset;
ULONG Length; ULONG Length;
@ -25,39 +25,33 @@ typedef struct _NOCC_BCB
typedef struct _NOCC_CACHE_MAP typedef struct _NOCC_CACHE_MAP
{ {
LIST_ENTRY Entry; LIST_ENTRY Entry;
LIST_ENTRY AssociatedBcb; LIST_ENTRY AssociatedBcb;
LIST_ENTRY PrivateCacheMaps; LIST_ENTRY PrivateCacheMaps;
ULONG NumberOfMaps; ULONG NumberOfMaps;
ULONG RefCount; ULONG RefCount;
CC_FILE_SIZES FileSizes; CC_FILE_SIZES FileSizes;
CACHE_MANAGER_CALLBACKS Callbacks; CACHE_MANAGER_CALLBACKS Callbacks;
PVOID LazyContext; PVOID LazyContext;
PVOID LogHandle; PVOID LogHandle;
PFLUSH_TO_LSN FlushToLsn; PFLUSH_TO_LSN FlushToLsn;
ULONG ReadAheadGranularity; ULONG ReadAheadGranularity;
} NOCC_CACHE_MAP, *PNOCC_CACHE_MAP; } NOCC_CACHE_MAP, *PNOCC_CACHE_MAP;
VOID VOID
NTAPI NTAPI
CcPfInitializePrefetcher( CcPfInitializePrefetcher(VOID);
VOID
);
VOID VOID
NTAPI NTAPI
CcMdlReadComplete2( CcMdlReadComplete2(IN PMDL MemoryDescriptorList,
IN PMDL MemoryDescriptorList, IN PFILE_OBJECT FileObject);
IN PFILE_OBJECT FileObject
);
VOID VOID
NTAPI NTAPI
CcMdlWriteComplete2( CcMdlWriteComplete2(IN PFILE_OBJECT FileObject,
IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset,
IN PLARGE_INTEGER FileOffset, IN PMDL MdlChain);
IN PMDL MdlChain
);
VOID VOID
NTAPI NTAPI
@ -65,7 +59,8 @@ CcInitView(VOID);
BOOLEAN BOOLEAN
NTAPI NTAPI
CcpUnpinData(PNOCC_BCB Bcb, BOOLEAN ActuallyRelease); CcpUnpinData(PNOCC_BCB Bcb,
BOOLEAN ActuallyRelease);
BOOLEAN BOOLEAN
NTAPI NTAPI
@ -82,24 +77,25 @@ CcInitCacheZeroPage(VOID);
/* Called by section.c */ /* Called by section.c */
BOOLEAN BOOLEAN
NTAPI NTAPI
CcFlushImageSection(PSECTION_OBJECT_POINTERS SectionObjectPointer, MMFLUSH_TYPE FlushType); CcFlushImageSection(PSECTION_OBJECT_POINTERS SectionObjectPointer,
MMFLUSH_TYPE FlushType);
VOID VOID
NTAPI NTAPI
_CcpFlushCache _CcpFlushCache(IN PNOCC_CACHE_MAP Map,
(IN PNOCC_CACHE_MAP Map, IN OPTIONAL PLARGE_INTEGER FileOffset,
IN OPTIONAL PLARGE_INTEGER FileOffset, IN ULONG Length,
IN ULONG Length, OUT OPTIONAL PIO_STATUS_BLOCK IoStatus,
OUT OPTIONAL PIO_STATUS_BLOCK IoStatus, BOOLEAN Delete,
BOOLEAN Delete, const char *File,
const char *File, int Line);
int Line);
#define CcpFlushCache(M,F,L,I,D) _CcpFlushCache(M,F,L,I,D,__FILE__,__LINE__) #define CcpFlushCache(M,F,L,I,D) _CcpFlushCache(M,F,L,I,D,__FILE__,__LINE__)
BOOLEAN BOOLEAN
NTAPI NTAPI
CcGetFileSizes(PFILE_OBJECT FileObject, PCC_FILE_SIZES FileSizes); CcGetFileSizes(PFILE_OBJECT FileObject,
PCC_FILE_SIZES FileSizes);
ULONG ULONG
NTAPI NTAPI
@ -125,13 +121,13 @@ CcpReleaseFileLock(PNOCC_CACHE_MAP Map);
/* Private data */ /* Private data */
#define CACHE_SINGLE_FILE_MAX (16) #define CACHE_SINGLE_FILE_MAX (16)
#define CACHE_OVERALL_SIZE (32 * 1024 * 1024) #define CACHE_OVERALL_SIZE (32 * 1024 * 1024)
#define CACHE_STRIPE VACB_MAPPING_GRANULARITY #define CACHE_STRIPE VACB_MAPPING_GRANULARITY
#define CACHE_SHIFT 18 #define CACHE_SHIFT 18
#define CACHE_NUM_SECTIONS (CACHE_OVERALL_SIZE / CACHE_STRIPE) #define CACHE_NUM_SECTIONS (CACHE_OVERALL_SIZE / CACHE_STRIPE)
#define CACHE_ROUND_UP(x) (((x) + (CACHE_STRIPE-1)) & ~(CACHE_STRIPE-1)) #define CACHE_ROUND_UP(x) (((x) + (CACHE_STRIPE-1)) & ~(CACHE_STRIPE-1))
#define CACHE_ROUND_DOWN(x) ((x) & ~(CACHE_STRIPE-1)) #define CACHE_ROUND_DOWN(x) ((x) & ~(CACHE_STRIPE-1))
#define INVALID_CACHE ((ULONG)~0) #define INVALID_CACHE ((ULONG)~0)
extern NOCC_BCB CcCacheSections[CACHE_NUM_SECTIONS]; extern NOCC_BCB CcCacheSections[CACHE_NUM_SECTIONS];
extern PRTL_BITMAP CcCacheBitmap; extern PRTL_BITMAP CcCacheBitmap;
@ -149,20 +145,20 @@ extern VOID _CcpUnlock(const char *file, int line);
extern VOID CcpReferenceCache(ULONG Sector); extern VOID CcpReferenceCache(ULONG Sector);
extern VOID CcpDereferenceCache(ULONG Sector, BOOLEAN Immediate); extern VOID CcpDereferenceCache(ULONG Sector, BOOLEAN Immediate);
BOOLEAN BOOLEAN
NTAPI NTAPI
CcpMapData CcpMapData(IN PFILE_OBJECT FileObject,
(IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset,
IN PLARGE_INTEGER FileOffset, IN ULONG Length,
IN ULONG Length, IN ULONG Flags,
IN ULONG Flags, OUT PVOID *BcbResult,
OUT PVOID *BcbResult, OUT PVOID *Buffer);
OUT PVOID *Buffer);
BOOLEAN BOOLEAN
NTAPI NTAPI
CcpPinMappedData(IN PNOCC_CACHE_MAP Map, CcpPinMappedData(IN PNOCC_CACHE_MAP Map,
IN PLARGE_INTEGER FileOffset, IN PLARGE_INTEGER FileOffset,
IN ULONG Length, IN ULONG Length,
IN ULONG Flags, IN ULONG Flags,
IN OUT PVOID *Bcb); IN OUT PVOID *Bcb);

830
reactos/ntoskrnl/cache/pinsup.c vendored
View file

File diff suppressed because it is too large Load diff