NTSTATUS
NTAPI
FatiRead(PFAT_IRP_CONTEXT IrpContext)
{
ULONG NumberOfBytes;
LARGE_INTEGER ByteOffset;
PFILE_OBJECT FileObject;
TYPE_OF_OPEN OpenType;
PIO_STACK_LOCATION IrpSp = IrpContext->Stack;
PFCB Fcb;
PVCB Vcb;
PCCB Ccb;
PVOID Buffer;
LONG BytesRead;
FileObject = IrpSp->FileObject;
NumberOfBytes = IrpSp->Parameters.Read.Length;
ByteOffset = IrpSp->Parameters.Read.ByteOffset;
if (NumberOfBytes == 0)
{
FatCompleteRequest(IrpContext, IrpContext->Irp, STATUS_SUCCESS);
return STATUS_SUCCESS;
}
OpenType = FatDecodeFileObject(FileObject, &Vcb, &Fcb, &Ccb);
DPRINT("FatiRead() Fcb %p, Name %wZ, Offset %d, Length %d, Handle %p\n",
Fcb, &FileObject->FileName, ByteOffset.LowPart, NumberOfBytes, Fcb->FatHandle);
/* Perform actual read */
if (IrpContext->MinorFunction & IRP_MN_MDL)
{
DPRINT1("MDL read\n");
}
else
{
Buffer = FatMapUserBuffer(IrpContext->Irp);
DPRINT("Normal cached read, buffer %p\n");
/* Set offset */
FF_Seek(Fcb->FatHandle, ByteOffset.LowPart, FF_SEEK_SET);
/* Read */
BytesRead = FF_Read(Fcb->FatHandle, NumberOfBytes, 1, Buffer);
DPRINT("Read %d bytes\n", BytesRead);
/* Indicate we read requested amount of bytes */
IrpContext->Irp->IoStatus.Information = BytesRead;
IrpContext->Irp->IoStatus.Status = STATUS_SUCCESS;
}
/* Complete the request */
FatCompleteRequest(IrpContext, IrpContext->Irp, STATUS_SUCCESS);
return STATUS_SUCCESS;
}
NTSTATUS
NTAPI
FatVerifyVolume(PFAT_IRP_CONTEXT IrpContext, PIRP Irp)
{
DPRINT1("FatVerifyVolume()\n");
FatCompleteRequest(IrpContext, Irp, STATUS_INVALID_DEVICE_REQUEST);
return STATUS_INVALID_DEVICE_REQUEST;
}
VOID
FatOplockComplete (
IN PVOID Context,
IN PIRP Irp
)
/*++
Routine Description:
This routine is called by the oplock package when an oplock break has
completed, allowing an Irp to resume execution. If the status in
the Irp is STATUS_SUCCESS, then we queue the Irp to the Fsp queue.
Otherwise we complete the Irp with the status in the Irp.
Arguments:
Context - Pointer to the IrpContext to be queued to the Fsp
Irp - I/O Request Packet.
Return Value:
None.
--*/
{
PAGED_CODE();
//
// Check on the return value in the Irp.
//
if (Irp->IoStatus.Status == STATUS_SUCCESS) {
//
// Insert the Irp context in the workqueue.
//
FatAddToWorkque( (PIRP_CONTEXT) Context, Irp );
//
// Otherwise complete the request.
//
} else {
FatCompleteRequest( (PIRP_CONTEXT) Context, Irp, Irp->IoStatus.Status );
}
return;
}
NTSTATUS
NTAPI
FatiFileSystemControl(PFAT_IRP_CONTEXT IrpContext, PIRP Irp)
{
PIO_STACK_LOCATION IrpSp;
NTSTATUS Status;
/* Get current IRP stack location */
IrpSp = IoGetCurrentIrpStackLocation(Irp);
/* Dispatch depending on the minor function */
switch (IrpSp->MinorFunction)
{
case IRP_MN_KERNEL_CALL:
case IRP_MN_USER_FS_REQUEST:
Status = FatUserFsCtrl(IrpContext, Irp);
break;
case IRP_MN_MOUNT_VOLUME:
Status = FatMountVolume(IrpContext,
IrpSp->Parameters.MountVolume.DeviceObject,
IrpSp->Parameters.MountVolume.Vpb,
IrpSp->DeviceObject);
FatCompleteRequest(IrpContext, Irp, Status);
break;
case IRP_MN_VERIFY_VOLUME:
Status = FatVerifyVolume(IrpContext, Irp);
break;
default:
DPRINT1("Unhandled FSCTL minor 0x%x\n", IrpSp->MinorFunction);
FatCompleteRequest(IrpContext, Irp, STATUS_INVALID_DEVICE_REQUEST);
Status = STATUS_INVALID_DEVICE_REQUEST;
}
return Status;
}
NTSTATUS
NTAPI
FatOplockRequest(IN PFAT_IRP_CONTEXT IrpContext,
IN PIRP Irp)
{
NTSTATUS Status;
DPRINT1("Oplock request!\n");
Status = STATUS_INVALID_DEVICE_REQUEST;
FatCompleteRequest(IrpContext, Irp, Status);
return Status;
}
NTSTATUS
NTAPI
FatMarkVolumeDirty(IN PFAT_IRP_CONTEXT IrpContext,
IN PIRP Irp)
{
NTSTATUS Status;
DPRINT1("Marking volume as dirty\n");
Status = STATUS_SUCCESS;
FatCompleteRequest(IrpContext, Irp, Status);
return Status;
}
NTSTATUS
FatPnpSurpriseRemove (
PIRP_CONTEXT IrpContext,
PIRP Irp,
PVCB Vcb
)
/*++
Routine Description:
This routine handles the PnP surprise remove operation. This is another
type of notification that the underlying storage device for the volume we
have is gone, and is excellent indication that the volume will never reappear.
The filesystem is responsible for initiation or completion the dismount.
For the most part, only "real" drivers care about the distinction of a
surprise remove, which is a result of our noticing that a user (usually)
physically reached into the machine and pulled something out.
Surprise will be followed by a Remove when all references have been shut down.
Arguments:
Irp - Supplies the Irp to process
Vcb - Supplies the volume being removed.
Return Value:
NTSTATUS - The return status for the operation
--*/
{
NTSTATUS Status;
KEVENT Event;
BOOLEAN VcbDeleted;
//
// SURPRISE - a device was physically yanked away without
// any warning. This means external forces.
//
FatAcquireExclusiveGlobal( IrpContext );
FatAcquireExclusiveVcb( IrpContext, Vcb );
//
// We need to pass this down before starting the dismount, which
// could disconnect us immediately from the stack.
//
//
// Get the next stack location, and copy over the stack location
//
IoCopyCurrentIrpStackLocationToNext( Irp );
//
// Set up the completion routine
//
KeInitializeEvent( &Event, NotificationEvent, FALSE );
IoSetCompletionRoutine( Irp,
FatPnpCompletionRoutine,
&Event,
TRUE,
TRUE,
TRUE );
//
// Send the request and wait.
//
Status = IoCallDriver(Vcb->TargetDeviceObject, Irp);
if (Status == STATUS_PENDING) {
KeWaitForSingleObject( &Event,
Executive,
KernelMode,
FALSE,
NULL );
Status = Irp->IoStatus.Status;
}
try {
//
// Knock as many files down for this volume as we can.
//
FatFlushAndCleanVolume( IrpContext, Irp, Vcb, NoFlush );
//
// Now make our dismount happen. This may not vaporize the
// Vcb, of course, since there could be any number of handles
// outstanding since this is an out of band notification.
//
VcbDeleted = FatCheckForDismount( IrpContext, Vcb, TRUE );
} finally {
//
// Release the Vcb if it could still remain.
//
if (!VcbDeleted) {
FatReleaseVcb( IrpContext, Vcb );
}
FatReleaseGlobal( IrpContext );
}
//
// Cleanup our IrpContext and complete the IRP.
//
FatCompleteRequest( IrpContext, Irp, Status );
return Status;
}
NTSTATUS
FatPnpRemove (
PIRP_CONTEXT IrpContext,
PIRP Irp,
PVCB Vcb
)
/*++
Routine Description:
This routine handles the PnP remove operation. This is our notification
that the underlying storage device for the volume we have is gone, and
an excellent indication that the volume will never reappear. The filesystem
is responsible for initiation or completion of the dismount.
Arguments:
Irp - Supplies the Irp to process
Vcb - Supplies the volume being removed.
Return Value:
NTSTATUS - The return status for the operation
--*/
{
NTSTATUS Status;
KEVENT Event;
BOOLEAN VcbDeleted;
//
// REMOVE - a storage device is now gone. We either got
// QUERY'd and said yes OR got a SURPRISE OR a storage
// stack failed to spin back up from a sleep/stop state
// (the only case in which this will be the first warning).
//
// Note that it is entirely unlikely that we will be around
// for a REMOVE in the first two cases, as we try to intiate
// dismount.
//
//
// Acquire the global resource so that we can try to vaporize
// the volume, and the vcb resource itself.
//
FatAcquireExclusiveGlobal( IrpContext );
FatAcquireExclusiveVcb( IrpContext, Vcb );
//
// The device will be going away. Remove our lock (benign
// if we never had it).
//
(VOID) FatUnlockVolumeInternal( IrpContext, Vcb, NULL );
//
// We need to pass this down before starting the dismount, which
// could disconnect us immediately from the stack.
//
//
// Get the next stack location, and copy over the stack location
//
IoCopyCurrentIrpStackLocationToNext( Irp );
//
// Set up the completion routine
//
KeInitializeEvent( &Event, NotificationEvent, FALSE );
IoSetCompletionRoutine( Irp,
FatPnpCompletionRoutine,
&Event,
TRUE,
TRUE,
TRUE );
//
// Send the request and wait.
//
Status = IoCallDriver(Vcb->TargetDeviceObject, Irp);
if (Status == STATUS_PENDING) {
KeWaitForSingleObject( &Event,
Executive,
KernelMode,
FALSE,
NULL );
Status = Irp->IoStatus.Status;
}
try {
//
// Knock as many files down for this volume as we can.
//
FatFlushAndCleanVolume( IrpContext, Irp, Vcb, NoFlush );
//
// Now make our dismount happen. This may not vaporize the
// Vcb, of course, since there could be any number of handles
// outstanding if we were not preceeded by a QUERY.
//
// PnP will take care of disconnecting this stack if we
// couldn't get off of it immediately.
//
VcbDeleted = FatCheckForDismount( IrpContext, Vcb, TRUE );
} finally {
//
// Release the Vcb if it could still remain.
//
if (!VcbDeleted) {
FatReleaseVcb( IrpContext, Vcb );
}
FatReleaseGlobal( IrpContext );
}
//
// Cleanup our IrpContext and complete the IRP.
//
FatCompleteRequest( IrpContext, Irp, Status );
return Status;
}
NTSTATUS
FatCommonRead (
IN PIRP_CONTEXT IrpContext,
IN PIRP Irp
)
/*++
Routine Description:
This is the common read routine for NtReadFile, called from both
the Fsd, or from the Fsp if a request could not be completed without
blocking in the Fsd. This routine has no code where it determines
whether it is running in the Fsd or Fsp. Instead, its actions are
conditionalized by the Wait input parameter, which determines whether
it is allowed to block or not. If a blocking condition is encountered
with Wait == FALSE, however, the request is posted to the Fsp, who
always calls with WAIT == TRUE.
Arguments:
Irp - Supplies the Irp to process
Return Value:
NTSTATUS - The return status for the operation
--*/
{
PVCB Vcb;
PFCB FcbOrDcb;
PCCB Ccb;
VBO StartingVbo;
ULONG ByteCount;
ULONG RequestedByteCount;
PIO_STACK_LOCATION IrpSp;
PFILE_OBJECT FileObject;
TYPE_OF_OPEN TypeOfOpen;
BOOLEAN PostIrp = FALSE;
BOOLEAN OplockPostIrp = FALSE;
BOOLEAN FcbOrDcbAcquired = FALSE;
BOOLEAN Wait;
BOOLEAN PagingIo;
BOOLEAN NonCachedIo;
BOOLEAN SynchronousIo;
NTSTATUS Status;
FAT_IO_CONTEXT StackFatIoContext;
//
// A system buffer is only used if we have to access the
// buffer directly from the Fsp to clear a portion or to
// do a synchronous I/O, or a cached transfer. It is
// possible that our caller may have already mapped a
// system buffer, in which case we must remember this so
// we do not unmap it on the way out.
//
PVOID SystemBuffer = NULL;
LARGE_INTEGER StartingByte;
PAGED_CODE();
//
// Get current Irp stack location.
//
IrpSp = IoGetCurrentIrpStackLocation( Irp );
FileObject = IrpSp->FileObject;
//
// Initialize the appropriate local variables.
//
Wait = BooleanFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT);
PagingIo = BooleanFlagOn(Irp->Flags, IRP_PAGING_IO);
NonCachedIo = BooleanFlagOn(Irp->Flags,IRP_NOCACHE);
SynchronousIo = BooleanFlagOn(FileObject->Flags, FO_SYNCHRONOUS_IO);
DebugTrace(+1, Dbg, "CommonRead\n", 0);
DebugTrace( 0, Dbg, " Irp = %8lx\n", Irp);
DebugTrace( 0, Dbg, " ->ByteCount = %8lx\n", IrpSp->Parameters.Read.Length);
DebugTrace( 0, Dbg, " ->ByteOffset.LowPart = %8lx\n", IrpSp->Parameters.Read.ByteOffset.LowPart);
DebugTrace( 0, Dbg, " ->ByteOffset.HighPart = %8lx\n", IrpSp->Parameters.Read.ByteOffset.HighPart);
//
// Extract starting Vbo and offset.
//
StartingByte = IrpSp->Parameters.Read.ByteOffset;
StartingVbo = StartingByte.LowPart;
ByteCount = IrpSp->Parameters.Read.Length;
RequestedByteCount = ByteCount;
//
// Check for a null request, and return immediately
//
if (ByteCount == 0) {
Irp->IoStatus.Information = 0;
FatCompleteRequest( IrpContext, Irp, STATUS_SUCCESS );
return STATUS_SUCCESS;
}
//
// Extract the nature of the read from the file object, and case on it
//
TypeOfOpen = FatDecodeFileObject(FileObject, &Vcb, &FcbOrDcb, &Ccb);
ASSERT( Vcb != NULL );
//
// Save callers who try to do cached IO to the raw volume from themselves.
//
if (TypeOfOpen == UserVolumeOpen) {
NonCachedIo = TRUE;
}
ASSERT(!(NonCachedIo == FALSE && TypeOfOpen == VirtualVolumeFile));
//
// Collect interesting statistics. The FLAG_USER_IO bit will indicate
// what type of io we're doing in the FatNonCachedIo function.
//
if (PagingIo) {
CollectReadStats(Vcb, TypeOfOpen, ByteCount);
if (TypeOfOpen == UserFileOpen) {
SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_USER_IO);
} else {
ClearFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_USER_IO);
}
}
ASSERT(!FlagOn( IrpContext->Flags, IRP_CONTEXT_STACK_IO_CONTEXT ));
//
// Allocate if necessary and initialize a FAT_IO_CONTEXT block for
// all non cached Io. For synchronous Io we use stack storage,
// otherwise we allocate pool.
//
if (NonCachedIo) {
if (IrpContext->FatIoContext == NULL) {
if (!Wait) {
IrpContext->FatIoContext =
FsRtlAllocatePoolWithTag( NonPagedPool,
sizeof(FAT_IO_CONTEXT),
TAG_FAT_IO_CONTEXT );
} else {
IrpContext->FatIoContext = &StackFatIoContext;
SetFlag( IrpContext->Flags, IRP_CONTEXT_STACK_IO_CONTEXT );
}
}
RtlZeroMemory( IrpContext->FatIoContext, sizeof(FAT_IO_CONTEXT) );
if (Wait) {
KeInitializeEvent( &IrpContext->FatIoContext->Wait.SyncEvent,
NotificationEvent,
FALSE );
} else {
IrpContext->FatIoContext->Wait.Async.ResourceThreadId =
ExGetCurrentResourceThread();
IrpContext->FatIoContext->Wait.Async.RequestedByteCount =
ByteCount;
IrpContext->FatIoContext->Wait.Async.FileObject = FileObject;
}
}
//
// These two cases correspond to either a general opened volume, ie.
// open ("a:"), or a read of the volume file (boot sector + fat(s))
//
if ((TypeOfOpen == VirtualVolumeFile) ||
(TypeOfOpen == UserVolumeOpen)) {
LBO StartingLbo;
StartingLbo = StartingByte.QuadPart;
DebugTrace(0, Dbg, "Type of read is User Volume or virtual volume file\n", 0);
if (TypeOfOpen == UserVolumeOpen) {
//
// Verify that the volume for this handle is still valid
//
//
// Verify that the volume for this handle is still valid, permitting
// operations to proceed on dismounted volumes via the handle which
// performed the dismount.
//
if (!FlagOn( Ccb->Flags, CCB_FLAG_COMPLETE_DISMOUNT | CCB_FLAG_SENT_FORMAT_UNIT )) {
FatQuickVerifyVcb( IrpContext, Vcb );
}
//
// If the caller previously sent a format unit command, then we will allow
// their read/write requests to ignore the verify flag on the device, since some
// devices send a media change event after format unit, but we don't want to
// process it yet since we're probably in the process of formatting the
// media.
//
if (FlagOn( Ccb->Flags, CCB_FLAG_SENT_FORMAT_UNIT )) {
SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_OVERRIDE_VERIFY );
}
if (!FlagOn( Ccb->Flags, CCB_FLAG_DASD_FLUSH_DONE )) {
(VOID)ExAcquireResourceExclusiveLite( &Vcb->Resource, TRUE );
try {
//
// If the volume isn't locked, flush it.
//
if (!FlagOn(Vcb->VcbState, VCB_STATE_FLAG_LOCKED)) {
FatFlushVolume( IrpContext, Vcb, Flush );
}
} finally {
ExReleaseResourceLite( &Vcb->Resource );
}
SetFlag( Ccb->Flags, CCB_FLAG_DASD_FLUSH_DONE );
}
if (!FlagOn( Ccb->Flags, CCB_FLAG_ALLOW_EXTENDED_DASD_IO )) {
LBO VolumeSize;
//
// Make sure we don't try to read past end of volume,
// reducing the byte count if necessary.
//
VolumeSize = (LBO) Vcb->Bpb.BytesPerSector *
(Vcb->Bpb.Sectors != 0 ? Vcb->Bpb.Sectors :
Vcb->Bpb.LargeSectors);
if (StartingLbo >= VolumeSize) {
Irp->IoStatus.Information = 0;
FatCompleteRequest( IrpContext, Irp, STATUS_END_OF_FILE );
return STATUS_END_OF_FILE;
}
if (ByteCount > VolumeSize - StartingLbo) {
ByteCount = RequestedByteCount = (ULONG) (VolumeSize - StartingLbo);
//
// For async reads we had set the byte count in the FatIoContext
// above, so fix that here.
//
if (!Wait) {
IrpContext->FatIoContext->Wait.Async.RequestedByteCount =
ByteCount;
}
}
}
//
// For DASD we have to probe and lock the user's buffer
//
FatLockUserBuffer( IrpContext, Irp, IoWriteAccess, ByteCount );
} else {
VOID
FatFspDispatch (
IN PVOID Context
)
/*++
Routine Description:
This is the main FSP thread routine that is executed to receive
and dispatch IRP requests. Each FSP thread begins its execution here.
There is one thread created at system initialization time and subsequent
threads created as needed.
Arguments:
Context - Supplies the thread id.
Return Value:
None - This routine never exits
--*/
{
NTSTATUS Status;
PIRP Irp;
PIRP_CONTEXT IrpContext;
PIO_STACK_LOCATION IrpSp;
BOOLEAN VcbDeleted;
PVOLUME_DEVICE_OBJECT VolDo;
IrpContext = (PIRP_CONTEXT)Context;
Irp = IrpContext->OriginatingIrp;
IrpSp = IoGetCurrentIrpStackLocation( Irp );
//
// Now because we are the Fsp we will force the IrpContext to
// indicate true on Wait.
//
SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT | IRP_CONTEXT_FLAG_IN_FSP);
//
// If this request has an associated volume device object, remember it.
//
if ( IrpSp->FileObject != NULL ) {
VolDo = CONTAINING_RECORD( IrpSp->DeviceObject,
VOLUME_DEVICE_OBJECT,
DeviceObject );
} else {
VolDo = NULL;
}
//
// Now case on the function code. For each major function code,
// either call the appropriate FSP routine or case on the minor
// function and then call the FSP routine. The FSP routine that
// we call is responsible for completing the IRP, and not us.
// That way the routine can complete the IRP and then continue
// post processing as required. For example, a read can be
// satisfied right away and then read can be done.
//
// We'll do all of the work within an exception handler that
// will be invoked if ever some underlying operation gets into
// trouble (e.g., if FatReadSectorsSync has trouble).
//
while ( TRUE ) {
DebugTrace(0, Dbg, "FatFspDispatch: Irp = 0x%08lx\n", Irp);
//
// If this Irp was top level, note it in our thread local storage.
//
FsRtlEnterFileSystem();
if ( FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_RECURSIVE_CALL) ) {
IoSetTopLevelIrp( (PIRP)FSRTL_FSP_TOP_LEVEL_IRP );
} else {
IoSetTopLevelIrp( Irp );
}
try {
switch ( IrpContext->MajorFunction ) {
//
// For Create Operation,
//
case IRP_MJ_CREATE:
(VOID) FatCommonCreate( IrpContext, Irp );
break;
//
// For close operations. We do a little kludge here in case
// this close causes a volume to go away. It will NULL the
// VolDo local variable so that we will not try to look at
// the overflow queue.
//
case IRP_MJ_CLOSE:
{
PVCB Vcb;
PFCB Fcb;
PCCB Ccb;
TYPE_OF_OPEN TypeOfOpen;
//
// Extract and decode the file object
//
TypeOfOpen = FatDecodeFileObject( IrpSp->FileObject, &Vcb, &Fcb, &Ccb );
//
// Do the close. We have a slightly different format
// for this call because of the async closes.
//
Status = FatCommonClose( Vcb,
Fcb,
Ccb,
TypeOfOpen,
TRUE,
&VcbDeleted );
//
// If the VCB was deleted, do not try to access it later.
//
if (VcbDeleted) {
VolDo = NULL;
}
ASSERT(Status == STATUS_SUCCESS);
FatCompleteRequest( IrpContext, Irp, Status );
break;
}
//
// For read operations
//
case IRP_MJ_READ:
(VOID) FatCommonRead( IrpContext, Irp );
break;
//
// For write operations,
//
case IRP_MJ_WRITE:
(VOID) FatCommonWrite( IrpContext, Irp );
break;
//
// For Query Information operations,
//
case IRP_MJ_QUERY_INFORMATION:
(VOID) FatCommonQueryInformation( IrpContext, Irp );
break;
//
// For Set Information operations,
//
case IRP_MJ_SET_INFORMATION:
(VOID) FatCommonSetInformation( IrpContext, Irp );
break;
//
// For Query EA operations,
//
case IRP_MJ_QUERY_EA:
(VOID) FatCommonQueryEa( IrpContext, Irp );
break;
//
// For Set EA operations,
//
case IRP_MJ_SET_EA:
(VOID) FatCommonSetEa( IrpContext, Irp );
break;
//
// For Flush buffers operations,
//
case IRP_MJ_FLUSH_BUFFERS:
(VOID) FatCommonFlushBuffers( IrpContext, Irp );
break;
//
// For Query Volume Information operations,
//
case IRP_MJ_QUERY_VOLUME_INFORMATION:
(VOID) FatCommonQueryVolumeInfo( IrpContext, Irp );
break;
//
// For Set Volume Information operations,
//
case IRP_MJ_SET_VOLUME_INFORMATION:
(VOID) FatCommonSetVolumeInfo( IrpContext, Irp );
break;
//
// For File Cleanup operations,
//
case IRP_MJ_CLEANUP:
(VOID) FatCommonCleanup( IrpContext, Irp );
break;
//
// For Directory Control operations,
//
case IRP_MJ_DIRECTORY_CONTROL:
(VOID) FatCommonDirectoryControl( IrpContext, Irp );
break;
//
// For File System Control operations,
//
case IRP_MJ_FILE_SYSTEM_CONTROL:
(VOID) FatCommonFileSystemControl( IrpContext, Irp );
break;
//
// For Lock Control operations,
//
case IRP_MJ_LOCK_CONTROL:
(VOID) FatCommonLockControl( IrpContext, Irp );
break;
//
// For Device Control operations,
//
case IRP_MJ_DEVICE_CONTROL:
(VOID) FatCommonDeviceControl( IrpContext, Irp );
break;
//
// For the Shutdown operation,
//
case IRP_MJ_SHUTDOWN:
(VOID) FatCommonShutdown( IrpContext, Irp );
break;
//
// For plug and play operations.
//
case IRP_MJ_PNP:
//
// I don't believe this should ever occur, but allow for the unexpected.
//
(VOID) FatCommonPnp( IrpContext, Irp );
break;
//
// For any other major operations, return an invalid
// request.
//
default:
FatCompleteRequest( IrpContext, Irp, STATUS_INVALID_DEVICE_REQUEST );
break;
}
} except(FatExceptionFilter( IrpContext, GetExceptionInformation() )) {
//
// We had some trouble trying to perform the requested
// operation, so we'll abort the I/O request with
// the error status that we get back from the
// execption code.
//
(VOID) FatProcessException( IrpContext, Irp, GetExceptionCode() );
}
IoSetTopLevelIrp( NULL );
FsRtlExitFileSystem();
//
// If there are any entries on this volume's overflow queue, service
// them.
//
if ( VolDo != NULL ) {
PVOID Entry;
//
// We have a volume device object so see if there is any work
// left to do in its overflow queue.
//
Entry = FatRemoveOverflowEntry( VolDo );
//
// There wasn't an entry, break out of the loop and return to
// the Ex Worker thread.
//
if ( Entry == NULL ) {
break;
}
//
// Extract the IrpContext, Irp, and IrpSp, and loop.
//
IrpContext = CONTAINING_RECORD( Entry,
IRP_CONTEXT,
WorkQueueItem.List );
SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT | IRP_CONTEXT_FLAG_IN_FSP);
Irp = IrpContext->OriginatingIrp;
IrpSp = IoGetCurrentIrpStackLocation( Irp );
continue;
} else {
break;
}
}
//
// Decrement the PostedRequestCount.
//
if ( VolDo ) {
ExInterlockedAddUlong( &VolDo->PostedRequestCount,
0xffffffff,
&VolDo->OverflowQueueSpinLock );
}
return;
}
__drv_mustHoldCriticalRegion
NTSTATUS
FatCommonShutdown (
IN PIRP_CONTEXT IrpContext,
IN PIRP Irp
)
/*++
Routine Description:
This is the common routine for shutdown called by both the fsd and
fsp threads.
Arguments:
Irp - Supplies the Irp being processed
Return Value:
NTSTATUS - The return status for the operation
--*/
{
KEVENT Event;
PLIST_ENTRY Links;
PVCB Vcb;
PIRP NewIrp;
IO_STATUS_BLOCK Iosb;
BOOLEAN VcbDeleted;
PAGED_CODE();
//
// Make sure we don't get any pop-ups, and write everything through.
//
SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_DISABLE_POPUPS |
IRP_CONTEXT_FLAG_WRITE_THROUGH);
//
// Initialize an event for doing calls down to
// our target device objects.
//
KeInitializeEvent( &Event, NotificationEvent, FALSE );
//
// Indicate that shutdown has started. This is used in FatFspClose.
//
FatData.ShutdownStarted = TRUE;
//
// Get everyone else out of the way
//
ASSERT( FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT) );
#pragma prefast( push )
#pragma prefast( disable: 28137, "prefast wants the wait to be a constant, but that isn't possible for the way fastfat is designed" )
#pragma prefast( disable: 28193, "this will always wait" )
(VOID) FatAcquireExclusiveGlobal( IrpContext );
#pragma prefast( pop )
try {
//
// For every volume that is mounted we will flush the
// volume and then shutdown the target device objects.
//
Links = FatData.VcbQueue.Flink;
while (Links != &FatData.VcbQueue) {
Vcb = CONTAINING_RECORD(Links, VCB, VcbLinks);
Links = Links->Flink;
//
// If we have already been called before for this volume
// (and yes this does happen), skip this volume as no writes
// have been allowed since the first shutdown.
//
if ( FlagOn( Vcb->VcbState, VCB_STATE_FLAG_SHUTDOWN) ||
(Vcb->VcbCondition != VcbGood) ) {
continue;
}
FatAcquireExclusiveVolume( IrpContext, Vcb );
try {
(VOID)FatFlushVolume( IrpContext, Vcb, Flush );
//
// The volume is now clean, note it. We purge the
// volume file cache map before marking the volume
// clean incase there is a stale Bpb in the cache.
//
if (!FlagOn(Vcb->VcbState, VCB_STATE_FLAG_MOUNTED_DIRTY)) {
CcPurgeCacheSection( &Vcb->SectionObjectPointers,
NULL,
0,
FALSE );
FatMarkVolume( IrpContext, Vcb, VolumeClean );
}
} except( EXCEPTION_EXECUTE_HANDLER ) {
FatResetExceptionState( IrpContext );
}
//
// Sometimes we take an excepion while flushing the volume, such
// as when autoconv has converted the volume and is rebooting.
// Even in that case we want to send the shutdown irp to the
// target device so it can know to flush its cache, if it has one.
//
try {
NewIrp = IoBuildSynchronousFsdRequest( IRP_MJ_SHUTDOWN,
Vcb->TargetDeviceObject,
NULL,
0,
NULL,
&Event,
&Iosb );
if (NewIrp != NULL) {
if (NT_SUCCESS(IoCallDriver( Vcb->TargetDeviceObject, NewIrp ))) {
(VOID) KeWaitForSingleObject( &Event,
Executive,
KernelMode,
FALSE,
NULL );
KeClearEvent( &Event );
}
}
} except( EXCEPTION_EXECUTE_HANDLER ) {
FatResetExceptionState( IrpContext );
}
SetFlag( Vcb->VcbState, VCB_STATE_FLAG_SHUTDOWN );
//
// Attempt to punch the volume down.
//
VcbDeleted = FatCheckForDismount( IrpContext,
Vcb,
FALSE );
if (!VcbDeleted) {
#pragma prefast( suppress:28107, "prefast is having trouble figuring out that Vcb is acquired" )
FatReleaseVolume( IrpContext, Vcb );
}
}
} finally {
FatReleaseGlobal( IrpContext );
//
// Unregister the file system.
//
IoUnregisterFileSystem( FatDiskFileSystemDeviceObject);
IoUnregisterFileSystem( FatCdromFileSystemDeviceObject);
IoDeleteDevice( FatDiskFileSystemDeviceObject);
IoDeleteDevice( FatCdromFileSystemDeviceObject);
FatCompleteRequest( IrpContext, Irp, STATUS_SUCCESS );
}
//
// And return to our caller
//
DebugTrace(-1, Dbg, "FatFsdShutdown -> STATUS_SUCCESS\n", 0);
return STATUS_SUCCESS;
}
NTSTATUS
FatProcessException (
IN PIRP_CONTEXT IrpContext,
IN PIRP Irp,
IN NTSTATUS ExceptionCode
)
/*++
Routine Description:
This routine process an exception. It either completes the request
with the saved exception status or it sends it off to IoRaiseHardError()
Arguments:
Irp - Supplies the Irp being processed
ExceptionCode - Supplies the normalized exception status being handled
Return Value:
NTSTATUS - Returns the results of either posting the Irp or the
saved completion status.
--*/
{
PVCB Vcb;
PIO_STACK_LOCATION IrpSp;
FAT_VOLUME_STATE TransitionState = VolumeDirty;
ULONG SavedFlags;
DebugTrace(0, Dbg, "FatProcessException\n", 0);
//
// If there is not an irp context, we must have had insufficient resources.
//
if ( !ARGUMENT_PRESENT( IrpContext ) ) {
FatCompleteRequest( FatNull, Irp, ExceptionCode );
return ExceptionCode;
}
//
// Get the real exception status from IrpContext->ExceptionStatus, and
// reset it.
//
ExceptionCode = IrpContext->ExceptionStatus;
FatResetExceptionState( IrpContext );
//
// If this is an Mdl write request, then take care of the Mdl
// here so that things get cleaned up properly. Cc now leaves
// the MDL in place so a filesystem can retry after clearing an
// internal condition (FAT does not).
//
#if __NDAS_FAT_WIN2K_SUPPORT__
if (NdFatCcMdlWriteAbort &&
(IrpContext->MajorFunction == IRP_MJ_WRITE) &&
(FlagOn( IrpContext->MinorFunction, IRP_MN_COMPLETE_MDL ) == IRP_MN_COMPLETE_MDL) &&
(Irp->MdlAddress != NULL)) {
PIO_STACK_LOCATION LocalIrpSp = IoGetCurrentIrpStackLocation(Irp);
NdFatCcMdlWriteAbort( LocalIrpSp->FileObject, Irp->MdlAddress );
Irp->MdlAddress = NULL;
}
#else
if ((IrpContext->MajorFunction == IRP_MJ_WRITE) &&
(FlagOn( IrpContext->MinorFunction, IRP_MN_COMPLETE_MDL ) == IRP_MN_COMPLETE_MDL) &&
(Irp->MdlAddress != NULL)) {
PIO_STACK_LOCATION LocalIrpSp = IoGetCurrentIrpStackLocation(Irp);
CcMdlWriteAbort( LocalIrpSp->FileObject, Irp->MdlAddress );
Irp->MdlAddress = NULL;
}
#endif
//
// If we are going to post the request, we may have to lock down the
// user's buffer, so do it here in a try except so that we failed the
// request if the LockPages fails.
//
// Also unpin any repinned Bcbs, protected by the try {} except {} filter.
//
try {
SavedFlags = IrpContext->Flags;
//
// Make sure we don't try to write through Bcbs
//
SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_DISABLE_WRITE_THROUGH);
FatUnpinRepinnedBcbs( IrpContext );
IrpContext->Flags = SavedFlags;
//
// If we will have to post the request, do it here. Note
// that the last thing FatPrePostIrp() does is mark the Irp pending,
// so it is critical that we actually return PENDING. Nothing
// from this point to return can fail, so we are OK.
//
// We cannot do a verify operations at APC level because we
// have to wait for Io operations to complete.
//
#if __NDAS_FAT__
if (!FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_RECURSIVE_CALL) &&
(((ExceptionCode == STATUS_VERIFY_REQUIRED) && (KeGetCurrentIrql() >= APC_LEVEL)) ||
(!FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT) && ExceptionCode == STATUS_CANT_WAIT))) {
ExceptionCode = FatFsdPostRequest( IrpContext, Irp );
}
#else
if (!FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_RECURSIVE_CALL) &&
(((ExceptionCode == STATUS_VERIFY_REQUIRED) && (KeGetCurrentIrql() >= APC_LEVEL)) ||
(ExceptionCode == STATUS_CANT_WAIT))) {
ExceptionCode = FatFsdPostRequest( IrpContext, Irp );
}
#endif
} except( FatExceptionFilter( IrpContext, GetExceptionInformation() ) ) {
ExceptionCode = IrpContext->ExceptionStatus;
IrpContext->ExceptionStatus = 0;
IrpContext->Flags = SavedFlags;
}
//
// If we posted the request, just return here.
//
if (ExceptionCode == STATUS_PENDING) {
return ExceptionCode;
}
Irp->IoStatus.Status = ExceptionCode;
//
// If this request is not a "top-level" irp, just complete it.
//
if (FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_RECURSIVE_CALL)) {
//
// If there is a cache operation above us, commute verify
// to a lock conflict. This will cause retries so that
// we have a chance of getting through without needing
// to return an unaesthetic error for the operation.
//
if (IoGetTopLevelIrp() == (PIRP)FSRTL_CACHE_TOP_LEVEL_IRP &&
ExceptionCode == STATUS_VERIFY_REQUIRED) {
ExceptionCode = STATUS_FILE_LOCK_CONFLICT;
}
FatCompleteRequest( IrpContext, Irp, ExceptionCode );
return ExceptionCode;
}
if (IoIsErrorUserInduced(ExceptionCode)) {
//
// Check for the various error conditions that can be caused by,
// and possibly resolved by the user.
//
if (ExceptionCode == STATUS_VERIFY_REQUIRED) {
PDEVICE_OBJECT Device;
DebugTrace(0, Dbg, "Perform Verify Operation\n", 0);
//
// Now we are at the top level file system entry point.
//
// Grab the device to verify from the thread local storage
// and stick it in the information field for transportation
// to the fsp. We also clear the field at this time.
//
Device = IoGetDeviceToVerify( Irp->Tail.Overlay.Thread );
IoSetDeviceToVerify( Irp->Tail.Overlay.Thread, NULL );
if ( Device == NULL ) {
Device = IoGetDeviceToVerify( PsGetCurrentThread() );
IoSetDeviceToVerify( PsGetCurrentThread(), NULL );
ASSERT( Device != NULL );
}
//
// Let's not BugCheck just because the driver messed up.
//
if (Device == NULL) {
ExceptionCode = STATUS_DRIVER_INTERNAL_ERROR;
FatCompleteRequest( IrpContext, Irp, ExceptionCode );
return ExceptionCode;
}
//
// FatPerformVerify() will do the right thing with the Irp.
return FatPerformVerify( IrpContext, Irp, Device );
}
//
// The other user induced conditions generate an error unless
// they have been disabled for this request.
//
if (FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_DISABLE_POPUPS)) {
FatCompleteRequest( IrpContext, Irp, ExceptionCode );
return ExceptionCode;
} else {
//
// Generate a pop-up
//
PDEVICE_OBJECT RealDevice;
PVPB Vpb;
PETHREAD Thread;
if (IoGetCurrentIrpStackLocation(Irp)->FileObject != NULL) {
Vpb = IoGetCurrentIrpStackLocation(Irp)->FileObject->Vpb;
} else {
Vpb = NULL;
}
//
// The device to verify is either in my thread local storage
// or that of the thread that owns the Irp.
//
Thread = Irp->Tail.Overlay.Thread;
RealDevice = IoGetDeviceToVerify( Thread );
if ( RealDevice == NULL ) {
Thread = PsGetCurrentThread();
RealDevice = IoGetDeviceToVerify( Thread );
ASSERT( RealDevice != NULL );
}
//
// Let's not BugCheck just because the driver messed up.
//
if (RealDevice == NULL) {
FatCompleteRequest( IrpContext, Irp, ExceptionCode );
return ExceptionCode;
}
//
// This routine actually causes the pop-up. It usually
// does this by queuing an APC to the callers thread,
// but in some cases it will complete the request immediately,
// so it is very important to IoMarkIrpPending() first.
//
IoMarkIrpPending( Irp );
IoRaiseHardError( Irp, Vpb, RealDevice );
//
// We will be handing control back to the caller here, so
// reset the saved device object.
//
IoSetDeviceToVerify( Thread, NULL );
//
// The Irp will be completed by Io or resubmitted. In either
// case we must clean up the IrpContext here.
//
FatDeleteIrpContext( IrpContext );
return STATUS_PENDING;
}
}
//
// This is just a run of the mill error. If is a STATUS that we
// raised ourselves, and the information would be use for the
// user, raise an informational pop-up.
//
IrpSp = IoGetCurrentIrpStackLocation( Irp );
Vcb = IrpContext->Vcb;
//
// Now, if the Vcb is unknown to us this means that the error was raised
// in the process of a mount and before we even had a chance to build
// a full Vcb - and was really handled there.
//
if (Vcb != NULL) {
if ( !FatDeviceIsFatFsdo( IrpSp->DeviceObject) &&
!NT_SUCCESS(ExceptionCode) &&
!FsRtlIsTotalDeviceFailure(ExceptionCode) ) {
TransitionState = VolumeDirtyWithSurfaceTest;
}
//
// If this was a STATUS_FILE_CORRUPT or similar error indicating some
// nastiness out on the media, then mark the volume permanently dirty.
//
if (!FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_DISABLE_POPUPS) &&
( TransitionState == VolumeDirtyWithSurfaceTest ||
(ExceptionCode == STATUS_FILE_CORRUPT_ERROR) ||
(ExceptionCode == STATUS_DISK_CORRUPT_ERROR) ||
(ExceptionCode == STATUS_EA_CORRUPT_ERROR) ||
(ExceptionCode == STATUS_INVALID_EA_NAME) ||
(ExceptionCode == STATUS_EA_LIST_INCONSISTENT) ||
(ExceptionCode == STATUS_NO_EAS_ON_FILE) )) {
ASSERT( NodeType(Vcb) == FAT_NTC_VCB );
SetFlag( Vcb->VcbState, VCB_STATE_FLAG_MOUNTED_DIRTY );
//
// Do the "dirty" work, ignoring any error.
//
try {
FatMarkVolume( IrpContext, Vcb, TransitionState );
} except( FatExceptionFilter( IrpContext, GetExceptionInformation() ) ) {
NOTHING;
}
}
}
NTSTATUS
FatCommonLockControl (
IN PIRP_CONTEXT IrpContext,
IN PIRP Irp
)
/*++
Routine Description:
This is the common routine for doing Lock control operations called
by both the fsd and fsp threads
Arguments:
Irp - Supplies the Irp to process
Return Value:
NTSTATUS - The return status for the operation
--*/
{
NTSTATUS Status = STATUS_SUCCESS;
PIO_STACK_LOCATION IrpSp;
TYPE_OF_OPEN TypeOfOpen;
PVCB Vcb;
PFCB Fcb;
PCCB Ccb;
BOOLEAN OplockPostIrp = FALSE;
PAGED_CODE();
//
// Get a pointer to the current Irp stack location
//
IrpSp = IoGetCurrentIrpStackLocation( Irp );
DebugTrace(+1, Dbg, "FatCommonLockControl\n", 0);
DebugTrace( 0, Dbg, "Irp = %08lx\n", Irp);
DebugTrace( 0, Dbg, "MinorFunction = %08lx\n", IrpSp->MinorFunction);
//
// Decode the type of file object we're being asked to process
//
TypeOfOpen = FatDecodeFileObject( IrpSp->FileObject, &Vcb, &Fcb, &Ccb );
//
// If the file is not a user file open then we reject the request
// as an invalid parameter
//
if (TypeOfOpen != UserFileOpen) {
FatCompleteRequest( IrpContext, Irp, STATUS_INVALID_PARAMETER );
DebugTrace(-1, Dbg, "FatCommonLockControl -> STATUS_INVALID_PARAMETER\n", 0);
return STATUS_INVALID_PARAMETER;
}
//
// Acquire exclusive access to the Fcb and enqueue the Irp if we didn't
// get access
//
if (!FatAcquireSharedFcb( IrpContext, Fcb )) {
Status = FatFsdPostRequest( IrpContext, Irp );
DebugTrace(-1, Dbg, "FatCommonLockControl -> %08lx\n", Status);
return Status;
}
try {
//
// We check whether we can proceed
// based on the state of the file oplocks.
//
#if (NTDDI_VERSION >= NTDDI_WIN8)
if (((IRP_MN_LOCK == IrpSp->MinorFunction) &&
((ULONGLONG)IrpSp->Parameters.LockControl.ByteOffset.QuadPart <
(ULONGLONG)Fcb->Header.AllocationSize.QuadPart)) ||
((IRP_MN_LOCK != IrpSp->MinorFunction) &&
FsRtlAreThereWaitingFileLocks( &Fcb->Specific.Fcb.FileLock ))) {
//
// Check whether we can proceed based on the state of file oplocks if doing
// an operation that interferes with oplocks. Those operations are:
//
// 1. Lock a range within the file's AllocationSize.
// 2. Unlock a range when there are waiting locks on the file. This one
// is not guaranteed to interfere with oplocks, but it could, as
// unlocking this range might cause a waiting lock to be granted
// within AllocationSize!
//
#endif
Status = FsRtlCheckOplock( FatGetFcbOplock(Fcb),
Irp,
IrpContext,
FatOplockComplete,
NULL );
#if (NTDDI_VERSION >= NTDDI_WIN8)
}
#endif
if (Status != STATUS_SUCCESS) {
OplockPostIrp = TRUE;
try_return( NOTHING );
}
//
// Now call the FsRtl routine to do the actual processing of the
// Lock request
//
Status = FsRtlProcessFileLock( &Fcb->Specific.Fcb.FileLock, Irp, NULL );
//
// Set the flag indicating if Fast I/O is possible
//
Fcb->Header.IsFastIoPossible = FatIsFastIoPossible( Fcb );
try_exit: NOTHING;
} finally {
DebugUnwind( FatCommonLockControl );
//
// Only if this is not an abnormal termination do we delete the
// irp context
//
if (!AbnormalTermination() && !OplockPostIrp) {
FatCompleteRequest( IrpContext, FatNull, 0 );
}
//
// Release the Fcb, and return to our caller
//
FatReleaseFcb( IrpContext, Fcb );
DebugTrace(-1, Dbg, "FatCommonLockControl -> %08lx\n", Status);
}
return Status;
}
NTSTATUS
FatCommonDirectoryControl (
IN PIRP_CONTEXT IrpContext,
IN PIRP Irp
)
/*++
Routine Description:
This is the common routine for doing directory control operations called
by both the fsd and fsp threads
Arguments:
Irp - Supplies the Irp to process
Return Value:
NTSTATUS - The return status for the operation
--*/
{
NTSTATUS Status;
PIO_STACK_LOCATION IrpSp;
//
// Get a pointer to the current Irp stack location
//
IrpSp = IoGetCurrentIrpStackLocation( Irp );
DebugTrace(+1, Dbg, "FatCommonDirectoryControl\n", 0);
DebugTrace( 0, Dbg, "Irp = %08lx\n", Irp );
DebugTrace( 0, Dbg, "MinorFunction = %08lx\n", IrpSp->MinorFunction );
//
// We know this is a directory control so we'll case on the
// minor function, and call a internal worker routine to complete
// the irp.
//
switch ( IrpSp->MinorFunction ) {
case IRP_MN_QUERY_DIRECTORY:
Status = FatQueryDirectory( IrpContext, Irp );
break;
case IRP_MN_NOTIFY_CHANGE_DIRECTORY:
Status = FatNotifyChangeDirectory( IrpContext, Irp );
break;
default:
DebugTrace(0, Dbg, "Invalid Directory Control Minor Function %08lx\n", IrpSp->MinorFunction);
FatCompleteRequest( IrpContext, Irp, STATUS_INVALID_DEVICE_REQUEST );
Status = STATUS_INVALID_DEVICE_REQUEST;
break;
}
DebugTrace(-1, Dbg, "FatCommonDirectoryControl -> %08lx\n", Status);
return Status;
}
NTSTATUS
FatCommonSetVolumeInfo (
IN PIRP_CONTEXT IrpContext,
IN PIRP Irp
)
/*++
Routine Description:
This is the common routine for setting Volume Information called by both
the fsd and fsp threads.
Arguments:
Irp - Supplies the Irp being processed
Return Value:
NTSTATUS - The return status for the operation
--*/
{
NTSTATUS Status;
PIO_STACK_LOCATION IrpSp;
PVCB Vcb;
PFCB Fcb;
PCCB Ccb;
TYPE_OF_OPEN TypeOfOpen;
ULONG Length;
FS_INFORMATION_CLASS FsInformationClass;
PVOID Buffer;
//
// Get the current stack location
//
IrpSp = IoGetCurrentIrpStackLocation( Irp );
DebugTrace(+1, Dbg, "FatCommonSetVolumeInfo...\n", 0);
DebugTrace( 0, Dbg, "Irp = %08lx\n", Irp );
DebugTrace( 0, Dbg, "->Length = %08lx\n", IrpSp->Parameters.SetVolume.Length);
DebugTrace( 0, Dbg, "->FsInformationClass = %08lx\n", IrpSp->Parameters.SetVolume.FsInformationClass);
DebugTrace( 0, Dbg, "->Buffer = %08lx\n", Irp->AssociatedIrp.SystemBuffer);
//
// Reference our input parameters to make things easier
//
Length = IrpSp->Parameters.SetVolume.Length;
FsInformationClass = IrpSp->Parameters.SetVolume.FsInformationClass;
Buffer = Irp->AssociatedIrp.SystemBuffer;
//
// Decode the file object to get the Vcb
//
TypeOfOpen = FatDecodeFileObject( IrpSp->FileObject, &Vcb, &Fcb, &Ccb );
if (TypeOfOpen != UserVolumeOpen) {
FatCompleteRequest( IrpContext, Irp, STATUS_ACCESS_DENIED );
DebugTrace(-1, Dbg, "FatCommonSetVolumeInfo -> STATUS_ACCESS_DENIED\n", 0);
return STATUS_ACCESS_DENIED;
}
//
// Acquire exclusive access to the Vcb and enqueue the Irp if we didn't
// get access
//
if (!FatAcquireExclusiveVcb( IrpContext, Vcb )) {
DebugTrace(0, Dbg, "Cannot acquire Vcb\n", 0);
Status = FatFsdPostRequest( IrpContext, Irp );
DebugTrace(-1, Dbg, "FatCommonSetVolumeInfo -> %08lx\n", Status );
return Status;
}
try {
//
// Make sure the vcb is in a usable condition. This will raise
// and error condition if the volume is unusable
//
// Also verify the Root Dcb since we need info from there.
//
FatVerifyFcb( IrpContext, Vcb->RootDcb );
//
// Based on the information class we'll do different actions. Each
// of the procedures that we're calling performs the action if
// possible and returns true if it successful and false if it couldn't
// wait for any I/O to complete.
//
switch (FsInformationClass) {
case FileFsLabelInformation:
Status = FatSetFsLabelInfo( IrpContext, Vcb, Buffer );
break;
default:
Status = STATUS_INVALID_PARAMETER;
break;
}
FatUnpinRepinnedBcbs( IrpContext );
} finally {
DebugUnwind( FatCommonSetVolumeInfo );
FatReleaseVcb( IrpContext, Vcb );
if (!AbnormalTermination()) {
FatCompleteRequest( IrpContext, Irp, Status );
}
DebugTrace(-1, Dbg, "FatCommonSetVolumeInfo -> %08lx\n", Status);
}
return Status;
}
NTSTATUS
FatCommonQueryVolumeInfo (
IN PIRP_CONTEXT IrpContext,
IN PIRP Irp
)
/*++
Routine Description:
This is the common routine for querying volume information called by both
the fsd and fsp threads.
Arguments:
Irp - Supplies the Irp being processed
Return Value:
NTSTATUS - The return status for the operation
--*/
{
NTSTATUS Status;
PIO_STACK_LOCATION IrpSp;
PVCB Vcb;
PFCB Fcb;
PCCB Ccb;
ULONG Length;
FS_INFORMATION_CLASS FsInformationClass;
PVOID Buffer;
BOOLEAN WeAcquiredVcb = FALSE;
//
// Get the current stack location
//
IrpSp = IoGetCurrentIrpStackLocation( Irp );
DebugTrace(+1, Dbg, "FatCommonQueryVolumeInfo...\n", 0);
DebugTrace( 0, Dbg, "Irp = %08lx\n", Irp );
DebugTrace( 0, Dbg, "->Length = %08lx\n", IrpSp->Parameters.QueryVolume.Length);
DebugTrace( 0, Dbg, "->FsInformationClass = %08lx\n", IrpSp->Parameters.QueryVolume.FsInformationClass);
DebugTrace( 0, Dbg, "->Buffer = %08lx\n", Irp->AssociatedIrp.SystemBuffer);
//
// Reference our input parameters to make things easier
//
Length = IrpSp->Parameters.QueryVolume.Length;
FsInformationClass = IrpSp->Parameters.QueryVolume.FsInformationClass;
Buffer = Irp->AssociatedIrp.SystemBuffer;
//
// Decode the file object to get the Vcb
//
(VOID) FatDecodeFileObject( IrpSp->FileObject, &Vcb, &Fcb, &Ccb );
ASSERT( Vcb != NULL );
try {
//
// Make sure the vcb is in a usable condition. This will raise
// and error condition if the volume is unusable
//
// Also verify the Root Dcb since we need info from there.
//
FatVerifyFcb( IrpContext, Vcb->RootDcb );
//
// Based on the information class we'll do different actions. Each
// of the procedures that we're calling fills up the output buffer
// if possible and returns true if it successfully filled the buffer
// and false if it couldn't wait for any I/O to complete.
//
switch (FsInformationClass) {
case FileFsVolumeInformation:
//
// This is the only routine we need the Vcb shared because of
// copying the volume label. All other routines copy fields that
// cannot change or are just manifest constants.
//
if (!FatAcquireSharedVcb( IrpContext, Vcb )) {
DebugTrace(0, Dbg, "Cannot acquire Vcb\n", 0);
Status = FatFsdPostRequest( IrpContext, Irp );
IrpContext = NULL;
Irp = NULL;
} else {
WeAcquiredVcb = TRUE;
Status = FatQueryFsVolumeInfo( IrpContext, Vcb, Buffer, &Length );
}
break;
case FileFsSizeInformation:
Status = FatQueryFsSizeInfo( IrpContext, Vcb, Buffer, &Length );
break;
case FileFsDeviceInformation:
Status = FatQueryFsDeviceInfo( IrpContext, Vcb, Buffer, &Length );
break;
case FileFsAttributeInformation:
Status = FatQueryFsAttributeInfo( IrpContext, Vcb, Buffer, &Length );
break;
case FileFsFullSizeInformation:
Status = FatQueryFsFullSizeInfo( IrpContext, Vcb, Buffer, &Length );
break;
default:
Status = STATUS_INVALID_PARAMETER;
break;
}
//
// Set the information field to the number of bytes actually filled in.
//
if (Irp != NULL) {
Irp->IoStatus.Information = IrpSp->Parameters.QueryVolume.Length - Length;
}
} finally {
DebugUnwind( FatCommonQueryVolumeInfo );
if ( WeAcquiredVcb ) { FatReleaseVcb( IrpContext, Vcb ); }
if (!AbnormalTermination()) {
FatCompleteRequest( IrpContext, Irp, Status );
}
DebugTrace(-1, Dbg, "FatCommonQueryVolumeInfo -> %08lx\n", Status);
}
return Status;
}
NTSTATUS
NTAPI
FatiLockControl(PFAT_IRP_CONTEXT IrpContext, PIRP Irp)
{
PIO_STACK_LOCATION IrpSp;
TYPE_OF_OPEN TypeOfOpen;
PVCB Vcb;
PFCB Fcb;
PCCB Ccb;
NTSTATUS Status;
/* Get IRP stack location */
IrpSp = IoGetCurrentIrpStackLocation(Irp);
/* Determine type of open */
TypeOfOpen = FatDecodeFileObject(IrpSp->FileObject, &Vcb, &Fcb, &Ccb);
/* Only user file open is allowed */
if (TypeOfOpen != UserFileOpen)
{
FatCompleteRequest(IrpContext, Irp, STATUS_INVALID_PARAMETER);
return STATUS_INVALID_PARAMETER;
}
/* Acquire shared FCB lock */
if (!FatAcquireSharedFcb(IrpContext, Fcb))
{
UNIMPLEMENTED;
//Status = FatFsdPostRequest(IrpContext, Irp);
Status = STATUS_NOT_IMPLEMENTED;
return Status;
}
/* Check oplock state */
Status = FsRtlCheckOplock(&Fcb->Fcb.Oplock,
Irp,
IrpContext,
FatOplockComplete,
NULL);
if (Status != STATUS_SUCCESS)
{
/* Release FCB lock */
FatReleaseFcb(IrpContext, Fcb);
return Status;
}
/* Process the lock */
Status = FsRtlProcessFileLock(&Fcb->Fcb.Lock, Irp, NULL);
/* Update Fast I/O state */
Fcb->Header.IsFastIoPossible = FatIsFastIoPossible(Fcb);
/* Complete the request */
FatCompleteRequest(IrpContext, NULL, 0);
/* Release FCB lock */
FatReleaseFcb(IrpContext, Fcb);
return Status;
}
NTSTATUS
FatPnpCancelRemove (
PIRP_CONTEXT IrpContext,
PIRP Irp,
PVCB Vcb
)
/*++
Routine Description:
This routine handles the PnP cancel remove operation. This is our
notification that a previously proposed remove (query) was eventually
vetoed by a component. The filesystem is responsible for cleaning up
and getting ready for more IO.
Arguments:
Irp - Supplies the Irp to process
Vcb - Supplies the volume being removed.
Return Value:
NTSTATUS - The return status for the operation
--*/
{
NTSTATUS Status;
//
// CANCEL - a previous QUERY has been rescinded as a result
// of someone vetoing. Since PnP cannot figure out who may
// have gotten the QUERY (think about it: stacked drivers),
// we must expect to deal with getting a CANCEL without having
// seen the QUERY.
//
// For FAT, this is quite easy. In fact, we can't get a
// CANCEL if the underlying drivers succeeded the QUERY since
// we disconnect the Vpb on our dismount initiation. This is
// actually pretty important because if PnP could get to us
// after the disconnect we'd be thoroughly unsynchronized
// with respect to the Vcb getting torn apart - merely referencing
// the volume device object is insufficient to keep us intact.
//
FatAcquireExclusiveVcb( IrpContext, Vcb );
//
// Unlock the volume. This is benign if we never had seen
// a QUERY.
//
Status = FatUnlockVolumeInternal( IrpContext, Vcb, NULL );
try {
//
// Send the request. The underlying driver will complete the
// IRP. Since we don't need to be in the way, simply ellide
// ourselves out of the IRP stack.
//
IoSkipCurrentIrpStackLocation( Irp );
Status = IoCallDriver(Vcb->TargetDeviceObject, Irp);
}
finally {
FatReleaseVcb( IrpContext, Vcb );
}
FatCompleteRequest( IrpContext, NULL, STATUS_SUCCESS );
return Status;
}
NTSTATUS
NdasFatSecondaryQueryDirectory (
IN PIRP_CONTEXT IrpContext,
IN PIRP Irp
)
/*++
Routine Description:
This routine performs the query directory operation. It is responsible
for either completing of enqueuing the input Irp.
Arguments:
Irp - Supplies the Irp to process
Return Value:
NTSTATUS - The return status for the operation
--*/
{
NTSTATUS Status;
PIO_STACK_LOCATION IrpSp;
PVCB Vcb;
PDCB Dcb;
PCCB Ccb;
PBCB Bcb;
ULONG i;
PUCHAR Buffer;
CLONG UserBufferLength;
PUNICODE_STRING UniArgFileName;
WCHAR LongFileNameBuffer[ FAT_CREATE_INITIAL_NAME_BUF_SIZE];
UNICODE_STRING LongFileName;
FILE_INFORMATION_CLASS FileInformationClass;
ULONG FileIndex;
BOOLEAN RestartScan;
BOOLEAN ReturnSingleEntry;
BOOLEAN IndexSpecified;
BOOLEAN InitialQuery;
VBO CurrentVbo;
BOOLEAN UpdateCcb;
PDIRENT Dirent;
UCHAR Fat8Dot3Buffer[12];
OEM_STRING Fat8Dot3String;
ULONG DiskAllocSize;
ULONG NextEntry;
ULONG LastEntry;
PFILE_DIRECTORY_INFORMATION DirInfo;
PFILE_FULL_DIR_INFORMATION FullDirInfo;
PFILE_BOTH_DIR_INFORMATION BothDirInfo;
PFILE_ID_FULL_DIR_INFORMATION IdFullDirInfo;
PFILE_ID_BOTH_DIR_INFORMATION IdBothDirInfo;
PFILE_NAMES_INFORMATION NamesInfo;
#if 1
PVOLUME_DEVICE_OBJECT volDo;
BOOLEAN secondarySessionResourceAcquired = FALSE;
PSECONDARY_REQUEST secondaryRequest = NULL;
PNDFS_REQUEST_HEADER ndfsRequestHeader;
PNDFS_WINXP_REQUEST_HEADER ndfsWinxpRequestHeader;
PNDFS_WINXP_REPLY_HEADER ndfsWinxpReplytHeader;
_U8 *ndfsWinxpRequestData;
LARGE_INTEGER timeOut;
struct QueryDirectory queryDirectory;
PVOID inputBuffer;
ULONG inputBufferLength;
ULONG returnedDataSize;
#endif
PAGED_CODE();
//
// Get the current Stack location
//
IrpSp = IoGetCurrentIrpStackLocation( Irp );
//
// Display the input values.
//
DebugTrace(+1, Dbg, "FatQueryDirectory...\n", 0);
DebugTrace( 0, Dbg, " Wait = %08lx\n", FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT));
DebugTrace( 0, Dbg, " Irp = %08lx\n", Irp);
DebugTrace( 0, Dbg, " ->Length = %08lx\n", IrpSp->Parameters.QueryDirectory.Length);
DebugTrace( 0, Dbg, " ->FileName = %08lx\n", IrpSp->Parameters.QueryDirectory.FileName);
DebugTrace( 0, Dbg, " ->FileInformationClass = %08lx\n", IrpSp->Parameters.QueryDirectory.FileInformationClass);
DebugTrace( 0, Dbg, " ->FileIndex = %08lx\n", IrpSp->Parameters.QueryDirectory.FileIndex);
DebugTrace( 0, Dbg, " ->UserBuffer = %08lx\n", Irp->AssociatedIrp.SystemBuffer);
DebugTrace( 0, Dbg, " ->RestartScan = %08lx\n", FlagOn( IrpSp->Flags, SL_RESTART_SCAN ));
DebugTrace( 0, Dbg, " ->ReturnSingleEntry = %08lx\n", FlagOn( IrpSp->Flags, SL_RETURN_SINGLE_ENTRY ));
DebugTrace( 0, Dbg, " ->IndexSpecified = %08lx\n", FlagOn( IrpSp->Flags, SL_INDEX_SPECIFIED ));
//
// Reference our input parameters to make things easier
//
UserBufferLength = IrpSp->Parameters.QueryDirectory.Length;
FileInformationClass = IrpSp->Parameters.QueryDirectory.FileInformationClass;
FileIndex = IrpSp->Parameters.QueryDirectory.FileIndex;
UniArgFileName = (PUNICODE_STRING) IrpSp->Parameters.QueryDirectory.FileName;
RestartScan = BooleanFlagOn(IrpSp->Flags, SL_RESTART_SCAN);
ReturnSingleEntry = BooleanFlagOn(IrpSp->Flags, SL_RETURN_SINGLE_ENTRY);
IndexSpecified = BooleanFlagOn(IrpSp->Flags, SL_INDEX_SPECIFIED);
//
// Check on the type of open. We return invalid parameter for all
// but UserDirectoryOpens. Also check that the filename is a valid
// UNICODE string.
//
if (FatDecodeFileObject( IrpSp->FileObject,
&Vcb,
&Dcb,
&Ccb) != UserDirectoryOpen ||
(UniArgFileName &&
UniArgFileName->Length % sizeof(WCHAR))) {
FatCompleteRequest( IrpContext, Irp, STATUS_INVALID_PARAMETER );
DebugTrace(-1, Dbg, "FatQueryDirectory -> STATUS_INVALID_PARAMETER\n", 0);
return STATUS_INVALID_PARAMETER;
}
#if 1
if (FlagOn(Ccb->NdasFatFlags, ND_FAT_CCB_FLAG_UNOPENED)) {
ASSERT( FlagOn(Ccb->NdasFatFlags, ND_FAT_CCB_FLAG_CORRUPTED) );
FatCompleteRequest( IrpContext, Irp, STATUS_FILE_CORRUPT_ERROR );
DebugTrace2( -1, Dbg, ("NtfsCommonDirectoryControl -> STATUS_FILE_CORRUPT_ERROR\n") );
return STATUS_FILE_CORRUPT_ERROR;
}
#endif
//
// Initialize the local variables.
//
Bcb = NULL;
UpdateCcb = TRUE;
Dirent = NULL;
Fat8Dot3String.MaximumLength = 12;
Fat8Dot3String.Buffer = Fat8Dot3Buffer;
LongFileName.Length = 0;
LongFileName.MaximumLength = sizeof( LongFileNameBuffer);
LongFileName.Buffer = LongFileNameBuffer;
InitialQuery = (BOOLEAN)((Ccb->UnicodeQueryTemplate.Buffer == NULL) &&
!FlagOn(Ccb->Flags, CCB_FLAG_MATCH_ALL));
Status = STATUS_SUCCESS;
Irp->IoStatus.Information = 0;
DiskAllocSize = 1 << Vcb->AllocationSupport.LogOfBytesPerCluster;
//
// If this is the initial query, then grab exclusive access in
// order to update the search string in the Ccb. We may
// discover that we are not the initial query once we grab the Fcb
// and downgrade our status.
//
if (InitialQuery) {
if (!FatAcquireExclusiveFcb( IrpContext, Dcb )) {
DebugTrace(0, Dbg, "FatQueryDirectory -> Enqueue to Fsp\n", 0);
Status = FatFsdPostRequest( IrpContext, Irp );
DebugTrace(-1, Dbg, "FatQueryDirectory -> %08lx\n", Status);
return Status;
}
if (Ccb->UnicodeQueryTemplate.Buffer != NULL) {
InitialQuery = FALSE;
FatConvertToSharedFcb( IrpContext, Dcb );
}
} else {
if (!FatAcquireSharedFcb( IrpContext, Dcb )) {
DebugTrace(0, Dbg, "FatQueryDirectory -> Enqueue to Fsp\n", 0);
Status = FatFsdPostRequest( IrpContext, Irp );
DebugTrace(-1, Dbg, "FatQueryDirectory -> %08lx\n", Status);
return Status;
}
}
try {
ULONG BaseLength;
ULONG BytesConverted;
//
// If we are in the Fsp now because we had to wait earlier,
// we must map the user buffer, otherwise we can use the
// user's buffer directly.
//
Buffer = FatMapUserBuffer( IrpContext, Irp );
#if 1
volDo = CONTAINING_RECORD( Vcb, VOLUME_DEVICE_OBJECT, Vcb );
secondarySessionResourceAcquired
= SecondaryAcquireResourceExclusiveLite( IrpContext,
&volDo->SessionResource,
BooleanFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT) );
if (FlagOn(volDo->Secondary->Thread.Flags, SECONDARY_THREAD_FLAG_REMOTE_DISCONNECTED)) {
NDASFAT_ASSERT( FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT) );
SetFlag( IrpContext->NdasFatFlags, NDAS_FAT_IRP_CONTEXT_FLAG_DONT_POST_REQUEST );
FatRaiseStatus( IrpContext, STATUS_CANT_WAIT );
}
queryDirectory.FileIndex = IrpSp->Parameters.QueryDirectory.FileIndex;
queryDirectory.FileInformationClass = IrpSp->Parameters.QueryDirectory.FileInformationClass;
queryDirectory.FileName = IrpSp->Parameters.QueryDirectory.FileName;
queryDirectory.Length = IrpSp->Parameters.QueryDirectory.Length;
inputBuffer = (queryDirectory.FileName) ? (queryDirectory.FileName->Buffer) : NULL;
inputBufferLength = (queryDirectory.FileName) ? (queryDirectory.FileName->Length) : 0;
if (queryDirectory.FileName) {
DebugTrace2( 0, Dbg, ("NdNtfsSecondaryQueryDirectory: queryFileName = %wZ\n", queryDirectory.FileName) );
}
ASSERT( inputBufferLength <= volDo->Secondary->Thread.SessionContext.PrimaryMaxDataSize );
ASSERT( UserBufferLength <= volDo->Secondary->Thread.SessionContext.SecondaryMaxDataSize );
secondaryRequest = AllocateWinxpSecondaryRequest( volDo->Secondary,
IRP_MJ_DIRECTORY_CONTROL,
((inputBufferLength > UserBufferLength) ? inputBufferLength : UserBufferLength) );
if (secondaryRequest == NULL) {
try_return( Status = STATUS_INSUFFICIENT_RESOURCES );
}
ndfsRequestHeader = &secondaryRequest->NdfsRequestHeader;
INITIALIZE_NDFS_REQUEST_HEADER( ndfsRequestHeader,
NDFS_COMMAND_EXECUTE,
volDo->Secondary,
IRP_MJ_DIRECTORY_CONTROL,
inputBufferLength );
ndfsWinxpRequestHeader = (PNDFS_WINXP_REQUEST_HEADER)(ndfsRequestHeader+1);
ASSERT( ndfsWinxpRequestHeader == (PNDFS_WINXP_REQUEST_HEADER)secondaryRequest->NdfsRequestData );
INITIALIZE_NDFS_WINXP_REQUEST_HEADER( ndfsWinxpRequestHeader, Irp, IrpSp, Ccb->PrimaryFileHandle );
ndfsWinxpRequestHeader->QueryDirectory.Length = UserBufferLength;
ndfsWinxpRequestHeader->QueryDirectory.FileInformationClass = queryDirectory.FileInformationClass;
ndfsWinxpRequestHeader->QueryDirectory.FileIndex = queryDirectory.FileIndex;
ndfsWinxpRequestData = (_U8 *)(ndfsWinxpRequestHeader+1);
if (inputBufferLength)
RtlCopyMemory( ndfsWinxpRequestData, inputBuffer, inputBufferLength );
secondaryRequest->RequestType = SECONDARY_REQ_SEND_MESSAGE;
QueueingSecondaryRequest( volDo->Secondary, secondaryRequest );
timeOut.QuadPart = -NDASFAT_TIME_OUT;
Status = KeWaitForSingleObject( &secondaryRequest->CompleteEvent, Executive, KernelMode, FALSE, &timeOut );
KeClearEvent( &secondaryRequest->CompleteEvent );
if (Status != STATUS_SUCCESS) {
secondaryRequest = NULL;
try_return( Status = STATUS_IO_DEVICE_ERROR );
}
SecondaryReleaseResourceLite( IrpContext, &volDo->SessionResource );
secondarySessionResourceAcquired = FALSE;
if (secondaryRequest->ExecuteStatus != STATUS_SUCCESS) {
if (IrpContext->OriginatingIrp)
PrintIrp( Dbg2, "secondaryRequest->ExecuteStatus != STATUS_SUCCESS", NULL, IrpContext->OriginatingIrp );
DebugTrace2( 0, Dbg2, ("secondaryRequest->ExecuteStatus != STATUS_SUCCESS file = %s, line = %d\n", __FILE__, __LINE__) );
NDASFAT_ASSERT( FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT) );
SetFlag( IrpContext->NdasFatFlags, NDAS_FAT_IRP_CONTEXT_FLAG_DONT_POST_REQUEST );
FatRaiseStatus( IrpContext, STATUS_CANT_WAIT );
}
ndfsWinxpReplytHeader = (PNDFS_WINXP_REPLY_HEADER)secondaryRequest->NdfsReplyData;
Status = Irp->IoStatus.Status = ndfsWinxpReplytHeader->Status;
Irp->IoStatus.Information = ndfsWinxpReplytHeader->Information;
returnedDataSize = secondaryRequest->NdfsReplyHeader.MessageSize - sizeof(NDFS_REPLY_HEADER) - sizeof(NDFS_WINXP_REPLY_HEADER);
if (returnedDataSize) {
ASSERT( ndfsWinxpReplytHeader->Information != 0 );
ASSERT(returnedDataSize <= ADD_ALIGN8(queryDirectory.Length));
ASSERT( Buffer );
RtlCopyMemory( Buffer,
(_U8 *)(ndfsWinxpReplytHeader+1),
(returnedDataSize < queryDirectory.Length) ? returnedDataSize : queryDirectory.Length );
}
#endif
#if 0
//
// Make sure the Dcb is still good.
//
FatVerifyFcb( IrpContext, Dcb );
//
// Determine where to start the scan. Highest priority is given
// to the file index. Lower priority is the restart flag. If
// neither of these is specified, then the Vbo offset field in the
// Ccb is used.
//
if (IndexSpecified) {
CurrentVbo = FileIndex + sizeof( DIRENT );
} else if (RestartScan) {
CurrentVbo = 0;
} else {
CurrentVbo = Ccb->OffsetToStartSearchFrom;
}
//
// If this is the first try then allocate a buffer for the file
// name.
//
if (InitialQuery) {
//
// If either:
//
// - No name was specified
// - An empty name was specified
// - We received a '*'
// - The user specified the DOS equivolent of ????????.???
//
// then match all names.
//
if ((UniArgFileName == NULL) ||
(UniArgFileName->Length == 0) ||
(UniArgFileName->Buffer == NULL) ||
((UniArgFileName->Length == sizeof(WCHAR)) &&
(UniArgFileName->Buffer[0] == L'*')) ||
((UniArgFileName->Length == 12*sizeof(WCHAR)) &&
(RtlEqualMemory( UniArgFileName->Buffer,
Fat8QMdot3QM,
12*sizeof(WCHAR) )))) {
Ccb->ContainsWildCards = TRUE;
SetFlag( Ccb->Flags, CCB_FLAG_MATCH_ALL );
} else {
BOOLEAN ExtendedName = FALSE;
OEM_STRING LocalBestFit;
//
// First and formost, see if the name has wild cards.
//
Ccb->ContainsWildCards =
FsRtlDoesNameContainWildCards( UniArgFileName );
//
// Now check to see if the name contains any extended
// characters
//
for (i=0; i < UniArgFileName->Length / sizeof(WCHAR); i++) {
if (UniArgFileName->Buffer[i] >= 0x80) {
ExtendedName = TRUE;
break;
}
}
//
// OK, now do the conversions we need.
//
if (ExtendedName) {
Status = RtlUpcaseUnicodeString( &Ccb->UnicodeQueryTemplate,
UniArgFileName,
TRUE );
if (!NT_SUCCESS(Status)) {
try_return( Status );
}
SetFlag( Ccb->Flags, CCB_FLAG_FREE_UNICODE );
//
// Upcase the name and convert it to the Oem code page.
//
Status = RtlUpcaseUnicodeStringToCountedOemString( &LocalBestFit,
UniArgFileName,
TRUE );
//
// If this conversion failed for any reason other than
// an unmappable character fail the request.
//
if (!NT_SUCCESS(Status)) {
if (Status == STATUS_UNMAPPABLE_CHARACTER) {
SetFlag( Ccb->Flags, CCB_FLAG_SKIP_SHORT_NAME_COMPARE );
} else {
try_return( Status );
}
} else {
SetFlag( Ccb->Flags, CCB_FLAG_FREE_OEM_BEST_FIT );
}
} else {
PVOID Buffers;
//
// This case is optimized because I know I only have to
// worry about a-z.
//
Buffers = FsRtlAllocatePoolWithTag( PagedPool,
UniArgFileName->Length +
UniArgFileName->Length / sizeof(WCHAR),
TAG_FILENAME_BUFFER );
Ccb->UnicodeQueryTemplate.Buffer = Buffers;
Ccb->UnicodeQueryTemplate.Length = UniArgFileName->Length;
Ccb->UnicodeQueryTemplate.MaximumLength = UniArgFileName->Length;
LocalBestFit.Buffer = (PUCHAR)Buffers + UniArgFileName->Length;
LocalBestFit.Length = UniArgFileName->Length / sizeof(WCHAR);
LocalBestFit.MaximumLength = LocalBestFit.Length;
SetFlag( Ccb->Flags, CCB_FLAG_FREE_UNICODE );
for (i=0; i < UniArgFileName->Length / sizeof(WCHAR); i++) {
WCHAR c = UniArgFileName->Buffer[i];
LocalBestFit.Buffer[i] = (UCHAR)
(Ccb->UnicodeQueryTemplate.Buffer[i] =
(c < 'a' ? c : c <= 'z' ? c - ('a' - 'A') : c));
}
}
//
// At this point we now have the upcased unicode name,
// and the two Oem names if they could be represented in
// this code page.
//
// Now determine if the Oem names are legal for what we
// going to try and do. Mark them as not usable is they
// are not legal. Note that we can optimize extended names
// since they are actually both the same string.
//
if (!FlagOn( Ccb->Flags, CCB_FLAG_SKIP_SHORT_NAME_COMPARE ) &&
!FatIsNameShortOemValid( IrpContext,
LocalBestFit,
Ccb->ContainsWildCards,
FALSE,
FALSE )) {
if (ExtendedName) {
RtlFreeOemString( &LocalBestFit );
ClearFlag( Ccb->Flags, CCB_FLAG_FREE_OEM_BEST_FIT );
}
SetFlag( Ccb->Flags, CCB_FLAG_SKIP_SHORT_NAME_COMPARE );
}
//
// OK, now both locals oem strings correctly reflect their
// usability. Now we want to load up the Ccb structure.
//
// Now we will branch on two paths of wheather the name
// is wild or not.
//
if (!FlagOn( Ccb->Flags, CCB_FLAG_SKIP_SHORT_NAME_COMPARE )) {
if (Ccb->ContainsWildCards) {
Ccb->OemQueryTemplate.Wild = LocalBestFit;
} else {
FatStringTo8dot3( IrpContext,
LocalBestFit,
&Ccb->OemQueryTemplate.Constant );
if (FlagOn(Ccb->Flags, CCB_FLAG_FREE_OEM_BEST_FIT)) {
RtlFreeOemString( &LocalBestFit );
ClearFlag( Ccb->Flags, CCB_FLAG_FREE_OEM_BEST_FIT );
}
}
}
}
//
// We convert to shared access.
//
FatConvertToSharedFcb( IrpContext, Dcb );
}
LastEntry = 0;
NextEntry = 0;
switch (FileInformationClass) {
case FileDirectoryInformation:
BaseLength = FIELD_OFFSET( FILE_DIRECTORY_INFORMATION,
FileName[0] );
break;
case FileFullDirectoryInformation:
BaseLength = FIELD_OFFSET( FILE_FULL_DIR_INFORMATION,
FileName[0] );
break;
case FileIdFullDirectoryInformation:
BaseLength = FIELD_OFFSET( FILE_ID_FULL_DIR_INFORMATION,
FileName[0] );
break;
case FileNamesInformation:
BaseLength = FIELD_OFFSET( FILE_NAMES_INFORMATION,
FileName[0] );
break;
case FileBothDirectoryInformation:
BaseLength = FIELD_OFFSET( FILE_BOTH_DIR_INFORMATION,
FileName[0] );
break;
case FileIdBothDirectoryInformation:
BaseLength = FIELD_OFFSET( FILE_ID_BOTH_DIR_INFORMATION,
FileName[0] );
break;
default:
try_return( Status = STATUS_INVALID_INFO_CLASS );
}
//
// At this point we are about to enter our query loop. We have
// determined the index into the directory file to begin the
// search. LastEntry and NextEntry are used to index into the user
// buffer. LastEntry is the last entry we've added, NextEntry is
// current one we're working on. If NextEntry is non-zero, then
// at least one entry was added.
//
while ( TRUE ) {
VBO NextVbo;
ULONG FileNameLength;
ULONG BytesRemainingInBuffer;
DebugTrace(0, Dbg, "FatQueryDirectory -> Top of loop\n", 0);
//
// If the user had requested only a single match and we have
// returned that, then we stop at this point.
//
if (ReturnSingleEntry && NextEntry != 0) {
try_return( Status );
}
//
// We call FatLocateDirent to lock down the next matching dirent.
//
FatLocateDirent( IrpContext,
Dcb,
Ccb,
CurrentVbo,
&Dirent,
&Bcb,
&NextVbo,
NULL,
&LongFileName);
//
// If we didn't receive a dirent, then we are at the end of the
// directory. If we have returned any files, we exit with
// success, otherwise we return STATUS_NO_MORE_FILES.
//
if (!Dirent) {
DebugTrace(0, Dbg, "FatQueryDirectory -> No dirent\n", 0);
if (NextEntry == 0) {
UpdateCcb = FALSE;
if (InitialQuery) {
Status = STATUS_NO_SUCH_FILE;
} else {
Status = STATUS_NO_MORE_FILES;
}
}
try_return( Status );
}
//
// Protect access to the user buffer with an exception handler.
// Since (at our request) IO doesn't buffer these requests, we have
// to guard against a user messing with the page protection and other
// such trickery.
//
try {
if (LongFileName.Length == 0) {
//
// Now we have an entry to return to our caller. We'll convert
// the name from the form in the dirent to a <name>.<ext> form.
// We'll case on the type of information requested and fill up
// the user buffer if everything fits.
//
Fat8dot3ToString( IrpContext, Dirent, TRUE, &Fat8Dot3String );
//
// Determine the UNICODE length of the file name.
//
FileNameLength = RtlOemStringToCountedUnicodeSize(&Fat8Dot3String);
//
// Here are the rules concerning filling up the buffer:
//
// 1. The Io system garentees that there will always be
// enough room for at least one base record.
//
// 2. If the full first record (including file name) cannot
// fit, as much of the name as possible is copied and
// STATUS_BUFFER_OVERFLOW is returned.
//
// 3. If a subsequent record cannot completely fit into the
// buffer, none of it (as in 0 bytes) is copied, and
// STATUS_SUCCESS is returned. A subsequent query will
// pick up with this record.
//
BytesRemainingInBuffer = UserBufferLength - NextEntry;
if ( (NextEntry != 0) &&
( (BaseLength + FileNameLength > BytesRemainingInBuffer) ||
(UserBufferLength < NextEntry) ) ) {
DebugTrace(0, Dbg, "Next entry won't fit\n", 0);
try_return( Status = STATUS_SUCCESS );
}
ASSERT( BytesRemainingInBuffer >= BaseLength );
//
// Zero the base part of the structure.
//
RtlZeroMemory( &Buffer[NextEntry], BaseLength );
switch ( FileInformationClass ) {
//
// Now fill the base parts of the strucure that are applicable.
//
case FileBothDirectoryInformation:
case FileFullDirectoryInformation:
case FileIdBothDirectoryInformation:
case FileIdFullDirectoryInformation:
DebugTrace(0, Dbg, "FatQueryDirectory -> Getting file full directory information\n", 0);
//
// Get the Ea file length.
//
FullDirInfo = (PFILE_FULL_DIR_INFORMATION)&Buffer[NextEntry];
//
// If the EAs are corrupt, ignore the error. We don't want
// to abort the directory query.
//
try {
FatGetEaLength( IrpContext,
Vcb,
Dirent,
&FullDirInfo->EaSize );
} except(EXCEPTION_EXECUTE_HANDLER) {
FatResetExceptionState( IrpContext );
FullDirInfo->EaSize = 0;
}
case FileDirectoryInformation:
DirInfo = (PFILE_DIRECTORY_INFORMATION)&Buffer[NextEntry];
FatGetDirTimes( IrpContext, Dirent, DirInfo );
DirInfo->EndOfFile.QuadPart = Dirent->FileSize;
if (!FlagOn( Dirent->Attributes, FAT_DIRENT_ATTR_DIRECTORY )) {
DirInfo->AllocationSize.QuadPart =
(((Dirent->FileSize + DiskAllocSize - 1) / DiskAllocSize) *
DiskAllocSize );
}
DirInfo->FileAttributes = Dirent->Attributes != 0 ?
Dirent->Attributes :
FILE_ATTRIBUTE_NORMAL;
DirInfo->FileIndex = NextVbo;
DirInfo->FileNameLength = FileNameLength;
DebugTrace(0, Dbg, "FatQueryDirectory -> Name = \"%Z\"\n", &Fat8Dot3String);
break;
case FileNamesInformation:
DebugTrace(0, Dbg, "FatQueryDirectory -> Getting file names information\n", 0);
NamesInfo = (PFILE_NAMES_INFORMATION)&Buffer[NextEntry];
NamesInfo->FileIndex = NextVbo;
NamesInfo->FileNameLength = FileNameLength;
DebugTrace(0, Dbg, "FatQueryDirectory -> Name = \"%Z\"\n", &Fat8Dot3String );
break;
default:
FatBugCheck( FileInformationClass, 0, 0 );
}
BytesConverted = 0;
Status = RtlOemToUnicodeN( (PWCH)&Buffer[NextEntry + BaseLength],
BytesRemainingInBuffer - BaseLength,
&BytesConverted,
Fat8Dot3String.Buffer,
Fat8Dot3String.Length );
//
// Check for the case that a single entry doesn't fit.
// This should only get this far on the first entry
//
if (BytesConverted < FileNameLength) {
ASSERT( NextEntry == 0 );
Status = STATUS_BUFFER_OVERFLOW;
}
//
// Set up the previous next entry offset
//
*((PULONG)(&Buffer[LastEntry])) = NextEntry - LastEntry;
//
// And indicate how much of the user buffer we have currently
// used up. We must compute this value before we long align
// ourselves for the next entry
//
Irp->IoStatus.Information = QuadAlign( Irp->IoStatus.Information ) +
BaseLength + BytesConverted;
//
// If something happened with the conversion, bail here.
//
if ( !NT_SUCCESS( Status ) ) {
try_return( NOTHING );
}
} else {
ULONG ShortNameLength;
FileNameLength = LongFileName.Length;
//
// Here are the rules concerning filling up the buffer:
//
// 1. The Io system garentees that there will always be
// enough room for at least one base record.
//
// 2. If the full first record (including file name) cannot
// fit, as much of the name as possible is copied and
// STATUS_BUFFER_OVERFLOW is returned.
//
// 3. If a subsequent record cannot completely fit into the
// buffer, none of it (as in 0 bytes) is copied, and
// STATUS_SUCCESS is returned. A subsequent query will
// pick up with this record.
//
BytesRemainingInBuffer = UserBufferLength - NextEntry;
if ( (NextEntry != 0) &&
( (BaseLength + FileNameLength > BytesRemainingInBuffer) ||
(UserBufferLength < NextEntry) ) ) {
DebugTrace(0, Dbg, "Next entry won't fit\n", 0);
try_return( Status = STATUS_SUCCESS );
}
ASSERT( BytesRemainingInBuffer >= BaseLength );
//
// Zero the base part of the structure.
//
RtlZeroMemory( &Buffer[NextEntry], BaseLength );
switch ( FileInformationClass ) {
//
// Now fill the base parts of the strucure that are applicable.
//
case FileBothDirectoryInformation:
case FileIdBothDirectoryInformation:
BothDirInfo = (PFILE_BOTH_DIR_INFORMATION)&Buffer[NextEntry];
//
// Now we have an entry to return to our caller. We'll convert
// the name from the form in the dirent to a <name>.<ext> form.
// We'll case on the type of information requested and fill up
// the user buffer if everything fits.
//
Fat8dot3ToString( IrpContext, Dirent, FALSE, &Fat8Dot3String );
ASSERT( Fat8Dot3String.Length <= 12 );
Status = RtlOemToUnicodeN( &BothDirInfo->ShortName[0],
12*sizeof(WCHAR),
&ShortNameLength,
Fat8Dot3String.Buffer,
Fat8Dot3String.Length );
ASSERT( Status != STATUS_BUFFER_OVERFLOW );
ASSERT( ShortNameLength <= 12*sizeof(WCHAR) );
//
// Copy the length into the dirinfo structure. Note
// that the LHS below is a USHORT, so it can not
// be specificed as the OUT parameter above.
//
BothDirInfo->ShortNameLength = (UCHAR)ShortNameLength;
//
// If something happened with the conversion, bail here.
//
if ( !NT_SUCCESS( Status ) ) {
try_return( NOTHING );
}
case FileFullDirectoryInformation:
case FileIdFullDirectoryInformation:
DebugTrace(0, Dbg, "FatQueryDirectory -> Getting file full directory information\n", 0);
//
// Get the Ea file length.
//
FullDirInfo = (PFILE_FULL_DIR_INFORMATION)&Buffer[NextEntry];
//
// If the EAs are corrupt, ignore the error. We don't want
// to abort the directory query.
//
try {
FatGetEaLength( IrpContext,
Vcb,
Dirent,
&FullDirInfo->EaSize );
} except(EXCEPTION_EXECUTE_HANDLER) {
FatResetExceptionState( IrpContext );
FullDirInfo->EaSize = 0;
}
case FileDirectoryInformation:
DirInfo = (PFILE_DIRECTORY_INFORMATION)&Buffer[NextEntry];
FatGetDirTimes( IrpContext, Dirent, DirInfo );
DirInfo->EndOfFile.QuadPart = Dirent->FileSize;
if (!FlagOn( Dirent->Attributes, FAT_DIRENT_ATTR_DIRECTORY )) {
DirInfo->AllocationSize.QuadPart = (
(( Dirent->FileSize
+ DiskAllocSize - 1 )
/ DiskAllocSize )
* DiskAllocSize );
}
DirInfo->FileAttributes = Dirent->Attributes != 0 ?
Dirent->Attributes :
FILE_ATTRIBUTE_NORMAL;
DirInfo->FileIndex = NextVbo;
DirInfo->FileNameLength = FileNameLength;
DebugTrace(0, Dbg, "FatQueryDirectory -> Name = \"%Z\"\n", &Fat8Dot3String);
break;
case FileNamesInformation:
DebugTrace(0, Dbg, "FatQueryDirectory -> Getting file names information\n", 0);
NamesInfo = (PFILE_NAMES_INFORMATION)&Buffer[NextEntry];
NamesInfo->FileIndex = NextVbo;
NamesInfo->FileNameLength = FileNameLength;
DebugTrace(0, Dbg, "FatQueryDirectory -> Name = \"%Z\"\n", &Fat8Dot3String );
break;
default:
FatBugCheck( FileInformationClass, 0, 0 );
}
BytesConverted = BytesRemainingInBuffer - BaseLength >= FileNameLength ?
FileNameLength :
BytesRemainingInBuffer - BaseLength;
RtlCopyMemory( &Buffer[NextEntry + BaseLength],
&LongFileName.Buffer[0],
BytesConverted );
//
// Set up the previous next entry offset
//
*((PULONG)(&Buffer[LastEntry])) = NextEntry - LastEntry;
//
// And indicate how much of the user buffer we have currently
// used up. We must compute this value before we long align
// ourselves for the next entry
//
Irp->IoStatus.Information = QuadAlign( Irp->IoStatus.Information ) +
BaseLength + BytesConverted;
//
// Check for the case that a single entry doesn't fit.
// This should only get this far on the first entry.
//
if (BytesConverted < FileNameLength) {
ASSERT( NextEntry == 0 );
try_return( Status = STATUS_BUFFER_OVERFLOW );
}
}
//
// Finish up by filling in the FileId
//
switch ( FileInformationClass ) {
case FileIdBothDirectoryInformation:
IdBothDirInfo = (PFILE_ID_BOTH_DIR_INFORMATION)&Buffer[NextEntry];
IdBothDirInfo->FileId.QuadPart = FatGenerateFileIdFromDirentAndOffset( Dcb, Dirent, NextVbo );
break;
case FileIdFullDirectoryInformation:
IdFullDirInfo = (PFILE_ID_FULL_DIR_INFORMATION)&Buffer[NextEntry];
IdFullDirInfo->FileId.QuadPart = FatGenerateFileIdFromDirentAndOffset( Dcb, Dirent, NextVbo );
break;
default:
break;
}
} except (EXCEPTION_EXECUTE_HANDLER) {
//
// We had a problem filling in the user's buffer, so stop and
// fail this request. This is the only reason any exception
// would have occured at this level.
//
Irp->IoStatus.Information = 0;
UpdateCcb = FALSE;
try_return( Status = GetExceptionCode());
}
//
// Set ourselves up for the next iteration
//
LastEntry = NextEntry;
NextEntry += (ULONG)QuadAlign(BaseLength + BytesConverted);
CurrentVbo = NextVbo + sizeof( DIRENT );
}
#endif
try_exit: NOTHING;
} finally {
NTSTATUS
NdasFatSecondaryUserFsCtrl (
IN PIRP_CONTEXT IrpContext,
IN PIRP Irp
)
/*++
Routine Description:
This is the common routine for implementing the user's requests made
through NtFsControlFile.
Arguments:
Irp - Supplies the Irp being processed
Return Value:
NTSTATUS - The return status for the operation
--*/
{
NTSTATUS Status;
ULONG FsControlCode;
PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation( Irp );
PVOLUME_DEVICE_OBJECT volDo = CONTAINING_RECORD( IrpContext->Vcb, VOLUME_DEVICE_OBJECT, Vcb );
BOOLEAN secondarySessionResourceAcquired = FALSE;
TYPE_OF_OPEN typeOfOpen;
PVCB vcb;
PFCB fcb;
PCCB ccb;
PSECONDARY_REQUEST secondaryRequest = NULL;
PNDFS_REQUEST_HEADER ndfsRequestHeader;
PNDFS_WINXP_REQUEST_HEADER ndfsWinxpRequestHeader;
PNDFS_WINXP_REPLY_HEADER ndfsWinxpReplytHeader;
UINT8 *ndfsWinxpRequestData;
LARGE_INTEGER timeOut;
struct FileSystemControl fileSystemControl;
PVOID inputBuffer = NULL;
ULONG inputBufferLength;
PVOID outputBuffer = NULL;
ULONG outputBufferLength;
ULONG bufferLength;
//
// Save some references to make our life a little easier
//
FsControlCode = IrpSp->Parameters.FileSystemControl.FsControlCode;
DebugTrace(+1, Dbg,"FatUserFsCtrl...\n", 0);
DebugTrace( 0, Dbg,"FsControlCode = %08lx\n", FsControlCode);
//
// Some of these Fs Controls use METHOD_NEITHER buffering. If the previous mode
// of the caller was userspace and this is a METHOD_NEITHER, we have the choice
// of realy buffering the request through so we can possibly post, or making the
// request synchronous. Since the former was not done by design, do the latter.
//
if (Irp->RequestorMode != KernelMode && (FsControlCode & 3) == METHOD_NEITHER) {
SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT);
}
//
// Case on the control code.
//
switch ( FsControlCode ) {
case FSCTL_REQUEST_OPLOCK_LEVEL_1:
case FSCTL_REQUEST_OPLOCK_LEVEL_2:
case FSCTL_REQUEST_BATCH_OPLOCK:
case FSCTL_OPLOCK_BREAK_ACKNOWLEDGE:
case FSCTL_OPBATCH_ACK_CLOSE_PENDING:
case FSCTL_OPLOCK_BREAK_NOTIFY:
case FSCTL_OPLOCK_BREAK_ACK_NO_2:
case FSCTL_REQUEST_FILTER_OPLOCK :
//ASSERT( FALSE );
//Status = STATUS_SUCCESS;
//break;
Status = FatOplockRequest( IrpContext, Irp );
return Status;
case FSCTL_LOCK_VOLUME:
FatCompleteRequest( IrpContext, Irp, Status = STATUS_ACCESS_DENIED );
DebugTrace2( -1, Dbg, ("NdasFatSecondaryUserFsCtrl -> %08lx\n", Status) );
return Status;
//Status = FatLockVolume( IrpContext, Irp );
break;
case FSCTL_UNLOCK_VOLUME:
FatCompleteRequest( IrpContext, Irp, Status = STATUS_ACCESS_DENIED );
DebugTrace2( -1, Dbg, ("NdasFatSecondaryUserFsCtrl -> %08lx\n", Status) );
return Status;
//Status = FatUnlockVolume( IrpContext, Irp );
break;
case FSCTL_DISMOUNT_VOLUME:
FatCompleteRequest( IrpContext, Irp, Status = STATUS_ACCESS_DENIED );
DebugTrace2( -1, Dbg, ("NdasFatSecondaryUserFsCtrl -> %08lx\n", Status) );
return Status;
//Status = FatDismountVolume( IrpContext, Irp );
break;
case FSCTL_MARK_VOLUME_DIRTY:
FatCompleteRequest( IrpContext, Irp, Status = STATUS_ACCESS_DENIED );
DebugTrace2( -1, Dbg, ("NdasFatSecondaryUserFsCtrl -> %08lx\n", Status) );
return Status;
//Status = FatDirtyVolume( IrpContext, Irp );
break;
case FSCTL_IS_VOLUME_DIRTY:
Status = FatIsVolumeDirty( IrpContext, Irp );
break;
case FSCTL_IS_VOLUME_MOUNTED:
Status = FatIsVolumeMounted( IrpContext, Irp );
DebugTrace2( -1, Dbg, ("NtfsUserFsRequest -> %08lx\n", Status) );
return Status;
break;
case FSCTL_IS_PATHNAME_VALID:
Status = FatIsPathnameValid( IrpContext, Irp );
DebugTrace2( -1, Dbg, ("NtfsUserFsRequest -> %08lx\n", Status) );
return Status;
break;
case FSCTL_QUERY_RETRIEVAL_POINTERS:
Status = FatQueryRetrievalPointers( IrpContext, Irp );
break;
case FSCTL_QUERY_FAT_BPB:
Status = FatQueryBpb( IrpContext, Irp );
DebugTrace2( -1, Dbg, ("NtfsUserFsRequest -> %08lx\n", Status) );
return Status;
break;
case FSCTL_FILESYSTEM_GET_STATISTICS:
Status = FatGetStatistics( IrpContext, Irp );
break;
case FSCTL_GET_VOLUME_BITMAP:
Status = FatGetVolumeBitmap( IrpContext, Irp );
break;
case FSCTL_GET_RETRIEVAL_POINTERS:
Status = FatGetRetrievalPointers( IrpContext, Irp );
break;
case FSCTL_MOVE_FILE:
FatCompleteRequest( IrpContext, Irp, Status = STATUS_ACCESS_DENIED );
DebugTrace2( -1, Dbg, ("NtfsUserFsRequest -> %08lx\n", Status) );
return Status;
//Status = FatMoveFile( IrpContext, Irp );
break;
case FSCTL_ALLOW_EXTENDED_DASD_IO:
Status = FatAllowExtendedDasdIo( IrpContext, Irp );
break;
default :
DebugTrace(0, Dbg, "Invalid control code -> %08lx\n", FsControlCode );
FatCompleteRequest( IrpContext, Irp, STATUS_INVALID_DEVICE_REQUEST );
Status = STATUS_INVALID_DEVICE_REQUEST;
break;
}
ASSERT( !ExIsResourceAcquiredSharedLite(&volDo->Vcb.Resource) );
if (Status != STATUS_SUCCESS) {
DebugTrace2( -1, Dbg, ("NtfsUserFsRequest -> %08lx\n", Status) );
return Status;
}
inputBuffer = IrpContext->InputBuffer;
outputBuffer = IrpContext->outputBuffer;
ASSERT( IrpSp->Parameters.FileSystemControl.InputBufferLength ? (inputBuffer != NULL) : (inputBuffer == NULL) );
ASSERT( IrpSp->Parameters.FileSystemControl.OutputBufferLength ? (outputBuffer != NULL) : (outputBuffer == NULL) );
ASSERT( KeGetCurrentIrql() == PASSIVE_LEVEL );
if (!FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT)) {
return FatFsdPostRequest( IrpContext, Irp );
}
try {
secondarySessionResourceAcquired
= SecondaryAcquireResourceExclusiveLite( IrpContext,
&volDo->SessionResource,
BooleanFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT) );
if (FlagOn(volDo->Secondary->Thread.Flags, SECONDARY_THREAD_FLAG_REMOTE_DISCONNECTED) ) {
PrintIrp( Dbg2, "SECONDARY_THREAD_FLAG_REMOTE_DISCONNECTED", NULL, IrpContext->OriginatingIrp );
NDAS_ASSERT( FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT) );
SetFlag( IrpContext->NdasFatFlags, NDAS_FAT_IRP_CONTEXT_FLAG_DONT_POST_REQUEST );
FatRaiseStatus( IrpContext, STATUS_CANT_WAIT );
}
ASSERT( IS_SECONDARY_FILEOBJECT(IrpSp->FileObject) );
typeOfOpen = FatDecodeFileObject( IrpSp->FileObject, &vcb, &fcb, &ccb );
if (FlagOn(ccb->NdasFatFlags, ND_FAT_CCB_FLAG_UNOPENED)) {
ASSERT( FlagOn(ccb->NdasFatFlags, ND_FAT_CCB_FLAG_CORRUPTED) );
try_return( Status = STATUS_FILE_CORRUPT_ERROR );
}
fileSystemControl.FsControlCode = IrpSp->Parameters.FileSystemControl.FsControlCode;
fileSystemControl.InputBufferLength = IrpSp->Parameters.FileSystemControl.InputBufferLength;
fileSystemControl.OutputBufferLength = IrpSp->Parameters.FileSystemControl.OutputBufferLength;
if (inputBuffer == NULL)
fileSystemControl.InputBufferLength = 0;
if (outputBuffer == NULL)
fileSystemControl.OutputBufferLength = 0;
outputBufferLength = fileSystemControl.OutputBufferLength;
if (fileSystemControl.FsControlCode == FSCTL_MOVE_FILE) { // 29
inputBufferLength = 0;
} else if (fileSystemControl.FsControlCode == FSCTL_MARK_HANDLE) { // 63
inputBufferLength = 0;
} else {
inputBufferLength = fileSystemControl.InputBufferLength;
}
bufferLength = (inputBufferLength >= outputBufferLength) ? inputBufferLength : outputBufferLength;
secondaryRequest = AllocateWinxpSecondaryRequest( volDo->Secondary,
IRP_MJ_FILE_SYSTEM_CONTROL,
bufferLength );
if (secondaryRequest == NULL) {
NDAS_ASSERT( NDAS_ASSERT_INSUFFICIENT_RESOURCES );
Status = Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
Irp->IoStatus.Information = 0;
try_return( Status );
}
ndfsRequestHeader = &secondaryRequest->NdfsRequestHeader;
INITIALIZE_NDFS_REQUEST_HEADER( ndfsRequestHeader,
NDFS_COMMAND_EXECUTE,
volDo->Secondary,
IRP_MJ_FILE_SYSTEM_CONTROL,
inputBufferLength );
ndfsWinxpRequestHeader = (PNDFS_WINXP_REQUEST_HEADER)(ndfsRequestHeader+1);
ASSERT( ndfsWinxpRequestHeader == (PNDFS_WINXP_REQUEST_HEADER)secondaryRequest->NdfsRequestData );
INITIALIZE_NDFS_WINXP_REQUEST_HEADER( ndfsWinxpRequestHeader, Irp, IrpSp, ccb->PrimaryFileHandle );
ndfsWinxpRequestHeader->FileSystemControl.OutputBufferLength = fileSystemControl.OutputBufferLength;
ndfsWinxpRequestHeader->FileSystemControl.InputBufferLength = fileSystemControl.InputBufferLength;
ndfsWinxpRequestHeader->FileSystemControl.FsControlCode = fileSystemControl.FsControlCode;
#if 0
if (fileSystemControl.FsControlCode == FSCTL_MOVE_FILE) { // 29
PMOVE_FILE_DATA moveFileData = inputBuffer;
PFILE_OBJECT moveFileObject;
PCCB moveCcb;
Status = ObReferenceObjectByHandle( moveFileData->FileHandle,
FILE_READ_DATA,
0,
KernelMode,
&moveFileObject,
NULL );
if (Status != STATUS_SUCCESS) {
ASSERT( FALSE );
try_return( Status );
}
ObDereferenceObject( moveFileObject );
moveCcb = moveFileObject->FsContext2;
ndfsWinxpRequestHeader->FileSystemControl.FscMoveFileData.FileHandle = moveCcb->PrimaryFileHandle;
ndfsWinxpRequestHeader->FileSystemControl.FscMoveFileData.StartingVcn = moveFileData->StartingVcn.QuadPart;
ndfsWinxpRequestHeader->FileSystemControl.FscMoveFileData.StartingLcn = moveFileData->StartingLcn.QuadPart;
ndfsWinxpRequestHeader->FileSystemControl.FscMoveFileData.ClusterCount = moveFileData->ClusterCount;
} else
#endif
if (fileSystemControl.FsControlCode == FSCTL_MARK_HANDLE) { // 63
PMARK_HANDLE_INFO markHandleInfo = inputBuffer;
PFILE_OBJECT volumeFileObject;
PCCB volumeCcb;
Status = ObReferenceObjectByHandle( markHandleInfo->VolumeHandle,
FILE_READ_DATA,
0,
KernelMode,
&volumeFileObject,
NULL );
if (Status != STATUS_SUCCESS) {
try_return( Status );
}
ObDereferenceObject( volumeFileObject );
volumeCcb = volumeFileObject->FsContext2;
ndfsWinxpRequestHeader->FileSystemControl.FscMarkHandleInfo.UsnSourceInfo = markHandleInfo->UsnSourceInfo;
ndfsWinxpRequestHeader->FileSystemControl.FscMarkHandleInfo.VolumeHandle = volumeCcb->PrimaryFileHandle;
ndfsWinxpRequestHeader->FileSystemControl.FscMarkHandleInfo.HandleInfo = markHandleInfo->HandleInfo;
} else {
ndfsWinxpRequestData = (UINT8 *)(ndfsWinxpRequestHeader+1);
if (inputBufferLength)
RtlCopyMemory( ndfsWinxpRequestData, inputBuffer, inputBufferLength );
}
ASSERT( !ExIsResourceAcquiredSharedLite(&IrpContext->Vcb->Resource) );
secondaryRequest->RequestType = SECONDARY_REQ_SEND_MESSAGE;
QueueingSecondaryRequest( volDo->Secondary, secondaryRequest );
timeOut.QuadPart = -NDASFAT_TIME_OUT;
Status = KeWaitForSingleObject( &secondaryRequest->CompleteEvent, Executive, KernelMode, FALSE, &timeOut );
if (Status != STATUS_SUCCESS) {
secondaryRequest = NULL;
try_return( Status = STATUS_IO_DEVICE_ERROR );
}
KeClearEvent( &secondaryRequest->CompleteEvent );
if (secondaryRequest->ExecuteStatus != STATUS_SUCCESS) {
if (IrpContext->OriginatingIrp)
PrintIrp( Dbg2, "secondaryRequest->ExecuteStatus != STATUS_SUCCESS", NULL, IrpContext->OriginatingIrp );
DebugTrace2( 0, Dbg2, ("secondaryRequest->ExecuteStatus != STATUS_SUCCESS file = %s, line = %d\n", __FILE__, __LINE__) );
NDAS_ASSERT( FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT) );
SetFlag( IrpContext->NdasFatFlags, NDAS_FAT_IRP_CONTEXT_FLAG_DONT_POST_REQUEST );
FatRaiseStatus( IrpContext, STATUS_CANT_WAIT );
}
ndfsWinxpReplytHeader = (PNDFS_WINXP_REPLY_HEADER)secondaryRequest->NdfsReplyData;
Status = Irp->IoStatus.Status = NTOHL(ndfsWinxpReplytHeader->Status4);
Irp->IoStatus.Information = NTOHL(ndfsWinxpReplytHeader->Information32);
if (FsControlCode == FSCTL_GET_NTFS_VOLUME_DATA && Status != STATUS_SUCCESS)
DebugTrace2( 0, Dbg2, ("FSCTL_GET_NTFS_VOLUME_DATA: Status = %x, Irp->IoStatus.Information = %d\n", Status, Irp->IoStatus.Information) );
if (NTOHL(secondaryRequest->NdfsReplyHeader.MessageSize4) - sizeof(NDFS_REPLY_HEADER) - sizeof(NDFS_WINXP_REPLY_HEADER)) {
ASSERT( Irp->IoStatus.Status == STATUS_SUCCESS || Irp->IoStatus.Status == STATUS_BUFFER_OVERFLOW );
ASSERT( Irp->IoStatus.Information );
ASSERT( Irp->IoStatus.Information <= outputBufferLength );
ASSERT( outputBuffer );
RtlCopyMemory( outputBuffer,
(UINT8 *)(ndfsWinxpReplytHeader+1),
Irp->IoStatus.Information );
}
if (fileSystemControl.FsControlCode == FSCTL_MOVE_FILE && Status != STATUS_SUCCESS)
DebugTrace2( 0, Dbg2, ("NtfsDefragFile: status = %x\n", Status) );
#if 0
if (Status == STATUS_SUCCESS && fileSystemControl.FsControlCode == FSCTL_MOVE_FILE) { // 29
PMOVE_FILE_DATA moveFileData = inputBuffer;
PFILE_OBJECT moveFileObject;
TYPE_OF_OPEN typeOfOpen;
PVCB vcb;
PFCB moveFcb;
PSCB moveScb;
PCCB moveCcb;
Status = ObReferenceObjectByHandle( moveFileData->FileHandle,
FILE_READ_DATA,
0,
KernelMode,
&moveFileObject,
NULL );
if (Status != STATUS_SUCCESS) {
try_return( Status );
}
ObDereferenceObject( moveFileObject );
typeOfOpen = NtfsDecodeFileObject( IrpContext, moveFileObject, &vcb, &moveFcb, &moveScb, &moveCcb, TRUE );
if (typeOfOpen == UserFileOpen && FlagOn(volDo->NdasFatFlags, ND_FAT_DEVICE_FLAG_DIRECT_RW) && ndfsWinxpReplytHeader->FileInformationSet && NTOHLL(ndfsWinxpReplytHeader->AllocationSize8)) {
PNDFS_FAT_MCB_ENTRY mcbEntry;
ULONG index;
VCN testVcn;
SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_ACQUIRE_PAGING );
NtfsAcquireFcbWithPaging( IrpContext, moveFcb, 0 );
NtfsAcquireNtfsMcbMutex( &moveScb->Mcb );
mcbEntry = (PNDFS_FAT_MCB_ENTRY)( ndfsWinxpReplytHeader+1 );
if (moveScb->Header.AllocationSize.QuadPart) {
NtfsRemoveNtfsMcbEntry( &moveScb->Mcb, 0, 0xFFFFFFFF );
}
for (index=0, testVcn=0; index < NTOHL(ndfsWinxpReplytHeader->NumberOfMcbEntry4); index++) {
ASSERT( mcbEntry[index].Vcn == testVcn );
testVcn += (LONGLONG)mcbEntry[index].ClusterCount;
NtfsAddNtfsMcbEntry( &moveScb->Mcb,
mcbEntry[index].Vcn,
(mcbEntry[index].Lcn << vcb->AllocationSupport.LogOfBytesPerSector),
(LONGLONG)mcbEntry[index].ClusterCount,
TRUE );
}
ASSERT( LlBytesFromClusters(vcb, testVcn) == NTOHLL(ndfsWinxpReplytHeader->AllocationSize8) );
if (moveScb->Header.AllocationSize.QuadPart != NTOHLL(ndfsWinxpReplytHeader->AllocationSize8))
SetFlag( moveScb->ScbState, SCB_STATE_TRUNCATE_ON_CLOSE );
moveScb->Header.FileSize.LowPart = NTOHLL(ndfsWinxpReplytHeader->FileSize8);
moveScb->Header.AllocationSize.QuadPart = NTOHLL(ndfsWinxpReplytHeader->AllocationSize8);
ASSERT( moveScb->Header.AllocationSize.QuadPart >= moveScb->Header.FileSize.LowPart );
if (moveFileObject->SectionObjectPointer->DataSectionObject != NULL && moveFileObject->PrivateCacheMap == NULL) {
CcInitializeCacheMap( moveFileObject,
(PCC_FILE_SIZES)&moveScb->Header.AllocationSize,
FALSE,
&NtfsData.CacheManagerCallbacks,
moveScb );
//CcSetAdditionalCacheAttributes( fileObject, TRUE, TRUE );
}
if (CcIsFileCached(moveFileObject)) {
NtfsSetBothCacheSizes( moveFileObject,
(PCC_FILE_SIZES)&scb->Header.AllocationSize,
moveScb );
}
NtfsReleaseNtfsMcbMutex( &moveScb->Mcb );
NtfsReleaseFcb( IrpContext, moveFcb );
}
}
#endif
try_exit: NOTHING;
} finally {
if (secondarySessionResourceAcquired == TRUE) {
SecondaryReleaseResourceLite( IrpContext, &volDo->SessionResource );
}
if (secondaryRequest)
DereferenceSecondaryRequest( secondaryRequest );
}
FatCompleteRequest( IrpContext, Irp, Status );
DebugTrace(-1, Dbg, "FatUserFsCtrl -> %08lx\n", Status );
return Status;
}
NTSTATUS
FatCommonDeviceControl (
IN PIRP_CONTEXT IrpContext,
IN PIRP Irp
)
/*++
Routine Description:
This is the common routine for doing Device control operations called
by both the fsd and fsp threads
Arguments:
Irp - Supplies the Irp to process
InFsp - Indicates if this is the fsp thread or someother thread
Return Value:
NTSTATUS - The return status for the operation
--*/
{
NTSTATUS Status;
PIO_STACK_LOCATION IrpSp;
KEVENT WaitEvent;
PVOID CompletionContext = NULL;
PVCB Vcb;
PFCB Fcb;
PCCB Ccb;
#if __NDAS_FAT_PRIMARY__
if (IrpContext->MajorFunction == IRP_MJ_DEVICE_CONTROL &&
IoGetCurrentIrpStackLocation(Irp)->Parameters.DeviceIoControl.IoControlCode == IOCTL_INSERT_PRIMARY_SESSION) {
PVOLUME_DEVICE_OBJECT VolDo = CONTAINING_RECORD( IoGetCurrentIrpStackLocation(Irp)->DeviceObject,
VOLUME_DEVICE_OBJECT,
DeviceObject );
PSESSION_INFORMATION inputBuffer = (PSESSION_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
ULONG inputBufferLength = IoGetCurrentIrpStackLocation(Irp)->Parameters.DeviceIoControl.InputBufferLength;
ULONG outputBufferLength;
PULONG outputBuffer;
PPRIMARY_SESSION primarySession;
if (inputBufferLength != sizeof(SESSION_INFORMATION)) {
FatCompleteRequest( IrpContext, Irp, Status = STATUS_INVALID_PARAMETER );
return Status;
}
outputBufferLength = IoGetCurrentIrpStackLocation(Irp)->Parameters.DeviceIoControl.OutputBufferLength;
outputBuffer = (PULONG)Irp->AssociatedIrp.SystemBuffer;
primarySession = PrimarySession_Create( IrpContext, VolDo, inputBuffer, Irp );
ASSERT( primarySession );
FatCompleteRequest( IrpContext, NULL, 0 );
Status = STATUS_PENDING;
return Status;
}
#endif
//
// Get a pointer to the current Irp stack location
//
IrpSp = IoGetCurrentIrpStackLocation( Irp );
DebugTrace(+1, Dbg, "FatCommonDeviceControl\n", 0);
DebugTrace( 0, Dbg, "Irp = %08lx\n", Irp);
DebugTrace( 0, Dbg, "MinorFunction = %08lx\n", IrpSp->MinorFunction);
//
// Decode the file object, the only type of opens we accept are
// user volume opens.
//
if (FatDecodeFileObject( IrpSp->FileObject, &Vcb, &Fcb, &Ccb ) != UserVolumeOpen) {
FatCompleteRequest( IrpContext, Irp, STATUS_INVALID_PARAMETER );
DebugTrace(-1, Dbg2, "FatCommonDeviceControl -> %08lx\n", STATUS_INVALID_PARAMETER);
return STATUS_INVALID_PARAMETER;
}
#define IOCTL_VOLUME_BASE ((ULONG) 'V')
#define MOUNTDEVCONTROLTYPE ((ULONG) 'M')
DebugTrace2( 0, Dbg2,
("FatCommonDeviceControl: deviceType = %d, function = %d IOCTL_VOLUME_BASE = %d, MOUNTDEVCONTROLTYPE = %d\n",
DEVICE_TYPE_FROM_CTL_CODE(IrpSp->Parameters.DeviceIoControl.IoControlCode),
(UCHAR)((IrpSp->Parameters.DeviceIoControl.IoControlCode & 0x00003FFC) >> 2), IOCTL_VOLUME_BASE, MOUNTDEVCONTROLTYPE) );
#if __NDAS_FAT__
if (CONTAINING_RECORD(Vcb, VOLUME_DEVICE_OBJECT, Vcb)->NetdiskEnableMode == NETDISK_SECONDARY)
SetFlag( IrpContext->NdFatFlags, ND_FAT_IRP_CONTEXT_FLAG_SECONDARY_CONTEXT );
#endif
//
// A few IOCTLs actually require some intervention on our part
//
switch (IrpSp->Parameters.DeviceIoControl.IoControlCode) {
case IOCTL_VOLSNAP_FLUSH_AND_HOLD_WRITES:
#if __NDAS_FAT_WIN2K_SUPPORT__
if (!IS_WINDOWSXP_OR_LATER()) {
ASSERT( FALSE );
IoSkipCurrentIrpStackLocation( Irp );
break;
}
#endif
//
// This is sent by the Volume Snapshot driver (Lovelace).
// We flush the volume, and hold all file resources
// to make sure that nothing more gets dirty. Then we wait
// for the IRP to complete or cancel.
//
SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT );
FatAcquireExclusiveVolume( IrpContext, Vcb );
FatFlushAndCleanVolume( IrpContext,
Irp,
Vcb,
FlushWithoutPurge );
KeInitializeEvent( &WaitEvent, NotificationEvent, FALSE );
CompletionContext = &WaitEvent;
//
// Get the next stack location, and copy over the stack location
//
IoCopyCurrentIrpStackLocationToNext( Irp );
//
// Set up the completion routine
//
IoSetCompletionRoutine( Irp,
FatDeviceControlCompletionRoutine,
CompletionContext,
TRUE,
TRUE,
TRUE );
break;
default:
//
// FAT doesn't need to see this on the way back, so skip ourselves.
//
IoSkipCurrentIrpStackLocation( Irp );
break;
}
//
// Send the request.
//
Status = IoCallDriver(Vcb->TargetDeviceObject, Irp);
if (Status == STATUS_PENDING && CompletionContext) {
KeWaitForSingleObject( &WaitEvent,
Executive,
KernelMode,
FALSE,
NULL );
Status = Irp->IoStatus.Status;
}
//DebugTrace(-1, Dbg2, "FatCommonDeviceControl -> Information %08lx\n", Irp->IoStatus.Information);
//
// If we had a context, the IRP remains for us and we will complete it.
// Handle it appropriately.
//
if (CompletionContext) {
//
// Release all the resources that we held because of a
// VOLSNAP_FLUSH_AND_HOLD.
//
ASSERT( IrpSp->Parameters.DeviceIoControl.IoControlCode == IOCTL_VOLSNAP_FLUSH_AND_HOLD_WRITES );
FatReleaseVolume( IrpContext, Vcb );
//
// If we had no context, the IRP will complete asynchronously.
//
} else {
Irp = NULL;
}
FatCompleteRequest( IrpContext, Irp, Status );
DebugTrace(-1, Dbg2, "FatCommonDeviceControl -> %08lx\n", Status);
return Status;
}
NTSTATUS
FatCommonDeviceControl (
IN PIRP_CONTEXT IrpContext,
IN PIRP Irp
)
/*++
Routine Description:
This is the common routine for doing Device control operations called
by both the fsd and fsp threads
Arguments:
Irp - Supplies the Irp to process
InFsp - Indicates if this is the fsp thread or someother thread
Return Value:
NTSTATUS - The return status for the operation
--*/
{
NTSTATUS Status;
PIO_STACK_LOCATION IrpSp;
KEVENT WaitEvent;
PVOID CompletionContext = NULL;
PVCB Vcb;
PFCB Fcb;
PCCB Ccb;
//
// Get a pointer to the current Irp stack location
//
IrpSp = IoGetCurrentIrpStackLocation( Irp );
DebugTrace(+1, Dbg, "FatCommonDeviceControl\n", 0);
DebugTrace( 0, Dbg, "Irp = %08lx\n", Irp);
DebugTrace( 0, Dbg, "MinorFunction = %08lx\n", IrpSp->MinorFunction);
//
// Decode the file object, the only type of opens we accept are
// user volume opens.
//
if (FatDecodeFileObject( IrpSp->FileObject, &Vcb, &Fcb, &Ccb ) != UserVolumeOpen) {
FatCompleteRequest( IrpContext, Irp, STATUS_INVALID_PARAMETER );
DebugTrace(-1, Dbg, "FatCommonDeviceControl -> %08lx\n", STATUS_INVALID_PARAMETER);
return STATUS_INVALID_PARAMETER;
}
//
// A few IOCTLs actually require some intervention on our part
//
switch (IrpSp->Parameters.DeviceIoControl.IoControlCode) {
case IOCTL_VOLSNAP_FLUSH_AND_HOLD_WRITES:
//
// This is sent by the Volume Snapshot driver (Lovelace).
// We flush the volume, and hold all file resources
// to make sure that nothing more gets dirty. Then we wait
// for the IRP to complete or cancel.
//
SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT );
FatAcquireExclusiveVolume( IrpContext, Vcb );
FatFlushAndCleanVolume( IrpContext,
Irp,
Vcb,
FlushWithoutPurge );
KeInitializeEvent( &WaitEvent, NotificationEvent, FALSE );
CompletionContext = &WaitEvent;
//
// Get the next stack location, and copy over the stack location
//
IoCopyCurrentIrpStackLocationToNext( Irp );
//
// Set up the completion routine
//
IoSetCompletionRoutine( Irp,
FatDeviceControlCompletionRoutine,
CompletionContext,
TRUE,
TRUE,
TRUE );
break;
default:
//
// FAT doesn't need to see this on the way back, so skip ourselves.
//
IoSkipCurrentIrpStackLocation( Irp );
break;
}
//
// Send the request.
//
Status = IoCallDriver(Vcb->TargetDeviceObject, Irp);
if (Status == STATUS_PENDING && CompletionContext) {
KeWaitForSingleObject( &WaitEvent,
Executive,
KernelMode,
FALSE,
NULL );
Status = Irp->IoStatus.Status;
}
//
// If we had a context, the IRP remains for us and we will complete it.
// Handle it appropriately.
//
if (CompletionContext) {
//
// Release all the resources that we held because of a
// VOLSNAP_FLUSH_AND_HOLD.
//
ASSERT( IrpSp->Parameters.DeviceIoControl.IoControlCode == IOCTL_VOLSNAP_FLUSH_AND_HOLD_WRITES );
FatReleaseVolume( IrpContext, Vcb );
//
// If we had no context, the IRP will complete asynchronously.
//
} else {
Irp = NULL;
}
FatCompleteRequest( IrpContext, Irp, Status );
DebugTrace(-1, Dbg, "FatCommonDeviceControl -> %08lx\n", Status);
return Status;
}
NTSTATUS
NdasFatSecondaryCommonFileSystemControl (
IN PIRP_CONTEXT IrpContext,
IN PIRP Irp
)
/*++
Routine Description:
This is the common routine for doing FileSystem control operations called
by both the fsd and fsp threads
Arguments:
Irp - Supplies the Irp to process
Return Value:
NTSTATUS - The return status for the operation
--*/
{
NTSTATUS Status;
PIO_STACK_LOCATION IrpSp;
//
// Get a pointer to the current Irp stack location
//
IrpSp = IoGetCurrentIrpStackLocation( Irp );
DebugTrace(+1, Dbg,"FatCommonFileSystemControl\n", 0);
DebugTrace( 0, Dbg,"Irp = %08lx\n", Irp);
DebugTrace( 0, Dbg,"MinorFunction = %08lx\n", IrpSp->MinorFunction);
//
// We know this is a file system control so we'll case on the
// minor function, and call a internal worker routine to complete
// the irp.
//
switch (IrpSp->MinorFunction) {
case IRP_MN_USER_FS_REQUEST:
Status = NdasFatSecondaryUserFsCtrl( IrpContext, Irp );
break;
case IRP_MN_MOUNT_VOLUME:
NDAS_ASSERT( FALSE );
Status = STATUS_INVALID_DEVICE_REQUEST;
//Status = FatMountVolume( IrpContext,
// IrpSp->Parameters.MountVolume.DeviceObject,
// IrpSp->Parameters.MountVolume.Vpb,
// IrpSp->DeviceObject );
//
// Complete the request.
//
// We do this here because FatMountVolume can be called recursively,
// but the Irp is only to be completed once.
//
// NOTE: I don't think this is true anymore (danlo 3/15/1999). Probably
// an artifact of the old doublespace attempt.
//
FatCompleteRequest( IrpContext, Irp, Status );
break;
case IRP_MN_VERIFY_VOLUME:
Status = STATUS_INVALID_DEVICE_REQUEST;
FatCompleteRequest( IrpContext, Irp, Status );
//Status = FatVerifyVolume( IrpContext, Irp );
break;
default:
DebugTrace( 0, Dbg, "Invalid FS Control Minor Function %08lx\n", IrpSp->MinorFunction);
FatCompleteRequest( IrpContext, Irp, STATUS_INVALID_DEVICE_REQUEST );
Status = STATUS_INVALID_DEVICE_REQUEST;
break;
}
DebugTrace(-1, Dbg, "FatCommonFileSystemControl -> %08lx\n", Status);
return Status;
}
NTSTATUS
NdFatSecondaryCommonWrite3 (
IN PIRP_CONTEXT IrpContext,
IN PIRP Irp
)
{
NTSTATUS status;
PVOLUME_DEVICE_OBJECT volDo = CONTAINING_RECORD( IrpContext->Vcb, VOLUME_DEVICE_OBJECT, Vcb );
BOOLEAN secondarySessionResourceAcquired = FALSE;
PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation( Irp );
PFILE_OBJECT fileObject = irpSp->FileObject;
struct Write write;
PSECONDARY_REQUEST secondaryRequest = NULL;
PNDFS_REQUEST_HEADER ndfsRequestHeader;
PNDFS_WINXP_REQUEST_HEADER ndfsWinxpRequestHeader;
PNDFS_WINXP_REPLY_HEADER ndfsWinxpReplytHeader;
LARGE_INTEGER timeOut;
TYPE_OF_OPEN typeOfOpen;
PVCB vcb;
PFCB fcb;
PCCB ccb;
BOOLEAN fcbAcquired = FALSE;
BOOLEAN writeToEof;
PUCHAR inputBuffer;
ULONG totalWriteLength;
ASSERT( KeGetCurrentIrql() < DISPATCH_LEVEL );
ASSERT (!FlagOn(Irp->Flags, IRP_PAGING_IO));
typeOfOpen = FatDecodeFileObject( fileObject, &vcb, &fcb, &ccb );
ASSERT( typeOfOpen == UserFileOpen );
if (FlagOn(ccb->NdFatFlags, ND_FAT_CCB_FLAG_UNOPENED)) {
/*if (FlagOn( fcb->FcbState, FCB_STATE_FILE_DELETED )) {
ASSERT( FALSE );
FatRaiseStatus( IrpContext, STATUS_FILE_DELETED, NULL, NULL );
} else */{
ASSERT( FlagOn(ccb->NdFatFlags, ND_FAT_CCB_FLAG_CORRUPTED) );
status = STATUS_FILE_CORRUPT_ERROR;
FatCompleteRequest( IrpContext, Irp, status );
return status;
}
}
writeToEof = (irpSp->Parameters.Write.ByteOffset.QuadPart == FILE_WRITE_TO_END_OF_FILE &&
irpSp->Parameters.Write.ByteOffset.HighPart == -1);
write.ByteOffset = irpSp->Parameters.Write.ByteOffset;
write.Key = irpSp->Parameters.Write.Key;
write.Length = irpSp->Parameters.Write.Length;
ASSERT( FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT) );
//FatAcquireSharedFcb( IrpContext, fcb );
//fcbAcquired = TRUE;
try {
secondarySessionResourceAcquired
= SecondaryAcquireResourceExclusiveLite( IrpContext,
&volDo->Secondary->SessionResource,
BooleanFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT) );
if (FlagOn(volDo->Secondary->Thread.Flags, SECONDARY_THREAD_FLAG_REMOTE_DISCONNECTED) ) {
PrintIrp( Dbg, "SECONDARY_THREAD_FLAG_REMOTE_DISCONNECTED", NULL, IrpContext->OriginatingIrp );
if (FlagOn(Irp->Flags, IRP_PAGING_IO)) {
try_return( status = STATUS_FILE_LOCK_CONFLICT );
} else {
FatRaiseStatus( IrpContext, STATUS_CANT_WAIT );
}
}
inputBuffer = FatMapUserBuffer( IrpContext, Irp );
totalWriteLength = 0;
do {
ULONG inputBufferLength;
_U8 *ndfsWinxpRequestData;
_U64 primaryFileHandle;
if (fcb->UncleanCount == 0) {
DebugTrace( 0, Dbg2, "NdFatSecondaryCommonWrite2: fileName = %wZ\n", &fileObject->FileName );
totalWriteLength = write.Length;
status = STATUS_FILE_CLOSED;
break;
}
if (!FlagOn(ccb->NdFatFlags, ND_FAT_CLEANUP_COMPLETE)) {
primaryFileHandle = ccb->PrimaryFileHandle;
} else {
PLIST_ENTRY ccbListEntry;
ExAcquireFastMutex( &fcb->CcbQMutex );
for (primaryFileHandle = 0, ccbListEntry = fcb->CcbQueue.Flink;
ccbListEntry != &fcb->CcbQueue;
ccbListEntry = ccbListEntry->Flink) {
if (!FlagOn(CONTAINING_RECORD(ccbListEntry, CCB, FcbListEntry)->NdFatFlags, ND_FAT_CLEANUP_COMPLETE)) {
primaryFileHandle = CONTAINING_RECORD(ccbListEntry, CCB, FcbListEntry)->PrimaryFileHandle;
break;
}
}
ExReleaseFastMutex( &fcb->CcbQMutex );
}
ASSERT( primaryFileHandle );
inputBufferLength = ((write.Length-totalWriteLength) <= volDo->Secondary->Thread.SessionContext.SecondaryMaxDataSize)
? (write.Length-totalWriteLength) : volDo->Secondary->Thread.SessionContext.SecondaryMaxDataSize;
secondaryRequest = ALLOC_WINXP_SECONDARY_REQUEST( volDo->Secondary,
IRP_MJ_WRITE,
volDo->Secondary->Thread.SessionContext.PrimaryMaxDataSize );
if (secondaryRequest == NULL) {
FatRaiseStatus( IrpContext, STATUS_INSUFFICIENT_RESOURCES );
}
ndfsRequestHeader = &secondaryRequest->NdfsRequestHeader;
INITIALIZE_NDFS_REQUEST_HEADER( ndfsRequestHeader, NDFS_COMMAND_EXECUTE, volDo->Secondary, IRP_MJ_WRITE, inputBufferLength );
ndfsWinxpRequestHeader = (PNDFS_WINXP_REQUEST_HEADER)(ndfsRequestHeader+1);
ASSERT( ndfsWinxpRequestHeader == (PNDFS_WINXP_REQUEST_HEADER)secondaryRequest->NdfsRequestData );
//ndfsWinxpRequestHeader->IrpTag = (_U32)Irp;
ndfsWinxpRequestHeader->IrpMajorFunction = IRP_MJ_WRITE;
ndfsWinxpRequestHeader->IrpMinorFunction = 0;
ndfsWinxpRequestHeader->FileHandle = primaryFileHandle;
ndfsWinxpRequestHeader->IrpFlags = 0;
ndfsWinxpRequestHeader->IrpSpFlags = 0;
ndfsWinxpRequestHeader->Write.Length = inputBufferLength;
ndfsWinxpRequestHeader->Write.Key = write.Key;
if (writeToEof)
ndfsWinxpRequestHeader->Write.ByteOffset = write.ByteOffset.QuadPart;
else
ndfsWinxpRequestHeader->Write.ByteOffset = write.ByteOffset.QuadPart + totalWriteLength;
ndfsWinxpRequestHeader->Write.ForceWrite = TRUE;
DebugTrace2( 0, Dbg, ("ndfsWinxpRequestHeader->Write.ByteOffset = %I64d, ndfsWinxpRequestHeader->Write.Length = %d\n",
ndfsWinxpRequestHeader->Write.ByteOffset, ndfsWinxpRequestHeader->Write.Length) );
ndfsWinxpRequestData = (_U8 *)(ndfsWinxpRequestHeader+1);
if (inputBufferLength) {
try {
RtlCopyMemory( ndfsWinxpRequestData,
inputBuffer + totalWriteLength,
inputBufferLength );
} except (EXCEPTION_EXECUTE_HANDLER) {
DebugTrace2( 0, Dbg2, ("RedirectIrp: Exception - Input buffer is not valid\n") );
status = GetExceptionCode();
break;
}
}
//if (fcb->Header.FileSize.LowPart < 100)
// DbgPrint( "data = %s\n", ndfsWinxpRequestData );
secondaryRequest->RequestType = SECONDARY_REQ_SEND_MESSAGE;
QueueingSecondaryRequest( volDo->Secondary, secondaryRequest );
timeOut.QuadPart = -NDFAT_TIME_OUT;
status = KeWaitForSingleObject( &secondaryRequest->CompleteEvent, Executive, KernelMode, FALSE, &timeOut );
if (status != STATUS_SUCCESS) {
secondaryRequest = NULL;
status = STATUS_IO_DEVICE_ERROR;
leave;
}
KeClearEvent( &secondaryRequest->CompleteEvent );
if (secondaryRequest->ExecuteStatus != STATUS_SUCCESS) {
if (IrpContext->OriginatingIrp)
PrintIrp( Dbg2, "secondaryRequest->ExecuteStatus != STATUS_SUCCESS", NULL, IrpContext->OriginatingIrp );
DebugTrace2( 0, Dbg2, ("secondaryRequest->ExecuteStatus != STATUS_SUCCESS file = %s, line = %d\n", __FILE__, __LINE__) );
if (FlagOn(Irp->Flags, IRP_PAGING_IO)) {
try_return( status = STATUS_FILE_LOCK_CONFLICT );
} else {
FatRaiseStatus( IrpContext, STATUS_CANT_WAIT );
}
}
ndfsWinxpReplytHeader = (PNDFS_WINXP_REPLY_HEADER)secondaryRequest->NdfsReplyData;
if (ndfsWinxpReplytHeader->Status != STATUS_SUCCESS) {
DebugTrace2( 0, Dbg, ("ndfsWinxpReplytHeader->Status = %x\n", ndfsWinxpReplytHeader->Status) );
if (totalWriteLength)
status = STATUS_SUCCESS;
else
status = ndfsWinxpReplytHeader->Status;
ASSERT( ndfsWinxpReplytHeader->Information == 0 );
DereferenceSecondaryRequest( secondaryRequest );
secondaryRequest = NULL;
break;
}
totalWriteLength += ndfsWinxpReplytHeader->Information;
ASSERT( ndfsWinxpReplytHeader->Information <= inputBufferLength );
ASSERT( ndfsWinxpReplytHeader->Information != 0 );
DereferenceSecondaryRequest( secondaryRequest );
secondaryRequest = NULL;
} while( totalWriteLength < write.Length );
try_exit: NOTHING;
} finally {
if (!AbnormalTermination()) {
if (totalWriteLength) {
Irp->IoStatus.Information = totalWriteLength;
Irp->IoStatus.Status = STATUS_SUCCESS;
} else {
Irp->IoStatus.Information = 0;
Irp->IoStatus.Status = status;
}
}
DebugTrace2( 0, Dbg, ("write.ByteOffset.QuadPart = %I64x, write.Length = %x, totalWriteRequestLength = %x lastStatus = %x\n",
write.ByteOffset.QuadPart, write.Length, totalWriteLength, status) );
if (!FlagOn(ccb->NdFatFlags, ND_FAT_CLEANUP_COMPLETE) && Irp->IoStatus.Status != STATUS_SUCCESS) {
DebugTrace2( 0, Dbg, ("write.ByteOffset.QuadPart = %I64x, write.Length = %x, totalWriteRequestLength = %x lastStatus = %x\n",
write.ByteOffset.QuadPart, write.Length, totalWriteLength, status) );
PrintIrp( Dbg, "RedirectIrpMajorWrite", NULL, Irp );
}
if (secondarySessionResourceAcquired == TRUE)
SecondaryReleaseResourceLite( IrpContext, &volDo->Secondary->SessionResource );
if (fcbAcquired) {
FatReleaseFcb( IrpContext, fcb );
}
if (secondaryRequest)
DereferenceSecondaryRequest( secondaryRequest );
}
FatCompleteRequest( IrpContext, Irp, status );
return status;
}
NTSTATUS
NdFatCommonFlushBuffers (
IN PIRP_CONTEXT IrpContext,
IN PIRP Irp
)
/*++
Routine Description:
This is the common routine for flushing a buffer.
Arguments:
Irp - Supplies the Irp to process
Return Value:
NTSTATUS - The return status for the operation
--*/
{
NTSTATUS Status;
PIO_STACK_LOCATION IrpSp;
PFILE_OBJECT FileObject;
TYPE_OF_OPEN TypeOfOpen;
PVCB Vcb;
PFCB Fcb;
PCCB Ccb;
BOOLEAN VcbAcquired = FALSE;
BOOLEAN FcbAcquired = FALSE;
PDIRENT Dirent;
PBCB DirentBcb = NULL;
PVOLUME_DEVICE_OBJECT volDo = CONTAINING_RECORD( IrpContext->Vcb, VOLUME_DEVICE_OBJECT, Vcb );
BOOLEAN secondarySessionResourceAcquired = FALSE;
PSECONDARY_REQUEST secondaryRequest = NULL;
PNDFS_REQUEST_HEADER ndfsRequestHeader;
PNDFS_WINXP_REQUEST_HEADER ndfsWinxpRequestHeader;
PNDFS_WINXP_REPLY_HEADER ndfsWinxpReplytHeader;
LARGE_INTEGER timeOut;
PAGED_CODE();
IrpSp = IoGetCurrentIrpStackLocation( Irp );
DebugTrace(+1, Dbg, "FatCommonFlushBuffers\n", 0);
DebugTrace( 0, Dbg, "Irp = %08lx\n", Irp);
DebugTrace( 0, Dbg, "->FileObject = %08lx\n", IrpSp->FileObject);
//
// Extract and decode the file object
//
FileObject = IrpSp->FileObject;
TypeOfOpen = FatDecodeFileObject( FileObject, &Vcb, &Fcb, &Ccb );
//
// CcFlushCache is always synchronous, so if we can't wait enqueue
// the irp to the Fsp.
//
if ( !FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT) ) {
Status = FatFsdPostRequest( IrpContext, Irp );
DebugTrace(-1, Dbg, "FatCommonFlushBuffers -> %08lx\n", Status );
return Status;
}
Status = STATUS_SUCCESS;
try {
if (!FlagOn(Ccb->NdFatFlags, ND_FAT_CCB_FLAG_UNOPENED)) {
do {
secondarySessionResourceAcquired
= SecondaryAcquireResourceExclusiveLite( IrpContext,
&volDo->Secondary->SessionResource,
BooleanFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT) );
if (FlagOn(volDo->Secondary->Thread.Flags, SECONDARY_THREAD_FLAG_REMOTE_DISCONNECTED) ) {
PrintIrp( Dbg2, "SECONDARY_THREAD_FLAG_REMOTE_DISCONNECTED", NULL, IrpContext->OriginatingIrp );
FatRaiseStatus( IrpContext, STATUS_CANT_WAIT );
}
secondaryRequest = ALLOC_WINXP_SECONDARY_REQUEST( volDo->Secondary, IRP_MJ_FLUSH_BUFFERS, 0 );
if (secondaryRequest == NULL) {
Status = STATUS_INSUFFICIENT_RESOURCES;
break;
}
ndfsRequestHeader = &secondaryRequest->NdfsRequestHeader;
INITIALIZE_NDFS_REQUEST_HEADER( ndfsRequestHeader, NDFS_COMMAND_EXECUTE, volDo->Secondary, IRP_MJ_FLUSH_BUFFERS, 0 );
ndfsWinxpRequestHeader = (PNDFS_WINXP_REQUEST_HEADER)(ndfsRequestHeader+1);
ASSERT( ndfsWinxpRequestHeader == (PNDFS_WINXP_REQUEST_HEADER)secondaryRequest->NdfsRequestData );
INITIALIZE_NDFS_WINXP_REQUEST_HEADER( ndfsWinxpRequestHeader,
IrpContext->OriginatingIrp,
IoGetCurrentIrpStackLocation(IrpContext->OriginatingIrp),
Ccb->PrimaryFileHandle );
ASSERT( !ExIsResourceAcquiredSharedLite(&IrpContext->Vcb->Resource) );
secondaryRequest->RequestType = SECONDARY_REQ_SEND_MESSAGE;
QueueingSecondaryRequest( volDo->Secondary, secondaryRequest );
timeOut.QuadPart = -NDFAT_TIME_OUT;
Status = KeWaitForSingleObject( &secondaryRequest->CompleteEvent, Executive, KernelMode, FALSE, &timeOut );
if (Status != STATUS_SUCCESS) {
ASSERT( NDFAT_BUG );
break;
}
KeClearEvent (&secondaryRequest->CompleteEvent);
if (BooleanFlagOn(volDo->Secondary->Thread.Flags, SECONDARY_THREAD_FLAG_REMOTE_DISCONNECTED)) {
FatRaiseStatus( IrpContext, STATUS_CANT_WAIT );
}
if (secondaryRequest->ExecuteStatus == STATUS_SUCCESS) {
ndfsWinxpReplytHeader = (PNDFS_WINXP_REPLY_HEADER)secondaryRequest->NdfsReplyData;
ASSERT(ndfsWinxpReplytHeader->Status == STATUS_SUCCESS);
}
if (secondaryRequest) {
DereferenceSecondaryRequest( secondaryRequest );
secondaryRequest = NULL;
}
if ( secondarySessionResourceAcquired == TRUE ) {
SecondaryReleaseResourceLite( IrpContext, &volDo->Secondary->SessionResource );
secondarySessionResourceAcquired = FALSE;
}
break;
} while(0);
}
Status = STATUS_SUCCESS;
//
// Case on the type of open that we are trying to flush
//
switch (TypeOfOpen) {
case VirtualVolumeFile:
case EaFile:
case DirectoryFile:
DebugTrace(0, Dbg, "Flush that does nothing\n", 0);
break;
case UserFileOpen:
DebugTrace(0, Dbg, "Flush User File Open\n", 0);
(VOID)FatAcquireExclusiveFcb( IrpContext, Fcb );
FcbAcquired = TRUE;
FatVerifyFcb( IrpContext, Fcb );
//
// If the file is cached then flush its cache
//
Status = FatFlushFile( IrpContext, Fcb, Flush );
//
// Also update and flush the file's dirent in the parent directory if the
// file flush worked.
//
if (NT_SUCCESS( Status )) {
//
// Insure that we get the filesize to disk correctly. This is
// benign if it was already good.
//
// (why do we need to do this?)
//
SetFlag(FileObject->Flags, FO_FILE_SIZE_CHANGED);
#if 0
FatUpdateDirentFromFcb( IrpContext, FileObject, Fcb, Ccb );
#endif
//
// Flush the volume file to get any allocation information
// updates to disk.
//
if (FlagOn(Fcb->FcbState, FCB_STATE_FLUSH_FAT)) {
Status = FatFlushFat( IrpContext, Vcb );
ClearFlag(Fcb->FcbState, FCB_STATE_FLUSH_FAT);
}
//
// Set the write through bit so that these modifications
// will be completed with the request.
//
SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_WRITE_THROUGH);
}
break;
case UserDirectoryOpen:
//
// If the user had opened the root directory then we'll
// oblige by flushing the volume.
//
if (NodeType(Fcb) != FAT_NTC_ROOT_DCB) {
DebugTrace(0, Dbg, "Flush a directory does nothing\n", 0);
break;
}
case UserVolumeOpen:
DebugTrace(0, Dbg, "Flush User Volume Open, or root dcb\n", 0);
//
// Acquire exclusive access to the Vcb.
//
{
BOOLEAN Finished;
Finished = FatAcquireExclusiveSecondaryVcb( IrpContext, Vcb );
ASSERT( Finished );
}
VcbAcquired = TRUE;
//
// Mark the volume clean and then flush the volume file,
// and then all directories
//
Status = FatFlushVolume( IrpContext, Vcb, Flush );
//
// If the volume was dirty, do the processing that the delayed
// callback would have done.
//
if (FlagOn(Vcb->VcbState, VCB_STATE_FLAG_VOLUME_DIRTY)) {
//
// Cancel any pending clean volumes.
//
(VOID)KeCancelTimer( &Vcb->CleanVolumeTimer );
(VOID)KeRemoveQueueDpc( &Vcb->CleanVolumeDpc );
//
// The volume is now clean, note it.
//
if (!FlagOn(Vcb->VcbState, VCB_STATE_FLAG_MOUNTED_DIRTY)) {
FatMarkVolume( IrpContext, Vcb, VolumeClean );
ClearFlag( Vcb->VcbState, VCB_STATE_FLAG_VOLUME_DIRTY );
}
//
// Unlock the volume if it is removable.
//
if (FlagOn(Vcb->VcbState, VCB_STATE_FLAG_REMOVABLE_MEDIA) &&
!FlagOn(Vcb->VcbState, VCB_STATE_FLAG_BOOT_OR_PAGING_FILE)) {
FatToggleMediaEjectDisable( IrpContext, Vcb, FALSE );
}
}
break;
default:
FatBugCheck( TypeOfOpen, 0, 0 );
}
FatUnpinBcb( IrpContext, DirentBcb );
FatUnpinRepinnedBcbs( IrpContext );
} finally {
DebugUnwind( FatCommonFlushBuffers );
if (secondaryRequest)
DereferenceSecondaryRequest( secondaryRequest );
if (secondarySessionResourceAcquired) {
SecondaryReleaseResourceLite( IrpContext, &volDo->Secondary->SessionResource );
}
FatUnpinBcb( IrpContext, DirentBcb );
if (VcbAcquired) { FatReleaseSecondaryVcb( IrpContext, Vcb ); }
if (FcbAcquired) { FatReleaseFcb( IrpContext, Fcb ); }
//
// If this is a normal termination then pass the request on
// to the target device object.
//
if (!AbnormalTermination()) {
NTSTATUS DriverStatus;
PIO_STACK_LOCATION NextIrpSp;
//
// Get the next stack location, and copy over the stack location
//
NextIrpSp = IoGetNextIrpStackLocation( Irp );
*NextIrpSp = *IrpSp;
//
// Set up the completion routine
//
IoSetCompletionRoutine( Irp,
FatFlushCompletionRoutine,
ULongToPtr( Status ),
TRUE,
TRUE,
TRUE );
//
// Send the request.
//
DriverStatus = IoCallDriver(Vcb->TargetDeviceObject, Irp);
Status = (DriverStatus == STATUS_INVALID_DEVICE_REQUEST) ?
Status : DriverStatus;
//
// Free the IrpContext and return to the caller.
//
FatCompleteRequest( IrpContext, FatNull, STATUS_SUCCESS );
}
DebugTrace(-1, Dbg, "FatCommonFlushBuffers -> %08lx\n", Status);
}
return Status;
}
NTSTATUS
FatCommonPnp (
IN PIRP_CONTEXT IrpContext,
IN PIRP Irp
)
/*++
Routine Description:
This is the common routine for doing PnP operations called
by both the fsd and fsp threads
Arguments:
Irp - Supplies the Irp to process
Return Value:
NTSTATUS - The return status for the operation
--*/
{
NTSTATUS Status;
PIO_STACK_LOCATION IrpSp;
PVOLUME_DEVICE_OBJECT OurDeviceObject;
PVCB Vcb;
//
// Force everything to wait.
//
SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT);
//
// Get the current Irp stack location.
//
IrpSp = IoGetCurrentIrpStackLocation( Irp );
//
// Find our Vcb. This is tricky since we have no file object in the Irp.
//
OurDeviceObject = (PVOLUME_DEVICE_OBJECT) IrpSp->DeviceObject;
//
// Take the global lock to synchronise against volume teardown.
//
FatAcquireExclusiveGlobal( IrpContext );
//
// Make sure this device object really is big enough to be a volume device
// object. If it isn't, we need to get out before we try to reference some
// field that takes us past the end of an ordinary device object.
//
if (OurDeviceObject->DeviceObject.Size != sizeof(VOLUME_DEVICE_OBJECT) ||
NodeType( &OurDeviceObject->Vcb ) != FAT_NTC_VCB) {
//
// We were called with something we don't understand.
//
FatReleaseGlobal( IrpContext );
Status = STATUS_INVALID_PARAMETER;
FatCompleteRequest( IrpContext, Irp, Status );
return Status;
}
#if __NDAS_FAT__
if (OurDeviceObject->NetdiskEnableMode == NETDISK_SECONDARY)
SetFlag( IrpContext->NdFatFlags, ND_FAT_IRP_CONTEXT_FLAG_SECONDARY_CONTEXT );
#endif
Vcb = &OurDeviceObject->Vcb;
//
// Case on the minor code.
//
#if __NDAS_FAT_SECONDARY__
if ( ((PVOLUME_DEVICE_OBJECT)IrpSp->DeviceObject)->Secondary &&
( ((PVOLUME_DEVICE_OBJECT)IrpSp->DeviceObject)->NetdiskEnableMode == NETDISK_SECONDARY ||
((PVOLUME_DEVICE_OBJECT)IrpSp->DeviceObject)->NetdiskEnableMode == NETDISK_SECONDARY2PRIMARY ) )
{
PSECONDARY Secondary = ((PVOLUME_DEVICE_OBJECT)IrpSp->DeviceObject)->Secondary;
Status = STATUS_SUCCESS;
Secondary_Reference( Secondary );
switch ( IrpSp->MinorFunction ) {
case IRP_MN_QUERY_REMOVE_DEVICE: {
DebugTrace2( 0, Dbg, ("FatCommonPnp: IRP_MN_QUERY_REMOVE_DEVICE NetdiskEnableMode = %d\n", ((PVOLUME_DEVICE_OBJECT)IrpSp->DeviceObject)->NetdiskEnableMode) );
ExAcquireFastMutex( &Secondary->FastMutex );
if (!Secondary->TryCloseActive) {
Secondary->TryCloseActive = TRUE;
ExReleaseFastMutex( &Secondary->FastMutex );
Secondary_Reference( Secondary );
//FatDebugTraceLevel |= DEBUG_TRACE_CLOSE;
SecondaryTryClose( IrpContext, Secondary );
//FatDebugTraceLevel &= ~DEBUG_TRACE_CLOSE;
} else {
ExReleaseFastMutex( &Secondary->FastMutex );
}
if (Vcb->SecondaryOpenFileCount) {
LARGE_INTEGER interval;
// Wait all files closed
interval.QuadPart = (1 * HZ); //delay 1 seconds
KeDelayExecutionThread(KernelMode, FALSE, &interval);
}
#if 0
if (Vcb->SecondaryOpenFileCount) {
LONG ccbCount;
PLIST_ENTRY ccbListEntry;
PVOID restartKey;
PFCB fcb;
ExAcquireFastMutex( &Secondary->RecoveryCcbQMutex );
for (ccbCount = 0, ccbListEntry = Secondary->RecoveryCcbQueue.Flink;
ccbListEntry != &Secondary->RecoveryCcbQueue;
ccbListEntry = ccbListEntry->Flink, ccbCount++);
ExReleaseFastMutex( &Secondary->RecoveryCcbQMutex );
ASSERT( !IsListEmpty(&Secondary->RecoveryCcbQueue) );
ASSERT( ccbCount == Vcb->SecondaryOpenFileCount );
DebugTrace2( 0, Dbg, ("IRP_MN_QUERY_REMOVE_DEVICE: Vcb->SecondaryCloseCount = %d, Vcb->CloseCount = %d, ccbCount = %d\n",
Vcb->SecondaryOpenFileCount, Vcb->OpenCount, ccbCount) );
restartKey = NULL;
fcb = NdFatGetNextFcbTableEntry( &Secondary->VolDo->Vcb, &restartKey );
ASSERT( fcb != NULL || !IsListEmpty(&Secondary->DeletedFcbQueue) );
Status = STATUS_UNSUCCESSFUL;
}
#endif
break;
}
case IRP_MN_REMOVE_DEVICE: {
PVOID restartKey;
PFCB fcb;
DebugTrace2( 0, Dbg, ("FatCommonPnp: IRP_MN_REMOVE_DEVICE NetdiskEnableMode = %d\n", ((PVOLUME_DEVICE_OBJECT)IrpSp->DeviceObject)->NetdiskEnableMode) );
#if 0
restartKey = NULL;
fcb = NdFatGetNextFcbTableEntry( &Secondary->VolDo->Vcb, &restartKey );
ASSERT( fcb == NULL && IsListEmpty(&Secondary->DeletedFcbQueue) );
#endif
if (Vcb->SecondaryOpenFileCount) {
ASSERT( NDFAT_BUG );
Status = STATUS_UNSUCCESSFUL;
}
break;
}
default: {
DebugTrace2( 0, Dbg, ("FatCommonPnp: IrpSp-MinorFunction = %d NetdiskEnableMode = %d\n",
IrpSp->MinorFunction, ((PVOLUME_DEVICE_OBJECT)IrpSp->DeviceObject)->NetdiskEnableMode) );
if (IrpSp->MinorFunction != IRP_MN_QUERY_DEVICE_RELATIONS) {
if (IrpSp->FileObject && IS_SECONDARY_FILEOBJECT(IrpSp->FileObject)) {
ASSERT( FALSE );
}
}
Status = STATUS_SUCCESS;
break;
}
}
Secondary_Dereference( Secondary );
if (!NT_SUCCESS(Status)) {
FatCompleteRequest( NULL, Irp, Status );
return Status;
}
}
#endif
switch ( IrpSp->MinorFunction ) {
case IRP_MN_QUERY_REMOVE_DEVICE:
Status = FatPnpQueryRemove( IrpContext, Irp, Vcb );
break;
case IRP_MN_SURPRISE_REMOVAL:
Status = FatPnpSurpriseRemove( IrpContext, Irp, Vcb );
break;
case IRP_MN_REMOVE_DEVICE:
Status = FatPnpRemove( IrpContext, Irp, Vcb );
break;
case IRP_MN_CANCEL_REMOVE_DEVICE:
Status = FatPnpCancelRemove( IrpContext, Irp, Vcb );
break;
default:
FatReleaseGlobal( IrpContext );
//
// Just pass the IRP on. As we do not need to be in the
// way on return, ellide ourselves out of the stack.
//
IoSkipCurrentIrpStackLocation( Irp );
Status = IoCallDriver(Vcb->TargetDeviceObject, Irp);
//
// Cleanup our Irp Context. The driver has completed the Irp.
//
FatCompleteRequest( IrpContext, NULL, STATUS_SUCCESS );
break;
}
return Status;
}
NTSTATUS
FatCommonLockControl (
IN PIRP_CONTEXT IrpContext,
IN PIRP Irp
)
/*++
Routine Description:
This is the common routine for doing Lock control operations called
by both the fsd and fsp threads
Arguments:
Irp - Supplies the Irp to process
Return Value:
NTSTATUS - The return status for the operation
--*/
{
NTSTATUS Status;
PIO_STACK_LOCATION IrpSp;
TYPE_OF_OPEN TypeOfOpen;
PVCB Vcb;
PFCB Fcb;
PCCB Ccb;
BOOLEAN OplockPostIrp = FALSE;
//
// Get a pointer to the current Irp stack location
//
IrpSp = IoGetCurrentIrpStackLocation( Irp );
DebugTrace(+1, Dbg, "FatCommonLockControl\n", 0);
DebugTrace( 0, Dbg, "Irp = %08lx\n", Irp);
DebugTrace( 0, Dbg, "MinorFunction = %08lx\n", IrpSp->MinorFunction);
//
// Decode the type of file object we're being asked to process
//
TypeOfOpen = FatDecodeFileObject( IrpSp->FileObject, &Vcb, &Fcb, &Ccb );
//
// If the file is not a user file open then we reject the request
// as an invalid parameter
//
if (TypeOfOpen != UserFileOpen) {
FatCompleteRequest( IrpContext, Irp, STATUS_INVALID_PARAMETER );
DebugTrace(-1, Dbg, "FatCommonLockControl -> STATUS_INVALID_PARAMETER\n", 0);
return STATUS_INVALID_PARAMETER;
}
//
// Acquire exclusive access to the Fcb and enqueue the Irp if we didn't
// get access
//
if (!FatAcquireSharedFcb( IrpContext, Fcb )) {
Status = FatFsdPostRequest( IrpContext, Irp );
DebugTrace(-1, Dbg, "FatCommonLockControl -> %08lx\n", Status);
return Status;
}
try {
//
// We check whether we can proceed
// based on the state of the file oplocks.
//
Status = FsRtlCheckOplock( &Fcb->Specific.Fcb.Oplock,
Irp,
IrpContext,
FatOplockComplete,
NULL );
if (Status != STATUS_SUCCESS) {
OplockPostIrp = TRUE;
try_return( NOTHING );
}
//
// Now call the FsRtl routine to do the actual processing of the
// Lock request
//
Status = FsRtlProcessFileLock( &Fcb->Specific.Fcb.FileLock, Irp, NULL );
//
// Set the flag indicating if Fast I/O is possible
//
Fcb->Header.IsFastIoPossible = FatIsFastIoPossible( Fcb );
try_exit:
NOTHING;
}
finally {
DebugUnwind( FatCommonLockControl );
//
// Only if this is not an abnormal termination do we delete the
// irp context
//
if (!AbnormalTermination() && !OplockPostIrp) {
FatCompleteRequest( IrpContext, FatNull, 0 );
}
//
// Release the Fcb, and return to our caller
//
FatReleaseFcb( IrpContext, Fcb );
DebugTrace(-1, Dbg, "FatCommonLockControl -> %08lx\n", Status);
}
return Status;
}
NTSTATUS
FatCommonPnp (
IN PIRP_CONTEXT IrpContext,
IN PIRP Irp
)
/*++
Routine Description:
This is the common routine for doing PnP operations called
by both the fsd and fsp threads
Arguments:
Irp - Supplies the Irp to process
Return Value:
NTSTATUS - The return status for the operation
--*/
{
NTSTATUS Status;
PIO_STACK_LOCATION IrpSp;
PVOLUME_DEVICE_OBJECT OurDeviceObject;
PVCB Vcb;
//
// Get the current Irp stack location.
//
IrpSp = IoGetCurrentIrpStackLocation( Irp );
//
// Find our Vcb. This is tricky since we have no file object in the Irp.
//
OurDeviceObject = (PVOLUME_DEVICE_OBJECT) IrpSp->DeviceObject;
//
// Make sure this device object really is big enough to be a volume device
// object. If it isn't, we need to get out before we try to reference some
// field that takes us past the end of an ordinary device object.
//
if (OurDeviceObject->DeviceObject.Size != sizeof(VOLUME_DEVICE_OBJECT) ||
NodeType( &OurDeviceObject->Vcb ) != FAT_NTC_VCB) {
//
// We were called with something we don't understand.
//
Status = STATUS_INVALID_PARAMETER;
FatCompleteRequest( IrpContext, Irp, Status );
return Status;
}
//
// Force everything to wait.
//
SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT);
Vcb = &OurDeviceObject->Vcb;
//
// Case on the minor code.
//
switch ( IrpSp->MinorFunction ) {
case IRP_MN_QUERY_REMOVE_DEVICE:
Status = FatPnpQueryRemove( IrpContext, Irp, Vcb );
break;
case IRP_MN_SURPRISE_REMOVAL:
Status = FatPnpSurpriseRemove( IrpContext, Irp, Vcb );
break;
case IRP_MN_REMOVE_DEVICE:
Status = FatPnpRemove( IrpContext, Irp, Vcb );
break;
case IRP_MN_CANCEL_REMOVE_DEVICE:
Status = FatPnpCancelRemove( IrpContext, Irp, Vcb );
break;
default:
//
// Just pass the IRP on. As we do not need to be in the
// way on return, ellide ourselves out of the stack.
//
IoSkipCurrentIrpStackLocation( Irp );
Status = IoCallDriver(Vcb->TargetDeviceObject, Irp);
//
// Cleanup our Irp Context. The driver has completed the Irp.
//
FatCompleteRequest( IrpContext, NULL, STATUS_SUCCESS );
break;
}
return Status;
}
NTSTATUS
FatFsdClose (
_In_ PVOLUME_DEVICE_OBJECT VolumeDeviceObject,
_Inout_ PIRP Irp
)
/*++
Routine Description:
This routine implements the FSD part of Close.
Arguments:
VolumeDeviceObject - Supplies the volume device object where the
file exists
Irp - Supplies the Irp being processed
Return Value:
NTSTATUS - The FSD status for the IRP
--*/
{
NTSTATUS Status = STATUS_SUCCESS;
PIO_STACK_LOCATION IrpSp;
PFILE_OBJECT FileObject;
PVCB Vcb;
PFCB Fcb;
PCCB Ccb;
TYPE_OF_OPEN TypeOfOpen;
BOOLEAN TopLevel;
BOOLEAN VcbDeleted = FALSE;
PAGED_CODE();
//
// If we were called with our file system device object instead of a
// volume device object, just complete this request with STATUS_SUCCESS
//
if (FatDeviceIsFatFsdo( VolumeDeviceObject)) {
Irp->IoStatus.Status = STATUS_SUCCESS;
Irp->IoStatus.Information = FILE_OPENED;
IoCompleteRequest( Irp, IO_DISK_INCREMENT );
return STATUS_SUCCESS;
}
DebugTrace(+1, Dbg, "FatFsdClose\n", 0);
//
// Call the common Close routine
//
FsRtlEnterFileSystem();
TopLevel = FatIsIrpTopLevel( Irp );
//
// Get a pointer to the current stack location and the file object
//
IrpSp = IoGetCurrentIrpStackLocation( Irp );
FileObject = IrpSp->FileObject;
//
// Decode the file object and set the read-only bit in the Ccb.
//
TypeOfOpen = FatDecodeFileObject( FileObject, &Vcb, &Fcb, &Ccb );
if (Ccb && IsFileObjectReadOnly(FileObject)) {
SetFlag( Ccb->Flags, CCB_FLAG_READ_ONLY );
}
try {
PCLOSE_CONTEXT CloseContext = NULL;
//
// If we are top level, WAIT can be TRUE, otherwise make it FALSE
// to avoid deadlocks, unless this is a top
// level request not originating from the system process.
//
BOOLEAN Wait = TopLevel && (PsGetCurrentProcess() != FatData.OurProcess);
#if (NTDDI_VERSION >= NTDDI_WIN8)
//
// To catch the odd case where a close comes in without a preceding cleanup,
// call the oplock package to get rid of any oplock state. This can only
// be safely done in the FSD path.
//
if ((Fcb != NULL) &&
!FlagOn( FileObject->Flags, FO_CLEANUP_COMPLETE ) &&
FatIsFileOplockable( Fcb )) {
//
// This is equivalent to handling cleanup, and it always cleans up any
// oplock immediately. Also, we don't need any locking of the FCB here;
// the oplock's own lock will be sufficient for this purpose.
//
FsRtlCheckOplockEx( FatGetFcbOplock(Fcb),
Irp,
0,
NULL,
NULL,
NULL );
}
#endif
//
// Call the common Close routine if we are not delaying this close.
//
if ((((TypeOfOpen == UserFileOpen) ||
(TypeOfOpen == UserDirectoryOpen)) &&
FlagOn(Fcb->FcbState, FCB_STATE_DELAY_CLOSE) &&
!FatData.ShutdownStarted) ||
(FatCommonClose( Vcb, Fcb, Ccb, TypeOfOpen, Wait, TopLevel, &VcbDeleted ) == STATUS_PENDING)) {
//
// Metadata streams have had close contexts preallocated.
//
if (TypeOfOpen == VirtualVolumeFile) {
NT_ASSERT( Vcb->CloseContext != NULL );
CloseContext = Vcb->CloseContext;
Vcb->CloseContext = NULL;
CloseContext->Free = TRUE;
}
else if ((TypeOfOpen == DirectoryFile) || (TypeOfOpen == EaFile)) {
CloseContext = FatAllocateCloseContext( Vcb);
NT_ASSERT( CloseContext != NULL );
CloseContext->Free = TRUE;
} else {
//
// Free up any query template strings before using the close context fields,
// which overlap (union)
//
FatDeallocateCcbStrings( Ccb );
CloseContext = &Ccb->CloseContext;
CloseContext->Free = FALSE;
SetFlag( Ccb->Flags, CCB_FLAG_CLOSE_CONTEXT );
}
//
// If the status is pending, then let's get the information we
// need into the close context we already have bagged, complete
// the request, and post it. It is important we allocate nothing
// in the close path.
//
CloseContext->Vcb = Vcb;
CloseContext->Fcb = Fcb;
CloseContext->TypeOfOpen = TypeOfOpen;
//
// Send it off, either to an ExWorkerThread or to the async
// close list.
//
FatQueueClose( CloseContext,
(BOOLEAN)(Fcb && FlagOn(Fcb->FcbState, FCB_STATE_DELAY_CLOSE)));
} else {
//
// The close proceeded synchronously, so for the metadata objects we
// can now drop the close context we preallocated.
//
if ((TypeOfOpen == VirtualVolumeFile) ||
(TypeOfOpen == DirectoryFile) ||
(TypeOfOpen == EaFile)) {
if (TypeOfOpen == VirtualVolumeFile) {
//
// If the VCB was deleted during the close, the close context for this
// open has already been freed.
//
if (!VcbDeleted) {
CloseContext = Vcb->CloseContext;
Vcb->CloseContext = NULL;
NT_ASSERT( CloseContext != NULL );
} else {
CloseContext = NULL;
}
}
else {
CloseContext = FatAllocateCloseContext( (VcbDeleted ? NULL : Vcb) );
NT_ASSERT( CloseContext != NULL );
}
if (CloseContext != NULL) {
ExFreePool( CloseContext );
}
}
}
FatCompleteRequest( FatNull, Irp, Status );
}
except(FatExceptionFilter( NULL, GetExceptionInformation() )) {
//
// We had some trouble trying to perform the requested
// operation, so we'll abort the I/O request with the
// error status that we get back from the execption code.
//
Status = FatProcessException( NULL, Irp, GetExceptionCode() );
}
if (TopLevel) { IoSetTopLevelIrp( NULL ); }
FsRtlExitFileSystem();
//
// And return to our caller
//
DebugTrace(-1, Dbg, "FatFsdClose -> %08lx\n", Status);
UNREFERENCED_PARAMETER( VolumeDeviceObject );
return Status;
}
NTSTATUS
FatPnpQueryRemove (
PIRP_CONTEXT IrpContext,
PIRP Irp,
PVCB Vcb
)
/*++
Routine Description:
This routine handles the PnP query remove operation. The filesystem
is responsible for answering whether there are any reasons it sees
that the volume can not go away (and the device removed). Initiation
of the dismount begins when we answer yes to this question.
Query will be followed by a Cancel or Remove.
Arguments:
Irp - Supplies the Irp to process
Vcb - Supplies the volume being queried.
Return Value:
NTSTATUS - The return status for the operation
--*/
{
NTSTATUS Status;
KEVENT Event;
BOOLEAN VcbDeleted = FALSE;
BOOLEAN GlobalHeld = FALSE;
//
// Having said yes to a QUERY, any communication with the
// underlying storage stack is undefined (and may block)
// until the bounding CANCEL or REMOVE is sent.
//
//
// Acquire the global resource so that we can try to vaporize
// the volume, and the vcb resource itself.
//
FatAcquireExclusiveVcb( IrpContext, Vcb );
try {
Status = FatLockVolumeInternal( IrpContext, Vcb, NULL );
//
// Reacquire the resources in the right order.
//
FatReleaseVcb( IrpContext, Vcb );
FatAcquireExclusiveGlobal( IrpContext );
GlobalHeld = TRUE;
FatAcquireExclusiveVcb( IrpContext, Vcb );
if (NT_SUCCESS( Status )) {
//
// With the volume held locked, note that we must finalize as much
// as possible right now.
//
FatFlushAndCleanVolume( IrpContext, Irp, Vcb, Flush );
//
// We need to pass this down before starting the dismount, which
// could disconnect us immediately from the stack.
//
//
// Get the next stack location, and copy over the stack location
//
IoCopyCurrentIrpStackLocationToNext( Irp );
//
// Set up the completion routine
//
KeInitializeEvent( &Event, NotificationEvent, FALSE );
IoSetCompletionRoutine( Irp,
FatPnpCompletionRoutine,
&Event,
TRUE,
TRUE,
TRUE );
//
// Send the request and wait.
//
Status = IoCallDriver(Vcb->TargetDeviceObject, Irp);
if (Status == STATUS_PENDING) {
KeWaitForSingleObject( &Event,
Executive,
KernelMode,
FALSE,
NULL );
Status = Irp->IoStatus.Status;
}
//
// Now if no one below us failed already, initiate the dismount
// on this volume, make it go away. PnP needs to see our internal
// streams close and drop their references to the target device.
//
// Since we were able to lock the volume, we are guaranteed to
// move this volume into dismount state and disconnect it from
// the underlying storage stack. The force on our part is actually
// unnecesary, though complete.
//
// What is not strictly guaranteed, though, is that the closes
// for the metadata streams take effect synchronously underneath
// of this call. This would leave references on the target device
// even though we are disconnected!
//
if (NT_SUCCESS( Status )) {
VcbDeleted = FatCheckForDismount( IrpContext, Vcb, TRUE );
ASSERT( VcbDeleted || Vcb->VcbCondition == VcbBad );
}
}
} finally {
//
// Release the Vcb if it could still remain.
//
if (!VcbDeleted) {
FatReleaseVcb( IrpContext, Vcb );
}
if (GlobalHeld) {
FatReleaseGlobal( IrpContext );
}
}
//
// Cleanup our IrpContext and complete the IRP if neccesary.
//
FatCompleteRequest( IrpContext, Irp, Status );
return Status;
}
