/* INCLUDES *****************************************************************/
#include <ntoskrnl.h>
+#include <ioevent.h>
#define NDEBUG
#include <debug.h>
#include "internal/io_i.h"
IN ULONG OutputBufferLength OPTIONAL,
IN BOOLEAN IsDevIoCtl)
{
- NTSTATUS Status = STATUS_SUCCESS;
+ NTSTATUS Status;
PFILE_OBJECT FileObject;
PDEVICE_OBJECT DeviceObject;
PIRP Irp;
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get the exception code */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
}
_SEH2_END;
- if (!NT_SUCCESS(Status)) return Status;
}
/* Don't check for access rights right now, KernelMode can do anything */
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Cleanup after exception */
+ /* Cleanup after exception and return */
IopCleanupAfterException(FileObject, Irp, EventObject, NULL);
- Status = _SEH2_GetExceptionCode();
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
}
_SEH2_END;
- if (!NT_SUCCESS(Status)) return Status;
break;
/* Direct I/O */
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Cleanup after exception */
+ /* Cleanup after exception and return */
IopCleanupAfterException(FileObject, Irp, EventObject, NULL);
- Status = _SEH2_GetExceptionCode();
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
}
_SEH2_END;
- if (!NT_SUCCESS(Status)) return Status;
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;
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get the exception code */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
}
_SEH2_END;
-
- /* Return exception code, if any */
- if (!NT_SUCCESS(Status)) return Status;
}
/* 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);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get the exception code */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
}
_SEH2_END;
- /* Check if probing failed */
- if (!NT_SUCCESS(Status)) return Status;
-
/* Check if CompletionFilter is valid */
if (!CompletionFilter || (CompletionFilter & ~FILE_NOTIFY_VALID_MASK))
{
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;
CapturedLength = ProbeForReadLargeInteger(Length);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
- {
- /* Get the exception code */
- Status = _SEH2_GetExceptionCode();
- }
- _SEH2_END;
-
- /* Check if probing failed */
- if (!NT_SUCCESS(Status))
{
/* Dereference the object and return exception code */
ObDereferenceObject(FileObject);
- return Status;
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
}
+ _SEH2_END;
}
else
{
}
_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 = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
}
_SEH2_END;
- if (!NT_SUCCESS(Status)) return Status;
/* 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;
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get exception code and free the buffer */
+ /* Free buffer and return the exception code */
if (AuxBuffer) ExFreePool(AuxBuffer);
- Status = _SEH2_GetExceptionCode();
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
}
_SEH2_END;
-
- /* Return status on failure */
- if (!NT_SUCCESS(Status)) return Status;
}
/* Get File Object */
}
_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 = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
}
_SEH2_END;
- if (!NT_SUCCESS(Status)) return Status;
/* Set the buffer and flags */
Irp->UserBuffer = FileInformation;
{
/* Allocate an MDL */
Mdl = IoAllocateMdl(FileInformation, Length, FALSE, TRUE, Irp);
+ if (!Mdl) ExRaiseStatus(STATUS_INSUFFICIENT_RESOURCES);
MmProbeAndLockPages(Mdl, PreviousMode, IoWriteAccess);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Allocating failed, clean up */
+ /* Allocating failed, clean up and return the exception code */
IopCleanupAfterException(FileObject, Irp, Event, NULL);
- Status = _SEH2_GetExceptionCode();
- _SEH2_YIELD(return Status);
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
}
_SEH2_END;
}
{
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 */
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get the exception code */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
}
_SEH2_END;
- if (!NT_SUCCESS(Status)) return Status;
}
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;
}
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Allocating failed, clean up */
+ /* Allocating failed, clean up and return the exception code */
IopCleanupAfterException(FileObject, Irp, NULL, Event);
- Status = _SEH2_GetExceptionCode();
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
}
_SEH2_END;
- if (!NT_SUCCESS(Status)) return Status;
/* Set the flags */
Irp->Flags |= (IRP_BUFFERED_IO |
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)
{
_SEH2_TRY
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get the exception code */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
}
_SEH2_END;
-
- /* Check for probe failure */
- if (!NT_SUCCESS(Status)) return Status;
}
else
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Allocating failed, clean up */
+ /* Allocating failed, clean up and return the exception code */
IopCleanupAfterException(FileObject, Irp, EventObject, NULL);
- Status = _SEH2_GetExceptionCode();
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
}
_SEH2_END;
- if (!NT_SUCCESS(Status)) return Status;
/* Set the buffer and flags */
Irp->UserBuffer = Buffer;
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Allocating failed, clean up */
+ /* Allocating failed, clean up and return the exception code */
IopCleanupAfterException(FileObject, Irp, EventObject, NULL);
- Status = _SEH2_GetExceptionCode();
- _SEH2_YIELD(return Status);
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
}
_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 */
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get the exception code */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
}
_SEH2_END;
-
- /* Check if probing failed */
- if (!NT_SUCCESS(Status)) return Status;
}
else
{
}
_SEH2_END;
+ /* Update transfer count */
+ IopUpdateTransferCount(IopOtherTransfer, Length);
+
/* Release the file lock, dereference the file and return */
IopUnlockFileObject(FileObject);
ObDereferenceObject(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;
}
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Allocating failed, clean up */
+ /* Allocating failed, clean up and return the exception code */
IopCleanupAfterException(FileObject, Irp, NULL, Event);
- Status = _SEH2_GetExceptionCode();
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
}
_SEH2_END;
- if (!NT_SUCCESS(Status)) return Status;
/* Set the flags */
Irp->Flags |= (IRP_BUFFERED_IO |
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();
CapturedLength = ProbeForReadLargeInteger(Length);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
- {
- /* Get the exception code */
- Status = _SEH2_GetExceptionCode();
- }
- _SEH2_END;
-
- /* Check if probing failed */
- if (!NT_SUCCESS(Status))
{
/* 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;
}
}
_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 = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
}
_SEH2_END;
- if (!NT_SUCCESS(Status)) return Status;
/* 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)
{
_SEH2_TRY
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get the exception code */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
}
_SEH2_END;
-
- /* Check for probe failure */
- if (!NT_SUCCESS(Status)) return Status;
}
else
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Allocating failed, clean up */
+ /* Allocating failed, clean up and return the exception code */
IopCleanupAfterException(FileObject, Irp, EventObject, NULL);
- Status = _SEH2_GetExceptionCode();
- _SEH2_YIELD(return Status);
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
}
_SEH2_END;
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Allocating failed, clean up */
+ /* Allocating failed, clean up and return the exception code */
IopCleanupAfterException(FileObject, Irp, EventObject, NULL);
- Status = _SEH2_GetExceptionCode();
- _SEH2_YIELD(return Status);
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
}
_SEH2_END;
}
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);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get the exception code */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
}
_SEH2_END;
- if (!NT_SUCCESS(Status)) return Status;
}
/* 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;
}
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Allocating failed, clean up */
+ /* Allocating failed, clean up and return the exception code */
IopCleanupAfterException(FileObject, Irp, NULL, Event);
- Status = _SEH2_GetExceptionCode();
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
}
_SEH2_END;
- if (!NT_SUCCESS(Status)) return Status;
/* 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);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get the exception code */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
}
_SEH2_END;
- if (!NT_SUCCESS(Status)) return Status;
}
/* 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;
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Allocating failed, clean up */
+ /* Allocating failed, clean up and return the exception code */
IopCleanupAfterException(FileObject, Irp, NULL, Event);
- Status = _SEH2_GetExceptionCode();
+ if (TargetDeviceObject) ObDereferenceObject(TargetDeviceObject);
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
}
_SEH2_END;
- if (!NT_SUCCESS(Status)) return Status;
/* 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;
}