/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
- * FILE: drivers/fs/vfat/rw.c
+ * FILE: drivers/filesystems/fastfat/rw.c
* PURPOSE: VFAT Filesystem
* PROGRAMMER: Jason Filby (jasonfilby@yahoo.com)
+ * Pierre Schweitzer (pierre@reactos.org)
*
*/
*/
/* #define DEBUG_VERIFY_OFFSET_CACHING */
+/* Arbitrary, taken from MS FastFAT, should be
+ * refined given what we experience in common
+ * out of stack operations
+ */
+#define OVERFLOW_READ_THRESHHOLD 0xE00
+
/* FUNCTIONS *****************************************************************/
/*
BytesPerSector = DeviceExt->FatInfo.BytesPerSector;
BytesPerCluster = DeviceExt->FatInfo.BytesPerCluster;
- ASSERT(ReadOffset.QuadPart + Length <= ROUND_UP(Fcb->RFCB.FileSize.QuadPart, BytesPerSector));
+ ASSERT(ReadOffset.QuadPart + Length <= ROUND_UP_64(Fcb->RFCB.FileSize.QuadPart, BytesPerSector));
ASSERT(ReadOffset.u.LowPart % BytesPerSector == 0);
ASSERT(Length % BytesPerSector == 0);
/* Is this a read of the FAT? */
- if (Fcb->Flags & FCB_IS_FAT)
+ if (BooleanFlagOn(Fcb->Flags, FCB_IS_FAT))
{
ReadOffset.QuadPart += DeviceExt->FatInfo.FATStart * BytesPerSector;
Status = VfatReadDiskPartial(IrpContext, &ReadOffset, Length, 0, TRUE);
}
/* Is this a read of the Volume ? */
- if (Fcb->Flags & FCB_IS_VOLUME)
+ if (BooleanFlagOn(Fcb->Flags, FCB_IS_VOLUME))
{
Status = VfatReadDiskPartial(IrpContext, &ReadOffset, Length, 0, TRUE);
if (NT_SUCCESS(Status))
ASSERT(Length % BytesPerSector == 0);
/* Is this a write of the volume? */
- if (Fcb->Flags & FCB_IS_VOLUME)
+ if (BooleanFlagOn(Fcb->Flags, FCB_IS_VOLUME))
{
Status = VfatWriteDiskPartial(IrpContext, &WriteOffset, Length, 0, TRUE);
if (!NT_SUCCESS(Status))
}
/* Is this a write to the FAT? */
- if (Fcb->Flags & FCB_IS_FAT)
+ if (BooleanFlagOn(Fcb->Flags, FCB_IS_FAT))
{
WriteOffset.u.LowPart += DeviceExt->FatInfo.FATStart * BytesPerSector;
IrpContext->RefCount = 1;
return Status;
}
+NTSTATUS
+VfatCommonRead(
+ PVFAT_IRP_CONTEXT IrpContext)
+{
+ PVFATFCB Fcb;
+ PVOID Buffer;
+ NTSTATUS Status;
+ ULONG Length = 0;
+ ULONG BytesPerSector;
+ LARGE_INTEGER ByteOffset;
+ ULONG ReturnedLength = 0;
+ BOOLEAN PagingIo, CanWait, IsVolume, NoCache;
+
+ PagingIo = BooleanFlagOn(IrpContext->Irp->Flags, IRP_PAGING_IO);
+ CanWait = BooleanFlagOn(IrpContext->Flags, IRPCONTEXT_CANWAIT);
+ NoCache = BooleanFlagOn(IrpContext->Irp->Flags, IRP_NOCACHE);
+ Fcb = IrpContext->FileObject->FsContext;
+ IsVolume = BooleanFlagOn(Fcb->Flags, FCB_IS_VOLUME);
+
+ ByteOffset = IrpContext->Stack->Parameters.Read.ByteOffset;
+ Length = IrpContext->Stack->Parameters.Read.Length;
+ BytesPerSector = IrpContext->DeviceExt->FatInfo.BytesPerSector;
+
+ if (!PagingIo &&
+ FsRtlAreThereCurrentFileLocks(&Fcb->FileLock))
+ {
+ if (!FsRtlCheckLockForReadAccess(&Fcb->FileLock, IrpContext->Irp))
+ {
+ return STATUS_FILE_LOCK_CONFLICT;
+ }
+ }
+
+ Buffer = VfatGetUserBuffer(IrpContext->Irp, PagingIo);
+
+ if (!PagingIo && !NoCache && !IsVolume)
+ {
+ // cached read
+ Status = STATUS_SUCCESS;
+ if (ByteOffset.u.LowPart + Length > Fcb->RFCB.FileSize.u.LowPart)
+ {
+ Length = Fcb->RFCB.FileSize.u.LowPart - ByteOffset.u.LowPart;
+ Status = /*STATUS_END_OF_FILE*/STATUS_SUCCESS;
+ }
+
+ vfatAddToStat(IrpContext->DeviceExt, Base.UserFileReads, 1);
+ vfatAddToStat(IrpContext->DeviceExt, Base.UserFileReadBytes, Length);
+
+ _SEH2_TRY
+ {
+ if (IrpContext->FileObject->PrivateCacheMap == NULL)
+ {
+ CcInitializeCacheMap(IrpContext->FileObject,
+ (PCC_FILE_SIZES)(&Fcb->RFCB.AllocationSize),
+ FALSE,
+ &(VfatGlobalData->CacheMgrCallbacks),
+ Fcb);
+ }
+
+ if (!CcCopyRead(IrpContext->FileObject,
+ &ByteOffset,
+ Length,
+ CanWait,
+ Buffer,
+ &IrpContext->Irp->IoStatus))
+ {
+ ASSERT(!CanWait);
+ Status = STATUS_PENDING;
+ goto ByeBye;
+ }
+ }
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
+ {
+ Status = _SEH2_GetExceptionCode();
+ goto ByeBye;
+ }
+ _SEH2_END;
+
+ if (!NT_SUCCESS(IrpContext->Irp->IoStatus.Status))
+ {
+ Status = IrpContext->Irp->IoStatus.Status;
+ }
+ }
+ else
+ {
+ // non cached read
+ Status = VfatLockUserBuffer(IrpContext->Irp, Length, IoWriteAccess);
+ if (!NT_SUCCESS(Status))
+ {
+ goto ByeBye;
+ }
+
+ if (ByteOffset.QuadPart + Length > ROUND_UP_64(Fcb->RFCB.FileSize.QuadPart, BytesPerSector))
+ {
+ Length = (ULONG)(ROUND_UP_64(Fcb->RFCB.FileSize.QuadPart, BytesPerSector) - ByteOffset.QuadPart);
+ }
+
+ if (!IsVolume)
+ {
+ vfatAddToStat(IrpContext->DeviceExt, Fat.NonCachedReads, 1);
+ vfatAddToStat(IrpContext->DeviceExt, Fat.NonCachedReadBytes, Length);
+ }
+ else
+ {
+ vfatAddToStat(IrpContext->DeviceExt, Base.MetaDataReads, 1);
+ vfatAddToStat(IrpContext->DeviceExt, Base.MetaDataReadBytes, Length);
+ }
+
+ Status = VfatReadFileData(IrpContext, Length, ByteOffset, &ReturnedLength);
+ if (NT_SUCCESS(Status))
+ {
+ IrpContext->Irp->IoStatus.Information = ReturnedLength;
+ }
+ }
+
+ByeBye:
+ return Status;
+}
+
+VOID
+NTAPI
+VfatStackOverflowRead(
+ PVOID Context,
+ IN PKEVENT Event)
+{
+ PVFAT_IRP_CONTEXT IrpContext;
+
+ IrpContext = Context;
+ /* In a separate thread, we can wait and resources got locked */
+ SetFlag(IrpContext->Flags, IRPCONTEXT_CANWAIT);
+
+ /* Perform the read operation */
+ DPRINT1("Performing posted read\n");
+ VfatCommonRead(IrpContext);
+
+ KeSetEvent(Event, 0, FALSE);
+}
+
+VOID
+VfatPostRead(
+ PVFAT_IRP_CONTEXT IrpContext,
+ PERESOURCE Lock,
+ BOOLEAN PagingIo)
+{
+ KEVENT Event;
+
+ KeInitializeEvent(&Event, NotificationEvent, FALSE);
+
+ ExAcquireResourceSharedLite(Lock, TRUE);
+
+ /* If paging IO, call the non failing but blocking routine */
+ if (PagingIo)
+ {
+ FsRtlPostPagingFileStackOverflow(IrpContext, &Event, VfatStackOverflowRead);
+ }
+ else
+ {
+ FsRtlPostStackOverflow(IrpContext, &Event, VfatStackOverflowRead);
+ }
+
+ /* Wait till it's done */
+ KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
+}
+
NTSTATUS
VfatRead(
PVFAT_IRP_CONTEXT IrpContext)
NTSTATUS Status;
PVFATFCB Fcb;
ULONG Length = 0;
- ULONG ReturnedLength = 0;
PERESOURCE Resource = NULL;
LARGE_INTEGER ByteOffset;
- PVOID Buffer;
ULONG BytesPerSector;
+ BOOLEAN PagingIo, CanWait, IsVolume, NoCache;
ASSERT(IrpContext);
ASSERT(IrpContext->DeviceObject);
+ PagingIo = BooleanFlagOn(IrpContext->Irp->Flags, IRP_PAGING_IO);
+ CanWait = BooleanFlagOn(IrpContext->Flags, IRPCONTEXT_CANWAIT);
+ NoCache = BooleanFlagOn(IrpContext->Irp->Flags, IRP_NOCACHE);
+
// This request is not allowed on the main device object
if (IrpContext->DeviceObject == VfatGlobalData->DeviceObject)
{
Fcb = IrpContext->FileObject->FsContext;
ASSERT(Fcb);
- if (Fcb->Flags & FCB_IS_PAGE_FILE)
+ IsVolume = BooleanFlagOn(Fcb->Flags, FCB_IS_VOLUME);
+
+ if (BooleanFlagOn(Fcb->Flags, FCB_IS_PAGE_FILE))
{
PFATINFO FatInfo = &IrpContext->DeviceExt->FatInfo;
IrpContext->Stack->Parameters.Read.ByteOffset.QuadPart += FatInfo->dataStart * FatInfo->BytesPerSector;
IoSkipCurrentIrpStackLocation(IrpContext->Irp);
+ IrpContext->Flags &= ~IRPCONTEXT_COMPLETE;
DPRINT("Read from page file, disk offset %I64x\n", IrpContext->Stack->Parameters.Read.ByteOffset.QuadPart);
Status = IoCallDriver(IrpContext->DeviceExt->StorageDevice, IrpContext->Irp);
- VfatFreeIrpContext(IrpContext);
return Status;
}
BytesPerSector = IrpContext->DeviceExt->FatInfo.BytesPerSector;
/* fail if file is a directory and no paged read */
- if (*Fcb->Attributes & FILE_ATTRIBUTE_DIRECTORY && !(IrpContext->Irp->Flags & IRP_PAGING_IO))
+ if (vfatFCBIsDirectory(Fcb) && !PagingIo)
{
Status = STATUS_INVALID_PARAMETER;
goto ByeBye;
DPRINT("'%wZ', Offset: %u, Length %u\n", &Fcb->PathNameU, ByteOffset.u.LowPart, Length);
- if (ByteOffset.u.HighPart && !(Fcb->Flags & FCB_IS_VOLUME))
+ if (ByteOffset.u.HighPart && !IsVolume)
{
Status = STATUS_INVALID_PARAMETER;
goto ByeBye;
}
+ if (Length == 0)
+ {
+ IrpContext->Irp->IoStatus.Information = 0;
+ Status = STATUS_SUCCESS;
+ goto ByeBye;
+ }
+
if (ByteOffset.QuadPart >= Fcb->RFCB.FileSize.QuadPart)
{
IrpContext->Irp->IoStatus.Information = 0;
goto ByeBye;
}
- if (IrpContext->Irp->Flags & (IRP_PAGING_IO | IRP_NOCACHE) || (Fcb->Flags & FCB_IS_VOLUME))
+ if (NoCache || PagingIo || IsVolume)
{
if (ByteOffset.u.LowPart % BytesPerSector != 0 || Length % BytesPerSector != 0)
{
}
}
- if (Length == 0)
- {
- IrpContext->Irp->IoStatus.Information = 0;
- Status = STATUS_SUCCESS;
- goto ByeBye;
- }
-
- if (Fcb->Flags & FCB_IS_VOLUME)
+ if (IsVolume)
{
Resource = &IrpContext->DeviceExt->DirResource;
}
- else if (IrpContext->Irp->Flags & IRP_PAGING_IO)
+ else if (PagingIo)
{
Resource = &Fcb->PagingIoResource;
}
Resource = &Fcb->MainResource;
}
- if (!ExAcquireResourceSharedLite(Resource,
- IrpContext->Flags & IRPCONTEXT_CANWAIT ? TRUE : FALSE))
+ /* Are we out of stack for the rest of the operation? */
+ if (IoGetRemainingStackSize() < OVERFLOW_READ_THRESHHOLD)
{
- Resource = NULL;
- Status = STATUS_PENDING;
- goto ByeBye;
- }
-
- if (!(IrpContext->Irp->Flags & IRP_PAGING_IO) &&
- FsRtlAreThereCurrentFileLocks(&Fcb->FileLock))
- {
- if (!FsRtlCheckLockForReadAccess(&Fcb->FileLock, IrpContext->Irp))
+ /* Lock the buffer */
+ Status = VfatLockUserBuffer(IrpContext->Irp, Length, IoWriteAccess);
+ if (!NT_SUCCESS(Status))
{
- Status = STATUS_FILE_LOCK_CONFLICT;
- goto ByeBye;
+ return Status;
}
- }
- Buffer = VfatGetUserBuffer(IrpContext->Irp);
- if (!Buffer)
- {
- Status = STATUS_INVALID_USER_BUFFER;
- goto ByeBye;
+ /* And post the read to the overflow thread */
+ VfatPostRead(IrpContext, Resource, PagingIo);
+
+ /* Return the appropriate status */
+ return IrpContext->Irp->IoStatus.Status;
}
- if (!(IrpContext->Irp->Flags & (IRP_NOCACHE|IRP_PAGING_IO)) &&
- !(Fcb->Flags & (FCB_IS_PAGE_FILE|FCB_IS_VOLUME)))
+ if (!ExAcquireResourceSharedLite(Resource, CanWait))
{
- // cached read
- Status = STATUS_SUCCESS;
- if (ByteOffset.u.LowPart + Length > Fcb->RFCB.FileSize.u.LowPart)
- {
- Length = Fcb->RFCB.FileSize.u.LowPart - ByteOffset.u.LowPart;
- Status = /*STATUS_END_OF_FILE*/STATUS_SUCCESS;
- }
-
- if (IrpContext->FileObject->PrivateCacheMap == NULL)
- {
- CcInitializeCacheMap(IrpContext->FileObject,
- (PCC_FILE_SIZES)(&Fcb->RFCB.AllocationSize),
- FALSE,
- &(VfatGlobalData->CacheMgrCallbacks),
- Fcb);
- }
-
- if (!CcCopyRead(IrpContext->FileObject, &ByteOffset, Length,
- (BOOLEAN)(IrpContext->Flags & IRPCONTEXT_CANWAIT), Buffer,
- &IrpContext->Irp->IoStatus))
- {
- Status = STATUS_PENDING;
- goto ByeBye;
- }
-
- if (!NT_SUCCESS(IrpContext->Irp->IoStatus.Status))
- {
- Status = IrpContext->Irp->IoStatus.Status;
- }
+ Resource = NULL;
+ Status = STATUS_PENDING;
+ goto ByeBye;
}
- else
- {
- // non cached read
- if (ByteOffset.QuadPart + Length > ROUND_UP(Fcb->RFCB.FileSize.QuadPart, BytesPerSector))
- {
- Length = (ULONG)(ROUND_UP(Fcb->RFCB.FileSize.QuadPart, BytesPerSector) - ByteOffset.QuadPart);
- }
-
- Status = VfatLockUserBuffer(IrpContext->Irp, Length, IoWriteAccess);
- if (!NT_SUCCESS(Status))
- {
- goto ByeBye;
- }
- Status = VfatReadFileData(IrpContext, Length, ByteOffset, &ReturnedLength);
- if (NT_SUCCESS(Status))
- {
- IrpContext->Irp->IoStatus.Information = ReturnedLength;
- }
- }
+ Status = VfatCommonRead(IrpContext);
ByeBye:
if (Resource)
Status = VfatLockUserBuffer(IrpContext->Irp, Length, IoWriteAccess);
if (NT_SUCCESS(Status))
{
- Status = VfatQueueRequest(IrpContext);
- }
- else
- {
- IrpContext->Irp->IoStatus.Status = Status;
- IoCompleteRequest(IrpContext->Irp, IO_NO_INCREMENT);
- VfatFreeIrpContext(IrpContext);
+ Status = VfatMarkIrpContextForQueue(IrpContext);
}
}
else
{
IrpContext->Irp->IoStatus.Status = Status;
- if (IrpContext->FileObject->Flags & FO_SYNCHRONOUS_IO &&
- !(IrpContext->Irp->Flags & IRP_PAGING_IO) &&
+ if (BooleanFlagOn(IrpContext->FileObject->Flags, FO_SYNCHRONOUS_IO) &&
+ !PagingIo &&
(NT_SUCCESS(Status) || Status == STATUS_END_OF_FILE))
{
IrpContext->FileObject->CurrentByteOffset.QuadPart =
ByteOffset.QuadPart + IrpContext->Irp->IoStatus.Information;
}
- IoCompleteRequest(IrpContext->Irp,
- (CCHAR)(NT_SUCCESS(Status) ? IO_DISK_INCREMENT : IO_NO_INCREMENT));
- VfatFreeIrpContext(IrpContext);
+ if (NT_SUCCESS(Status))
+ IrpContext->PriorityBoost = IO_DISK_INCREMENT;
}
DPRINT("%x\n", Status);
return Status;
ULONG Length = 0;
PVOID Buffer;
ULONG BytesPerSector;
+ BOOLEAN PagingIo, CanWait, IsVolume, IsFAT, NoCache;
ASSERT(IrpContext);
ASSERT(IrpContext->DeviceObject);
+ PagingIo = BooleanFlagOn(IrpContext->Irp->Flags, IRP_PAGING_IO);
+ CanWait = BooleanFlagOn(IrpContext->Flags, IRPCONTEXT_CANWAIT);
+ NoCache = BooleanFlagOn(IrpContext->Irp->Flags, IRP_NOCACHE);
+
// This request is not allowed on the main device object
if (IrpContext->DeviceObject == VfatGlobalData->DeviceObject)
{
Fcb = IrpContext->FileObject->FsContext;
ASSERT(Fcb);
- if (Fcb->Flags & FCB_IS_PAGE_FILE)
+ IsVolume = BooleanFlagOn(Fcb->Flags, FCB_IS_VOLUME);
+ IsFAT = BooleanFlagOn(Fcb->Flags, FCB_IS_FAT);
+
+ if (BooleanFlagOn(Fcb->Flags, FCB_IS_PAGE_FILE))
{
PFATINFO FatInfo = &IrpContext->DeviceExt->FatInfo;
IrpContext->Stack->Parameters.Write.ByteOffset.QuadPart += FatInfo->dataStart * FatInfo->BytesPerSector;
IoSkipCurrentIrpStackLocation(IrpContext->Irp);
+ IrpContext->Flags &= ~IRPCONTEXT_COMPLETE;
DPRINT("Write to page file, disk offset %I64x\n", IrpContext->Stack->Parameters.Write.ByteOffset.QuadPart);
Status = IoCallDriver(IrpContext->DeviceExt->StorageDevice, IrpContext->Irp);
- VfatFreeIrpContext(IrpContext);
return Status;
}
DPRINT("<%wZ>\n", &Fcb->PathNameU);
/* fail if file is a directory and no paged read */
- if (*Fcb->Attributes & FILE_ATTRIBUTE_DIRECTORY && !(IrpContext->Irp->Flags & IRP_PAGING_IO))
+ if (vfatFCBIsDirectory(Fcb) && !PagingIo)
{
Status = STATUS_INVALID_PARAMETER;
goto ByeBye;
Length = IrpContext->Stack->Parameters.Write.Length;
BytesPerSector = IrpContext->DeviceExt->FatInfo.BytesPerSector;
- if (ByteOffset.u.HighPart && !(Fcb->Flags & FCB_IS_VOLUME))
+ if (ByteOffset.u.HighPart && !IsVolume)
{
Status = STATUS_INVALID_PARAMETER;
goto ByeBye;
}
- if (Fcb->Flags & (FCB_IS_FAT | FCB_IS_VOLUME) ||
+ if (IsFAT || IsVolume ||
vfatDirEntryGetFirstCluster(IrpContext->DeviceExt, &Fcb->entry) == 1)
{
if (ByteOffset.QuadPart + Length > Fcb->RFCB.FileSize.QuadPart)
}
}
- if (IrpContext->Irp->Flags & (IRP_PAGING_IO|IRP_NOCACHE) || (Fcb->Flags & FCB_IS_VOLUME))
+ if (PagingIo || NoCache || IsVolume)
{
if (ByteOffset.u.LowPart % BytesPerSector != 0 || Length % BytesPerSector != 0)
{
}
}
+ OldFileSize = Fcb->RFCB.FileSize;
+
if (Length == 0)
{
- /* FIXME: Update last write time */
+ /* Update last write time */
IrpContext->Irp->IoStatus.Information = 0;
Status = STATUS_SUCCESS;
- goto ByeBye;
+ goto Metadata;
}
- if (IrpContext->Irp->Flags & IRP_PAGING_IO)
+ if (PagingIo)
{
if (ByteOffset.u.LowPart + Length > Fcb->RFCB.AllocationSize.u.LowPart)
{
}
}
- if (Fcb->Flags & FCB_IS_VOLUME)
+ if (!NoCache && !CcCanIWrite(IrpContext->FileObject, Length, CanWait,
+ BooleanFlagOn(IrpContext->Flags, IRPCONTEXT_DEFERRED_WRITE)))
+ {
+ BOOLEAN Retrying;
+
+ Retrying = BooleanFlagOn(IrpContext->Flags, IRPCONTEXT_DEFERRED_WRITE);
+ SetFlag(IrpContext->Flags, IRPCONTEXT_DEFERRED_WRITE);
+
+ Status = STATUS_PENDING;
+ CcDeferWrite(IrpContext->FileObject, VfatHandleDeferredWrite,
+ IrpContext, NULL, Length, Retrying);
+
+ DPRINT1("Dererring write!\n");
+
+ goto ByeBye;
+ }
+
+ if (IsVolume)
{
Resource = &IrpContext->DeviceExt->DirResource;
}
- else if (IrpContext->Irp->Flags & IRP_PAGING_IO)
+ else if (PagingIo)
{
Resource = &Fcb->PagingIoResource;
}
Resource = &Fcb->MainResource;
}
- if (Fcb->Flags & FCB_IS_PAGE_FILE)
+ if (PagingIo)
{
- if (!ExAcquireResourceSharedLite(Resource,
- (BOOLEAN)(IrpContext->Flags & IRPCONTEXT_CANWAIT)))
+ if (!ExAcquireResourceSharedLite(Resource, CanWait))
{
Resource = NULL;
Status = STATUS_PENDING;
}
else
{
- if (!ExAcquireResourceExclusiveLite(Resource,
- (BOOLEAN)(IrpContext->Flags & IRPCONTEXT_CANWAIT)))
+ if (!ExAcquireResourceExclusiveLite(Resource, CanWait))
{
Resource = NULL;
Status = STATUS_PENDING;
}
}
- if (!(IrpContext->Irp->Flags & IRP_PAGING_IO) &&
+ if (!PagingIo &&
FsRtlAreThereCurrentFileLocks(&Fcb->FileLock))
{
if (!FsRtlCheckLockForWriteAccess(&Fcb->FileLock, IrpContext->Irp))
}
}
- if (!(IrpContext->Flags & IRPCONTEXT_CANWAIT) && !(Fcb->Flags & FCB_IS_VOLUME))
+ if (!CanWait && !IsVolume)
{
if (ByteOffset.u.LowPart + Length > Fcb->RFCB.AllocationSize.u.LowPart)
{
}
}
- OldFileSize = Fcb->RFCB.FileSize;
-
- Buffer = VfatGetUserBuffer(IrpContext->Irp);
- if (!Buffer)
- {
- Status = STATUS_INVALID_USER_BUFFER;
- goto ByeBye;
- }
-
+ Buffer = VfatGetUserBuffer(IrpContext->Irp, PagingIo);
- if (!(Fcb->Flags & (FCB_IS_FAT|FCB_IS_VOLUME)) &&
- !(IrpContext->Irp->Flags & IRP_PAGING_IO) &&
+ if (!IsFAT && !IsVolume && !PagingIo &&
ByteOffset.u.LowPart + Length > Fcb->RFCB.FileSize.u.LowPart)
{
LARGE_INTEGER AllocationSize;
}
}
- if (!(IrpContext->Irp->Flags & (IRP_NOCACHE|IRP_PAGING_IO)) &&
- !(Fcb->Flags & (FCB_IS_PAGE_FILE|FCB_IS_VOLUME)))
+ if (!NoCache && !PagingIo && !IsVolume)
{
// cached write
- if (IrpContext->FileObject->PrivateCacheMap == NULL)
- {
- CcInitializeCacheMap(IrpContext->FileObject,
- (PCC_FILE_SIZES)(&Fcb->RFCB.AllocationSize),
- FALSE,
- &VfatGlobalData->CacheMgrCallbacks,
- Fcb);
- }
+ vfatAddToStat(IrpContext->DeviceExt, Base.UserFileWrites, 1);
+ vfatAddToStat(IrpContext->DeviceExt, Base.UserFileWriteBytes, Length);
- if (ByteOffset.QuadPart > OldFileSize.QuadPart)
+ _SEH2_TRY
{
- CcZeroData(IrpContext->FileObject, &OldFileSize, &ByteOffset, TRUE);
- }
+ if (IrpContext->FileObject->PrivateCacheMap == NULL)
+ {
+ CcInitializeCacheMap(IrpContext->FileObject,
+ (PCC_FILE_SIZES)(&Fcb->RFCB.AllocationSize),
+ FALSE,
+ &VfatGlobalData->CacheMgrCallbacks,
+ Fcb);
+ }
- if (CcCopyWrite(IrpContext->FileObject, &ByteOffset, Length,
- 1 /*IrpContext->Flags & IRPCONTEXT_CANWAIT*/, Buffer))
- {
- IrpContext->Irp->IoStatus.Information = Length;
- Status = STATUS_SUCCESS;
+ if (ByteOffset.QuadPart > OldFileSize.QuadPart)
+ {
+ CcZeroData(IrpContext->FileObject, &OldFileSize, &ByteOffset, TRUE);
+ }
+
+ if (CcCopyWrite(IrpContext->FileObject,
+ &ByteOffset,
+ Length,
+ TRUE /*CanWait*/,
+ Buffer))
+ {
+ IrpContext->Irp->IoStatus.Information = Length;
+ Status = STATUS_SUCCESS;
+ }
+ else
+ {
+ ASSERT(FALSE /*!CanWait*/);
+ Status = STATUS_UNSUCCESSFUL;
+ }
}
- else
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- Status = STATUS_UNSUCCESSFUL;
+ Status = _SEH2_GetExceptionCode();
}
+ _SEH2_END;
}
else
{
// non cached write
+ Status = VfatLockUserBuffer(IrpContext->Irp, Length, IoReadAccess);
+ if (!NT_SUCCESS(Status))
+ {
+ Status = STATUS_INVALID_USER_BUFFER;
+ goto ByeBye;
+ }
if (ByteOffset.QuadPart > OldFileSize.QuadPart)
{
CcZeroData(IrpContext->FileObject, &OldFileSize, &ByteOffset, TRUE);
}
- Status = VfatLockUserBuffer(IrpContext->Irp, Length, IoReadAccess);
- if (!NT_SUCCESS(Status))
+ if (!IsVolume)
{
- goto ByeBye;
+ vfatAddToStat(IrpContext->DeviceExt, Fat.NonCachedWrites, 1);
+ vfatAddToStat(IrpContext->DeviceExt, Fat.NonCachedWriteBytes, Length);
+ }
+ else
+ {
+ vfatAddToStat(IrpContext->DeviceExt, Base.MetaDataWrites, 1);
+ vfatAddToStat(IrpContext->DeviceExt, Base.MetaDataWriteBytes, Length);
}
Status = VfatWriteFileData(IrpContext, Length, ByteOffset);
}
}
- if (!(IrpContext->Irp->Flags & IRP_PAGING_IO) &&
- !(Fcb->Flags & (FCB_IS_FAT|FCB_IS_VOLUME)))
+Metadata:
+ if (!PagingIo && !IsFAT && !IsVolume)
{
- if(!(*Fcb->Attributes & FILE_ATTRIBUTE_DIRECTORY))
+ if(!vfatFCBIsDirectory(Fcb))
{
LARGE_INTEGER SystemTime;
ULONG Filter;
// set dates and times
KeQuerySystemTime (&SystemTime);
- if (Fcb->Flags & FCB_IS_FATX_ENTRY)
+ if (vfatVolumeIsFatX(IrpContext->DeviceExt))
{
FsdSystemTimeToDosDateTime(IrpContext->DeviceExt,
&SystemTime, &Fcb->entry.FatX.UpdateDate,
Filter = FILE_NOTIFY_CHANGE_LAST_WRITE | FILE_NOTIFY_CHANGE_ATTRIBUTES;
if (ByteOffset.QuadPart != OldFileSize.QuadPart) Filter |= FILE_NOTIFY_CHANGE_SIZE;
- FsRtlNotifyFullReportChange(IrpContext->DeviceExt->NotifySync,
- &(IrpContext->DeviceExt->NotifyList),
- (PSTRING)&Fcb->PathNameU,
- Fcb->PathNameU.Length - Fcb->LongNameU.Length,
- NULL,
- NULL,
- Filter,
- FILE_ACTION_MODIFIED,
- NULL);
+ vfatReportChange(IrpContext->DeviceExt, Fcb, Filter, FILE_ACTION_MODIFIED);
}
}
Status = VfatLockUserBuffer(IrpContext->Irp, Length, IoReadAccess);
if (NT_SUCCESS(Status))
{
- Status = VfatQueueRequest(IrpContext);
- }
- else
- {
- IrpContext->Irp->IoStatus.Status = Status;
- IoCompleteRequest(IrpContext->Irp, IO_NO_INCREMENT);
- VfatFreeIrpContext(IrpContext);
+ Status = VfatMarkIrpContextForQueue(IrpContext);
}
}
else
{
IrpContext->Irp->IoStatus.Status = Status;
- if (IrpContext->FileObject->Flags & FO_SYNCHRONOUS_IO &&
- !(IrpContext->Irp->Flags & IRP_PAGING_IO) && NT_SUCCESS(Status))
+ if (BooleanFlagOn(IrpContext->FileObject->Flags, FO_SYNCHRONOUS_IO) &&
+ !PagingIo && NT_SUCCESS(Status))
{
IrpContext->FileObject->CurrentByteOffset.QuadPart =
ByteOffset.QuadPart + IrpContext->Irp->IoStatus.Information;
}
- IoCompleteRequest(IrpContext->Irp,
- (CCHAR)(NT_SUCCESS(Status) ? IO_DISK_INCREMENT : IO_NO_INCREMENT));
- VfatFreeIrpContext(IrpContext);
+ if (NT_SUCCESS(Status))
+ IrpContext->PriorityBoost = IO_DISK_INCREMENT;
}
DPRINT("%x\n", Status);
return Status;
projects / reactos.git / blobdiff