Use safe copy routine to copy IoStatusBlock if a system funtion was called from user mode.
Do not use local IoStatusBlock copy in system functions.
svn path=/trunk/; revision=6995
FileObject = IoStack->FileObject;
- if (DeviceObject->Flags & DO_BUFFERED_IO)
+ if (DeviceObject->Flags & DO_BUFFERED_IO)
{
if (IoStack->MajorFunction == IRP_MJ_READ)
{
if (Irp->UserIosb!=NULL)
{
- *Irp->UserIosb=Irp->IoStatus;
+ if (Irp->RequestorMode == KernelMode)
+ {
+ *Irp->UserIosb = Irp->IoStatus;
+ }
+ else
+ {
+ DPRINT("Irp->RequestorMode == UserMode\n");
+ MmSafeCopyToUser(Irp->UserIosb,
+ &Irp->IoStatus,
+ sizeof(IO_STATUS_BLOCK));
+ }
}
if (Irp->UserEvent)
{
if (Irp->UserEvent == NULL)
{
- KeSetEvent(&OriginalFileObject->Event,PriorityBoost,FALSE);
+ KeSetEvent(&OriginalFileObject->Event,PriorityBoost,FALSE);
}
else if (OriginalFileObject->Flags & FO_SYNCHRONOUS_IO && Irp->UserEvent != &OriginalFileObject->Event)
{
- KeSetEvent(&OriginalFileObject->Event,PriorityBoost,FALSE);
+ KeSetEvent(&OriginalFileObject->Event,PriorityBoost,FALSE);
}
}
//Windows NT File System Internals, page 154
if (!(Irp->Flags & IRP_PAGING_IO) && OriginalFileObject)
{
- // if the event is not the one in the file object, it needs dereferenced
- if (Irp->UserEvent && Irp->UserEvent != &OriginalFileObject->Event)
+ // if the event is not the one in the file object, it needs dereferenced
+ if (Irp->UserEvent && Irp->UserEvent != &OriginalFileObject->Event)
{
ObDereferenceObject(Irp->UserEvent);
}
}
IoFreeIrp(Irp);
-
}
-/* $Id: create.c,v 1.69 2003/11/06 18:05:54 ekohl Exp $
+/* $Id: create.c,v 1.70 2003/12/13 14:36:42 ekohl Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
PIRP Irp;
PIO_STACK_LOCATION StackLoc;
IO_SECURITY_CONTEXT SecurityContext;
+ KPROCESSOR_MODE PreviousMode;
DPRINT("IoCreateFile(FileHandle %x, DesiredAccess %x, "
"ObjectAttributes %x ObjectAttributes->ObjectName->Buffer %S)\n",
*FileHandle = 0;
- Status = ObCreateObject(ExGetPreviousMode(),
+ PreviousMode = ExGetPreviousMode();
+
+ Status = ObCreateObject(PreviousMode,
IoFileObjectType,
ObjectAttributes,
- ExGetPreviousMode(),
+ PreviousMode,
NULL,
sizeof(FILE_OBJECT),
0,
//trigger FileObject/Event dereferencing
Irp->Tail.Overlay.OriginalFileObject = FileObject;
-
+ Irp->RequestorMode = PreviousMode;
Irp->UserIosb = IoStatusBlock;
Irp->AssociatedIrp.SystemBuffer = EaBuffer;
Irp->Tail.Overlay.AuxiliaryBuffer = (PCHAR)ExtraCreateParameters;
{
KeWaitForSingleObject(&FileObject->Event,
Executive,
- KernelMode,
+ PreviousMode,
FALSE,
NULL);
Status = IoStatusBlock->Status;
-/* $Id: dir.c,v 1.19 2003/08/07 11:47:33 silverblade Exp $
+/* $Id: dir.c,v 1.20 2003/12/13 14:36:42 ekohl Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
PFILE_OBJECT FileObject;
NTSTATUS Status;
PEXTENDED_IO_STACK_LOCATION IoStack;
- IO_STATUS_BLOCK IoSB;
+ KPROCESSOR_MODE PreviousMode;
DPRINT("NtQueryDirectoryFile()\n");
-
+
+ PreviousMode = ExGetPreviousMode();
+
Status = ObReferenceObjectByHandle(FileHandle,
FILE_LIST_DIRECTORY,
IoFileObjectType,
- UserMode,
+ PreviousMode,
(PVOID *)&FileObject,
NULL);
return STATUS_UNSUCCESSFUL;
}
- //trigger FileObject/Event dereferencing
+ /* Trigger FileObject/Event dereferencing */
Irp->Tail.Overlay.OriginalFileObject = FileObject;
-
- Irp->UserIosb = &IoSB;
+ Irp->RequestorMode = PreviousMode;
+ Irp->UserIosb = IoStatusBlock;
Irp->UserEvent = &FileObject->Event;
KeResetEvent( &FileObject->Event );
Irp->UserBuffer=FileInformation;
Status = IoCallDriver(FileObject->DeviceObject,Irp);
if (Status==STATUS_PENDING && !(FileObject->Flags & FO_SYNCHRONOUS_IO))
{
- if (FileObject->Flags & FO_ALERTABLE_IO)
- {
- KeWaitForSingleObject(&FileObject->Event,Executive,KernelMode,TRUE,NULL);
- }
- else
- {
- KeWaitForSingleObject(&FileObject->Event,Executive,KernelMode,FALSE,NULL);
- }
- Status = IoSB.Status;
- }
- if (IoStatusBlock)
- {
- *IoStatusBlock = IoSB;
+ KeWaitForSingleObject(&FileObject->Event,
+ Executive,
+ PreviousMode,
+ FileObject->Flags & FO_ALERTABLE_IO,
+ NULL);
+ Status = IoStatusBlock->Status;
}
+
return(Status);
}
-/* $Id: file.c,v 1.27 2003/11/08 07:42:10 ekohl Exp $
+/* $Id: file.c,v 1.28 2003/12/13 14:36:42 ekohl Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
PDEVICE_OBJECT DeviceObject;
PIO_STACK_LOCATION StackPtr;
PVOID SystemBuffer;
+ KPROCESSOR_MODE PreviousMode;
assert(IoStatusBlock != NULL);
assert(FileInformation != NULL);
DPRINT("NtQueryInformationFile(Handle %x StatBlk %x FileInfo %x Length %d "
"Class %d)\n", FileHandle, IoStatusBlock, FileInformation,
Length, FileInformationClass);
-
+
+ PreviousMode = ExGetPreviousMode();
+
Status = ObReferenceObjectByHandle(FileHandle,
FILE_READ_ATTRIBUTES,
IoFileObjectType,
- UserMode,
+ PreviousMode,
(PVOID *)&FileObject,
NULL);
if (!NT_SUCCESS(Status))
/* Trigger FileObject/Event dereferencing */
Irp->Tail.Overlay.OriginalFileObject = FileObject;
-
+ Irp->RequestorMode = PreviousMode;
Irp->AssociatedIrp.SystemBuffer = SystemBuffer;
Irp->UserIosb = IoStatusBlock;
Irp->UserEvent = &FileObject->Event;
{
KeWaitForSingleObject(&FileObject->Event,
Executive,
- KernelMode,
- FALSE,
+ PreviousMode,
+ FileObject->Flags & FO_ALERTABLE_IO,
NULL);
Status = IoStatusBlock->Status;
}
/* Trigger FileObject/Event dereferencing */
Irp->Tail.Overlay.OriginalFileObject = FileObject;
-
+ Irp->RequestorMode = KernelMode;
Irp->AssociatedIrp.SystemBuffer = FileInformation;
Irp->UserIosb = &IoStatusBlock;
Irp->UserEvent = &FileObject->Event;
KeWaitForSingleObject(&FileObject->Event,
Executive,
KernelMode,
- FALSE,
+ FileObject->Flags & FO_ALERTABLE_IO,
NULL);
Status = IoStatusBlock.Status;
}
PIRP Irp;
NTSTATUS Status;
PVOID SystemBuffer;
+ KPROCESSOR_MODE PreviousMode;
assert(IoStatusBlock != NULL)
assert(FileInformation != NULL)
DPRINT("NtSetInformationFile(Handle %x StatBlk %x FileInfo %x Length %d "
"Class %d)\n", FileHandle, IoStatusBlock, FileInformation,
Length, FileInformationClass);
-
+
+ PreviousMode = ExGetPreviousMode();
+
/* Get the file object from the file handle */
Status = ObReferenceObjectByHandle(FileHandle,
FILE_WRITE_ATTRIBUTES,
IoFileObjectType,
- UserMode,
+ PreviousMode,
(PVOID *)&FileObject,
NULL);
if (!NT_SUCCESS(Status))
Status = ObReferenceObjectByHandle(((PFILE_COMPLETION_INFORMATION)FileInformation)->IoCompletionHandle,
IO_COMPLETION_MODIFY_STATE,//???
ExIoCompletionType,
- UserMode,
+ PreviousMode,
(PVOID*)&Queue,
NULL);
if (NT_SUCCESS(Status))
/* Trigger FileObject/Event dereferencing */
Irp->Tail.Overlay.OriginalFileObject = FileObject;
-
+ Irp->RequestorMode = PreviousMode;
Irp->AssociatedIrp.SystemBuffer = SystemBuffer;
Irp->UserIosb = IoStatusBlock;
Irp->UserEvent = &FileObject->Event;
{
KeWaitForSingleObject(&FileObject->Event,
Executive,
- KernelMode,
- FALSE,
+ PreviousMode,
+ FileObject->Flags & FO_ALERTABLE_IO,
NULL);
Status = IoStatusBlock->Status;
}
STDCALL
NtFlushWriteBuffer(VOID)
{
- KeFlushWriteBuffer();
- return STATUS_SUCCESS;
+ KeFlushWriteBuffer();
+ return STATUS_SUCCESS;
}
NTSTATUS
PIRP Irp;
PIO_STACK_LOCATION StackPtr;
NTSTATUS Status;
- IO_STATUS_BLOCK IoSB;
-
+ KPROCESSOR_MODE PreviousMode;
+
+ PreviousMode = ExGetPreviousMode();
+
Status = ObReferenceObjectByHandle(FileHandle,
FILE_WRITE_DATA,
NULL,
- UserMode,
+ PreviousMode,
(PVOID*)&FileObject,
NULL);
if (Status != STATUS_SUCCESS)
0,
NULL,
&FileObject->Event,
- &IoSB);
+ IoStatusBlock);
- //trigger FileObject/Event dereferencing
+ /* Trigger FileObject/Event dereferencing */
Irp->Tail.Overlay.OriginalFileObject = FileObject;
+ Irp->RequestorMode = PreviousMode;
+
StackPtr = IoGetNextIrpStackLocation(Irp);
StackPtr->FileObject = FileObject;
Status = IoCallDriver(FileObject->DeviceObject,Irp);
- if (Status==STATUS_PENDING)
+ if (Status == STATUS_PENDING)
{
- KeWaitForSingleObject(&FileObject->Event,Executive,KernelMode,FALSE,NULL);
- Status = IoSB.Status;
- }
- if (IoStatusBlock)
- {
- *IoStatusBlock = IoSB;
+ KeWaitForSingleObject(&FileObject->Event,
+ Executive,
+ PreviousMode,
+ FileObject->Flags & FO_ALERTABLE_IO,
+ NULL);
+ Status = IoStatusBlock->Status;
}
+
return(Status);
}
-/* $Id: fs.c,v 1.39 2003/11/27 00:50:05 gdalsnes Exp $
+/* $Id: fs.c,v 1.40 2003/12/13 14:36:42 ekohl Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
PIRP Irp;
PEXTENDED_IO_STACK_LOCATION StackPtr;
PKEVENT ptrEvent;
- IO_STATUS_BLOCK IoSB;
+ KPROCESSOR_MODE PreviousMode;
DPRINT("NtFsControlFile(DeviceHandle %x EventHandle %x ApcRoutine %x "
"ApcContext %x IoStatusBlock %x IoControlCode %x "
IoControlCode,InputBuffer,InputBufferSize,OutputBuffer,
OutputBufferSize);
+ PreviousMode = ExGetPreviousMode();
+
Status = ObReferenceObjectByHandle(DeviceHandle,
FILE_READ_DATA | FILE_WRITE_DATA,
NULL,
- KernelMode,
+ PreviousMode,
(PVOID *) &FileObject,
NULL);
Status = ObReferenceObjectByHandle (EventHandle,
SYNCHRONIZE,
ExEventObjectType,
- UserMode,
+ PreviousMode,
(PVOID*)&ptrEvent,
NULL);
if (!NT_SUCCESS(Status))
OutputBufferSize,
FALSE,
ptrEvent,
- &IoSB);
+ IoStatusBlock);
- //trigger FileObject/Event dereferencing
+ /* Trigger FileObject/Event dereferencing */
Irp->Tail.Overlay.OriginalFileObject = FileObject;
-
+
+ Irp->RequestorMode = PreviousMode;
Irp->Overlay.AsynchronousParameters.UserApcRoutine = ApcRoutine;
Irp->Overlay.AsynchronousParameters.UserApcContext = ApcContext;
StackPtr->MajorFunction = IRP_MJ_FILE_SYSTEM_CONTROL;
Status = IoCallDriver(DeviceObject,Irp);
- if (Status == STATUS_PENDING && !(FileObject->Flags & FO_SYNCHRONOUS_IO))
+ if (Status == STATUS_PENDING && (FileObject->Flags & FO_SYNCHRONOUS_IO))
{
- KeWaitForSingleObject(ptrEvent,Executive,KernelMode,FALSE,NULL);
- Status = IoSB.Status;
- }
- if (IoStatusBlock)
- {
- *IoStatusBlock = IoSB;
+ KeWaitForSingleObject(ptrEvent,
+ Executive,
+ PreviousMode,
+ FileObject->Flags & FO_ALERTABLE_IO,
+ NULL);
+ Status = IoStatusBlock->Status;
}
+
return(Status);
}
-/* $Id: ioctrl.c,v 1.22 2003/11/28 17:17:44 ekohl Exp $
+/* $Id: ioctrl.c,v 1.23 2003/12/13 14:36:42 ekohl Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
OUT PVOID OutputBuffer,
IN ULONG OutputBufferLength OPTIONAL)
{
- IO_STATUS_BLOCK SafeIoStatusBlock;
NTSTATUS Status;
PFILE_OBJECT FileObject;
PDEVICE_OBJECT DeviceObject;
PIRP Irp;
PIO_STACK_LOCATION StackPtr;
PKEVENT EventObject;
+ KPROCESSOR_MODE PreviousMode;
DPRINT("NtDeviceIoControlFile(DeviceHandle %x Event %x UserApcRoutine %x "
"UserApcContext %x IoStatusBlock %x IoControlCode %x "
if (IoStatusBlock == NULL)
return STATUS_ACCESS_VIOLATION;
+ PreviousMode = ExGetPreviousMode();
+
Status = ObReferenceObjectByHandle (DeviceHandle,
FILE_READ_DATA | FILE_WRITE_DATA,
IoFileObjectType,
- KernelMode,
+ PreviousMode,
(PVOID *) &FileObject,
NULL);
if (!NT_SUCCESS(Status))
Status = ObReferenceObjectByHandle (Event,
SYNCHRONIZE,
ExEventObjectType,
- UserMode,
+ PreviousMode,
(PVOID*)&EventObject,
NULL);
if (!NT_SUCCESS(Status))
OutputBufferLength,
FALSE,
EventObject,
- &SafeIoStatusBlock);
+ IoStatusBlock);
/* Trigger FileObject/Event dereferencing */
Irp->Tail.Overlay.OriginalFileObject = FileObject;
+ Irp->RequestorMode = PreviousMode;
Irp->Overlay.AsynchronousParameters.UserApcRoutine = UserApcRoutine;
Irp->Overlay.AsynchronousParameters.UserApcContext = UserApcContext;
Status = IoCallDriver(DeviceObject,Irp);
if (Status == STATUS_PENDING && (FileObject->Flags & FO_SYNCHRONOUS_IO))
{
- BOOLEAN Alertable;
-
- Alertable = (FileObject->Flags & FO_ALERTABLE_IO) ? TRUE : FALSE;
Status = KeWaitForSingleObject (EventObject,
Executive,
- UserMode,
- Alertable,
+ PreviousMode,
+ FileObject->Flags & FO_ALERTABLE_IO,
NULL);
if (Status != STATUS_WAIT_0)
{
return Status;
}
- Status = SafeIoStatusBlock.Status;
+ Status = IoStatusBlock->Status;
}
- IoStatusBlock->Status = SafeIoStatusBlock.Status;
- IoStatusBlock->Information = SafeIoStatusBlock.Information;
-
return Status;
}
/* FUNCTIONS *****************************************************************/
-NTSTATUS
-STDCALL
- NtLockFileCompletionRoutine(
+static NTSTATUS STDCALL
+IopLockFileCompletionRoutine(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
IN PVOID Context
)
{
- ExFreePool(Context);
- return STATUS_SUCCESS;
- //FIXME: should I call IoFreeIrp and return STATUS_MORE_PROCESSING_REQUIRED?
+ ExFreePool(Context);
+ return STATUS_SUCCESS;
+ // FIXME: Should I call IoFreeIrp and return STATUS_MORE_PROCESSING_REQUIRED?
}
/*
STDCALL
NtLockFile (
IN HANDLE FileHandle,
- IN HANDLE EventHandle OPTIONAL,
- IN PIO_APC_ROUTINE ApcRoutine OPTIONAL,
- IN PVOID ApcContext OPTIONAL,
- OUT PIO_STATUS_BLOCK UserIoStatusBlock,
+ IN HANDLE EventHandle OPTIONAL,
+ IN PIO_APC_ROUTINE ApcRoutine OPTIONAL,
+ IN PVOID ApcContext OPTIONAL,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
IN PLARGE_INTEGER ByteOffset,
IN PLARGE_INTEGER Length,
IN PULONG Key,
IN BOOLEAN ExclusiveLock
)
{
- NTSTATUS Status;
- PFILE_OBJECT FileObject = NULL;
- PLARGE_INTEGER LocalLength = NULL;
- PKEVENT Event = NULL;
- PIRP Irp = NULL;
- PEXTENDED_IO_STACK_LOCATION StackPtr;
- IO_STATUS_BLOCK LocalIoStatusBlock;
- PIO_STATUS_BLOCK IoStatusBlock;
- PDEVICE_OBJECT DeviceObject;
- ULONG FobFlags;
-
- //FIXME: instead of this, use SEH when available?
- if (!Length || !ByteOffset) {
- Status = STATUS_INVALID_PARAMETER;
- goto fail;
- }
-
- Status = ObReferenceObjectByHandle(
- FileHandle,
+ PFILE_OBJECT FileObject = NULL;
+ PLARGE_INTEGER LocalLength = NULL;
+ PKEVENT Event = NULL;
+ PIRP Irp = NULL;
+ PEXTENDED_IO_STACK_LOCATION StackPtr;
+ PDEVICE_OBJECT DeviceObject;
+ KPROCESSOR_MODE PreviousMode;
+ NTSTATUS Status;
+
+ // FIXME: instead of this, use SEH when available?
+ if (!Length || !ByteOffset)
+ {
+ Status = STATUS_INVALID_PARAMETER;
+ goto fail;
+ }
+
+ PreviousMode = ExGetPreviousMode();
+
+ Status = ObReferenceObjectByHandle(FileHandle,
0,
IoFileObjectType,
- ExGetPreviousMode(),
+ PreviousMode,
(PVOID*)&FileObject,
NULL);
-
- if (!NT_SUCCESS(Status)){
- goto fail;
- }
-
- DeviceObject = IoGetRelatedDeviceObject(FileObject);
-
- Irp = IoAllocateIrp(
- DeviceObject->StackSize,
- TRUE
- );
-
- if (Irp == NULL) {
- Status = STATUS_INSUFFICIENT_RESOURCES;
- goto fail;
- }
-
- if (EventHandle != NULL && !FailImmediatedly) {
- Status = ObReferenceObjectByHandle(
- EventHandle,
- SYNCHRONIZE,
- ExEventObjectType,
- ExGetPreviousMode(),
- (PVOID*)&Event,
- NULL);
-
- if (!NT_SUCCESS(Status)) {
- goto fail;
- }
-
- }
- else {
- Event = &FileObject->Event;
- KeResetEvent(Event);
- }
-
- if ((FileObject->Flags & FO_SYNCHRONOUS_IO) || FailImmediatedly)
- IoStatusBlock = &LocalIoStatusBlock;
- else
- IoStatusBlock = UserIoStatusBlock;
-
- //trigger FileObject/Event dereferencing
- Irp->Tail.Overlay.OriginalFileObject = FileObject;
-
- Irp->Overlay.AsynchronousParameters.UserApcRoutine = ApcRoutine;
- Irp->Overlay.AsynchronousParameters.UserApcContext = ApcContext;
-
- Irp->UserEvent = Event;
- Irp->UserIosb = IoStatusBlock;
- Irp->Tail.Overlay.Thread = PsGetCurrentThread();
-
- StackPtr = (PEXTENDED_IO_STACK_LOCATION) IoGetNextIrpStackLocation(Irp);
- StackPtr->MajorFunction = IRP_MJ_LOCK_CONTROL;
- StackPtr->MinorFunction = IRP_MN_LOCK;
- StackPtr->FileObject = FileObject;
-
- if (ExclusiveLock) StackPtr->Flags |= SL_EXCLUSIVE_LOCK;
- if (FailImmediatedly) StackPtr->Flags |= SL_FAIL_IMMEDIATELY;
-
- LocalLength = ExAllocatePoolWithTag(
- NonPagedPool,
- sizeof(LARGE_INTEGER),
- TAG_LOCK
- );
- if (!LocalLength){
- Status = STATUS_INSUFFICIENT_RESOURCES;
- goto fail;
- }
-
- *LocalLength = *Length;
-
- StackPtr->Parameters.LockControl.Length = LocalLength;
- StackPtr->Parameters.LockControl.ByteOffset = *ByteOffset;
- StackPtr->Parameters.LockControl.Key = Key ? *Key : 0;
-
- IoSetCompletionRoutine(
- Irp,
- NtLockFileCompletionRoutine,
- LocalLength,
- TRUE,
- TRUE,
- TRUE );
-
- //can't touch FileObject after IoCallDriver since it might be freed
- FobFlags = FileObject->Flags;
- Status = IofCallDriver(DeviceObject, Irp);
-
- if (Status == STATUS_PENDING && (FobFlags & FO_SYNCHRONOUS_IO)) {
-
- Status = KeWaitForSingleObject(
- Event,
- Executive,
- ExGetPreviousMode() ,
- (FobFlags & FO_ALERTABLE_IO) ? TRUE : FALSE,
- NULL
- );
-
- if (Status != STATUS_WAIT_0) {
- DPRINT1("NtLockFile -> KeWaitForSingleObject failed!\n");
- /*
- FIXME: should do some special processing here if alertable wait
- was interupted by user apc or a thread alert (STATUS_ALERTED, STATUS_USER_APC)
- */
- return Status; //set status to something else?
- }
-
- Status = LocalIoStatusBlock.Status;
- }
-
- if (FobFlags & FO_SYNCHRONOUS_IO)
- *UserIoStatusBlock = LocalIoStatusBlock;
-
- return Status;
-
- fail:;
-
- if (LocalLength) ExFreePool(LocalLength);
- if (Irp) IoFreeIrp(Irp);
- if (Event) ObDereferenceObject(Event);
- if (FileObject) ObDereferenceObject(FileObject);
-
- return Status;
-
+ if (!NT_SUCCESS(Status))
+ {
+ goto fail;
+ }
+
+ DeviceObject = IoGetRelatedDeviceObject(FileObject);
+
+ Irp = IoAllocateIrp(DeviceObject->StackSize,
+ TRUE);
+ if (Irp == NULL)
+ {
+ Status = STATUS_INSUFFICIENT_RESOURCES;
+ goto fail;
+ }
+
+ if (EventHandle != NULL && !FailImmediatedly)
+ {
+ Status = ObReferenceObjectByHandle(EventHandle,
+ SYNCHRONIZE,
+ ExEventObjectType,
+ PreviousMode,
+ (PVOID*)&Event,
+ NULL);
+ if (!NT_SUCCESS(Status))
+ {
+ goto fail;
+ }
+ }
+ else
+ {
+ Event = &FileObject->Event;
+ KeResetEvent(Event);
+ }
+
+ /* Trigger FileObject/Event dereferencing */
+ Irp->Tail.Overlay.OriginalFileObject = FileObject;
+
+ Irp->RequestorMode = PreviousMode;
+ Irp->Overlay.AsynchronousParameters.UserApcRoutine = ApcRoutine;
+ Irp->Overlay.AsynchronousParameters.UserApcContext = ApcContext;
+
+ Irp->UserEvent = Event;
+ Irp->UserIosb = IoStatusBlock;
+ Irp->Tail.Overlay.Thread = PsGetCurrentThread();
+
+ StackPtr = (PEXTENDED_IO_STACK_LOCATION) IoGetNextIrpStackLocation(Irp);
+ StackPtr->MajorFunction = IRP_MJ_LOCK_CONTROL;
+ StackPtr->MinorFunction = IRP_MN_LOCK;
+ StackPtr->FileObject = FileObject;
+
+ if (ExclusiveLock)
+ StackPtr->Flags |= SL_EXCLUSIVE_LOCK;
+
+ if (FailImmediatedly)
+ StackPtr->Flags |= SL_FAIL_IMMEDIATELY;
+
+ LocalLength = ExAllocatePoolWithTag(NonPagedPool,
+ sizeof(LARGE_INTEGER),
+ TAG_LOCK);
+ if (!LocalLength)
+ {
+ Status = STATUS_INSUFFICIENT_RESOURCES;
+ goto fail;
+ }
+
+ *LocalLength = *Length;
+
+ StackPtr->Parameters.LockControl.Length = LocalLength;
+ StackPtr->Parameters.LockControl.ByteOffset = *ByteOffset;
+ StackPtr->Parameters.LockControl.Key = Key ? *Key : 0;
+
+ IoSetCompletionRoutine(Irp,
+ IopLockFileCompletionRoutine,
+ LocalLength,
+ TRUE,
+ TRUE,
+ TRUE);
+
+ /* Can't touch FileObject after IoCallDriver since it might be freed */
+ Status = IofCallDriver(DeviceObject, Irp);
+ if (Status == STATUS_PENDING && (FileObject->Flags & FO_SYNCHRONOUS_IO))
+ {
+ Status = KeWaitForSingleObject(Event,
+ Executive,
+ PreviousMode,
+ FileObject->Flags & FO_ALERTABLE_IO,
+ NULL);
+
+ if (Status != STATUS_WAIT_0)
+ {
+ DPRINT1("NtLockFile -> KeWaitForSingleObject failed!\n");
+ /*
+ * FIXME: Should do some special processing here if alertable wait
+ * was interupted by user apc or a thread alert (STATUS_ALERTED, STATUS_USER_APC)
+ */
+ return Status; /* Set status to something else? */
+ }
+
+ Status = IoStatusBlock->Status;
+ }
+
+ return Status;
+
+fail:;
+ if (LocalLength)
+ ExFreePool(LocalLength);
+
+ if (Irp)
+ IoFreeIrp(Irp);
+
+ if (Event)
+ ObDereferenceObject(Event);
+
+ if (FileObject)
+ ObDereferenceObject(FileObject);
+
+ return Status;
}
-
-
/*
* @unimplemented
*/
STDCALL
NtUnlockFile (
IN HANDLE FileHandle,
- OUT PIO_STATUS_BLOCK UserIoStatusBlock,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
IN PLARGE_INTEGER ByteOffset,
IN PLARGE_INTEGER Length,
- OUT PULONG Key OPTIONAL
+ OUT PULONG Key OPTIONAL
)
{
- NTSTATUS Status;
- PFILE_OBJECT FileObject = NULL;
- PLARGE_INTEGER LocalLength = NULL;
- PIRP Irp = NULL;
- PEXTENDED_IO_STACK_LOCATION StackPtr;
- IO_STATUS_BLOCK LocalIoStatusBlock;
- PDEVICE_OBJECT DeviceObject;
-
- //FIXME: instead of this, use SEH when available
- if (!Length || !ByteOffset) {
- Status = STATUS_INVALID_PARAMETER;
- goto fail;
- }
-
- /*
- BUGBUG: ObReferenceObjectByHandle fails if DesiredAccess=0 and mode=UserMode
- It should ONLY fail if we desire an access that conflict with granted access!
- */
- Status = ObReferenceObjectByHandle(
- FileHandle,
- FILE_READ_DATA,//BUGBUG: have to use something...but shouldn't have to!
+ PFILE_OBJECT FileObject = NULL;
+ PLARGE_INTEGER LocalLength = NULL;
+ PIRP Irp = NULL;
+ PEXTENDED_IO_STACK_LOCATION StackPtr;
+ PDEVICE_OBJECT DeviceObject;
+ KPROCESSOR_MODE PreviousMode;
+ NTSTATUS Status;
+
+ // FIXME: instead of this, use SEH when available
+ if (!Length || !ByteOffset)
+ {
+ Status = STATUS_INVALID_PARAMETER;
+ goto fail;
+ }
+
+ PreviousMode = ExGetPreviousMode();
+
+ /*
+ * BUGBUG: ObReferenceObjectByHandle fails if DesiredAccess=0 and mode=UserMode
+ * It should ONLY fail if we desire an access that conflict with granted access!
+ */
+ Status = ObReferenceObjectByHandle(FileHandle,
+ 0, //FILE_READ_DATA,//BUGBUG: have to use something...but shouldn't have to!
IoFileObjectType,
- ExGetPreviousMode(),
+ PreviousMode,
(PVOID*)&FileObject,
NULL);
-
- if (!NT_SUCCESS(Status)){
- goto fail;
- }
-
- DeviceObject = IoGetRelatedDeviceObject(FileObject);
-
- Irp = IoAllocateIrp(
- DeviceObject->StackSize,
- TRUE
- );
-
- if (Irp == NULL) {
- Status = STATUS_INSUFFICIENT_RESOURCES;
- goto fail;
- }
-
- //trigger FileObject/Event dereferencing
- Irp->Tail.Overlay.OriginalFileObject = FileObject;
-
- Irp->UserIosb = &LocalIoStatusBlock;
- Irp->Tail.Overlay.Thread = PsGetCurrentThread();
-
- StackPtr = (PEXTENDED_IO_STACK_LOCATION) IoGetNextIrpStackLocation(Irp);
- StackPtr->MajorFunction = IRP_MJ_LOCK_CONTROL;
- StackPtr->MinorFunction = IRP_MN_UNLOCK_SINGLE;
- StackPtr->DeviceObject = DeviceObject;
- StackPtr->FileObject = FileObject;
-
- LocalLength = ExAllocatePoolWithTag(
- NonPagedPool,
- sizeof(LARGE_INTEGER),
- TAG_LOCK
- );
- if (!LocalLength){
- Status = STATUS_INSUFFICIENT_RESOURCES;
- goto fail;
- }
-
- *LocalLength = *Length;
-
- StackPtr->Parameters.LockControl.Length = LocalLength;
- StackPtr->Parameters.LockControl.ByteOffset = *ByteOffset;
- StackPtr->Parameters.LockControl.Key = Key ? *Key : 0;
-
- //allways syncronious
- Status = IofCallDriver(DeviceObject, Irp);
-
- *UserIoStatusBlock = LocalIoStatusBlock;
-
- ExFreePool(LocalLength);
-
- return Status;
-
- fail:;
-
- if (LocalLength) ExFreePool(LocalLength);
- if (Irp) IoFreeIrp(Irp);
- if (FileObject) ObDereferenceObject(FileObject);
-
- return Status;
+ if (!NT_SUCCESS(Status))
+ {
+ goto fail;
+ }
+
+ DeviceObject = IoGetRelatedDeviceObject(FileObject);
+
+ Irp = IoAllocateIrp(DeviceObject->StackSize,
+ TRUE);
+ if (Irp == NULL)
+ {
+ Status = STATUS_INSUFFICIENT_RESOURCES;
+ goto fail;
+ }
+
+ /* Trigger FileObject/Event dereferencing */
+ Irp->Tail.Overlay.OriginalFileObject = FileObject;
+ Irp->RequestorMode = PreviousMode;
+ Irp->UserIosb = IoStatusBlock;
+ Irp->Tail.Overlay.Thread = PsGetCurrentThread();
+
+ StackPtr = (PEXTENDED_IO_STACK_LOCATION) IoGetNextIrpStackLocation(Irp);
+ StackPtr->MajorFunction = IRP_MJ_LOCK_CONTROL;
+ StackPtr->MinorFunction = IRP_MN_UNLOCK_SINGLE;
+ StackPtr->DeviceObject = DeviceObject;
+ StackPtr->FileObject = FileObject;
+
+ LocalLength = ExAllocatePoolWithTag(NonPagedPool,
+ sizeof(LARGE_INTEGER),
+ TAG_LOCK);
+ if (!LocalLength)
+ {
+ Status = STATUS_INSUFFICIENT_RESOURCES;
+ goto fail;
+ }
+
+ *LocalLength = *Length;
+
+ StackPtr->Parameters.LockControl.Length = LocalLength;
+ StackPtr->Parameters.LockControl.ByteOffset = *ByteOffset;
+ StackPtr->Parameters.LockControl.Key = Key ? *Key : 0;
+
+ /* Allways synchronous */
+ Status = IofCallDriver(DeviceObject, Irp);
+
+ ExFreePool(LocalLength);
+
+ return Status;
+
+fail:;
+ if (LocalLength)
+ ExFreePool(LocalLength);
+
+ if (Irp)
+ IoFreeIrp(Irp);
+
+ if (FileObject)
+ ObDereferenceObject(FileObject);
+
+ return Status;
}
-/* $Id: rw.c,v 1.51 2003/11/30 19:59:41 gdalsnes Exp $
+/* $Id: rw.c,v 1.52 2003/12/13 14:36:42 ekohl Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
OUT PIO_STATUS_BLOCK IoStatusBlock,
OUT PVOID Buffer,
IN ULONG Length,
- IN PLARGE_INTEGER ByteOffset OPTIONAL, /* NOT optional for asynch. operations! */
+ IN PLARGE_INTEGER ByteOffset OPTIONAL, /* NOT optional for asynch. operations! */
IN PULONG Key OPTIONAL)
{
NTSTATUS Status;
PFILE_OBJECT FileObject;
PIRP Irp;
PIO_STACK_LOCATION StackPtr;
+ KPROCESSOR_MODE PreviousMode;
PKEVENT EventObject = NULL;
DPRINT("NtReadFile(FileHandle %x Buffer %x Length %x ByteOffset %x, "
if (IoStatusBlock == NULL)
return STATUS_ACCESS_VIOLATION;
+ PreviousMode = ExGetPreviousMode();
+
Status = ObReferenceObjectByHandle(FileHandle,
FILE_READ_DATA,
IoFileObjectType,
- UserMode,
+ PreviousMode,
(PVOID*)&FileObject,
NULL);
if (!NT_SUCCESS(Status))
Status = ObReferenceObjectByHandle(Event,
SYNCHRONIZE,
ExEventObjectType,
- UserMode,
+ PreviousMode,
(PVOID*)&EventObject,
NULL);
if (!NT_SUCCESS(Status))
Length,
ByteOffset,
EventObject,
- IoStatusBlock);
+ IoStatusBlock);
/* Trigger FileObject/Event dereferencing */
Irp->Tail.Overlay.OriginalFileObject = FileObject;
+ Irp->RequestorMode = PreviousMode;
+
Irp->Overlay.AsynchronousParameters.UserApcRoutine = ApcRoutine;
Irp->Overlay.AsynchronousParameters.UserApcContext = ApcContext;
Status = IoCallDriver(FileObject->DeviceObject, Irp);
if (Status == STATUS_PENDING && (FileObject->Flags & FO_SYNCHRONOUS_IO))
- {
+ {
Status = KeWaitForSingleObject (&FileObject->Event,
Executive,
- UserMode,
- FileObject->Flags & FO_ALERTABLE_IO,
+ PreviousMode,
+ FileObject->Flags & FO_ALERTABLE_IO,
NULL);
+
if (Status != STATUS_WAIT_0)
{
/* Wait failed. */
return(Status);
}
- Status = IoStatusBlock->Status;
+ Status = IoStatusBlock->Status;
}
return Status;
OUT PIO_STATUS_BLOCK IoStatusBlock,
IN PVOID Buffer,
IN ULONG Length,
- IN PLARGE_INTEGER ByteOffset OPTIONAL, /* NOT optional for asynch. operations! */
+ IN PLARGE_INTEGER ByteOffset OPTIONAL, /* NOT optional for asynch. operations! */
IN PULONG Key OPTIONAL)
{
NTSTATUS Status;
PFILE_OBJECT FileObject;
PIRP Irp;
PIO_STACK_LOCATION StackPtr;
+ KPROCESSOR_MODE PreviousMode;
PKEVENT EventObject = NULL;
DPRINT("NtWriteFile(FileHandle %x Buffer %x Length %x ByteOffset %x, "
if (IoStatusBlock == NULL)
return STATUS_ACCESS_VIOLATION;
+ PreviousMode = ExGetPreviousMode();
+
Status = ObReferenceObjectByHandle(FileHandle,
FILE_WRITE_DATA,
IoFileObjectType,
- UserMode,
+ PreviousMode,
(PVOID*)&FileObject,
NULL);
if (!NT_SUCCESS(Status))
Status = ObReferenceObjectByHandle(Event,
SYNCHRONIZE,
ExEventObjectType,
- UserMode,
+ PreviousMode,
(PVOID*)&EventObject,
NULL);
/* Trigger FileObject/Event dereferencing */
Irp->Tail.Overlay.OriginalFileObject = FileObject;
+ Irp->RequestorMode = PreviousMode;
+
Irp->Overlay.AsynchronousParameters.UserApcRoutine = ApcRoutine;
Irp->Overlay.AsynchronousParameters.UserApcContext = ApcContext;
{
Status = KeWaitForSingleObject (&FileObject->Event,
Executive,
- UserMode,
- FileObject->Flags & FO_ALERTABLE_IO,
+ PreviousMode,
+ FileObject->Flags & FO_ALERTABLE_IO,
NULL);
if (Status != STATUS_WAIT_0)
{
-/* $Id: vpb.c,v 1.23 2003/10/12 17:05:45 hbirr Exp $
+/* $Id: vpb.c,v 1.24 2003/12/13 14:36:42 ekohl Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
}
-/*
- * @implemented
- */
-NTSTATUS STDCALL
-NtQueryVolumeInformationFile(IN HANDLE FileHandle,
- OUT PIO_STATUS_BLOCK IoStatusBlock,
- OUT PVOID FsInformation,
- IN ULONG Length,
- IN FS_INFORMATION_CLASS FsInformationClass)
-
/*
* FUNCTION: Queries the volume information
* ARGUMENTS:
* FileFsMaximumInformation
*
* RETURNS: Status
+ *
+ * @implemented
*/
+
+NTSTATUS STDCALL
+NtQueryVolumeInformationFile(IN HANDLE FileHandle,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
+ OUT PVOID FsInformation,
+ IN ULONG Length,
+ IN FS_INFORMATION_CLASS FsInformationClass)
{
PFILE_OBJECT FileObject;
PDEVICE_OBJECT DeviceObject;
NTSTATUS Status;
PIO_STACK_LOCATION StackPtr;
PVOID SystemBuffer;
- IO_STATUS_BLOCK IoSB;
+ KPROCESSOR_MODE PreviousMode;
assert(IoStatusBlock != NULL);
assert(FsInformation != NULL);
DPRINT("FsInformation %p\n", FsInformation);
-
+
+ PreviousMode = ExGetPreviousMode();
+
Status = ObReferenceObjectByHandle(FileHandle,
FILE_READ_ATTRIBUTES,
IoFileObjectType,
- UserMode,
+ PreviousMode,
(PVOID*)&FileObject,
NULL);
if (!NT_SUCCESS(Status))
return(STATUS_INSUFFICIENT_RESOURCES);
}
- //trigger FileObject/Event dereferencing
+ /* Trigger FileObject/Event dereferencing */
Irp->Tail.Overlay.OriginalFileObject = FileObject;
+ Irp->RequestorMode = PreviousMode;
Irp->AssociatedIrp.SystemBuffer = SystemBuffer;
KeResetEvent( &FileObject->Event );
Irp->UserEvent = &FileObject->Event;
- Irp->UserIosb = &IoSB;
+ Irp->UserIosb = IoStatusBlock;
Irp->Tail.Overlay.Thread = PsGetCurrentThread();
StackPtr = IoGetNextIrpStackLocation(Irp);
{
KeWaitForSingleObject(&FileObject->Event,
UserRequest,
- KernelMode,
+ PreviousMode,
FALSE,
NULL);
- Status = IoSB.Status;
+ Status = IoStatusBlock->Status;
}
DPRINT("Status %x\n", Status);
DPRINT("Information %lu\n", IoStatusBlock->Information);
MmSafeCopyToUser(FsInformation,
SystemBuffer,
- IoSB.Information);
- }
- if (IoStatusBlock)
- {
- *IoStatusBlock = IoSB;
+ IoStatusBlock->Information);
}
+
ExFreePool(SystemBuffer);
return(Status);
return(STATUS_INSUFFICIENT_RESOURCES);
}
- //trigger FileObject/Event dereferencing
+ /* Trigger FileObject/Event dereferencing */
Irp->Tail.Overlay.OriginalFileObject = FileObject;
-
+ Irp->RequestorMode = KernelMode;
Irp->AssociatedIrp.SystemBuffer = FsInformation;
KeResetEvent( &FileObject->Event );
Irp->UserEvent = &FileObject->Event;
NTSTATUS Status;
PEXTENDED_IO_STACK_LOCATION StackPtr;
PVOID SystemBuffer;
- IO_STATUS_BLOCK IoSB;
-
+ KPROCESSOR_MODE PreviousMode;
+
+ assert(IoStatusBlock != NULL);
+ assert(FsInformation != NULL);
+
+ PreviousMode = ExGetPreviousMode();
+
Status = ObReferenceObjectByHandle(FileHandle,
FILE_WRITE_ATTRIBUTES,
NULL,
- UserMode,
+ PreviousMode,
(PVOID*)&FileObject,
NULL);
if (Status != STATUS_SUCCESS)
FsInformation,
Length);
- //trigger FileObject/Event dereferencing
+ /* Trigger FileObject/Event dereferencing */
Irp->Tail.Overlay.OriginalFileObject = FileObject;
-
+ Irp->RequestorMode = PreviousMode;
Irp->AssociatedIrp.SystemBuffer = SystemBuffer;
KeResetEvent( &FileObject->Event );
Irp->UserEvent = &FileObject->Event;
- Irp->UserIosb = &IoSB;
+ Irp->UserIosb = IoStatusBlock;
Irp->Tail.Overlay.Thread = PsGetCurrentThread();
StackPtr = (PEXTENDED_IO_STACK_LOCATION) IoGetNextIrpStackLocation(Irp);
{
KeWaitForSingleObject(&FileObject->Event,
UserRequest,
- KernelMode,
+ PreviousMode,
FALSE,
NULL);
- Status = IoSB.Status;
+ Status = IoStatusBlock->Status;
}
- if (IoStatusBlock)
- {
- *IoStatusBlock = IoSB;
- }
+
ExFreePool(SystemBuffer);
return(Status);
projects / reactos.git / commitdiff