able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/ntos/io/iomgr/qsinfo.c

1777 lines
57 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1989-1993 Microsoft Corporation
Module Name:
qsinfo.c
Abstract:
This module contains the code to implement the NtQueryInformationFile and
NtSetInformationFile system services for the NT I/O system.
Author:
Darryl E. Havens (darrylh) 6-Jun-1989
Environment:
Kernel mode only
Revision History:
--*/
#include "iomgr.h"
//
// Create local definitions for long flag names to make code slightly more
// readable.
//
#define FSIO_A FILE_SYNCHRONOUS_IO_ALERT
#define FSIO_NA FILE_SYNCHRONOUS_IO_NONALERT
//
// Forward declarations of local routines.
//
ULONG
IopGetModeInformation(
IN PFILE_OBJECT FileObject
);
#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE, IopGetModeInformation)
#pragma alloc_text(PAGE, NtQueryInformationFile)
#pragma alloc_text(PAGE, NtSetInformationFile)
#endif
ULONG
IopGetModeInformation(
IN PFILE_OBJECT FileObject
)
/*++
Routine Description:
This encapsulates extracting and translating the mode bits from
the passed file object, to be returned from a query information call.
Arguments:
FileObject - Specifies the file object for which to return Mode info.
Return Value:
The translated mode information is returned.
--*/
{
ULONG mode = 0;
if (FileObject->Flags & FO_WRITE_THROUGH) {
mode = FILE_WRITE_THROUGH;
}
if (FileObject->Flags & FO_SEQUENTIAL_ONLY) {
mode |= FILE_SEQUENTIAL_ONLY;
}
if (FileObject->Flags & FO_NO_INTERMEDIATE_BUFFERING) {
mode |= FILE_NO_INTERMEDIATE_BUFFERING;
}
if (FileObject->Flags & FO_SYNCHRONOUS_IO) {
if (FileObject->Flags & FO_ALERTABLE_IO) {
mode |= FILE_SYNCHRONOUS_IO_ALERT;
} else {
mode |= FILE_SYNCHRONOUS_IO_NONALERT;
}
}
if (FileObject->Flags & FO_DELETE_ON_CLOSE) {
mode |= FILE_DELETE_ON_CLOSE;
}
return mode;
}
NTSTATUS
NtQueryInformationFile(
IN HANDLE FileHandle,
OUT PIO_STATUS_BLOCK IoStatusBlock,
OUT PVOID FileInformation,
IN ULONG Length,
IN FILE_INFORMATION_CLASS FileInformationClass
)
/*++
Routine Description:
This service returns the requested information about a specified file.
The information returned is determined by the FileInformationClass that
is specified, and it is placed into the caller's FileInformation buffer.
Arguments:
FileHandle - Supplies a handle to the file about which the requested
information should be returned.
IoStatusBlock - Address of the caller's I/O status block.
FileInformation - Supplies a buffer to receive the requested information
returned about the file.
Length - Supplies the length, in bytes, of the FileInformation buffer.
FileInformationClass - Specifies the type of information which should be
returned about the file.
Return Value:
The status returned is the final completion status of the operation.
--*/
{
PIRP irp;
NTSTATUS status;
PFILE_OBJECT fileObject;
PDEVICE_OBJECT deviceObject;
PFAST_IO_DISPATCH fastIoDispatch;
PKEVENT event = (PKEVENT) NULL;
KPROCESSOR_MODE requestorMode;
PIO_STACK_LOCATION irpSp;
IO_STATUS_BLOCK localIoStatus;
OBJECT_HANDLE_INFORMATION handleInformation;
BOOLEAN synchronousIo;
BOOLEAN skipDriver;
PETHREAD CurrentThread;
PAGED_CODE();
//
// Get the previous mode; i.e., the mode of the caller.
//
CurrentThread = PsGetCurrentThread ();
requestorMode = KeGetPreviousModeByThread(&CurrentThread->Tcb);
if (requestorMode != KernelMode) {
//
// Ensure that the FileInformationClass parameter is legal for querying
// information about the file.
//
if ((ULONG) FileInformationClass >= FileMaximumInformation ||
!IopQueryOperationLength[FileInformationClass]) {
return STATUS_INVALID_INFO_CLASS;
}
//
// Ensure that the supplied buffer is large enough to contain the
// information associated with the specified set operation that is
// to be performed.
//
if (Length < (ULONG) IopQueryOperationLength[FileInformationClass]) {
return STATUS_INFO_LENGTH_MISMATCH;
}
//
// The caller's access mode is not kernel so probe each of the arguments
// and capture them as necessary. If any failures occur, the condition
// handler will be invoked to handle them. It will simply cleanup and
// return an access violation status code back to the system service
// dispatcher.
//
try {
//
// The IoStatusBlock parameter must be writeable by the caller.
//
ProbeForWriteIoStatus( IoStatusBlock );
//
// The FileInformation buffer must be writeable by the caller.
//
#if defined(_X86_)
ProbeForWrite( FileInformation, Length, sizeof( ULONG ) );
#elif defined(_WIN64)
//
// If we are a wow64 process, follow the X86 rules
//
if (PsGetCurrentProcessByThread(CurrentThread)->Wow64Process) {
ProbeForWrite( FileInformation, Length, sizeof( ULONG ) );
} else {
ProbeForWrite( FileInformation,
Length,
IopQuerySetAlignmentRequirement[FileInformationClass] );
}
#else
ProbeForWrite( FileInformation,
Length,
IopQuerySetAlignmentRequirement[FileInformationClass] );
#endif
} except(EXCEPTION_EXECUTE_HANDLER) {
//
// An exception was incurred while probing the caller's
// parameters. Simply return an appropriate error status
// code.
//
return GetExceptionCode();
}
#if DBG
} else {
//
// The caller's mode is kernel. Ensure that at least the information
// class and lengths are appropriate.
//
if ((ULONG) FileInformationClass >= FileMaximumInformation ||
!IopQueryOperationLength[FileInformationClass]) {
return STATUS_INVALID_INFO_CLASS;
}
if (Length < (ULONG) IopQueryOperationLength[FileInformationClass]) {
return STATUS_INFO_LENGTH_MISMATCH;
}
#endif // DBG
}
//
// There were no blatant errors so far, so reference the file object so
// the target device object can be found. Note that if the handle does
// not refer to a file object, or if the caller does not have the required
// access to the file, then it will fail.
//
status = ObReferenceObjectByHandle( FileHandle,
IopQueryOperationAccess[FileInformationClass],
IoFileObjectType,
requestorMode,
(PVOID *) &fileObject,
&handleInformation);
if (!NT_SUCCESS( status )) {
return status;
}
//
// Get the address of the target device object. If this file represents
// a device that was opened directly, then simply use the device or its
// attached device(s) directly. Also get the address of the Fast Io
// dispatch structure.
//
if (!(fileObject->Flags & FO_DIRECT_DEVICE_OPEN)) {
deviceObject = IoGetRelatedDeviceObject( fileObject );
} else {
deviceObject = IoGetAttachedDevice( fileObject->DeviceObject );
}
fastIoDispatch = deviceObject->DriverObject->FastIoDispatch;
//
// Make a special check here to determine whether this is a synchronous
// I/O operation. If it is, then wait here until the file is owned by
// the current thread. If this is not a (serialized) synchronous I/O
// operation, then allocate and initialize the local event.
//
if (fileObject->Flags & FO_SYNCHRONOUS_IO) {
BOOLEAN interrupted;
if (!IopAcquireFastLock( fileObject )) {
status = IopAcquireFileObjectLock( fileObject,
requestorMode,
(BOOLEAN) ((fileObject->Flags & FO_ALERTABLE_IO) != 0),
&interrupted );
if (interrupted) {
ObDereferenceObject( fileObject );
return status;
}
}
//
// Make a special check here to determine whether or not the caller
// is attempting to query the file position pointer. If so, then
// return it immediately and get out.
//
if (FileInformationClass == FilePositionInformation) {
//
// The caller has requested the current file position context
// information. This is a relatively frequent call, so it is
// optimized here to cut through the normal IRP path.
//
// Begin by establishing a condition handler and attempting to
// return both the file position information as well as the I/O
// status block. If writing the output buffer fails, then return
// an appropriate error status code. If writing the I/O status
// block fails, then ignore the error. This is what would
// normally happen were everything to go through normal special
// kernel APC processing.
//
BOOLEAN writingBuffer = TRUE;
PFILE_POSITION_INFORMATION fileInformation = FileInformation;
try {
//
// Return the current position information.
//
fileInformation->CurrentByteOffset = fileObject->CurrentByteOffset;
writingBuffer = FALSE;
//
// Write the I/O status block.
//
IoStatusBlock->Status = STATUS_SUCCESS;
IoStatusBlock->Information = sizeof( FILE_POSITION_INFORMATION );
} except( EXCEPTION_EXECUTE_HANDLER ) {
//
// One of writing the caller's buffer or writing the I/O
// status block failed. Set the final status appropriately.
//
if (writingBuffer) {
status = GetExceptionCode();
}
}
//
// Note that the state of the event in the file object has not yet
// been reset, so it need not be set either. Therefore, simply
// cleanup and return.
//
IopReleaseFileObjectLock( fileObject );
ObDereferenceObject( fileObject );
return status;
//
// Also do a special check if the caller it doing a query for basic or
// standard information and if so then try the fast query calls if they
// exist.
//
} else if (fastIoDispatch &&
(((FileInformationClass == FileBasicInformation) &&
fastIoDispatch->FastIoQueryBasicInfo) ||
((FileInformationClass == FileStandardInformation) &&
fastIoDispatch->FastIoQueryStandardInfo))) {
IO_STATUS_BLOCK localIoStatus;
BOOLEAN queryResult = FALSE;
BOOLEAN writingStatus = FALSE;
//
// Do the query and setting of the IoStatusBlock inside an exception
// handler. Note that if an exception occurs, other than writing
// the status back, then the IRP route will be taken. If an error
// occurs attempting to write the status back to the caller's buffer
// then it will be ignored, just as it would be on the long path.
//
try {
if (FileInformationClass == FileBasicInformation) {
queryResult = fastIoDispatch->FastIoQueryBasicInfo( fileObject,
TRUE,
FileInformation,
&localIoStatus,
deviceObject );
} else {
queryResult = fastIoDispatch->FastIoQueryStandardInfo( fileObject,
TRUE,
FileInformation,
&localIoStatus,
deviceObject );
}
if (queryResult) {
status = localIoStatus.Status;
writingStatus = TRUE;
*IoStatusBlock = localIoStatus;
}
} except( EXCEPTION_EXECUTE_HANDLER ) {
//
// If the result of the preceeding block is an exception that
// occurred after the Fast I/O path itself, then the query
// actually succeeded so everything is done already, but the
// user's I/O status buffer is not writable. This case is
// ignored to be consistent w/the long path.
//
if (!writingStatus) {
status = GetExceptionCode();
}
}
//
// If the results of the preceeding statement block is true, then
// the fast query call succeeeded, so simply cleanup and return.
//
if (queryResult) {
//
// Note that once again, the event in the file object has not
// yet been set reset, so it need not be set to the Signaled
// state, so simply cleanup and return.
//
IopReleaseFileObjectLock( fileObject );
ObDereferenceObject( fileObject );
return status;
}
}
synchronousIo = TRUE;
} else {
//
// This is a synchronous API being invoked for a file that is opened
// for asynchronous I/O. This means that this system service is
// to synchronize the completion of the operation before returning
// to the caller. A local event is used to do this.
//
event = ExAllocatePool( NonPagedPool, sizeof( KEVENT ) );
if (event == NULL) {
ObDereferenceObject( fileObject );
return STATUS_INSUFFICIENT_RESOURCES;
}
KeInitializeEvent( event, SynchronizationEvent, FALSE );
synchronousIo = FALSE;
}
//
// Set the file object to the Not-Signaled state.
//
KeClearEvent( &fileObject->Event );
//
// Allocate and initialize the I/O Request Packet (IRP) for this operation.
// The allocation is performed with an exception handler in case the
// caller does not have enough quota to allocate the packet.
//
irp = IoAllocateIrp( deviceObject->StackSize, TRUE );
if (!irp) {
//
// An IRP could not be allocated. Cleanup and return an appropriate
// error status code.
//
if (!(fileObject->Flags & FO_SYNCHRONOUS_IO)) {
ExFreePool( event );
}
IopAllocateIrpCleanup( fileObject, (PKEVENT) NULL );
return STATUS_INSUFFICIENT_RESOURCES;
}
irp->Tail.Overlay.OriginalFileObject = fileObject;
irp->Tail.Overlay.Thread = CurrentThread;
irp->RequestorMode = requestorMode;
//
// Fill in the service independent parameters in the IRP.
//
if (synchronousIo) {
irp->UserEvent = (PKEVENT) NULL;
irp->UserIosb = IoStatusBlock;
} else {
irp->UserEvent = event;
irp->UserIosb = &localIoStatus;
irp->Flags = IRP_SYNCHRONOUS_API;
}
irp->Overlay.AsynchronousParameters.UserApcRoutine = (PIO_APC_ROUTINE) NULL;
//
// Get a pointer to the stack location for the first driver. This will be
// used to pass the original function codes and parameters.
//
irpSp = IoGetNextIrpStackLocation( irp );
irpSp->MajorFunction = IRP_MJ_QUERY_INFORMATION;
irpSp->FileObject = fileObject;
//
// Allocate a buffer which should be used to put the information into by
// the driver. This will be copied back to the caller's buffer when the
// service completes. This is done by setting the flag which says that
// this is an input operation.
//
irp->UserBuffer = FileInformation;
irp->AssociatedIrp.SystemBuffer = (PVOID) NULL;
irp->MdlAddress = (PMDL) NULL;
try {
//
// Allocate the system buffer using an exception handler so that
// errors can be caught and handled.
//
irp->AssociatedIrp.SystemBuffer = ExAllocatePoolWithQuota( NonPagedPool,
Length );
} except(EXCEPTION_EXECUTE_HANDLER) {
//
// An exception was incurred by attempting to allocate the intermediary
// system buffer. Cleanup everything and return an appropriate error
// status code.
//
IopExceptionCleanup( fileObject,
irp,
(PKEVENT) NULL,
event );
return GetExceptionCode();
}
irp->Flags |= IRP_BUFFERED_IO |
IRP_DEALLOCATE_BUFFER |
IRP_INPUT_OPERATION |
IRP_DEFER_IO_COMPLETION;
//
// Copy the caller's parameters to the service-specific portion of the
// IRP.
//
irpSp->Parameters.QueryFile.Length = Length;
irpSp->Parameters.QueryFile.FileInformationClass = FileInformationClass;
//
// Insert the packet at the head of the IRP list for the thread.
//
IopQueueThreadIrp( irp );
//
// Update the operation count statistic for the current process for
// operations other than read and write.
//
IopUpdateOtherOperationCount();
//
// Everything is now set to invoke the device driver with this request.
// However, it is possible that the information that the caller wants
// is device independent. If this is the case, then the request can
// be satisfied here without having to have all of the drivers implement
// the same code. Note that having the IRP is still necessary since
// the I/O completion code requires it.
//
skipDriver = FALSE;
if (FileInformationClass == FileAccessInformation) {
PFILE_ACCESS_INFORMATION accessBuffer = irp->AssociatedIrp.SystemBuffer;
//
// Return the access information for this file.
//
accessBuffer->AccessFlags = handleInformation.GrantedAccess;
//
// Complete the I/O operation.
//
irp->IoStatus.Information = sizeof( FILE_ACCESS_INFORMATION );
skipDriver = TRUE;
} else if (FileInformationClass == FileModeInformation) {
PFILE_MODE_INFORMATION modeBuffer = irp->AssociatedIrp.SystemBuffer;
//
// Return the mode information for this file.
//
modeBuffer->Mode = IopGetModeInformation( fileObject );
//
// Complete the I/O operation.
//
irp->IoStatus.Information = sizeof( FILE_MODE_INFORMATION );
skipDriver = TRUE;
} else if (FileInformationClass == FileAlignmentInformation) {
PFILE_ALIGNMENT_INFORMATION alignmentInformation = irp->AssociatedIrp.SystemBuffer;
//
// Return the alignment information for this file.
//
alignmentInformation->AlignmentRequirement = deviceObject->AlignmentRequirement;
//
// Complete the I/O operation.
//
irp->IoStatus.Information = sizeof( FILE_ALIGNMENT_INFORMATION );
skipDriver = TRUE;
} else if (FileInformationClass == FileAllInformation) {
PFILE_ALL_INFORMATION allInformation = irp->AssociatedIrp.SystemBuffer;
//
// The caller has requested all of the information about the file.
// This request is handled specially because the service will fill
// in the Access and Mode and Alignment information in the buffer
// and then pass the buffer to the driver to fill in the remainder.
//
// Begin by returning the Access information for the file.
//
allInformation->AccessInformation.AccessFlags =
handleInformation.GrantedAccess;
//
// Return the mode information for this file.
//
allInformation->ModeInformation.Mode =
IopGetModeInformation( fileObject );
//
// Return the alignment information for this file.
//
allInformation->AlignmentInformation.AlignmentRequirement =
deviceObject->AlignmentRequirement;
//
// Finally, set the information field of the IoStatus block in the IRP
// to account for the amount information already filled in and invoke
// the driver to fill in the remainder.
//
irp->IoStatus.Information = sizeof( FILE_ACCESS_INFORMATION ) +
sizeof( FILE_MODE_INFORMATION ) +
sizeof( FILE_ALIGNMENT_INFORMATION );
}
if (skipDriver) {
//
// The requested operation has already been performed. Simply
// set the final status in the packet and the return state.
//
status = STATUS_SUCCESS;
irp->IoStatus.Status = STATUS_SUCCESS;
} else {
//
// This is not a request that can be [completely] performed here, so
// invoke the driver at its appropriate dispatch entry with the IRP.
//
status = IoCallDriver( deviceObject, irp );
}
//
// If this operation was a synchronous I/O operation, check the return
// status to determine whether or not to wait on the file object. If
// the file object is to be waited on, wait for the operation to complete
// and obtain the final status from the file object itself.
//
if (status == STATUS_PENDING) {
if (synchronousIo) {
status = KeWaitForSingleObject( &fileObject->Event,
Executive,
requestorMode,
(BOOLEAN) ((fileObject->Flags & FO_ALERTABLE_IO) != 0),
(PLARGE_INTEGER) NULL );
if (status == STATUS_ALERTED || status == STATUS_USER_APC) {
//
// The wait request has ended either because the thread was
// alerted or an APC was queued to this thread, because of
// thread rundown or CTRL/C processing. In either case, try
// to bail out of this I/O request carefully so that the IRP
// completes before this routine exists so that synchronization
// with the file object will remain intact.
//
IopCancelAlertedRequest( &fileObject->Event, irp );
}
status = fileObject->FinalStatus;
IopReleaseFileObjectLock( fileObject );
} else {
//
// This is a normal synchronous I/O operation, as opposed to a
// serialized synchronous I/O operation. For this case, wait for
// the local event and copy the final status information back to
// the caller.
//
status = KeWaitForSingleObject( event,
Executive,
requestorMode,
FALSE,
(PLARGE_INTEGER) NULL );
if (status == STATUS_ALERTED || status == STATUS_USER_APC) {
//
// The wait request has ended either because the thread was
// alerted or an APC was queued to this thread, because of
// thread rundown or CTRL/C processing. In either case, try
// to bail out of this I/O request carefully so that the IRP
// completes before this routine exists or the event will not
// be around to set to the Signaled state.
//
IopCancelAlertedRequest( event, irp );
}
status = localIoStatus.Status;
try {
*IoStatusBlock = localIoStatus;
} except(EXCEPTION_EXECUTE_HANDLER) {
//
// An exception occurred attempting to write the caller's I/O
// status block. Simply change the final status of the operation
// to the exception code.
//
status = GetExceptionCode();
}
ExFreePool( event );
}
} else {
//
// The I/O operation finished without return a status of pending.
// This means that the operation has not been through I/O completion,
// so it must be done here.
//
PKNORMAL_ROUTINE normalRoutine;
PVOID normalContext;
KIRQL irql;
if (!synchronousIo) {
//
// This is not a synchronous I/O operation, it is a synchronous
// I/O API to a file opened for asynchronous I/O. Since this
// code path need never wait on the allocated and supplied event,
// get rid of it so that it doesn't have to be set to the
// Signaled state by the I/O completion code.
//
irp->UserEvent = (PKEVENT) NULL;
ExFreePool( event );
}
irp->UserIosb = IoStatusBlock;
KeRaiseIrql( APC_LEVEL, &irql );
IopCompleteRequest( &irp->Tail.Apc,
&normalRoutine,
&normalContext,
(PVOID *) &fileObject,
&normalContext );
KeLowerIrql( irql );
if (synchronousIo) {
IopReleaseFileObjectLock( fileObject );
}
}
return status;
}
NTSTATUS
NtSetInformationFile(
IN HANDLE FileHandle,
OUT PIO_STATUS_BLOCK IoStatusBlock,
IN PVOID FileInformation,
IN ULONG Length,
IN FILE_INFORMATION_CLASS FileInformationClass
)
/*++
Routine Description:
This service changes the provided information about a specified file. The
information that is changed is determined by the FileInformationClass that
is specified. The new information is taken from the FileInformation buffer.
Arguments:
FileHandle - Supplies a handle to the file whose information should be
changed.
IoStatusBlock - Address of the caller's I/O status block.
FileInformation - Supplies a buffer containing the information which should
be changed on the file.
Length - Supplies the length, in bytes, of the FileInformation buffer.
FileInformationClass - Specifies the type of information which should be
changed about the file.
Return Value:
The status returned is the final completion status of the operation.
--*/
{
PIRP irp;
NTSTATUS status;
PFILE_OBJECT fileObject;
PDEVICE_OBJECT deviceObject;
PKEVENT event = (PKEVENT) NULL;
KPROCESSOR_MODE requestorMode;
PIO_STACK_LOCATION irpSp;
IO_STATUS_BLOCK localIoStatus;
HANDLE targetHandle = (HANDLE) NULL;
BOOLEAN synchronousIo;
PETHREAD CurrentThread;
PAGED_CODE();
//
// Get the previous mode; i.e., the mode of the caller.
//
CurrentThread = PsGetCurrentThread ();
requestorMode = KeGetPreviousModeByThread(&CurrentThread->Tcb);
if (requestorMode != KernelMode) {
//
// Ensure that the FileInformationClass parameter is legal for setting
// information about the file.
//
if ((ULONG) FileInformationClass >= FileMaximumInformation ||
!IopSetOperationLength[FileInformationClass]) {
return STATUS_INVALID_INFO_CLASS;
}
//
// Ensure that the supplied buffer is large enough to contain the
// information associated with the specified set operation that is
// to be performed.
//
if (Length < (ULONG) IopSetOperationLength[FileInformationClass]) {
return STATUS_INFO_LENGTH_MISMATCH;
}
//
// The caller's access mode is user, so probe each of the arguments
// and capture them as necessary. If any failures occur, the condition
// handler will be invoked to handle them. It will simply cleanup and
// return an access violation status code back to the system service
// dispatcher.
//
try {
//
// The IoStatusBlock parameter must be writeable by the caller.
//
ProbeForWriteIoStatus( IoStatusBlock );
//
// The FileInformation buffer must be readable by the caller.
//
#if defined(_X86_)
ProbeForRead( FileInformation,
Length,
Length == sizeof( BOOLEAN ) ? sizeof( BOOLEAN ) : sizeof( ULONG ) );
#elif defined(_WIN64)
// If we are a wow64 process, follow the X86 rules
if (PsGetCurrentProcessByThread(CurrentThread)->Wow64Process) {
ProbeForRead( FileInformation,
Length,
Length == sizeof( BOOLEAN ) ? sizeof( BOOLEAN ) : sizeof( ULONG ) );
}
else {
ProbeForRead( FileInformation,
Length,
IopQuerySetAlignmentRequirement[FileInformationClass] );
}
#else
ProbeForRead( FileInformation,
Length,
IopQuerySetAlignmentRequirement[FileInformationClass] );
#endif
} except(EXCEPTION_EXECUTE_HANDLER) {
//
// An exception was incurred while probing the caller's parameters.
// Simply return an appropriate error status code.
//
return GetExceptionCode();
}
#if DBG
} else {
//
// The caller's mode is kernel. Ensure that at least the information
// class and lengths are appropriate.
//
if ((ULONG) FileInformationClass >= FileMaximumInformation ||
!IopSetOperationLength[FileInformationClass]) {
return STATUS_INVALID_INFO_CLASS;
}
if (Length < (ULONG) IopSetOperationLength[FileInformationClass]) {
return STATUS_INFO_LENGTH_MISMATCH;
}
#endif // DBG
}
//
// There were no blatant errors so far, so reference the file object so
// the target device object can be found. Note that if the handle does
// not refer to a file object, or if the caller does not have the required
// access to the file, then it will fail.
//
status = ObReferenceObjectByHandle( FileHandle,
IopSetOperationAccess[FileInformationClass],
IoFileObjectType,
requestorMode,
(PVOID *) &fileObject,
NULL );
if (!NT_SUCCESS( status )) {
return status;
}
//
// Get the address of the target device object. If this file represents
// a device that was opened directly, then simply use the device or its
// attached device(s) directly.
//
if (!(fileObject->Flags & FO_DIRECT_DEVICE_OPEN)) {
deviceObject = IoGetRelatedDeviceObject( fileObject );
} else {
deviceObject = IoGetAttachedDevice( fileObject->DeviceObject );
}
//
// Make a special check here to determine whether this is a synchronous
// I/O operation. If it is, then wait here until the file is owned by
// the current thread. If this is not a (serialized) synchronous I/O
// operation, then allocate and initialize the local event.
//
if (fileObject->Flags & FO_SYNCHRONOUS_IO) {
BOOLEAN interrupted;
if (!IopAcquireFastLock( fileObject )) {
status = IopAcquireFileObjectLock( fileObject,
requestorMode,
(BOOLEAN) ((fileObject->Flags & FO_ALERTABLE_IO) != 0),
&interrupted );
if (interrupted) {
ObDereferenceObject( fileObject );
return status;
}
}
//
// Make a special check here to determine whether or not the caller
// is attempting to set the file position pointer information. If so,
// then set it immediately and get out.
//
if (FileInformationClass == FilePositionInformation) {
//
// The caller has requested setting the current file position
// context information. This is a relatively frequent call, so
// it is optimized here to cut through the normal IRP path.
//
// Begin by checking to see whether the file was opened with no
// intermediate buffering. If so, then the file pointer must be
// set in a manner consistent with the alignment requirement of
// read and write operations to a non-buffered file.
//
PFILE_POSITION_INFORMATION fileInformation = FileInformation;
LARGE_INTEGER currentByteOffset;
try {
//
// Attempt to read the position information from the buffer.
//
currentByteOffset.QuadPart = fileInformation->CurrentByteOffset.QuadPart;
} except( EXCEPTION_EXECUTE_HANDLER ) {
IopReleaseFileObjectLock( fileObject );
ObDereferenceObject( fileObject );
return GetExceptionCode();
}
if ((fileObject->Flags & FO_NO_INTERMEDIATE_BUFFERING &&
(deviceObject->SectorSize &&
(currentByteOffset.LowPart &
(deviceObject->SectorSize - 1)))) ||
currentByteOffset.HighPart < 0) {
status = STATUS_INVALID_PARAMETER;
} else {
//
// Set the current file position information.
//
fileObject->CurrentByteOffset.QuadPart = currentByteOffset.QuadPart;
try {
//
// Write the I/O status block.
//
IoStatusBlock->Status = STATUS_SUCCESS;
IoStatusBlock->Information = 0;
} except( EXCEPTION_EXECUTE_HANDLER ) {
//
// Writes to I/O status blocks are ignored since the
// operation succeeded.
//
NOTHING;
}
}
//
// Update the transfer count statistic for the current process for
// operations other than read and write.
//
IopUpdateOtherTransferCount( Length );
//
// Note that the file object's event has not yet been reset,
// so it is not necessary to set it to the Signaled state, since
// that is it's state at this point by definition. Therefore,
// simply cleanup and return.
//
IopReleaseFileObjectLock( fileObject );
ObDereferenceObject( fileObject );
return status;
}
synchronousIo = TRUE;
} else {
//
// This is a synchronous API being invoked for a file that is opened
// for asynchronous I/O. This means that this system service is
// to synchronize the completion of the operation before returning
// to the caller. A local event is used to do this.
//
event = ExAllocatePool( NonPagedPool, sizeof( KEVENT ) );
if (event == NULL) {
ObDereferenceObject( fileObject );
return STATUS_INSUFFICIENT_RESOURCES;
}
KeInitializeEvent( event, SynchronizationEvent, FALSE );
synchronousIo = FALSE;
}
//
// Set the file object to the Not-Signaled state.
//
KeClearEvent( &fileObject->Event );
//
// If a link is being tracked, handle this out-of-line.
//
if (FileInformationClass == FileTrackingInformation) {
status = IopTrackLink( fileObject,
&localIoStatus,
FileInformation,
Length,
synchronousIo ? &fileObject->Event : event,
requestorMode );
if (NT_SUCCESS( status )) {
try {
IoStatusBlock->Information = 0;
IoStatusBlock->Status = status;
} except(EXCEPTION_EXECUTE_HANDLER) {
NOTHING;
}
}
if (synchronousIo) {
IopReleaseFileObjectLock( fileObject );
} else {
ExFreePool( event );
}
ObDereferenceObject( fileObject );
return status;
}
//
// Allocate and initialize the I/O Request Packet (IRP) for this operation.
// The allocation is performed with an exception handler in case the
// caller does not have enough quota to allocate the packet.
irp = IoAllocateIrp( deviceObject->StackSize, TRUE );
if (!irp) {
//
// An IRP could not be allocated. Cleanup and return an appropriate
// error status code.
//
if (!(fileObject->Flags & FO_SYNCHRONOUS_IO)) {
ExFreePool( event );
}
IopAllocateIrpCleanup( fileObject, (PKEVENT) NULL );
return STATUS_INSUFFICIENT_RESOURCES;
}
irp->Tail.Overlay.OriginalFileObject = fileObject;
irp->Tail.Overlay.Thread = CurrentThread;
irp->RequestorMode = requestorMode;
//
// Fill in the service independent parameters in the IRP.
//
if (synchronousIo) {
irp->UserEvent = (PKEVENT) NULL;
irp->UserIosb = IoStatusBlock;
} else {
irp->UserEvent = event;
irp->UserIosb = &localIoStatus;
irp->Flags = IRP_SYNCHRONOUS_API;
}
irp->Overlay.AsynchronousParameters.UserApcRoutine = (PIO_APC_ROUTINE) NULL;
//
// Get a pointer to the stack location for the first driver. This will
// be used to pass the original function codes and parameters.
//
irpSp = IoGetNextIrpStackLocation( irp );
irpSp->MajorFunction = IRP_MJ_SET_INFORMATION;
irpSp->FileObject = fileObject;
//
// Allocate a buffer and copy the information that is to be set on the
// file into it. Also, set the flags so that the completion code will
// properly handle getting rid of the buffer and will not attempt to
// copy data.
//
irp->AssociatedIrp.SystemBuffer = (PVOID) NULL;
irp->MdlAddress = (PMDL) NULL;
try {
PVOID systemBuffer;
systemBuffer =
irp->AssociatedIrp.SystemBuffer = ExAllocatePoolWithQuota( NonPagedPool,
Length );
RtlCopyMemory( irp->AssociatedIrp.SystemBuffer,
FileInformation,
Length );
//
// Negative file offsets are illegal.
//
ASSERT((FIELD_OFFSET(FILE_END_OF_FILE_INFORMATION, EndOfFile) |
FIELD_OFFSET(FILE_ALLOCATION_INFORMATION, AllocationSize) |
FIELD_OFFSET(FILE_POSITION_INFORMATION, CurrentByteOffset)) == 0);
if (((FileInformationClass == FileEndOfFileInformation) ||
(FileInformationClass == FileAllocationInformation) ||
(FileInformationClass == FilePositionInformation)) &&
(((PFILE_POSITION_INFORMATION)systemBuffer)->CurrentByteOffset.HighPart < 0)) {
ExRaiseStatus(STATUS_INVALID_PARAMETER);
}
} except(EXCEPTION_EXECUTE_HANDLER) {
//
// An exception was incurred while allocating the intermediary
// system buffer or while copying the caller's data into the
// buffer. Cleanup and return an appropriate error status code.
//
IopExceptionCleanup( fileObject,
irp,
(PKEVENT) NULL,
event );
return GetExceptionCode();
}
irp->Flags |= IRP_BUFFERED_IO | IRP_DEALLOCATE_BUFFER | IRP_DEFER_IO_COMPLETION;
//
// Copy the caller's parameters to the service-specific portion of the
// IRP.
//
irpSp->Parameters.SetFile.Length = Length;
irpSp->Parameters.SetFile.FileInformationClass = FileInformationClass;
//
// Insert the packet at the head of the IRP list for the thread.
//
IopQueueThreadIrp( irp );
//
// Update the operation count statistic for the current process for
// operations other than read and write.
//
IopUpdateOtherOperationCount();
//
// Everything is now set to invoke the device driver with this request.
// However, it is possible that the information that the caller wants
// to set is device independent. If this is the case, then the request
// can be satisfied here without having to have all of the drivers
// implement the same code. Note that having the IRP is still necessary
// since the I/O completion code requires it.
//
if (FileInformationClass == FileModeInformation) {
PFILE_MODE_INFORMATION modeBuffer = irp->AssociatedIrp.SystemBuffer;
//
// Set the various flags in the mode field for the file object, if
// they are reasonable. There are 4 different invalid combinations
// that the caller may not specify:
//
// 1) An invalid flag was set in the mode field. Not all Create/
// Open options may be changed.
//
// 2) The caller set one of the synchronous I/O flags (alert or
// nonalert), but the file is not opened for synchronous I/O.
//
// 3) The file is opened for synchronous I/O but the caller did
// not set either of the synchronous I/O flags (alert or non-
// alert).
//
// 4) The caller set both of the synchronous I/O flags (alert and
// nonalert).
//
if ((modeBuffer->Mode & ~FILE_VALID_SET_FLAGS) ||
((modeBuffer->Mode & (FSIO_A | FSIO_NA)) && (!(fileObject->Flags & FO_SYNCHRONOUS_IO))) ||
((!(modeBuffer->Mode & (FSIO_A | FSIO_NA))) && (fileObject->Flags & FO_SYNCHRONOUS_IO)) ||
(((modeBuffer->Mode & FSIO_A) && (modeBuffer->Mode & FSIO_NA) ))) {
status = STATUS_INVALID_PARAMETER;
} else {
//
// Set or clear the appropriate flags in the file object.
//
if (!(fileObject->Flags & FO_NO_INTERMEDIATE_BUFFERING)) {
if (modeBuffer->Mode & FILE_WRITE_THROUGH) {
fileObject->Flags |= FO_WRITE_THROUGH;
} else {
fileObject->Flags &= ~FO_WRITE_THROUGH;
}
}
if (modeBuffer->Mode & FILE_SEQUENTIAL_ONLY) {
fileObject->Flags |= FO_SEQUENTIAL_ONLY;
} else {
fileObject->Flags &= ~FO_SEQUENTIAL_ONLY;
}
if (fileObject->Flags & FO_SYNCHRONOUS_IO) {
if (modeBuffer->Mode & FSIO_A) {
fileObject->Flags |= FO_ALERTABLE_IO;
} else {
fileObject->Flags &= ~FO_ALERTABLE_IO;
}
}
status = STATUS_SUCCESS;
}
//
// Complete the I/O operation.
//
irp->IoStatus.Status = status;
irp->IoStatus.Information = 0L;
} else if (FileInformationClass == FileRenameInformation ||
FileInformationClass == FileLinkInformation ||
FileInformationClass == FileMoveClusterInformation) {
//
// Note that following code depends on the fact that the rename
// information, link information and copy-on-write information
// structures look exactly the same.
//
PFILE_RENAME_INFORMATION renameBuffer = irp->AssociatedIrp.SystemBuffer;
//
// The information being set is a variable-length structure with
// embedded size information. Walk the structure to ensure that
// it is valid so the driver does not walk off the end and incur
// an access violation in kernel mode.
//
if (renameBuffer->FileNameLength <= 0 || (renameBuffer->FileNameLength & (sizeof(WCHAR) -1))) {
status = STATUS_INVALID_PARAMETER;
irp->IoStatus.Status = status;
} else if ((ULONG) (Length - FIELD_OFFSET( FILE_RENAME_INFORMATION, FileName[0] )) < renameBuffer->FileNameLength) {
status = STATUS_INVALID_PARAMETER;
irp->IoStatus.Status = status;
} else {
//
// Copy the value of the replace BOOLEAN (or the ClusterCount field)
// from the caller's buffer to the I/O stack location parameter
// field where it is expected by file systems.
//
if (FileInformationClass == FileMoveClusterInformation) {
irpSp->Parameters.SetFile.ClusterCount =
((FILE_MOVE_CLUSTER_INFORMATION *) renameBuffer)->ClusterCount;
} else {
irpSp->Parameters.SetFile.ReplaceIfExists = renameBuffer->ReplaceIfExists;
}
//
// Check to see whether or not a fully qualified pathname was
// supplied. If so, then more processing is required.
//
if (renameBuffer->FileName[0] == (WCHAR) OBJ_NAME_PATH_SEPARATOR ||
renameBuffer->RootDirectory) {
//
// A fully qualified file name was specified as the target of
// the rename operation. Attempt to open the target file and
// ensure that the replacement policy for the file is consistent
// with the caller's request, and ensure that the file is on the
// same volume.
//
status = IopOpenLinkOrRenameTarget( &targetHandle,
irp,
renameBuffer,
fileObject );
if (!NT_SUCCESS( status )) {
irp->IoStatus.Status = status;
} else {
//
// The fully qualified file name specifies a file on the
// same volume and if it exists, then the caller specified
// that it should be replaced.
//
status = IoCallDriver( deviceObject, irp );
}
} else {
//
// This is a simple rename operation, so call the driver and
// let it perform the rename operation within the same directory
// as the source file.
//
status = IoCallDriver( deviceObject, irp );
}
}
} else if (FileInformationClass == FileShortNameInformation) {
PFILE_NAME_INFORMATION shortnameBuffer = irp->AssociatedIrp.SystemBuffer;
//
// The information being set is a variable-length structure with
// embedded size information. Walk the structure to ensure that
// it is valid so the driver does not walk off the end and incur
// an access violation in kernel mode.
//
if (shortnameBuffer->FileNameLength <= 0) {
status = STATUS_INVALID_PARAMETER;
irp->IoStatus.Status = status;
} else if ((ULONG) (Length - FIELD_OFFSET( FILE_NAME_INFORMATION, FileName[0] )) < shortnameBuffer->FileNameLength) {
status = STATUS_INVALID_PARAMETER;
irp->IoStatus.Status = status;
//
// The short name must not begin with a separator character.
//
} else if (shortnameBuffer->FileName[0] == (WCHAR) OBJ_NAME_PATH_SEPARATOR) {
status = STATUS_INVALID_PARAMETER;
irp->IoStatus.Status = status;
//
// Pass the request to the driver below.
//
} else {
status = IoCallDriver( deviceObject, irp );
}
} else if (FileInformationClass == FileDispositionInformation) {
PFILE_DISPOSITION_INFORMATION disposition = irp->AssociatedIrp.SystemBuffer;
//
// Check to see whether the disposition delete field has been set to
// TRUE and, if so, copy the handle being used to do this to the IRP
// stack location parameter.
//
if (disposition->DeleteFile) {
irpSp->Parameters.SetFile.DeleteHandle = FileHandle;
}
//
// Simply invoke the driver to perform the (un)delete operation.
//
status = IoCallDriver( deviceObject, irp );
} else if (FileInformationClass == FileCompletionInformation) {
PFILE_COMPLETION_INFORMATION completion = irp->AssociatedIrp.SystemBuffer;
PIO_COMPLETION_CONTEXT context;
PVOID portObject;
//
// It is an error if this file object already has an LPC port associated
// with it.
//
if (fileObject->CompletionContext || fileObject->Flags & FO_SYNCHRONOUS_IO) {
status = STATUS_INVALID_PARAMETER;
} else {
//
// Attempt to reference the port object by its handle and convert it
// into a pointer to the port object itself.
//
status = ObReferenceObjectByHandle( completion->Port,
IO_COMPLETION_MODIFY_STATE,
IoCompletionObjectType,
requestorMode,
(PVOID *) &portObject,
NULL );
if (NT_SUCCESS( status )) {
//
// Allocate the memory to be associated w/this file object
//
context = ExAllocatePoolWithTag( PagedPool,
sizeof( IO_COMPLETION_CONTEXT ),
'cCoI' );
if (!context) {
ObDereferenceObject( portObject );
status = STATUS_INSUFFICIENT_RESOURCES;
} else {
//
// Everything was successful. Capture the completion port
// and the key.
//
context->Port = portObject;
context->Key = completion->Key;
if (!InterlockedCompareExchangePointer( &fileObject->CompletionContext, context, NULL )) {
status = STATUS_SUCCESS;
} else {
//
// Someone set the completion context after the check.
// Simply drop everything on the floor and return an
// error.
//
ExFreePool( context );
ObDereferenceObject( portObject );
status = STATUS_INVALID_PARAMETER;
}
}
}
}
//
// Complete the I/O operation.
//
irp->IoStatus.Status = status;
irp->IoStatus.Information = 0;
} else {
//
// This is not a request that can be performed here, so invoke the
// driver at its appropriate dispatch entry with the IRP.
//
status = IoCallDriver( deviceObject, irp );
}
//
// If this operation was a synchronous I/O operation, check the return
// status to determine whether or not to wait on the file object. If
// the file object is to be waited on, wait for the operation to complete
// and obtain the final status from the file object itself.
//
if (status == STATUS_PENDING) {
if (synchronousIo) {
status = KeWaitForSingleObject( &fileObject->Event,
Executive,
requestorMode,
(BOOLEAN) ((fileObject->Flags & FO_ALERTABLE_IO) != 0),
(PLARGE_INTEGER) NULL );
if (status == STATUS_ALERTED || status == STATUS_USER_APC) {
//
// The wait request has ended either because the thread was
// alerted or an APC was queued to this thread, because of
// thread rundown or CTRL/C processing. In either case, try
// to bail out of this I/O request carefully so that the IRP
// completes before this routine exists so that synchronization
// with the file object will remain intact.
//
IopCancelAlertedRequest( &fileObject->Event, irp );
}
status = fileObject->FinalStatus;
IopReleaseFileObjectLock( fileObject );
} else {
//
// This is a normal synchronous I/O operation, as opposed to a
// serialized synchronous I/O operation. For this case, wait for
// the local event and copy the final status information back to
// the caller.
//
status = KeWaitForSingleObject( event,
Executive,
requestorMode,
FALSE,
(PLARGE_INTEGER) NULL );
if (status == STATUS_ALERTED || status == STATUS_USER_APC) {
//
// The wait request has ended either because the thread was
// alerted or an APC was queued to this thread, because of
// thread rundown or CTRL/C processing. In either case, try
// to bail out of this I/O request carefully so that the IRP
// completes before this routine exists or the event will not
// be around to set to the Signaled state.
//
IopCancelAlertedRequest( event, irp );
}
status = localIoStatus.Status;
try {
*IoStatusBlock = localIoStatus;
} except(EXCEPTION_EXECUTE_HANDLER) {
//
// An exception occurred attempting to write the caller's I/O
// status block. Simply change the final status of the
// operation to the exception code.
//
status = GetExceptionCode();
}
ExFreePool( event );
}
} else {
//
// The I/O operation finished without return a status of pending.
// This means that the operation has not been through I/O completion,
// so it must be done here.
//
PKNORMAL_ROUTINE normalRoutine;
PVOID normalContext;
KIRQL irql;
if (!synchronousIo) {
//
// This is not a synchronous I/O operation, it is a synchronous
// I/O API to a file opened for asynchronous I/O. Since this
// code path need never wait on the allocated and supplied event,
// get rid of it so that it doesn't have to be set to the
// Signaled state by the I/O completion code.
//
irp->UserEvent = (PKEVENT) NULL;
ExFreePool( event );
}
irp->UserIosb = IoStatusBlock;
KeRaiseIrql( APC_LEVEL, &irql );
IopCompleteRequest( &irp->Tail.Apc,
&normalRoutine,
&normalContext,
(PVOID *) &fileObject,
&normalContext );
KeLowerIrql( irql );
if (synchronousIo) {
IopReleaseFileObjectLock( fileObject );
}
}
//
// If there was a target handle generated because of a rename operation,
// close it now.
//
if (targetHandle) {
ObCloseHandle( targetHandle, KernelMode );
}
return status;
}
Reference in a new issue Copy permalink