/* INCLUDES *****************************************************************/
#include <ntoskrnl.h>
+#include <ioevent.h>
#define NDEBUG
#include <debug.h>
#include "internal/io_i.h"
}
/* Wrap potential user-mode write in SEH */
- _SEH_TRY
+ _SEH2_TRY
{
*IoStatusBlock = *KernelIosb;
}
- _SEH_HANDLE
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
/* Get the exception code */
- FinalStatus = _SEH_GetExceptionCode();
+ FinalStatus = _SEH2_GetExceptionCode();
}
- _SEH_END;
+ _SEH2_END;
/* Free the event and return status */
ExFreePool(Event);
IN ULONG OutputBufferLength OPTIONAL,
IN BOOLEAN IsDevIoCtl)
{
- NTSTATUS Status = STATUS_SUCCESS;
+ NTSTATUS Status;
PFILE_OBJECT FileObject;
PDEVICE_OBJECT DeviceObject;
PIRP Irp;
/* Check if we came from user mode */
if (PreviousMode != KernelMode)
{
- _SEH_TRY
+ _SEH2_TRY
{
/* Probe the status block */
ProbeForWriteIoStatusBlock(IoStatusBlock);
}
}
}
- _SEH_HANDLE
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get the exception code */
- Status = _SEH_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
}
- _SEH_END;
- if (!NT_SUCCESS(Status)) return Status;
+ _SEH2_END;
}
/* Don't check for access rights right now, KernelMode can do anything */
case METHOD_BUFFERED:
/* Enter SEH for allocations */
- _SEH_TRY
+ _SEH2_TRY
{
/* Select the right Buffer Length */
BufferLength = (InputBufferLength > OutputBufferLength) ?
Irp->UserBuffer = NULL;
}
}
- _SEH_HANDLE
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Cleanup after exception */
- IopCleanupAfterException(FileObject, Irp, Event, NULL);
- Status = _SEH_GetExceptionCode();
+ /* Cleanup after exception and return */
+ IopCleanupAfterException(FileObject, Irp, EventObject, NULL);
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
}
- _SEH_END;
- if (!NT_SUCCESS(Status)) return Status;
+ _SEH2_END;
break;
/* Direct I/O */
case METHOD_OUT_DIRECT:
/* Enter SEH */
- _SEH_TRY
+ _SEH2_TRY
{
/* Check if we got an input buffer */
if ((InputBufferLength) && (InputBuffer))
IoReadAccess : IoWriteAccess);
}
}
- _SEH_HANDLE
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Cleanup after exception */
- IopCleanupAfterException(FileObject, Irp, Event, NULL);
- Status = _SEH_GetExceptionCode();
+ /* Cleanup after exception and return */
+ IopCleanupAfterException(FileObject, Irp, EventObject, NULL);
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
}
- _SEH_END;
- if (!NT_SUCCESS(Status)) return Status;
+ _SEH2_END;
break;
case METHOD_NEITHER:
PFILE_OBJECT FileObject;
PIRP Irp;
PIO_STACK_LOCATION StackPtr;
- NTSTATUS Status = STATUS_SUCCESS;
+ NTSTATUS Status;
PDEVICE_OBJECT DeviceObject;
PKEVENT Event = NULL;
BOOLEAN LocalEvent = FALSE;
if (PreviousMode != KernelMode)
{
/* Protect probes */
- _SEH_TRY
+ _SEH2_TRY
{
/* Probe the I/O Status block */
ProbeForWriteIoStatusBlock(IoStatusBlock);
}
- _SEH_HANDLE
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get the exception code */
- Status = _SEH_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
}
- _SEH_END;
-
- /* Return exception code, if any */
- if (!NT_SUCCESS(Status)) return Status;
+ _SEH2_END;
}
/* Get the File Object */
{
/* Use local event */
Event = ExAllocatePoolWithTag(NonPagedPool, sizeof(KEVENT), TAG_IO);
+ if (!Event)
+ {
+ /* We failed */
+ ObDereferenceObject(FileObject);
+ return STATUS_INSUFFICIENT_RESOURCES;
+ }
KeInitializeEvent(Event, SynchronizationEvent, FALSE);
LocalEvent = TRUE;
}
PFILE_OBJECT FileObject;
PIO_STACK_LOCATION IoStack;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
- NTSTATUS Status = STATUS_SUCCESS;
+ NTSTATUS Status;
BOOLEAN LockedForSync = FALSE;
PAGED_CODE();
IOTRACE(IO_API_DEBUG, "FileHandle: %p\n", FileHandle);
if (PreviousMode != KernelMode)
{
/* Enter SEH for probing */
- _SEH_TRY
+ _SEH2_TRY
{
/* Probe the I/O STatus block */
ProbeForWriteIoStatusBlock(IoStatusBlock);
/* Probe the buffer */
if (BufferSize) ProbeForWrite(Buffer, BufferSize, sizeof(ULONG));
}
- _SEH_HANDLE
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get the exception code */
- Status = _SEH_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
}
- _SEH_END;
+ _SEH2_END;
- /* Check if probing failed */
- if (!NT_SUCCESS(Status)) return Status;
+ /* Check if CompletionFilter is valid */
+ if (!CompletionFilter || (CompletionFilter & ~FILE_NOTIFY_VALID_MASK))
+ {
+ return STATUS_INVALID_PARAMETER;
+ }
}
/* Get File Object */
PreviousMode,
(PVOID *)&Event,
NULL);
- if (Status != STATUS_SUCCESS) return Status;
+ if (Status != STATUS_SUCCESS)
+ {
+ ObDereferenceObject(FileObject);
+ return Status;
+ }
KeClearEvent(Event);
}
Irp->RequestorMode = PreviousMode;
Irp->UserIosb = IoStatusBlock;
Irp->UserEvent = Event;
+ Irp->UserBuffer = Buffer;
Irp->Tail.Overlay.Thread = PsGetCurrentThread();
Irp->Tail.Overlay.OriginalFileObject = FileObject;
Irp->Overlay.AsynchronousParameters.UserApcRoutine = ApcRoutine;
BOOLEAN LockedForSync = FALSE;
KPROCESSOR_MODE PreviousMode = KeGetPreviousMode();
LARGE_INTEGER CapturedByteOffset, CapturedLength;
- NTSTATUS Status = STATUS_SUCCESS;
+ NTSTATUS Status;
OBJECT_HANDLE_INFORMATION HandleInformation;
PAGED_CODE();
CapturedByteOffset.QuadPart = 0;
}
/* Enter SEH for probing */
- _SEH_TRY
+ _SEH2_TRY
{
/* Probe the I/O STatus block */
ProbeForWriteIoStatusBlock(IoStatusBlock);
CapturedByteOffset = ProbeForReadLargeInteger(ByteOffset);
CapturedLength = ProbeForReadLargeInteger(Length);
}
- _SEH_HANDLE
- {
- /* Get the exception code */
- Status = _SEH_GetExceptionCode();
- }
- _SEH_END;
-
- /* Check if probing failed */
- if (!NT_SUCCESS(Status))
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
/* Dereference the object and return exception code */
ObDereferenceObject(FileObject);
- return Status;
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
}
+ _SEH2_END;
}
else
{
StackPtr->FileObject = FileObject;
/* Enter SEH */
- _SEH_TRY
+ _SEH2_TRY
{
/* Allocate local buffer */
LocalLength = ExAllocatePoolWithTag(NonPagedPool,
Irp->Tail.Overlay.AuxiliaryBuffer = (PVOID)LocalLength;
StackPtr->Parameters.LockControl.Length = LocalLength;
}
- _SEH_HANDLE
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Allocating failed, clean up */
+ /* Allocating failed, clean up and return the exception code */
IopCleanupAfterException(FileObject, Irp, Event, NULL);
if (LocalLength) ExFreePool(LocalLength);
- /* Get status */
- Status = _SEH_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
}
- _SEH_END;
- if (!NT_SUCCESS(Status)) return Status;
+ _SEH2_END;
/* Set Parameters */
StackPtr->Parameters.LockControl.ByteOffset = CapturedByteOffset;
PFILE_OBJECT FileObject;
PIO_STACK_LOCATION StackPtr;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
- NTSTATUS Status = STATUS_SUCCESS;
+ NTSTATUS Status;
BOOLEAN LockedForSynch = FALSE;
PKEVENT Event = NULL;
PVOID AuxBuffer = NULL;
if (PreviousMode != KernelMode)
{
/* Enter SEH for probing */
- _SEH_TRY
+ _SEH2_TRY
{
/* Probe the I/O Status Block */
ProbeForWriteIoStatusBlock(IoStatusBlock);
SearchPattern->MaximumLength = CapturedFileName.Length;
}
}
- _SEH_HANDLE
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get exception code and free the buffer */
+ /* Free buffer and return the exception code */
if (AuxBuffer) ExFreePool(AuxBuffer);
- Status = _SEH_GetExceptionCode();
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
}
- _SEH_END;
-
- /* Return status on failure */
- if (!NT_SUCCESS(Status)) return Status;
+ _SEH2_END;
}
/* Get File Object */
if (DeviceObject->Flags & DO_BUFFERED_IO)
{
/* Enter SEH */
- _SEH_TRY
+ _SEH2_TRY
{
/* Allocate a buffer */
Irp->AssociatedIrp.SystemBuffer =
Length,
TAG_SYSB);
}
- _SEH_HANDLE
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Allocating failed, clean up */
+ /* Allocating failed, clean up and return the exception code */
IopCleanupAfterException(FileObject, Irp, Event, NULL);
if (AuxBuffer) ExFreePool(AuxBuffer);
- /* Get status */
- Status = _SEH_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
}
- _SEH_END;
- if (!NT_SUCCESS(Status)) return Status;
+ _SEH2_END;
/* Set the buffer and flags */
Irp->UserBuffer = FileInformation;
}
else if (DeviceObject->Flags & DO_DIRECT_IO)
{
- _SEH_TRY
+ _SEH2_TRY
{
/* Allocate an MDL */
Mdl = IoAllocateMdl(FileInformation, Length, FALSE, TRUE, Irp);
+ if (!Mdl) ExRaiseStatus(STATUS_INSUFFICIENT_RESOURCES);
MmProbeAndLockPages(Mdl, PreviousMode, IoWriteAccess);
}
- _SEH_HANDLE
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Allocating failed, clean up */
+ /* Allocating failed, clean up and return the exception code */
IopCleanupAfterException(FileObject, Irp, Event, NULL);
- Status = _SEH_GetExceptionCode();
- _SEH_YIELD(return Status);
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
}
- _SEH_END;
+ _SEH2_END;
}
else
{
{
OBJECT_HANDLE_INFORMATION HandleInformation;
PFILE_OBJECT FileObject;
- NTSTATUS Status = STATUS_SUCCESS;
+ NTSTATUS Status;
PIRP Irp;
PDEVICE_OBJECT DeviceObject;
PIO_STACK_LOCATION StackPtr;
PVOID NormalContext;
KIRQL OldIrql;
IO_STATUS_BLOCK KernelIosb;
+ PAGED_CODE();
IOTRACE(IO_API_DEBUG, "FileHandle: %p\n", FileHandle);
/* Check if we're called from user mode */
}
/* Enter SEH for probing */
- _SEH_TRY
+ _SEH2_TRY
{
/* Probe the I/O Status block */
ProbeForWriteIoStatusBlock(IoStatusBlock);
/* Probe the information */
ProbeForWrite(FileInformation, Length, sizeof(ULONG));
}
- _SEH_HANDLE
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get the exception code */
- Status = _SEH_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
}
- _SEH_END;
- if (!NT_SUCCESS(Status)) return Status;
+ _SEH2_END;
}
else
{
if (FileInformationClass == FilePositionInformation)
{
/* Protect write in SEH */
- _SEH_TRY
+ _SEH2_TRY
{
/* Write the offset */
((PFILE_POSITION_INFORMATION)FileInformation)->
IoStatusBlock->Information = sizeof(FILE_POSITION_INFORMATION);
Status = IoStatusBlock->Status = STATUS_SUCCESS;
}
- _SEH_HANDLE
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
/* Get the exception code */
- Status = _SEH_GetExceptionCode();
+ Status = _SEH2_GetExceptionCode();
}
- _SEH_END;
+ _SEH2_END;
/* Release the file lock, dereference the file and return */
IopUnlockFileObject(FileObject);
{
/* Use local event */
Event = ExAllocatePoolWithTag(NonPagedPool, sizeof(KEVENT), TAG_IO);
+ if (!Event)
+ {
+ ObDereferenceObject(FileObject);
+ return STATUS_INSUFFICIENT_RESOURCES;
+ }
KeInitializeEvent(Event, SynchronizationEvent, FALSE);
LocalEvent = TRUE;
}
StackPtr->FileObject = FileObject;
/* Enter SEH */
- _SEH_TRY
+ _SEH2_TRY
{
/* Allocate a buffer */
Irp->AssociatedIrp.SystemBuffer =
Length,
TAG_SYSB);
}
- _SEH_HANDLE
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Allocating failed, clean up */
+ /* Allocating failed, clean up and return the exception code */
IopCleanupAfterException(FileObject, Irp, NULL, Event);
- Status = _SEH_GetExceptionCode();
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
}
- _SEH_END;
- if (!NT_SUCCESS(Status)) return Status;
+ _SEH2_END;
/* Set the flags */
Irp->Flags |= (IRP_BUFFERED_IO |
Status = KernelIosb.Status;
/* Enter SEH to write the IOSB back */
- _SEH_TRY
+ _SEH2_TRY
{
/* Write it back to the caller */
*IoStatusBlock = KernelIosb;
}
- _SEH_HANDLE
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
/* Get the exception code */
- Status = _SEH_GetExceptionCode();
+ Status = _SEH2_GetExceptionCode();
}
- _SEH_END;
+ _SEH2_END;
/* Free the event */
ExFreePool(Event);
IN PLARGE_INTEGER ByteOffset OPTIONAL,
IN PULONG Key OPTIONAL)
{
- NTSTATUS Status = STATUS_SUCCESS;
+ NTSTATUS Status;
PFILE_OBJECT FileObject;
PIRP Irp;
PDEVICE_OBJECT DeviceObject;
IOTRACE(IO_API_DEBUG, "FileHandle: %p\n", FileHandle);
/* Validate User-Mode Buffers */
- if(PreviousMode != KernelMode)
+ if (PreviousMode != KernelMode)
{
- _SEH_TRY
+ _SEH2_TRY
{
/* Probe the status block */
ProbeForWriteIoStatusBlock(IoStatusBlock);
/* Capture and probe the key */
if (Key) CapturedKey = ProbeForReadUlong(Key);
}
- _SEH_HANDLE
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get the exception code */
- Status = _SEH_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
}
- _SEH_END;
-
- /* Check for probe failure */
- if (!NT_SUCCESS(Status)) return Status;
+ _SEH2_END;
}
else
{
/* Set the IRP */
Irp->Tail.Overlay.OriginalFileObject = FileObject;
Irp->Tail.Overlay.Thread = PsGetCurrentThread();
- Irp->RequestorMode = KernelMode;
+ Irp->RequestorMode = PreviousMode;
Irp->Overlay.AsynchronousParameters.UserApcRoutine = ApcRoutine;
Irp->Overlay.AsynchronousParameters.UserApcContext = ApcContext;
Irp->UserIosb = IoStatusBlock;
if (Length)
{
/* Enter SEH */
- _SEH_TRY
+ _SEH2_TRY
{
/* Allocate a buffer */
Irp->AssociatedIrp.SystemBuffer =
Length,
TAG_SYSB);
}
- _SEH_HANDLE
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Allocating failed, clean up */
- IopCleanupAfterException(FileObject, Irp, NULL, Event);
- Status = _SEH_GetExceptionCode();
+ /* Allocating failed, clean up and return the exception code */
+ IopCleanupAfterException(FileObject, Irp, EventObject, NULL);
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
}
- _SEH_END;
- if (!NT_SUCCESS(Status)) return Status;
+ _SEH2_END;
/* Set the buffer and flags */
Irp->UserBuffer = Buffer;
/* Check if we have a buffer length */
if (Length)
{
- _SEH_TRY
+ _SEH2_TRY
{
/* Allocate an MDL */
Mdl = IoAllocateMdl(Buffer, Length, FALSE, TRUE, Irp);
MmProbeAndLockPages(Mdl, PreviousMode, IoWriteAccess);
}
- _SEH_HANDLE
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Allocating failed, clean up */
- IopCleanupAfterException(FileObject, Irp, Event, NULL);
- Status = _SEH_GetExceptionCode();
- _SEH_YIELD(return Status);
+ /* Allocating failed, clean up and return the exception code */
+ IopCleanupAfterException(FileObject, Irp, EventObject, NULL);
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
}
- _SEH_END;
+ _SEH2_END;
}
IN FILE_INFORMATION_CLASS FileInformationClass)
{
PFILE_OBJECT FileObject;
- NTSTATUS Status = STATUS_SUCCESS;
+ NTSTATUS Status;
PIRP Irp;
PDEVICE_OBJECT DeviceObject;
PIO_STACK_LOCATION StackPtr;
PVOID Queue;
PFILE_COMPLETION_INFORMATION CompletionInfo = FileInformation;
PIO_COMPLETION_CONTEXT Context;
+ PAGED_CODE();
IOTRACE(IO_API_DEBUG, "FileHandle: %p\n", FileHandle);
/* Check if we're called from user mode */
}
/* Enter SEH for probing */
- _SEH_TRY
+ _SEH2_TRY
{
/* Probe the I/O Status block */
ProbeForWriteIoStatusBlock(IoStatusBlock);
(Length == sizeof(BOOLEAN)) ?
sizeof(BOOLEAN) : sizeof(ULONG));
}
- _SEH_HANDLE
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get the exception code */
- Status = _SEH_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
}
- _SEH_END;
-
- /* Check if probing failed */
- if (!NT_SUCCESS(Status)) return Status;
+ _SEH2_END;
}
else
{
if (FileInformationClass == FilePositionInformation)
{
/* Protect write in SEH */
- _SEH_TRY
+ _SEH2_TRY
{
/* Write the offset */
FileObject->CurrentByteOffset =
IoStatusBlock->Information = 0;
Status = IoStatusBlock->Status = STATUS_SUCCESS;
}
- _SEH_HANDLE
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
/* Get the exception code */
- Status = _SEH_GetExceptionCode();
+ Status = _SEH2_GetExceptionCode();
}
- _SEH_END;
+ _SEH2_END;
+
+ /* Update transfer count */
+ IopUpdateTransferCount(IopOtherTransfer, Length);
/* Release the file lock, dereference the file and return */
IopUnlockFileObject(FileObject);
{
/* Use local event */
Event = ExAllocatePoolWithTag(NonPagedPool, sizeof(KEVENT), TAG_IO);
+ if (!Event)
+ {
+ ObDereferenceObject(FileObject);
+ return STATUS_INSUFFICIENT_RESOURCES;
+ }
+
KeInitializeEvent(Event, SynchronizationEvent, FALSE);
LocalEvent = TRUE;
}
StackPtr->FileObject = FileObject;
/* Enter SEH */
- _SEH_TRY
+ _SEH2_TRY
{
/* Allocate a buffer */
Irp->AssociatedIrp.SystemBuffer =
FileInformation,
Length);
}
- _SEH_HANDLE
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Allocating failed, clean up */
+ /* Allocating failed, clean up and return the exception code */
IopCleanupAfterException(FileObject, Irp, NULL, Event);
- Status = _SEH_GetExceptionCode();
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
}
- _SEH_END;
- if (!NT_SUCCESS(Status)) return Status;
+ _SEH2_END;
/* Set the flags */
Irp->Flags |= (IRP_BUFFERED_IO |
/* Set the Data */
Context->Key = CompletionInfo->Key;
Context->Port = Queue;
- if (InterlockedCompareExchangePointer(&FileObject->
+ if (InterlockedCompareExchangePointer((PVOID*)&FileObject->
CompletionContext,
Context,
NULL))
Status = KernelIosb.Status;
/* Enter SEH to write the IOSB back */
- _SEH_TRY
+ _SEH2_TRY
{
/* Write it back to the caller */
*IoStatusBlock = KernelIosb;
}
- _SEH_HANDLE
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
/* Get the exception code */
- Status = _SEH_GetExceptionCode();
+ Status = _SEH2_GetExceptionCode();
}
- _SEH_END;
+ _SEH2_END;
/* Free the event */
ExFreePool(Event);
BOOLEAN LocalEvent = FALSE;
KPROCESSOR_MODE PreviousMode = KeGetPreviousMode();
LARGE_INTEGER CapturedByteOffset, CapturedLength;
- NTSTATUS Status = STATUS_SUCCESS;
+ NTSTATUS Status;
OBJECT_HANDLE_INFORMATION HandleInformation;
IO_STATUS_BLOCK KernelIosb;
PAGED_CODE();
}
/* Enter SEH for probing */
- _SEH_TRY
+ _SEH2_TRY
{
/* Probe the I/O Status block */
ProbeForWriteIoStatusBlock(IoStatusBlock);
CapturedByteOffset = ProbeForReadLargeInteger(ByteOffset);
CapturedLength = ProbeForReadLargeInteger(Length);
}
- _SEH_HANDLE
- {
- /* Get the exception code */
- Status = _SEH_GetExceptionCode();
- }
- _SEH_END;
-
- /* Check if probing failed */
- if (!NT_SUCCESS(Status))
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
/* Dereference the object and return exception code */
ObDereferenceObject(FileObject);
- return Status;
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
}
+ _SEH2_END;
}
else
{
{
/* Use local event */
Event = ExAllocatePoolWithTag(NonPagedPool, sizeof(KEVENT), TAG_IO);
+ if (!Event)
+ {
+ ObDereferenceObject(FileObject);
+ return STATUS_INSUFFICIENT_RESOURCES;
+ }
KeInitializeEvent(Event, SynchronizationEvent, FALSE);
LocalEvent = TRUE;
}
StackPtr->FileObject = FileObject;
/* Enter SEH */
- _SEH_TRY
+ _SEH2_TRY
{
/* Allocate a buffer */
LocalLength = ExAllocatePoolWithTag(NonPagedPool,
Irp->Tail.Overlay.AuxiliaryBuffer = (PVOID)LocalLength;
StackPtr->Parameters.LockControl.Length = LocalLength;
}
- _SEH_HANDLE
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Allocating failed, clean up */
+ /* Allocating failed, clean up and return the exception code */
IopCleanupAfterException(FileObject, Irp, NULL, Event);
if (LocalLength) ExFreePool(LocalLength);
- /* Get exception status */
- Status = _SEH_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
}
- _SEH_END;
- if (!NT_SUCCESS(Status)) return Status;
+ _SEH2_END;
/* Set Parameters */
StackPtr->Parameters.LockControl.ByteOffset = CapturedByteOffset;
IN PLARGE_INTEGER ByteOffset OPTIONAL,
IN PULONG Key OPTIONAL)
{
- NTSTATUS Status = STATUS_SUCCESS;
+ NTSTATUS Status;
PFILE_OBJECT FileObject;
PIRP Irp;
PDEVICE_OBJECT DeviceObject;
if (!NT_SUCCESS(Status)) return Status;
/* Validate User-Mode Buffers */
- if(PreviousMode != KernelMode)
+ if (PreviousMode != KernelMode)
{
- _SEH_TRY
+ _SEH2_TRY
{
/*
* Check if the handle has either FILE_WRITE_DATA or
{
/* We failed */
ObDereferenceObject(FileObject);
- _SEH_YIELD(return STATUS_ACCESS_DENIED);
+ _SEH2_YIELD(return STATUS_ACCESS_DENIED);
}
/* Probe the status block */
/* Capture and probe the key */
if (Key) CapturedKey = ProbeForReadUlong(Key);
}
- _SEH_HANDLE
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get the exception code */
- Status = _SEH_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
}
- _SEH_END;
-
- /* Check for probe failure */
- if (!NT_SUCCESS(Status)) return Status;
+ _SEH2_END;
}
else
{
/* Set the IRP */
Irp->Tail.Overlay.OriginalFileObject = FileObject;
Irp->Tail.Overlay.Thread = PsGetCurrentThread();
- Irp->RequestorMode = KernelMode;
+ Irp->RequestorMode = PreviousMode;
Irp->Overlay.AsynchronousParameters.UserApcRoutine = ApcRoutine;
Irp->Overlay.AsynchronousParameters.UserApcContext = ApcContext;
Irp->UserIosb = IoStatusBlock;
if (Length)
{
/* Enter SEH */
- _SEH_TRY
+ _SEH2_TRY
{
/* Allocate a buffer */
Irp->AssociatedIrp.SystemBuffer =
/* Copy the data into it */
RtlCopyMemory(Irp->AssociatedIrp.SystemBuffer, Buffer, Length);
}
- _SEH_HANDLE
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Allocating failed, clean up */
- IopCleanupAfterException(FileObject, Irp, Event, NULL);
- Status = _SEH_GetExceptionCode();
- _SEH_YIELD(return Status);
+ /* Allocating failed, clean up and return the exception code */
+ IopCleanupAfterException(FileObject, Irp, EventObject, NULL);
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
}
- _SEH_END;
+ _SEH2_END;
/* Set the flags */
Irp->Flags = (IRP_BUFFERED_IO | IRP_DEALLOCATE_BUFFER);
/* Check if we have a buffer length */
if (Length)
{
- _SEH_TRY
+ _SEH2_TRY
{
/* Allocate an MDL */
Mdl = IoAllocateMdl(Buffer, Length, FALSE, TRUE, Irp);
MmProbeAndLockPages(Mdl, PreviousMode, IoReadAccess);
}
- _SEH_HANDLE
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Allocating failed, clean up */
- IopCleanupAfterException(FileObject, Irp, Event, NULL);
- Status = _SEH_GetExceptionCode();
- _SEH_YIELD(return Status);
+ /* Allocating failed, clean up and return the exception code */
+ IopCleanupAfterException(FileObject, Irp, EventObject, NULL);
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
}
- _SEH_END;
+ _SEH2_END;
}
/* No allocation flags */
PKEVENT Event = NULL;
BOOLEAN LocalEvent = FALSE;
KPROCESSOR_MODE PreviousMode = KeGetPreviousMode();
- NTSTATUS Status = STATUS_SUCCESS;
+ NTSTATUS Status;
IO_STATUS_BLOCK KernelIosb;
PAGED_CODE();
IOTRACE(IO_API_DEBUG, "FileHandle: %p\n", FileHandle);
}
/* Enter SEH for probing */
- _SEH_TRY
+ _SEH2_TRY
{
/* Probe the I/O Status block */
ProbeForWriteIoStatusBlock(IoStatusBlock);
/* Probe the information */
ProbeForWrite(FsInformation, Length, sizeof(ULONG));
}
- _SEH_HANDLE
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get the exception code */
- Status = _SEH_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
}
- _SEH_END;
- if (!NT_SUCCESS(Status)) return Status;
+ _SEH2_END;
}
/* Get File Object */
{
/* Use local event */
Event = ExAllocatePoolWithTag(NonPagedPool, sizeof(KEVENT), TAG_IO);
+ if (!Event)
+ {
+ ObDereferenceObject(FileObject);
+ return STATUS_INSUFFICIENT_RESOURCES;
+ }
KeInitializeEvent(Event, SynchronizationEvent, FALSE);
LocalEvent = TRUE;
}
StackPtr->FileObject = FileObject;
/* Enter SEH */
- _SEH_TRY
+ _SEH2_TRY
{
/* Allocate a buffer */
Irp->AssociatedIrp.SystemBuffer =
Length,
TAG_SYSB);
}
- _SEH_HANDLE
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Allocating failed, clean up */
+ /* Allocating failed, clean up and return the exception code */
IopCleanupAfterException(FileObject, Irp, NULL, Event);
- Status = _SEH_GetExceptionCode();
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
}
- _SEH_END;
- if (!NT_SUCCESS(Status)) return Status;
+ _SEH2_END;
/* Set the flags for this buffered + deferred I/O */
Irp->Flags |= (IRP_BUFFERED_IO |
PFILE_OBJECT FileObject;
PIRP Irp;
PIO_STACK_LOCATION StackPtr;
- PDEVICE_OBJECT DeviceObject;
+ PDEVICE_OBJECT DeviceObject, TargetDeviceObject;
PKEVENT Event = NULL;
BOOLEAN LocalEvent = FALSE;
KPROCESSOR_MODE PreviousMode = KeGetPreviousMode();
- NTSTATUS Status = STATUS_SUCCESS;
+ NTSTATUS Status;
IO_STATUS_BLOCK KernelIosb;
+ TARGET_DEVICE_CUSTOM_NOTIFICATION NotificationStructure;
PAGED_CODE();
IOTRACE(IO_API_DEBUG, "FileHandle: %p\n", FileHandle);
}
/* Enter SEH for probing */
- _SEH_TRY
+ _SEH2_TRY
{
/* Probe the I/O Status block */
ProbeForWriteIoStatusBlock(IoStatusBlock);
/* Probe the information */
ProbeForRead(FsInformation, Length, sizeof(ULONG));
}
- _SEH_HANDLE
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get the exception code */
- Status = _SEH_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
}
- _SEH_END;
- if (!NT_SUCCESS(Status)) return Status;
+ _SEH2_END;
}
/* Get File Object */
NULL);
if (!NT_SUCCESS(Status)) return Status;
+ /* Get target device for notification */
+ Status = IoGetRelatedTargetDevice(FileObject, &TargetDeviceObject);
+ if (!NT_SUCCESS(Status)) TargetDeviceObject = NULL;
+
/* Check if we should use Sync IO or not */
if (FileObject->Flags & FO_SYNCHRONOUS_IO)
{
{
/* Use local event */
Event = ExAllocatePoolWithTag(NonPagedPool, sizeof(KEVENT), TAG_IO);
+ if (!Event)
+ {
+ ObDereferenceObject(FileObject);
+ if (TargetDeviceObject) ObDereferenceObject(TargetDeviceObject);
+ return STATUS_INSUFFICIENT_RESOURCES;
+ }
KeInitializeEvent(Event, SynchronizationEvent, FALSE);
LocalEvent = TRUE;
}
/* Allocate the IRP */
Irp = IoAllocateIrp(DeviceObject->StackSize, FALSE);
- if (!Irp) return IopCleanupFailedIrp(FileObject, NULL, Event);
+ if (!Irp)
+ {
+ if (TargetDeviceObject) ObDereferenceObject(TargetDeviceObject);
+ return IopCleanupFailedIrp(FileObject, NULL, Event);
+ }
/* Set up the IRP */
Irp->RequestorMode = PreviousMode;
StackPtr->FileObject = FileObject;
/* Enter SEH */
- _SEH_TRY
+ _SEH2_TRY
{
/* Allocate a buffer */
Irp->AssociatedIrp.SystemBuffer =
/* Copy the data into it */
RtlCopyMemory(Irp->AssociatedIrp.SystemBuffer, FsInformation, Length);
}
- _SEH_HANDLE
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Allocating failed, clean up */
+ /* Allocating failed, clean up and return the exception code */
IopCleanupAfterException(FileObject, Irp, NULL, Event);
- Status = _SEH_GetExceptionCode();
+ if (TargetDeviceObject) ObDereferenceObject(TargetDeviceObject);
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
}
- _SEH_END;
- if (!NT_SUCCESS(Status)) return Status;
+ _SEH2_END;
/* Set the flags for this buffered + deferred I/O */
Irp->Flags |= (IRP_BUFFERED_IO | IRP_DEALLOCATE_BUFFER);
IoStatusBlock);
}
+ if (TargetDeviceObject && NT_SUCCESS(Status))
+ {
+ /* Time to report change */
+ NotificationStructure.Version = 1;
+ NotificationStructure.Size = sizeof(TARGET_DEVICE_CUSTOM_NOTIFICATION);
+ NotificationStructure.Event = GUID_IO_VOLUME_NAME_CHANGE;
+ NotificationStructure.FileObject = NULL;
+ NotificationStructure.NameBufferOffset = - 1;
+ Status = IoReportTargetDeviceChange(TargetDeviceObject, &NotificationStructure);
+ }
+
/* Return status */
return Status;
}
projects / reactos.git / blobdiff