-/* $Id: copy.c,v 1.5 2002/06/04 15:26:55 dwelch Exp $
+/* $Id$
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* FILE: ntoskrnl/cc/copy.c
* PURPOSE: Implements cache managers copy interface
- * PROGRAMMER: Hartmut Birr
- * UPDATE HISTORY:
- * Created 05.10.2001
+ *
+ * PROGRAMMERS: Hartmut Birr
*/
/* INCLUDES ******************************************************************/
-#include <ddk/ntddk.h>
-#include <ddk/ntifs.h>
-#include <internal/mm.h>
-#include <internal/cc.h>
-#include <internal/pool.h>
-#include <internal/io.h>
-#include <ntos/minmax.h>
-
+#include <ntoskrnl.h>
#define NDEBUG
#include <internal/debug.h>
/* GLOBALS *******************************************************************/
-#define ROUND_DOWN(N, S) ((N) - ((N) % (S)))
+static PFN_TYPE CcZeroPage = 0;
+
+#define MAX_ZERO_LENGTH (256 * 1024)
+#define MAX_RW_LENGTH (256 * 1024)
+
+#if defined(__GNUC__)
+/* void * alloca(size_t size); */
+#elif defined(_MSC_VER)
+void* _alloca(size_t size);
+#else
+#error Unknown compiler for alloca intrinsic stack allocation "function"
+#endif
+
+ULONG CcFastMdlReadWait;
+ULONG CcFastReadNotPossible;
+ULONG CcFastReadWait;
+ULONG CcFastReadNoWait;
+ULONG CcFastReadResourceMiss;
+
/* FUNCTIONS *****************************************************************/
+VOID
+NTAPI
+CcInitCacheZeroPage(VOID)
+{
+ NTSTATUS Status;
+
+ Status = MmRequestPageMemoryConsumer(MC_NPPOOL, TRUE, &CcZeroPage);
+ if (!NT_SUCCESS(Status))
+ {
+ DbgPrint("Can't allocate CcZeroPage.\n");
+ KEBUGCHECKCC;
+ }
+ Status = MiZeroPage(CcZeroPage);
+ if (!NT_SUCCESS(Status))
+ {
+ DbgPrint("Can't zero out CcZeroPage.\n");
+ KEBUGCHECKCC;
+ }
+}
+
NTSTATUS
+NTAPI
ReadCacheSegmentChain(PBCB Bcb, ULONG ReadOffset, ULONG Length,
PVOID Buffer)
{
LARGE_INTEGER SegOffset;
NTSTATUS Status;
ULONG TempLength;
+ KEVENT Event;
+ PMDL Mdl;
+
+ Mdl = alloca(MmSizeOfMdl(NULL, MAX_RW_LENGTH));
Status = CcRosGetCacheSegmentChain(Bcb, ReadOffset, Length, &head);
if (!NT_SUCCESS(Status))
{
TempLength = min(Bcb->CacheSegmentSize, Length);
memcpy(Buffer, current->BaseAddress, TempLength);
- Buffer += TempLength;
- Length = Length - TempLength;
+
+ Buffer = (PVOID)((ULONG_PTR)Buffer + TempLength);
+
+ Length = Length - TempLength;
previous = current;
current = current->NextInChain;
CcRosReleaseCacheSegment(Bcb, previous, TRUE, FALSE, FALSE);
}
/*
- * Otherwise read in a much as we can.
+ * Otherwise read in as much as we can.
*/
else
{
PCACHE_SEGMENT current2;
ULONG current_size;
- PMDL Mdl;
ULONG i;
- ULONG offset;
+ PPFN_TYPE MdlPages;
/*
* Count the maximum number of bytes we could read starting
*/
current2 = current;
current_size = 0;
- while (current2 != NULL && !current2->Valid)
+ while (current2 != NULL && !current2->Valid && current_size < MAX_RW_LENGTH)
{
current2 = current2->NextInChain;
current_size += Bcb->CacheSegmentSize;
}
-
+
/*
* Create an MDL which contains all their pages.
*/
- Mdl = MmCreateMdl(NULL, NULL, current_size);
+ MmInitializeMdl(Mdl, NULL, current_size);
Mdl->MdlFlags |= (MDL_PAGES_LOCKED | MDL_IO_PAGE_READ);
current2 = current;
- offset = 0;
- while (current2 != NULL && !current2->Valid)
+ current_size = 0;
+ MdlPages = (PPFN_TYPE)(Mdl + 1);
+ while (current2 != NULL && !current2->Valid && current_size < MAX_RW_LENGTH)
{
- for (i = 0; i < (Bcb->CacheSegmentSize / PAGESIZE); i++)
+ PVOID address = current2->BaseAddress;
+ for (i = 0; i < (Bcb->CacheSegmentSize / PAGE_SIZE); i++, address = RVA(address, PAGE_SIZE))
{
- PVOID address;
- PHYSICAL_ADDRESS page;
- address = current2->BaseAddress + (i * PAGESIZE);
- page = MmGetPhysicalAddressForProcess(NULL, address);
- ((PULONG)(Mdl + 1))[offset] = page.u.LowPart;
- offset++;
+ *MdlPages++ = MmGetPfnForProcess(NULL, address);
}
current2 = current2->NextInChain;
+ current_size += Bcb->CacheSegmentSize;
}
/*
* Read in the information.
*/
SegOffset.QuadPart = current->FileOffset;
+ KeInitializeEvent(&Event, NotificationEvent, FALSE);
Status = IoPageRead(Bcb->FileObject,
Mdl,
&SegOffset,
- &Iosb,
- TRUE);
+ &Event,
+ &Iosb);
+ if (Status == STATUS_PENDING)
+ {
+ KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
+ Status = Iosb.Status;
+ }
+ if (Mdl->MdlFlags & MDL_MAPPED_TO_SYSTEM_VA)
+ {
+ MmUnmapLockedPages(Mdl->MappedSystemVa, Mdl);
+ }
if (!NT_SUCCESS(Status) && Status != STATUS_END_OF_FILE)
{
while (current != NULL)
}
return(Status);
}
- while (current != NULL && !current->Valid)
+ current_size = 0;
+ while (current != NULL && !current->Valid && current_size < MAX_RW_LENGTH)
{
previous = current;
current = current->NextInChain;
TempLength = min(Bcb->CacheSegmentSize, Length);
memcpy(Buffer, previous->BaseAddress, TempLength);
- Buffer += TempLength;
- Length = Length - TempLength;
+
+ Buffer = (PVOID)((ULONG_PTR)Buffer + TempLength);
+
+ Length = Length - TempLength;
CcRosReleaseCacheSegment(Bcb, previous, TRUE, FALSE, FALSE);
+ current_size += Bcb->CacheSegmentSize;
}
}
}
return(STATUS_SUCCESS);
}
-NTSTATUS
+NTSTATUS
+NTAPI
ReadCacheSegment(PCACHE_SEGMENT CacheSeg)
{
ULONG Size;
NTSTATUS Status;
LARGE_INTEGER SegOffset;
IO_STATUS_BLOCK IoStatus;
+ KEVENT Event;
SegOffset.QuadPart = CacheSeg->FileOffset;
- Size = CacheSeg->Bcb->AllocationSize.QuadPart - CacheSeg->FileOffset;
+ Size = (ULONG)(CacheSeg->Bcb->AllocationSize.QuadPart - CacheSeg->FileOffset);
if (Size > CacheSeg->Bcb->CacheSegmentSize)
{
Size = CacheSeg->Bcb->CacheSegmentSize;
}
- Mdl = MmCreateMdl(NULL, CacheSeg->BaseAddress, Size);
+ Mdl = alloca(MmSizeOfMdl(CacheSeg->BaseAddress, Size));
+ MmInitializeMdl(Mdl, CacheSeg->BaseAddress, Size);
MmBuildMdlForNonPagedPool(Mdl);
- Status = IoPageRead(CacheSeg->Bcb->FileObject, Mdl, &SegOffset, &IoStatus,
- TRUE);
+ Mdl->MdlFlags |= MDL_IO_PAGE_READ;
+ KeInitializeEvent(&Event, NotificationEvent, FALSE);
+ Status = IoPageRead(CacheSeg->Bcb->FileObject, Mdl, &SegOffset, & Event, &IoStatus);
+ if (Status == STATUS_PENDING)
+ {
+ KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
+ Status = IoStatus.Status;
+ }
+
if (!NT_SUCCESS(Status) && Status != STATUS_END_OF_FILE)
{
- CcRosReleaseCacheSegment(CacheSeg->Bcb, CacheSeg, FALSE, FALSE, FALSE);
DPRINT1("IoPageRead failed, Status %x\n", Status);
return Status;
}
if (CacheSeg->Bcb->CacheSegmentSize > Size)
{
- memset (CacheSeg->BaseAddress + Size, 0,
+ memset ((char*)CacheSeg->BaseAddress + Size, 0,
CacheSeg->Bcb->CacheSegmentSize - Size);
}
return STATUS_SUCCESS;
}
-NTSTATUS WriteCacheSegment(PCACHE_SEGMENT CacheSeg)
+NTSTATUS
+NTAPI
+WriteCacheSegment(PCACHE_SEGMENT CacheSeg)
{
ULONG Size;
PMDL Mdl;
NTSTATUS Status;
IO_STATUS_BLOCK IoStatus;
LARGE_INTEGER SegOffset;
+ KEVENT Event;
+ CacheSeg->Dirty = FALSE;
SegOffset.QuadPart = CacheSeg->FileOffset;
- Size = CacheSeg->Bcb->AllocationSize.QuadPart - CacheSeg->FileOffset;
+ Size = (ULONG)(CacheSeg->Bcb->AllocationSize.QuadPart - CacheSeg->FileOffset);
if (Size > CacheSeg->Bcb->CacheSegmentSize)
- {
- Size = CacheSeg->Bcb->CacheSegmentSize;
- }
- Mdl = MmCreateMdl(NULL, CacheSeg->BaseAddress, Size);
+ {
+ Size = CacheSeg->Bcb->CacheSegmentSize;
+ }
+ Mdl = alloca(MmSizeOfMdl(CacheSeg->BaseAddress, Size));
+ MmInitializeMdl(Mdl, CacheSeg->BaseAddress, Size);
MmBuildMdlForNonPagedPool(Mdl);
- Status = IoPageWrite(CacheSeg->Bcb->FileObject, Mdl, &SegOffset, &IoStatus, TRUE);
- if (!NT_SUCCESS(Status))
+ Mdl->MdlFlags |= MDL_IO_PAGE_READ;
+ KeInitializeEvent(&Event, NotificationEvent, FALSE);
+ Status = IoSynchronousPageWrite(CacheSeg->Bcb->FileObject, Mdl, &SegOffset, &Event, &IoStatus);
+ if (Status == STATUS_PENDING)
{
- DPRINT1("IoPageWrite failed, Status %x\n", Status);
+ KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
+ Status = IoStatus.Status;
}
- return Status;
+ if (!NT_SUCCESS(Status) && (Status != STATUS_END_OF_FILE))
+ {
+ DPRINT1("IoPageWrite failed, Status %x\n", Status);
+ CacheSeg->Dirty = TRUE;
+ return(Status);
+ }
+ return(STATUS_SUCCESS);
+}
+
+
+/*
+ * @unimplemented
+ */
+BOOLEAN STDCALL
+CcCanIWrite (
+ IN PFILE_OBJECT FileObject,
+ IN ULONG BytesToWrite,
+ IN BOOLEAN Wait,
+ IN BOOLEAN Retrying)
+{
+ UNIMPLEMENTED;
+ return FALSE;
}
+
+/*
+ * @implemented
+ */
BOOLEAN STDCALL
CcCopyRead (IN PFILE_OBJECT FileObject,
IN PLARGE_INTEGER FileOffset,
KIRQL oldirql;
PLIST_ENTRY current_entry;
PCACHE_SEGMENT current;
-
- DPRINT("CcCopyRead(FileObject %x, FileOffset %x, "
- "Length %d, Wait %d, Buffer %x, IoStatus %x)\n",
- FileObject, (ULONG)FileOffset->QuadPart, Length, Wait,
+
+ DPRINT("CcCopyRead(FileObject 0x%p, FileOffset %I64x, "
+ "Length %d, Wait %d, Buffer 0x%p, IoStatus 0x%p)\n",
+ FileObject, FileOffset->QuadPart, Length, Wait,
Buffer, IoStatus);
- Bcb = ((REACTOS_COMMON_FCB_HEADER*)FileObject->FsContext)->Bcb;
- ReadOffset = FileOffset->QuadPart;
-
+ Bcb = FileObject->SectionObjectPointer->SharedCacheMap;
+ ReadOffset = (ULONG)FileOffset->QuadPart;
+
DPRINT("AllocationSize %d, FileSize %d\n",
(ULONG)Bcb->AllocationSize.QuadPart,
(ULONG)Bcb->FileSize.QuadPart);
current_entry = Bcb->BcbSegmentListHead.Flink;
while (current_entry != &Bcb->BcbSegmentListHead)
{
- current = CONTAINING_RECORD(current_entry, CACHE_SEGMENT,
+ current = CONTAINING_RECORD(current_entry, CACHE_SEGMENT,
BcbSegmentListEntry);
if (!current->Valid && current->FileOffset < ReadOffset + Length
&& current->FileOffset + Bcb->CacheSegmentSize > ReadOffset)
{
TempLength = min (Length, Bcb->CacheSegmentSize - TempLength);
Status = CcRosRequestCacheSegment(Bcb,
- ROUND_DOWN(ReadOffset,
+ ROUND_DOWN(ReadOffset,
Bcb->CacheSegmentSize),
&BaseAddress, &Valid, &CacheSeg);
if (!NT_SUCCESS(Status))
{
IoStatus->Information = 0;
IoStatus->Status = Status;
+ CcRosReleaseCacheSegment(Bcb, CacheSeg, FALSE, FALSE, FALSE);
return FALSE;
}
}
- memcpy (Buffer, BaseAddress + ReadOffset % Bcb->CacheSegmentSize,
+ memcpy (Buffer, (char*)BaseAddress + ReadOffset % Bcb->CacheSegmentSize,
TempLength);
CcRosReleaseCacheSegment(Bcb, CacheSeg, TRUE, FALSE, FALSE);
ReadLength += TempLength;
Length -= TempLength;
ReadOffset += TempLength;
- Buffer += TempLength;
+ Buffer = (PVOID)((char*)Buffer + TempLength);
}
-
while (Length > 0)
{
- TempLength = min(max(Bcb->CacheSegmentSize, 65536), Length);
+ TempLength = min(max(Bcb->CacheSegmentSize, MAX_RW_LENGTH), Length);
ReadCacheSegmentChain(Bcb, ReadOffset, TempLength, Buffer);
ReadLength += TempLength;
Length -= TempLength;
ReadOffset += TempLength;
- Buffer += TempLength;
+
+ Buffer = (PVOID)((ULONG_PTR)Buffer + TempLength);
}
IoStatus->Status = STATUS_SUCCESS;
IoStatus->Information = ReadLength;
return TRUE;
}
+/*
+ * @implemented
+ */
BOOLEAN STDCALL
-CcCopyWrite (
- IN PFILE_OBJECT FileObject,
- IN PLARGE_INTEGER FileOffset,
- IN ULONG Length,
- IN BOOLEAN Wait,
- IN PVOID Buffer)
+CcCopyWrite (IN PFILE_OBJECT FileObject,
+ IN PLARGE_INTEGER FileOffset,
+ IN ULONG Length,
+ IN BOOLEAN Wait,
+ IN PVOID Buffer)
{
NTSTATUS Status;
ULONG WriteOffset;
PVOID BaseAddress;
BOOLEAN Valid;
- DPRINT("CcCopyWrite(FileObject %x, FileOffset %x, "
- "Length %d, Wait %d, Buffer %x)\n",
- FileObject, (ULONG)FileOffset->QuadPart, Length, Wait, Buffer);
+ DPRINT("CcCopyWrite(FileObject 0x%p, FileOffset %I64x, "
+ "Length %d, Wait %d, Buffer 0x%p)\n",
+ FileObject, FileOffset->QuadPart, Length, Wait, Buffer);
- Bcb = ((REACTOS_COMMON_FCB_HEADER*)FileObject->FsContext)->Bcb;
+ Bcb = FileObject->SectionObjectPointer->SharedCacheMap;
WriteOffset = (ULONG)FileOffset->QuadPart;
if (!Wait)
- {
- // testing, if the requested datas are available
- KeAcquireSpinLock(&Bcb->BcbLock, &oldirql);
- current_entry = Bcb->BcbSegmentListHead.Flink;
- while (current_entry != &Bcb->BcbSegmentListHead)
{
- CacheSeg = CONTAINING_RECORD(current_entry, CACHE_SEGMENT, BcbSegmentListEntry);
- if (!CacheSeg->Valid)
- {
- if ((WriteOffset >= CacheSeg->FileOffset && WriteOffset < CacheSeg->FileOffset + Bcb->CacheSegmentSize)
- || (WriteOffset + Length > CacheSeg->FileOffset && WriteOffset + Length <= CacheSeg->FileOffset + Bcb->CacheSegmentSize))
- {
- KeReleaseSpinLock(&Bcb->BcbLock, oldirql);
- // datas not available
- return FALSE;
- }
- }
- current_entry = current_entry->Flink;
+ /* testing, if the requested datas are available */
+ KeAcquireSpinLock(&Bcb->BcbLock, &oldirql);
+ current_entry = Bcb->BcbSegmentListHead.Flink;
+ while (current_entry != &Bcb->BcbSegmentListHead)
+ {
+ CacheSeg = CONTAINING_RECORD(current_entry, CACHE_SEGMENT,
+ BcbSegmentListEntry);
+ if (!CacheSeg->Valid)
+ {
+ if ((WriteOffset >= CacheSeg->FileOffset &&
+ WriteOffset < CacheSeg->FileOffset + Bcb->CacheSegmentSize)
+ || (WriteOffset + Length > CacheSeg->FileOffset &&
+ WriteOffset + Length <= CacheSeg->FileOffset +
+ Bcb->CacheSegmentSize))
+ {
+ KeReleaseSpinLock(&Bcb->BcbLock, oldirql);
+ /* datas not available */
+ return(FALSE);
+ }
+ }
+ current_entry = current_entry->Flink;
+ }
+ KeReleaseSpinLock(&Bcb->BcbLock, oldirql);
}
- KeReleaseSpinLock(&Bcb->BcbLock, oldirql);
- }
TempLength = WriteOffset % Bcb->CacheSegmentSize;
if (TempLength != 0)
- {
- TempLength = min (Length, Bcb->CacheSegmentSize - TempLength);
- Status = CcRosRequestCacheSegment(Bcb,
- ROUND_DOWN(WriteOffset, Bcb->CacheSegmentSize),
- &BaseAddress, &Valid, &CacheSeg);
- if (!NT_SUCCESS(Status))
- {
- return FALSE;
- }
- if (!Valid)
- {
- if (!NT_SUCCESS(ReadCacheSegment(CacheSeg)))
- {
- return FALSE;
- }
- }
- memcpy (BaseAddress + WriteOffset % Bcb->CacheSegmentSize, Buffer, TempLength);
- if (!NT_SUCCESS(WriteCacheSegment(CacheSeg)))
- {
- return FALSE;
- }
- CcRosReleaseCacheSegment(Bcb, CacheSeg, TRUE, FALSE, FALSE);
+ {
+ ULONG ROffset;
+ ROffset = ROUND_DOWN(WriteOffset, Bcb->CacheSegmentSize);
+ TempLength = min (Length, Bcb->CacheSegmentSize - TempLength);
+ Status = CcRosRequestCacheSegment(Bcb, ROffset,
+ &BaseAddress, &Valid, &CacheSeg);
+ if (!NT_SUCCESS(Status))
+ {
+ return(FALSE);
+ }
+ if (!Valid)
+ {
+ if (!NT_SUCCESS(ReadCacheSegment(CacheSeg)))
+ {
+ return(FALSE);
+ }
+ }
+ memcpy ((char*)BaseAddress + WriteOffset % Bcb->CacheSegmentSize,
+ Buffer, TempLength);
+ CcRosReleaseCacheSegment(Bcb, CacheSeg, TRUE, TRUE, FALSE);
- Length -= TempLength;
- WriteOffset += TempLength;
- Buffer += TempLength;
- }
+ Length -= TempLength;
+ WriteOffset += TempLength;
+
+ Buffer = (PVOID)((ULONG_PTR)Buffer + TempLength);
+ }
while (Length > 0)
- {
- TempLength = min (Bcb->CacheSegmentSize, Length);
- Status = CcRosRequestCacheSegment(Bcb, WriteOffset,
- &BaseAddress, &Valid, &CacheSeg);
- if (!NT_SUCCESS(Status))
- {
- return FALSE;
- }
- if (!Valid && TempLength < Bcb->CacheSegmentSize)
- {
- if (!NT_SUCCESS(ReadCacheSegment(CacheSeg)))
- {
- return FALSE;
- }
- }
- memcpy (BaseAddress, Buffer, TempLength);
- if (!NT_SUCCESS(WriteCacheSegment(CacheSeg)))
- {
- return FALSE;
- }
- CcRosReleaseCacheSegment(Bcb, CacheSeg, TRUE, FALSE, FALSE);
- Length -= TempLength;
- WriteOffset += TempLength;
- Buffer += TempLength;
- }
- return TRUE;
+ {
+ TempLength = min (Bcb->CacheSegmentSize, Length);
+ Status = CcRosRequestCacheSegment(Bcb, WriteOffset,
+ &BaseAddress, &Valid, &CacheSeg);
+ if (!NT_SUCCESS(Status))
+ {
+ return(FALSE);
+ }
+ if (!Valid && TempLength < Bcb->CacheSegmentSize)
+ {
+ if (!NT_SUCCESS(ReadCacheSegment(CacheSeg)))
+ {
+ CcRosReleaseCacheSegment(Bcb, CacheSeg, FALSE, FALSE, FALSE);
+ return FALSE;
+ }
+ }
+ memcpy (BaseAddress, Buffer, TempLength);
+ CcRosReleaseCacheSegment(Bcb, CacheSeg, TRUE, TRUE, FALSE);
+ Length -= TempLength;
+ WriteOffset += TempLength;
+
+ Buffer = (PVOID)((ULONG_PTR)Buffer + TempLength);
+ }
+ return(TRUE);
}
+/*
+ * @unimplemented
+ */
+VOID
+STDCALL
+CcDeferWrite (
+ IN PFILE_OBJECT FileObject,
+ IN PCC_POST_DEFERRED_WRITE PostRoutine,
+ IN PVOID Context1,
+ IN PVOID Context2,
+ IN ULONG BytesToWrite,
+ IN BOOLEAN Retrying
+ )
+{
+ UNIMPLEMENTED;
+}
+/*
+ * @unimplemented
+ */
+VOID
+STDCALL
+CcFastCopyRead (
+ IN PFILE_OBJECT FileObject,
+ IN ULONG FileOffset,
+ IN ULONG Length,
+ IN ULONG PageCount,
+ OUT PVOID Buffer,
+ OUT PIO_STATUS_BLOCK IoStatus
+ )
+{
+ UNIMPLEMENTED;
+}
+/*
+ * @unimplemented
+ */
+VOID
+STDCALL
+CcFastCopyWrite(
+ IN PFILE_OBJECT FileObject,
+ IN ULONG FileOffset,
+ IN ULONG Length,
+ IN PVOID Buffer)
+{
+ UNIMPLEMENTED;
+}
+
+/*
+ * @unimplemented
+ */
+NTSTATUS
+STDCALL
+CcWaitForCurrentLazyWriterActivity (
+ VOID
+ )
+{
+ UNIMPLEMENTED;
+ return STATUS_NOT_IMPLEMENTED;
+}
+
+/*
+ * @implemented
+ */
+BOOLEAN STDCALL
+CcZeroData (IN PFILE_OBJECT FileObject,
+ IN PLARGE_INTEGER StartOffset,
+ IN PLARGE_INTEGER EndOffset,
+ IN BOOLEAN Wait)
+{
+ NTSTATUS Status;
+ LARGE_INTEGER WriteOffset;
+ ULONG Length;
+ ULONG CurrentLength;
+ PMDL Mdl;
+ ULONG i;
+ IO_STATUS_BLOCK Iosb;
+ KEVENT Event;
+
+ DPRINT("CcZeroData(FileObject 0x%p, StartOffset %I64x, EndOffset %I64x, "
+ "Wait %d)\n", FileObject, StartOffset->QuadPart, EndOffset->QuadPart,
+ Wait);
+
+ Length = EndOffset->u.LowPart - StartOffset->u.LowPart;
+ WriteOffset.QuadPart = StartOffset->QuadPart;
+
+ if (FileObject->SectionObjectPointer->SharedCacheMap == NULL)
+ {
+ /* File is not cached */
+
+ Mdl = alloca(MmSizeOfMdl(NULL, MAX_ZERO_LENGTH));
+
+ while (Length > 0)
+ {
+ if (Length + WriteOffset.u.LowPart % PAGE_SIZE > MAX_ZERO_LENGTH)
+ {
+ CurrentLength = MAX_ZERO_LENGTH - WriteOffset.u.LowPart % PAGE_SIZE;
+ }
+ else
+ {
+ CurrentLength = Length;
+ }
+ MmInitializeMdl(Mdl, (PVOID)WriteOffset.u.LowPart, CurrentLength);
+ Mdl->MdlFlags |= (MDL_PAGES_LOCKED | MDL_IO_PAGE_READ);
+ for (i = 0; i < ((Mdl->Size - sizeof(MDL)) / sizeof(ULONG)); i++)
+ {
+ ((PPFN_TYPE)(Mdl + 1))[i] = CcZeroPage;
+ }
+ KeInitializeEvent(&Event, NotificationEvent, FALSE);
+ Status = IoSynchronousPageWrite(FileObject, Mdl, &WriteOffset, &Event, &Iosb);
+ if (Status == STATUS_PENDING)
+ {
+ KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
+ Status = Iosb.Status;
+ }
+ MmUnmapLockedPages(Mdl->MappedSystemVa, Mdl);
+ if (!NT_SUCCESS(Status))
+ {
+ return(FALSE);
+ }
+ WriteOffset.QuadPart += CurrentLength;
+ Length -= CurrentLength;
+ }
+ }
+ else
+ {
+ /* File is cached */
+ KIRQL oldirql;
+ PBCB Bcb;
+ PLIST_ENTRY current_entry;
+ PCACHE_SEGMENT CacheSeg, current, previous;
+ ULONG TempLength;
+
+ Bcb = FileObject->SectionObjectPointer->SharedCacheMap;
+ if (Wait)
+ {
+ /* testing, if the requested datas are available */
+ KeAcquireSpinLock(&Bcb->BcbLock, &oldirql);
+ current_entry = Bcb->BcbSegmentListHead.Flink;
+ while (current_entry != &Bcb->BcbSegmentListHead)
+ {
+ CacheSeg = CONTAINING_RECORD(current_entry, CACHE_SEGMENT,
+ BcbSegmentListEntry);
+ if (!CacheSeg->Valid)
+ {
+ if ((WriteOffset.u.LowPart >= CacheSeg->FileOffset &&
+ WriteOffset.u.LowPart < CacheSeg->FileOffset + Bcb->CacheSegmentSize)
+ || (WriteOffset.u.LowPart + Length > CacheSeg->FileOffset &&
+ WriteOffset.u.LowPart + Length <=
+ CacheSeg->FileOffset + Bcb->CacheSegmentSize))
+ {
+ KeReleaseSpinLock(&Bcb->BcbLock, oldirql);
+ /* datas not available */
+ return(FALSE);
+ }
+ }
+ current_entry = current_entry->Flink;
+ }
+ KeReleaseSpinLock(&Bcb->BcbLock, oldirql);
+ }
+ while (Length > 0)
+ {
+ ULONG Offset;
+ Offset = WriteOffset.u.LowPart % Bcb->CacheSegmentSize;
+ if (Length + Offset > MAX_ZERO_LENGTH)
+ {
+ CurrentLength = MAX_ZERO_LENGTH - Offset;
+ }
+ else
+ {
+ CurrentLength = Length;
+ }
+ Status = CcRosGetCacheSegmentChain (Bcb, WriteOffset.u.LowPart - Offset,
+ Offset + CurrentLength, &CacheSeg);
+ if (!NT_SUCCESS(Status))
+ {
+ return FALSE;
+ }
+ current = CacheSeg;
+
+ while (current != NULL)
+ {
+ Offset = WriteOffset.u.LowPart % Bcb->CacheSegmentSize;
+ if (Offset != 0 ||
+ Offset + CurrentLength < Bcb->CacheSegmentSize)
+ {
+ if (!current->Valid)
+ {
+ /* read the segment */
+ Status = ReadCacheSegment(current);
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT1("ReadCacheSegment failed, status %x\n",
+ Status);
+ }
+ }
+ TempLength = min (CurrentLength, Bcb->CacheSegmentSize - Offset);
+ }
+ else
+ {
+ TempLength = Bcb->CacheSegmentSize;
+ }
+ memset ((PUCHAR)current->BaseAddress + Offset, 0, TempLength);
+
+ WriteOffset.QuadPart += TempLength;
+ CurrentLength -= TempLength;
+ Length -= TempLength;
+
+ current = current->NextInChain;
+ }
+
+ current = CacheSeg;
+ while (current != NULL)
+ {
+ previous = current;
+ current = current->NextInChain;
+ CcRosReleaseCacheSegment(Bcb, previous, TRUE, TRUE, FALSE);
+ }
+ }
+ }
+ return(TRUE);
+}