#include <debug.h>
#include "internal/io_i.h"
+volatile LONG IoPageReadIrpAllocationFailure = 0;
+volatile LONG IoPageReadNonPagefileIrpAllocationFailure = 0;
+
/* PRIVATE FUNCTIONS *********************************************************/
VOID
if (FileObject->Flags & FO_SYNCHRONOUS_IO)
{
/* Lock it */
- IopLockFileObject(FileObject);
+ Status = IopLockFileObject(FileObject, PreviousMode);
+ if (Status != STATUS_SUCCESS)
+ {
+ if (EventObject) ObDereferenceObject(EventObject);
+ ObDereferenceObject(FileObject);
+ return Status;
+ }
/* Remember to unlock later */
LockedForSynch = TRUE;
{
/* Allocate the System Buffer */
Irp->AssociatedIrp.SystemBuffer =
- ExAllocatePoolWithTag(PoolType,
- BufferLength,
- TAG_SYS_BUF);
+ ExAllocatePoolWithQuotaTag(PoolType,
+ BufferLength,
+ TAG_SYS_BUF);
/* Check if we got a buffer */
if (InputBuffer)
{
/* Allocate the System Buffer */
Irp->AssociatedIrp.SystemBuffer =
- ExAllocatePoolWithTag(PoolType,
- InputBufferLength,
- TAG_SYS_BUF);
+ ExAllocatePoolWithQuotaTag(PoolType,
+ InputBufferLength,
+ TAG_SYS_BUF);
/* Copy into the System Buffer */
RtlCopyMemory(Irp->AssociatedIrp.SystemBuffer,
}
/* Check if we got an output buffer */
- if (OutputBuffer)
+ if (OutputBufferLength)
{
/* Allocate the System Buffer */
Irp->MdlAddress = IoAllocateMdl(OutputBuffer,
if (FileObject->Flags & FO_SYNCHRONOUS_IO)
{
/* Lock it */
- IopLockFileObject(FileObject);
+ (void)IopLockFileObject(FileObject, KernelMode);
/* Use File Object event */
KeClearEvent(&FileObject->Event);
RenameInfo->RootDirectory,
NULL);
- /* And open its parent directory */
+ /* And open its parent directory
+ * Use hint if specified
+ */
if (FileObject->Flags & FO_FILE_OBJECT_HAS_EXTENSION)
{
+ PFILE_OBJECT_EXTENSION FileObjectExtension;
+
ASSERT(!(FileObject->Flags & FO_DIRECT_DEVICE_OPEN));
-#if 0
- /* Commented out - we don't support FO extension yet
- * FIXME: Corrected last arg when it's supported
- */
+
+ FileObjectExtension = FileObject->FileObjectExtension;
Status = IoCreateFileSpecifyDeviceObjectHint(&TargetHandle,
DesiredAccess | SYNCHRONIZE,
&ObjectAttributes,
CreateFileTypeNone,
NULL,
IO_FORCE_ACCESS_CHECK | IO_OPEN_TARGET_DIRECTORY | IO_NO_PARAMETER_CHECKING,
- FileObject->DeviceObject);
-#else
- ASSERT(FALSE);
- UNIMPLEMENTED;
- return STATUS_NOT_IMPLEMENTED;
-#endif
+ FileObjectExtension->TopDeviceObjectHint);
}
else
{
IOTRACE(IO_API_DEBUG, "FileObject: %p. Mdl: %p. Offset: %p \n",
FileObject, Mdl, Offset);
+ /* Is the write originating from Cc? */
+ if (FileObject->SectionObjectPointer != NULL &&
+ FileObject->SectionObjectPointer->SharedCacheMap != NULL)
+ {
+ ++CcDataFlushes;
+ CcDataPages += BYTES_TO_PAGES(MmGetMdlByteCount(Mdl));
+ }
+
/* Get the Device Object */
DeviceObject = IoGetRelatedDeviceObject(FileObject);
/* Allocate IRP */
Irp = IoAllocateIrp(DeviceObject->StackSize, FALSE);
- if (!Irp) return STATUS_INSUFFICIENT_RESOURCES;
+ /* If allocation failed, try to see whether we can use
+ * the reserve IRP
+ */
+ if (Irp == NULL)
+ {
+ /* We will use it only for paging file */
+ if (MmIsFileObjectAPagingFile(FileObject))
+ {
+ InterlockedExchangeAdd(&IoPageReadIrpAllocationFailure, 1);
+ Irp = IopAllocateReserveIrp(DeviceObject->StackSize);
+ }
+ else
+ {
+ InterlockedExchangeAdd(&IoPageReadNonPagefileIrpAllocationFailure, 1);
+ }
+
+ /* If allocation failed (not a paging file or too big stack size)
+ * Fail for real
+ */
+ if (Irp == NULL)
+ {
+ return STATUS_INSUFFICIENT_RESOURCES;
+ }
+ }
/* Get the Stack */
StackPtr = IoGetNextIrpStackLocation(Irp);
if (FileObject->Flags & FO_SYNCHRONOUS_IO)
{
/* Lock it */
- IopLockFileObject(FileObject);
+ (void)IopLockFileObject(FileObject, KernelMode);
/* Use File Object event */
KeClearEvent(&FileObject->Event);
if (FileObject->Flags & FO_SYNCHRONOUS_IO)
{
/* Lock it */
- IopLockFileObject(FileObject);
+ Status = IopLockFileObject(FileObject, PreviousMode);
+ if (Status != STATUS_SUCCESS)
+ {
+ ObDereferenceObject(FileObject);
+ return Status;
+ }
}
else
{
if (FileObject->Flags & FO_SYNCHRONOUS_IO)
{
/* Lock it */
- IopLockFileObject(FileObject);
+ Status = IopLockFileObject(FileObject, PreviousMode);
+ if (Status != STATUS_SUCCESS)
+ {
+ if (Event) ObDereferenceObject(Event);
+ ObDereferenceObject(FileObject);
+ return Status;
+ }
LockedForSync = TRUE;
}
if (FileObject->Flags & FO_SYNCHRONOUS_IO)
{
/* Lock it */
- IopLockFileObject(FileObject);
+ Status = IopLockFileObject(FileObject, PreviousMode);
+ if (Status != STATUS_SUCCESS)
+ {
+ if (Event) ObDereferenceObject(Event);
+ ObDereferenceObject(FileObject);
+ return Status;
+ }
LockedForSync = TRUE;
}
if (FileObject->Flags & FO_SYNCHRONOUS_IO)
{
/* Lock it */
- IopLockFileObject(FileObject);
+ Status = IopLockFileObject(FileObject, PreviousMode);
+ if (Status != STATUS_SUCCESS)
+ {
+ if (Event) ObDereferenceObject(Event);
+ ObDereferenceObject(FileObject);
+ if (AuxBuffer) ExFreePoolWithTag(AuxBuffer, TAG_SYSB);
+ return Status;
+ }
/* Remember to unlock later */
LockedForSynch = TRUE;
if (FileObject->Flags & FO_SYNCHRONOUS_IO)
{
/* Lock it */
- IopLockFileObject(FileObject);
+ Status = IopLockFileObject(FileObject, PreviousMode);
+ if (Status != STATUS_SUCCESS)
+ {
+ ObDereferenceObject(FileObject);
+ return Status;
+ }
/* Check if the caller just wants the position */
if (FileInformationClass == FilePositionInformation)
CapturedByteOffset.QuadPart = 0;
IOTRACE(IO_API_DEBUG, "FileHandle: %p\n", FileHandle);
+ /* Get File Object */
+ Status = ObReferenceObjectByHandle(FileHandle,
+ FILE_READ_DATA,
+ IoFileObjectType,
+ PreviousMode,
+ (PVOID*)&FileObject,
+ NULL);
+ if (!NT_SUCCESS(Status)) return Status;
+
+ /* Get the device object */
+ DeviceObject = IoGetRelatedDeviceObject(FileObject);
+
/* Validate User-Mode Buffers */
if (PreviousMode != KernelMode)
{
CapturedByteOffset = ProbeForReadLargeInteger(ByteOffset);
}
+ /* Perform additional checks for non-cached file access */
+ if (FileObject->Flags & FO_NO_INTERMEDIATE_BUFFERING)
+ {
+ /* Fail if Length is not sector size aligned */
+ if ((DeviceObject->SectorSize != 0) &&
+ (Length % DeviceObject->SectorSize != 0))
+ {
+ /* Release the file object and and fail */
+ ObDereferenceObject(FileObject);
+ return STATUS_INVALID_PARAMETER;
+ }
+
+ /* Fail if buffer doesn't match alignment requirements */
+ if (((ULONG_PTR)Buffer & DeviceObject->AlignmentRequirement) != 0)
+ {
+ /* Release the file object and and fail */
+ ObDereferenceObject(FileObject);
+ return STATUS_INVALID_PARAMETER;
+ }
+
+ if (ByteOffset)
+ {
+ /* Fail if ByteOffset is not sector size aligned */
+ if ((DeviceObject->SectorSize != 0) &&
+ (CapturedByteOffset.QuadPart % DeviceObject->SectorSize != 0))
+ {
+ /* Release the file object and and fail */
+ ObDereferenceObject(FileObject);
+ return STATUS_INVALID_PARAMETER;
+ }
+ }
+ }
+
/* Capture and probe the key */
if (Key) CapturedKey = ProbeForReadUlong(Key);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Return the exception code */
+ /* Release the file object and return the exception code */
+ ObDereferenceObject(FileObject);
_SEH2_YIELD(return _SEH2_GetExceptionCode());
}
_SEH2_END;
if (Key) CapturedKey = *Key;
}
- /* Get File Object */
- Status = ObReferenceObjectByHandle(FileHandle,
- FILE_READ_DATA,
- IoFileObjectType,
- PreviousMode,
- (PVOID*)&FileObject,
- NULL);
- if (!NT_SUCCESS(Status)) return Status;
-
/* Check for event */
if (Event)
{
KeClearEvent(EventObject);
}
- /* Get the device object */
- DeviceObject = IoGetRelatedDeviceObject(FileObject);
-
/* Check if we should use Sync IO or not */
if (FileObject->Flags & FO_SYNCHRONOUS_IO)
{
/* Lock the file object */
- IopLockFileObject(FileObject);
+ Status = IopLockFileObject(FileObject, PreviousMode);
+ if (Status != STATUS_SUCCESS)
+ {
+ if (EventObject) ObDereferenceObject(EventObject);
+ ObDereferenceObject(FileObject);
+ return Status;
+ }
/* Check if we don't have a byte offset available */
if (!(ByteOffset) ||
if (FileObject->Flags & FO_SYNCHRONOUS_IO)
{
/* Lock it */
- IopLockFileObject(FileObject);
+ Status = IopLockFileObject(FileObject, PreviousMode);
+ if (Status != STATUS_SUCCESS)
+ {
+ ObDereferenceObject(FileObject);
+ return Status;
+ }
/* Check if the caller just wants the position */
if (FileInformationClass == FilePositionInformation)
if (FileObject->Flags & FO_SYNCHRONOUS_IO)
{
/* Lock it */
- IopLockFileObject(FileObject);
+ Status = IopLockFileObject(FileObject, PreviousMode);
+ if (Status != STATUS_SUCCESS)
+ {
+ ObDereferenceObject(FileObject);
+ return Status;
+ }
}
else
{
&ObjectHandleInfo);
if (!NT_SUCCESS(Status)) return Status;
+ /* Get the device object */
+ DeviceObject = IoGetRelatedDeviceObject(FileObject);
+
/* Validate User-Mode Buffers */
if (PreviousMode != KernelMode)
{
CapturedByteOffset = ProbeForReadLargeInteger(ByteOffset);
}
+ /* Perform additional checks for non-cached file access */
+ if (FileObject->Flags & FO_NO_INTERMEDIATE_BUFFERING)
+ {
+ /* Fail if Length is not sector size aligned */
+ if ((DeviceObject->SectorSize != 0) &&
+ (Length % DeviceObject->SectorSize != 0))
+ {
+ /* Release the file object and and fail */
+ ObDereferenceObject(FileObject);
+ return STATUS_INVALID_PARAMETER;
+ }
+
+ /* Fail if buffer doesn't match alignment requirements */
+ if (((ULONG_PTR)Buffer & DeviceObject->AlignmentRequirement) != 0)
+ {
+ /* Release the file object and and fail */
+ ObDereferenceObject(FileObject);
+ return STATUS_INVALID_PARAMETER;
+ }
+
+ if (ByteOffset)
+ {
+ /* Fail if ByteOffset is not sector size aligned */
+ if ((DeviceObject->SectorSize != 0) &&
+ (CapturedByteOffset.QuadPart % DeviceObject->SectorSize != 0))
+ {
+ /* Only if that's not specific values for synchronous IO */
+ if ((CapturedByteOffset.QuadPart != FILE_WRITE_TO_END_OF_FILE) &&
+ (CapturedByteOffset.QuadPart != FILE_USE_FILE_POINTER_POSITION ||
+ !BooleanFlagOn(FileObject->Flags, FO_SYNCHRONOUS_IO)))
+ {
+ /* Release the file object and and fail */
+ ObDereferenceObject(FileObject);
+ return STATUS_INVALID_PARAMETER;
+ }
+ }
+ }
+ }
+
/* Capture and probe the key */
if (Key) CapturedKey = ProbeForReadUlong(Key);
}
KeClearEvent(EventObject);
}
- /* Get the device object */
- DeviceObject = IoGetRelatedDeviceObject(FileObject);
-
/* Check if we should use Sync IO or not */
if (FileObject->Flags & FO_SYNCHRONOUS_IO)
{
/* Lock the file object */
- IopLockFileObject(FileObject);
+ Status = IopLockFileObject(FileObject, PreviousMode);
+ if (Status != STATUS_SUCCESS)
+ {
+ if (EventObject) ObDereferenceObject(EventObject);
+ ObDereferenceObject(FileObject);
+ return Status;
+ }
/* Check if we don't have a byte offset available */
if (!(ByteOffset) ||
if (FileObject->Flags & FO_SYNCHRONOUS_IO)
{
/* Lock it */
- IopLockFileObject(FileObject);
+ Status = IopLockFileObject(FileObject, PreviousMode);
+ if (Status != STATUS_SUCCESS)
+ {
+ ObDereferenceObject(FileObject);
+ return Status;
+ }
}
else
{
if (FileObject->Flags & FO_SYNCHRONOUS_IO)
{
/* Lock it */
- IopLockFileObject(FileObject);
+ Status = IopLockFileObject(FileObject, PreviousMode);
+ if (Status != STATUS_SUCCESS)
+ {
+ ObDereferenceObject(FileObject);
+ if (TargetDeviceObject) ObDereferenceObject(TargetDeviceObject);
+ return Status;
+ }
}
else
{
projects / reactos.git / blobdiff