4 Jul
2006
4 Jul
'06
4:50 p.m.
Author: ion
Date: Tue Jul 4 20:50:56 2006
New Revision: 22837
URL: http://svn.reactos.org/svn/reactos?rev=22837&view=rev
Log:
- Fix NtSetInformationFile to use correct sync/async semantics and use deferred I/O
completion. This routine doesn't use IopSyncronous/Asyncronous helper routines because
it can be optimized to handle some Information classes in-line (not currently being done
except for Completion Ports, like the previous code).
Modified:
trunk/reactos/ntoskrnl/io/iomgr/iofunc.c
Modified: trunk/reactos/ntoskrnl/io/iomgr/iofunc.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/io/iomgr/iofunc.c…
==============================================================================
--- trunk/reactos/ntoskrnl/io/iomgr/iofunc.c (original)
+++ trunk/reactos/ntoskrnl/io/iomgr/iofunc.c Tue Jul 4 20:50:56 2006
@@ -24,12 +24,6 @@
///
//
// TODO:
-// - Update to new semantics:
-// - Lock/Unlock <= DONE
-// - Query/Set Volume Info <= DONE
-// - Read/Write file <= DONE
-// - QueryDirectoryFile <= DONE
-// - Query/Set File Info
// - Add SEH to some places where it's missing (MDLs, etc)
// - Add a generic Cleanup/Exception Routine
// - Add probe/alignment checks for Query/Set routines
@@ -2014,311 +2008,311 @@
*/
NTSTATUS
NTAPI
-NtSetInformationFile(HANDLE FileHandle,
- PIO_STATUS_BLOCK IoStatusBlock,
- PVOID FileInformation,
- ULONG Length,
- FILE_INFORMATION_CLASS FileInformationClass)
+NtSetInformationFile(IN HANDLE FileHandle,
+ IN PIO_STATUS_BLOCK IoStatusBlock,
+ IN PVOID FileInformation,
+ IN ULONG Length,
+ IN FILE_INFORMATION_CLASS FileInformationClass)
{
- OBJECT_HANDLE_INFORMATION HandleInformation;
+ PFILE_OBJECT FileObject;
+ NTSTATUS Status = STATUS_SUCCESS;
+ PIRP Irp;
+ PDEVICE_OBJECT DeviceObject;
PIO_STACK_LOCATION StackPtr;
- PFILE_OBJECT FileObject;
- PDEVICE_OBJECT DeviceObject;
- PIRP Irp;
- KEVENT Event;
+ KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
+ PKEVENT Event = NULL;
BOOLEAN LocalEvent = FALSE;
- NTSTATUS Status = STATUS_SUCCESS;
- KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
- BOOLEAN Failed = FALSE;
-
+ PKNORMAL_ROUTINE NormalRoutine;
+ PVOID NormalContext;
+ KIRQL OldIrql;
+ IO_STATUS_BLOCK KernelIosb;
+ PVOID Queue;
+ PFILE_COMPLETION_INFORMATION CompletionInfo = FileInformation;
+ PIO_COMPLETION_CONTEXT Context;
+
+ /* Check if we're called from user mode */
if (PreviousMode != KernelMode)
{
+ /* Enter SEH for probing */
_SEH_TRY
{
- if (IoStatusBlock)
- {
- ProbeForWrite(IoStatusBlock,
- sizeof(IO_STATUS_BLOCK),
- sizeof(ULONG));
- }
-
+ /* Probe the I/O Status block */
+ ProbeForWrite(IoStatusBlock,
+ sizeof(IO_STATUS_BLOCK),
+ sizeof(ULONG));
+
+ /* Probe the information */
if (Length) ProbeForRead(FileInformation, Length, 1);
}
_SEH_HANDLE
{
+ /* Get the exception code */
Status = _SEH_GetExceptionCode();
}
_SEH_END;
-
- if (!NT_SUCCESS(Status))
- {
- return Status;
- }
- }
-
- /* Get the file object from the file handle */
+
+ /* Check if probing failed */
+ if (!NT_SUCCESS(Status)) return Status;
+ }
+
+ /* Reference the Handle */
Status = ObReferenceObjectByHandle(FileHandle,
- 0,
+ 0, // FIXME
IoFileObjectType,
PreviousMode,
(PVOID *)&FileObject,
- &HandleInformation);
+ NULL);
if (!NT_SUCCESS(Status)) return Status;
- /* Check information class specific access rights */
- switch (FileInformationClass)
- {
- case FileBasicInformation:
- if (!(HandleInformation.GrantedAccess & FILE_WRITE_ATTRIBUTES))
- Failed = TRUE;
- break;
-
- case FileDispositionInformation:
- if (!(HandleInformation.GrantedAccess & DELETE))
- Failed = TRUE;
- break;
-
- case FilePositionInformation:
- if (!(HandleInformation.GrantedAccess & (FILE_READ_DATA |
FILE_WRITE_DATA)) ||
- !(FileObject->Flags & FO_SYNCHRONOUS_IO))
- Failed = TRUE;
- break;
-
- case FileEndOfFileInformation:
- if (!(HandleInformation.GrantedAccess & FILE_WRITE_DATA))
- Failed = TRUE;
- break;
-
- default:
- break;
- }
-
- if (Failed)
- {
- ObDereferenceObject(FileObject);
- return STATUS_ACCESS_DENIED;
- }
-
- if (FileInformationClass == FilePositionInformation)
- {
- if (Length < sizeof(FILE_POSITION_INFORMATION))
- {
- Status = STATUS_BUFFER_OVERFLOW;
- }
- else
- {
- _SEH_TRY
- {
- FileObject->CurrentByteOffset =
((PFILE_POSITION_INFORMATION)FileInformation)->CurrentByteOffset;
- IoStatusBlock->Information = 0;
- Status = IoStatusBlock->Status = STATUS_SUCCESS;
- }
- _SEH_HANDLE
- {
- Status = _SEH_GetExceptionCode();
- }
- _SEH_END;
- }
- ObDereferenceObject(FileObject);
- return Status;
- }
+ /* Check if this is a direct open or not */
+ if (FileObject->Flags & FO_DIRECT_DEVICE_OPEN)
+ {
+ /* Get the device object */
+ DeviceObject = IoGetAttachedDevice(FileObject->DeviceObject);
+ }
+ else
+ {
+ /* Get the device object */
+ DeviceObject = IoGetRelatedDeviceObject(FileObject);
+ }
+
+ /* Check if this is a file that was opened for Synch I/O */
+ if (FileObject->Flags & FO_SYNCHRONOUS_IO)
+ {
+ /* Lock it */
+ IopLockFileObject(FileObject);
+
+ /* Check if the caller just wants the position */
+ if (FileInformationClass == FilePositionInformation)
+ {
+ /* Protect write in SEH */
+ _SEH_TRY
+ {
+ /* Write the offset */
+ FileObject->CurrentByteOffset =
+ ((PFILE_POSITION_INFORMATION)FileInformation)->
+ CurrentByteOffset;
+
+ /* Fill out the I/O Status Block */
+ IoStatusBlock->Information = 0;
+ Status = IoStatusBlock->Status = STATUS_SUCCESS;
+ }
+ _SEH_HANDLE
+ {
+ /* Get the exception code */
+ Status = _SEH_GetExceptionCode();
+ }
+ _SEH_END;
+
+ /* Release the file lock, dereference the file and return */
+ IopUnlockFileObject(FileObject);
+ ObDereferenceObject(FileObject);
+ return Status;
+ }
+ }
+ else
+ {
+ /* Use local event */
+ Event = ExAllocatePoolWithTag(NonPagedPool, sizeof(KEVENT), TAG_IO);
+ KeInitializeEvent(Event, SynchronizationEvent, FALSE);
+ LocalEvent = TRUE;
+ }
+
+ /* Clear the File Object event */
+ KeClearEvent(&FileObject->Event);
+
+ /* Allocate the IRP */
+ Irp = IoAllocateIrp(DeviceObject->StackSize, TRUE);
+ if (!Irp) return IopCleanupFailedIrp(FileObject, NULL);
+
+ /* Set the IRP */
+ Irp->Tail.Overlay.OriginalFileObject = FileObject;
+ Irp->Tail.Overlay.Thread = PsGetCurrentThread();
+ Irp->RequestorMode = PreviousMode;
+ Irp->Overlay.AsynchronousParameters.UserApcRoutine = NULL;
+ Irp->Flags = (LocalEvent) ? IRP_SYNCHRONOUS_API : 0;
+ Irp->UserIosb = (LocalEvent) ? &KernelIosb : IoStatusBlock;
+ Irp->UserEvent = (LocalEvent) ? Event : NULL;
+ Irp->AssociatedIrp.SystemBuffer = NULL;
+ Irp->MdlAddress = NULL;
+ Irp->UserBuffer = FileInformation;
+
+ /* Set the Stack Data */
+ StackPtr = IoGetNextIrpStackLocation(Irp);
+ StackPtr->MajorFunction = IRP_MJ_SET_INFORMATION;
+ StackPtr->FileObject = FileObject;
+
+ /* Allocate a buffer */
+ Irp->AssociatedIrp.SystemBuffer =
+ ExAllocatePoolWithTag(NonPagedPool,
+ Length,
+ TAG_SYSB);
+
+ /* Copy the data into it */
+ RtlCopyMemory(Irp->AssociatedIrp.SystemBuffer, FileInformation, Length);
+
+ /* Set the flags */
+ Irp->Flags = (IRP_BUFFERED_IO |
+ IRP_DEALLOCATE_BUFFER |
+ IRP_DEFER_IO_COMPLETION);
+
+ /* Set the Parameters */
+ StackPtr->Parameters.SetFile.FileInformationClass = FileInformationClass;
+ StackPtr->Parameters.SetFile.Length = Length;
+
+ /* Queue the IRP */
+ //IopQueueIrpToThread(Irp);
+
+ /* Update operation counts */
+ IopUpdateOperationCount(IopOtherTransfer);
/* FIXME: Later, we can implement a lot of stuff here and avoid a driver call */
/* Handle IO Completion Port quickly */
if (FileInformationClass == FileCompletionInformation)
{
- PVOID Queue;
- PFILE_COMPLETION_INFORMATION CompletionInfo = FileInformation;
- PIO_COMPLETION_CONTEXT Context;
-
- if (FileObject->Flags & FO_SYNCHRONOUS_IO ||
FileObject->CompletionContext != NULL)
- {
+ /* Check if the file object already has a completion port */
+ if ((FileObject->Flags & FO_SYNCHRONOUS_IO) ||
+ (FileObject->CompletionContext))
+ {
+ /* Fail */
Status = STATUS_INVALID_PARAMETER;
}
else
{
- if (Length < sizeof(FILE_COMPLETION_INFORMATION))
+ /* Reference the Port */
+ CompletionInfo = Irp->AssociatedIrp.SystemBuffer;
+ Status = ObReferenceObjectByHandle(CompletionInfo->Port,
+ IO_COMPLETION_MODIFY_STATE,
+ IoCompletionType,
+ PreviousMode,
+ (PVOID*)&Queue,
+ NULL);
+ if (NT_SUCCESS(Status))
{
- Status = STATUS_INFO_LENGTH_MISMATCH;
- }
- else
- {
- /* Reference the Port */
- Status = ObReferenceObjectByHandle(CompletionInfo->Port, /* FIXME -
protect with SEH! */
- IO_COMPLETION_MODIFY_STATE,
- IoCompletionType,
- PreviousMode,
- (PVOID*)&Queue,
- NULL);
- if (NT_SUCCESS(Status))
+ /* Allocate the Context */
+ Context = ExAllocatePoolWithTag(PagedPool,
+ sizeof(IO_COMPLETION_CONTEXT),
+ IOC_TAG);
+ if (Context)
{
- /* Allocate the Context */
- Context = ExAllocatePoolWithTag(PagedPool,
- sizeof(IO_COMPLETION_CONTEXT),
- TAG('I', 'o',
'C', 'p'));
-
- if (Context != NULL)
+ /* Set the Data */
+ Context->Key = CompletionInfo->Key;
+ Context->Port = Queue;
+ if (InterlockedCompareExchangePointer(&FileObject->
+ CompletionContext,
+ Context,
+ NULL))
{
- /* Set the Data */
- Context->Key = CompletionInfo->Key; /* FIXME - protect with
SEH! */
- Context->Port = Queue;
-
- if
(InterlockedCompareExchangePointer(&FileObject->CompletionContext,
- Context,
- NULL) != NULL)
- {
- /* someone else set the completion port in the
- meanwhile, fail */
- ExFreePool(Context);
- ObDereferenceObject(Queue);
- Status = STATUS_INVALID_PARAMETER;
- }
- }
- else
- {
- /* Dereference the Port now */
+ /*
+ * Someone else set the completion port in the
+ * meanwhile, so dereference the port and fail.
+ */
+ ExFreePool(Context);
ObDereferenceObject(Queue);
- Status = STATUS_INSUFFICIENT_RESOURCES;
+ Status = STATUS_INVALID_PARAMETER;
}
}
+ else
+ {
+ /* Dereference the Port now */
+ ObDereferenceObject(Queue);
+ Status = STATUS_INSUFFICIENT_RESOURCES;
+ }
}
}
- /* Complete the I/O */
- ObDereferenceObject(FileObject);
- return Status;
- }
-
- /* Check if this is a direct open or not */
- if (FileObject->Flags & FO_DIRECT_DEVICE_OPEN)
- {
- DeviceObject = IoGetAttachedDevice(FileObject->DeviceObject);
+ /* Set the IRP Status */
+ Irp->IoStatus.Status = Status;
+ Irp->IoStatus.Information = 0;
}
else
{
- DeviceObject = IoGetRelatedDeviceObject(FileObject);
- }
-
- /* Check if we should use Sync IO or not */
- if (FileObject->Flags & FO_SYNCHRONOUS_IO)
- {
- /* Use File Object event */
- KeClearEvent(&FileObject->Event);
- }
- else
- {
- /* Use local event */
- KeInitializeEvent(&Event, SynchronizationEvent, FALSE);
- LocalEvent = TRUE;
- }
-
- /* Allocate the IRP */
- if (!(Irp = IoAllocateIrp(DeviceObject->StackSize, FALSE)))
- {
- ObDereferenceObject(FileObject);
- return STATUS_INSUFFICIENT_RESOURCES;
- }
-
- /* Allocate the System Buffer */
- Irp->AssociatedIrp.SystemBuffer = ExAllocatePoolWithTag(NonPagedPool,
- Length,
- TAG_SYSB);
- if (!Irp->AssociatedIrp.SystemBuffer)
- {
- Status = STATUS_INSUFFICIENT_RESOURCES;
- goto failfreeirp;
- }
-
- /* Copy the data inside */
- if (PreviousMode != KernelMode)
- {
- _SEH_TRY
- {
- /* no need to probe again */
- RtlCopyMemory(Irp->AssociatedIrp.SystemBuffer,
- FileInformation,
- Length);
- }
- _SEH_HANDLE
- {
- Status = _SEH_GetExceptionCode();
- }
- _SEH_END;
-
- if (!NT_SUCCESS(Status))
- {
- ExFreePoolWithTag(Irp->AssociatedIrp.SystemBuffer,
- TAG_SYSB);
- Irp->AssociatedIrp.SystemBuffer = NULL;
-failfreeirp:
- IoFreeIrp(Irp);
- ObDereferenceObject(FileObject);
- return Status;
- }
- }
- else
- {
- RtlCopyMemory(Irp->AssociatedIrp.SystemBuffer,
- FileInformation,
- Length);
- }
-
- /* Set up the IRP */
- Irp->Tail.Overlay.OriginalFileObject = FileObject;
- Irp->RequestorMode = PreviousMode;
- Irp->UserIosb = IoStatusBlock;
- Irp->UserEvent = (LocalEvent) ? &Event : NULL;
- Irp->Tail.Overlay.Thread = PsGetCurrentThread();
- Irp->Flags = IRP_BUFFERED_IO | IRP_DEALLOCATE_BUFFER;
- Irp->Flags |= (LocalEvent) ? IRP_SYNCHRONOUS_API : 0;
-
- /* Set up Stack Data */
- StackPtr = IoGetNextIrpStackLocation(Irp);
- StackPtr->MajorFunction = IRP_MJ_SET_INFORMATION;
- StackPtr->FileObject = FileObject;
-
- /* Set the Parameters */
- StackPtr->Parameters.SetFile.FileInformationClass = FileInformationClass;
- StackPtr->Parameters.SetFile.Length = Length;
-
- /* Call the Driver */
- Status = IoCallDriver(DeviceObject, Irp);
+ /* Call the Driver */
+ Status = IoCallDriver(DeviceObject, Irp);
+ }
+
+ /* Check if we're waiting for the IRP to complete */
if (Status == STATUS_PENDING)
{
+ /* Check if this was async I/O */
if (LocalEvent)
{
- KeWaitForSingleObject(&Event,
- Executive,
- PreviousMode,
- FileObject->Flags & FO_ALERTABLE_IO,
- NULL);
+ /* Then to a non-alertable wait */
+ Status = KeWaitForSingleObject(&Event,
+ Executive,
+ PreviousMode,
+ FALSE,
+ NULL);
+ if (Status == STATUS_USER_APC)
+ {
+ /* Abort the request */
+ IopAbortInterruptedIrp(Event, Irp);
+ }
+
+ /* Set the final status */
+ Status = KernelIosb.Status;
+
+ /* Enter SEH to write the IOSB back */
_SEH_TRY
{
- Status = IoStatusBlock->Status;
+ /* Write it back to the caller */
+ *IoStatusBlock = KernelIosb;
}
_SEH_HANDLE
{
+ /* Get the exception code */
Status = _SEH_GetExceptionCode();
}
_SEH_END;
+
+ /* Free the event */
+ ExFreePool(Event);
}
else
{
- KeWaitForSingleObject(&FileObject->Event,
- Executive,
- PreviousMode,
- FileObject->Flags & FO_ALERTABLE_IO,
- NULL);
- _SEH_TRY
+ /* Wait for the IRP */
+ Status = KeWaitForSingleObject(&FileObject->Event,
+ Executive,
+ PreviousMode,
+ FileObject->Flags & FO_ALERTABLE_IO,
+ NULL);
+ if ((Status == STATUS_USER_APC) || (Status == STATUS_ALERTED))
{
- Status = FileObject->FinalStatus;
+ /* Abort the request */
+ IopAbortInterruptedIrp(&FileObject->Event, Irp);
}
- _SEH_HANDLE
- {
- Status = _SEH_GetExceptionCode();
- }
- _SEH_END;
- }
+
+ /* Set the final status */
+ Status = FileObject->FinalStatus;
+
+ /* Release the file lock */
+ IopUnlockFileObject(FileObject);
+ }
+ }
+ else
+ {
+ /* Free the event if we had one */
+ if (LocalEvent)
+ {
+ /* Clear it in the IRP for completion */
+ Irp->UserEvent = NULL;
+ ExFreePool(Event);
+ }
+
+ /* Set the caller IOSB */
+ Irp->UserIosb = IoStatusBlock;
+
+ /* The IRP wasn't completed, complete it ourselves */
+ KeRaiseIrql(APC_LEVEL, &OldIrql);
+ IopCompleteRequest(&Irp->Tail.Apc,
+ &NormalRoutine,
+ &NormalContext,
+ (PVOID*)&FileObject,
+ &NormalContext);
+ KeLowerIrql(OldIrql);
+
+ /* Release the file object if we had locked it*/
+ if (!LocalEvent) IopUnlockFileObject(FileObject);
}
/* Return the Status */