NTSTATUS
NtfsFsdPnp (
IN PVOLUME_DEVICE_OBJECT VolumeDeviceObject,
IN PIRP Irp
)
/*++
Routine Description:
This routine we always return STATUS_SUCCESS for the moment. Later on we will complete it.
Arguments:
VolumeDeviceObject - Volume's DeviceObject to checkpoint until done
Irp - Irp from last DeviceObject
Return Value:
STATUS_SUCCESS
--*/
{
UNREFERENCED_PARAMETER( VolumeDeviceObject );
ASSERT_IRP( Irp );
return STATUS_SUCCESS;
}
NTSTATUS
CdFsdPostRequest (
_Inout_ PIRP_CONTEXT IrpContext,
_Inout_ PIRP Irp
)
/*++
Routine Description:
This routine enqueues the request packet specified by IrpContext to the
work queue associated with the FileSystemDeviceObject. This is a FSD
routine.
Arguments:
IrpContext - Pointer to the IrpContext to be queued to the Fsp.
Irp - I/O Request Packet.
Return Value:
STATUS_PENDING
--*/
{
PAGED_CODE();
ASSERT_IRP_CONTEXT( IrpContext );
ASSERT_IRP( Irp );
//
// Posting is a three step operation. First lock down any buffers
// in the Irp. Next cleanup the IrpContext for the post and finally
// add this to a workque.
//
CdPrePostIrp( IrpContext, Irp );
CdAddToWorkque( IrpContext, Irp );
//
// And return to our caller
//
return STATUS_PENDING;
}
NTSTATUS
NdasNtfsSecondaryCommonFileSystemControl (
IN PIRP_CONTEXT IrpContext,
IN PIRP Irp
)
{
NTSTATUS Status;
PIO_STACK_LOCATION IrpSp;
ASSERT_IRP_CONTEXT( IrpContext );
ASSERT_IRP( Irp );
ASSERT( FlagOn( IrpContext->TopLevelIrpContext->State, IRP_CONTEXT_STATE_OWNS_TOP_LEVEL ));
PAGED_CODE();
IrpSp = IoGetCurrentIrpStackLocation( Irp );
DebugTrace( +1, Dbg, ("NtfsCommonFileSystemControl\n") );
DebugTrace( 0, Dbg, ("IrpContext = %08lx\n", IrpContext) );
DebugTrace( 0, Dbg, ("Irp = %08lx\n", Irp) );
switch (IrpSp->MinorFunction) {
case IRP_MN_MOUNT_VOLUME:
ASSERT( FALSE );
NtfsCompleteRequest( IrpContext, Irp, Status = STATUS_INVALID_DEVICE_REQUEST );
break;
case IRP_MN_USER_FS_REQUEST:
case IRP_MN_KERNEL_CALL:
Status = NdasNtfsSecondaryUserFsRequest( IrpContext, Irp );
break;
default:
DebugTrace( -1, Dbg, ("Invalid Minor Function %08lx\n", IrpSp->MinorFunction) );
NtfsCompleteRequest( IrpContext, Irp, Status = STATUS_INVALID_DEVICE_REQUEST );
break;
}
DebugTrace( -1, Dbg, ("NtfsCommonFileSystemControl -> %08lx\n", Status) );
return Status;
}
NTSTATUS
NtfsFsdPnp (
IN PVOLUME_DEVICE_OBJECT VolumeDeviceObject,
IN PIRP Irp
)
/*++
Routine Description:
This routine implements the FSD entry point for plug and play (Pnp).
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;
TOP_LEVEL_CONTEXT TopLevelContext;
PTOP_LEVEL_CONTEXT ThreadTopLevelContext;
PIRP_CONTEXT IrpContext = NULL;
#if __NDAS_NTFS__
if ((PVOID)NdasNtfsControlDeviceObject == VolumeDeviceObject) {
Status = Irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
Irp->IoStatus.Information = 0;
IoCompleteRequest( Irp, IO_DISK_INCREMENT );
return Status;
}
#endif
ASSERT_IRP( Irp );
UNREFERENCED_PARAMETER( VolumeDeviceObject );
#ifdef NTFSPNPDBG
if (NtfsDebugTraceLevel != 0) SetFlag( NtfsDebugTraceLevel, DEBUG_TRACE_PNP );
#endif
DebugTrace( +1, Dbg, ("NtfsFsdPnp\n") );
//
// Call the common Pnp routine
//
FsRtlEnterFileSystem();
switch( IoGetCurrentIrpStackLocation( Irp )->MinorFunction ) {
case IRP_MN_QUERY_REMOVE_DEVICE:
case IRP_MN_REMOVE_DEVICE:
case IRP_MN_CANCEL_REMOVE_DEVICE:
case IRP_MN_SURPRISE_REMOVAL:
ThreadTopLevelContext = NtfsInitializeTopLevelIrp( &TopLevelContext, FALSE, FALSE );
break;
default:
ThreadTopLevelContext = NtfsInitializeTopLevelIrp( &TopLevelContext, TRUE, TRUE );
break;
}
do {
try {
//
// We are either initiating this request or retrying it.
//
if (IrpContext == NULL) {
//
// Allocate and initialize the Irp.
//
NtfsInitializeIrpContext( Irp, TRUE, &IrpContext );
//
// Initialize the thread top level structure, if needed.
//
NtfsUpdateIrpContextWithTopLevel( IrpContext, ThreadTopLevelContext );
} else if (Status == STATUS_LOG_FILE_FULL) {
NtfsCheckpointForLogFileFull( IrpContext );
}
#if __NDAS_NTFS_SECONDARY__
if (!FlagOn(VolumeDeviceObject->NetdiskPartitionInformation.Flags, NETDISK_PARTITION_INFORMATION_FLAG_INDIRECT) &&
VolumeDeviceObject->NetdiskEnableMode == NETDISK_SECONDARY) {
if ((IrpContext->MinorFunction == IRP_MN_QUERY_REMOVE_DEVICE ||
IrpContext->MinorFunction == IRP_MN_SURPRISE_REMOVAL ||
IrpContext->MinorFunction == IRP_MN_CANCEL_REMOVE_DEVICE)) {
BOOLEAN secondaryResourceAcquired = FALSE;
BOOLEAN secondaryRecoveryResourceAcquired = FALSE;
ASSERT( NtfsIsTopLevelRequest(IrpContext) );
Status = STATUS_SUCCESS;
for (;;) {
NDAS_ASSERT( secondaryRecoveryResourceAcquired == FALSE );
NDAS_ASSERT( secondaryResourceAcquired == FALSE );
if (!FlagOn(IrpContext->State, IRP_CONTEXT_STATE_WAIT)) {
Status = NtfsPostRequest( IrpContext, Irp );
break;
}
if (FlagOn(VolumeDeviceObject->Secondary->Thread.Flags, SECONDARY_THREAD_FLAG_REMOTE_DISCONNECTED)) {
secondaryRecoveryResourceAcquired
= SecondaryAcquireResourceExclusiveLite( IrpContext,
&VolumeDeviceObject->RecoveryResource,
BooleanFlagOn(IrpContext->State, IRP_CONTEXT_STATE_WAIT) );
if (!FlagOn(VolumeDeviceObject->Secondary->Thread.Flags, SECONDARY_THREAD_FLAG_REMOTE_DISCONNECTED) ) {
SecondaryReleaseResourceLite( IrpContext, &VolumeDeviceObject->RecoveryResource );
secondaryRecoveryResourceAcquired = FALSE;
continue;
}
secondaryResourceAcquired
= SecondaryAcquireResourceExclusiveLite( IrpContext,
&VolumeDeviceObject->Resource,
BooleanFlagOn(IrpContext->State, IRP_CONTEXT_STATE_WAIT) );
try {
SecondaryRecoverySessionStart( VolumeDeviceObject->Secondary, IrpContext );
} finally {
SecondaryReleaseResourceLite( IrpContext, &VolumeDeviceObject->Resource );
secondaryResourceAcquired = FALSE;
SecondaryReleaseResourceLite( IrpContext, &VolumeDeviceObject->RecoveryResource );
secondaryRecoveryResourceAcquired = FALSE;
}
continue;
}
secondaryResourceAcquired
= SecondaryAcquireResourceSharedLite( IrpContext,
&VolumeDeviceObject->Resource,
BooleanFlagOn(IrpContext->State, IRP_CONTEXT_STATE_WAIT) );
NDAS_ASSERT( secondaryResourceAcquired == TRUE );
break;
}
if (Status == STATUS_SUCCESS) {
try {
if (VolumeDeviceObject->NetdiskEnableMode != NETDISK_SECONDARY) {
NDAS_ASSERT( VolumeDeviceObject->NetdiskEnableMode == NETDISK_SECONDARY2PRIMARY );
NtfsRaiseStatus( IrpContext, STATUS_CANT_WAIT, NULL, NULL );
}
SetFlag( IrpContext->NdasNtfsFlags, NDAS_NTFS_IRP_CONTEXT_FLAG_SECONDARY_CONTEXT );
Status = NtfsCommonPnp( IrpContext, &Irp );
} finally {
ASSERT( ExIsResourceAcquiredSharedLite(&VolumeDeviceObject->Resource) );
SecondaryReleaseResourceLite( NULL, &VolumeDeviceObject->Resource );
}
}
} else {
if (VolumeDeviceObject->NetdiskEnableMode != NETDISK_SECONDARY) {
NDAS_ASSERT( VolumeDeviceObject->NetdiskEnableMode == NETDISK_SECONDARY2PRIMARY );
NtfsRaiseStatus( IrpContext, STATUS_CANT_WAIT, NULL, NULL );
}
SetFlag( IrpContext->NdasNtfsFlags, NDAS_NTFS_IRP_CONTEXT_FLAG_SECONDARY_CONTEXT );
Status = NtfsCommonPnp( IrpContext, &Irp );
}
} else {
Status = NtfsCommonPnp( IrpContext, &Irp );
}
#else
Status = NtfsCommonPnp( IrpContext, &Irp );
#endif
break;
} except(NtfsExceptionFilter( IrpContext, GetExceptionInformation() )) {
NTSTATUS
NtfsFsdLockControl (
IN PVOLUME_DEVICE_OBJECT VolumeDeviceObject,
IN PIRP Irp
)
/*++
Routine Description:
This routine implements the FSD part of Lock Control.
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
--*/
{
TOP_LEVEL_CONTEXT TopLevelContext;
PTOP_LEVEL_CONTEXT ThreadTopLevelContext;
NTSTATUS Status = STATUS_SUCCESS;
PIRP_CONTEXT IrpContext = NULL;
#if __NDAS_NTFS__
if ((PVOID)NdasNtfsControlDeviceObject == VolumeDeviceObject) {
Status = Irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
Irp->IoStatus.Information = 0;
IoCompleteRequest( Irp, IO_DISK_INCREMENT );
return Status;
}
#endif
ASSERT_IRP( Irp );
UNREFERENCED_PARAMETER( VolumeDeviceObject );
PAGED_CODE();
DebugTrace( +1, Dbg, ("NtfsFsdLockControl\n") );
//
// Call the common Lock Control routine
//
FsRtlEnterFileSystem();
ThreadTopLevelContext = NtfsInitializeTopLevelIrp( &TopLevelContext, FALSE, FALSE );
do {
try {
//
// We are either initiating this request or retrying it.
//
if (IrpContext == NULL) {
//
// Allocate and initialize the Irp.
//
NtfsInitializeIrpContext( Irp, CanFsdWait( Irp ), &IrpContext );
//
// Initialize the thread top level structure, if needed.
//
NtfsUpdateIrpContextWithTopLevel( IrpContext, ThreadTopLevelContext );
} else if (Status == STATUS_LOG_FILE_FULL) {
NtfsCheckpointForLogFileFull( IrpContext );
}
#if __NDAS_NTFS_SECONDARY__
if (IS_SECONDARY_FILEOBJECT(IoGetCurrentIrpStackLocation(Irp)->FileObject)) {
BOOLEAN secondaryResourceAcquired = FALSE;
BOOLEAN secondaryRecoveryResourceAcquired = FALSE;
ASSERT( NtfsIsTopLevelRequest(IrpContext) );
SetFlag( IrpContext->NdasNtfsFlags, NDAS_NTFS_IRP_CONTEXT_FLAG_SECONDARY_CONTEXT );
SetFlag( IrpContext->NdasNtfsFlags, NDAS_NTFS_IRP_CONTEXT_FLAG_SECONDARY_FILE );
Status = STATUS_SUCCESS;
for (;;) {
NDAS_ASSERT( secondaryRecoveryResourceAcquired == FALSE );
NDAS_ASSERT( secondaryResourceAcquired == FALSE );
if (!FlagOn(IrpContext->State, IRP_CONTEXT_STATE_WAIT)) {
Status = NtfsPostRequest( IrpContext, Irp );
break;
}
if (FlagOn(VolumeDeviceObject->Secondary->Thread.Flags, SECONDARY_THREAD_FLAG_REMOTE_DISCONNECTED)) {
secondaryRecoveryResourceAcquired
= SecondaryAcquireResourceExclusiveLite( IrpContext,
&VolumeDeviceObject->RecoveryResource,
BooleanFlagOn(IrpContext->State, IRP_CONTEXT_STATE_WAIT) );
if (!FlagOn(VolumeDeviceObject->Secondary->Thread.Flags, SECONDARY_THREAD_FLAG_REMOTE_DISCONNECTED) ) {
SecondaryReleaseResourceLite( IrpContext, &VolumeDeviceObject->RecoveryResource );
secondaryRecoveryResourceAcquired = FALSE;
continue;
}
secondaryResourceAcquired
= SecondaryAcquireResourceExclusiveLite( IrpContext,
&VolumeDeviceObject->Resource,
BooleanFlagOn(IrpContext->State, IRP_CONTEXT_STATE_WAIT) );
try {
SecondaryRecoverySessionStart( VolumeDeviceObject->Secondary, IrpContext );
} finally {
SecondaryReleaseResourceLite( IrpContext, &VolumeDeviceObject->Resource );
secondaryResourceAcquired = FALSE;
SecondaryReleaseResourceLite( IrpContext, &VolumeDeviceObject->RecoveryResource );
secondaryRecoveryResourceAcquired = FALSE;
}
continue;
}
secondaryResourceAcquired
= SecondaryAcquireResourceSharedLite( IrpContext,
&VolumeDeviceObject->Resource,
BooleanFlagOn(IrpContext->State, IRP_CONTEXT_STATE_WAIT) );
NDAS_ASSERT( secondaryResourceAcquired == TRUE );
break;
}
if (Status == STATUS_SUCCESS) {
try {
Status = NtfsCommonLockControl( IrpContext, Irp );
} finally {
ASSERT( ExIsResourceAcquiredSharedLite(&VolumeDeviceObject->Resource) );
SecondaryReleaseResourceLite( NULL, &VolumeDeviceObject->Resource );
}
}
} else
Status = NtfsCommonLockControl( IrpContext, Irp );
#else
Status = NtfsCommonLockControl( IrpContext, Irp );
#endif
break;
} except(NtfsExceptionFilter( 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
//
Status = NtfsProcessException( IrpContext, Irp, GetExceptionCode() );
}
} while (Status == STATUS_CANT_WAIT ||
NTSTATUS
NtfsCommonSetVolumeInfo (
IN PIRP_CONTEXT IrpContext,
IN PIRP Irp
)
/*++
Routine Description:
This is the common routine for set Volume Information 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;
PFILE_OBJECT FileObject;
TYPE_OF_OPEN TypeOfOpen;
PVCB Vcb;
PFCB Fcb;
PSCB Scb;
PCCB Ccb;
ULONG Length;
FS_INFORMATION_CLASS FsInformationClass;
PVOID Buffer;
ASSERT_IRP_CONTEXT( IrpContext );
ASSERT_IRP( Irp );
ASSERT( FlagOn( IrpContext->TopLevelIrpContext->State, IRP_CONTEXT_STATE_OWNS_TOP_LEVEL ));
PAGED_CODE();
//
// Get the current Irp stack location
//
IrpSp = IoGetCurrentIrpStackLocation( Irp );
DebugTrace( +1, Dbg, ("NtfsCommonSetVolumeInfo\n") );
DebugTrace( 0, Dbg, ("IrpContext = %08lx\n", IrpContext) );
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;
//
// Extract and decode the file object to get the Vcb, we don't really
// care what the type of open is.
//
FileObject = IrpSp->FileObject;
TypeOfOpen = NtfsDecodeFileObject( IrpContext, FileObject, &Vcb, &Fcb, &Scb, &Ccb, TRUE );
if (TypeOfOpen != UserVolumeOpen &&
(TypeOfOpen != UserViewIndexOpen ||
FsInformationClass != FileFsControlInformation ||
Fcb != Vcb->QuotaTableScb->Fcb)) {
NtfsCompleteRequest( IrpContext, Irp, STATUS_ACCESS_DENIED );
DebugTrace( -1, Dbg2, ("NtfsCommonSetVolumeInfo -> STATUS_ACCESS_DENIED\n") );
return STATUS_ACCESS_DENIED;
}
//
// The volume must be writable.
//
if (NtfsIsVolumeReadOnly( Vcb )) {
Status = STATUS_MEDIA_WRITE_PROTECTED;
NtfsCompleteRequest( IrpContext, Irp, Status );
DebugTrace( -1, Dbg, ("NtfsCommonSetVolumeInfo -> %08lx\n", Status) );
return Status;
}
#ifdef __ND_NTFS_SECONDARY__
if (!FlagOn( IrpContext->State, IRP_CONTEXT_STATE_WAIT )) {
return NtfsPostRequest( IrpContext, Irp );
}
#endif
//
// Acquire exclusive access to the Vcb
//
NtfsAcquireExclusiveVcb( IrpContext, Vcb, TRUE );
try {
//
// Proceed only if the volume is mounted.
//
if (FlagOn( Vcb->VcbState, VCB_STATE_VOLUME_MOUNTED )) {
#ifdef __ND_NTFS_SECONDARY__
if(IoGetCurrentIrpStackLocation(Irp)->FileObject == NULL) {
DebugTrace( 0, DEBUG_TRACE_ALL, ("IrpSp->FileObject is NULL, IrpSp->MajorFunction = %x, IrpSp->MinorFunction = %x\n", IrpSp->MajorFunction, IrpSp->MinorFunction) );
}
if (IS_SECONDARY_FILEOBJECT(IoGetCurrentIrpStackLocation(Irp)->FileObject)) {
Status = NdNtfsSecondaryCommonSetVolumeInfo( IrpContext, Irp );
leave;
}
#endif
//
// 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 = NtfsSetFsLabelInfo( IrpContext, Vcb, Buffer );
break;
case FileFsControlInformation:
Status = NtfsSetFsControlInfo( IrpContext, Vcb, Buffer );
break;
case FileFsObjectIdInformation:
Status = NtfsSetFsVolumeObjectIdInfo( IrpContext, Vcb, Buffer );
DebugTrace( 0, Dbg2, ("NtfsCommonSetVolumeInfo %x, FileFsObjectIdInformation Vcb = %p\n", Status, IrpContext->Vcb) );
break;
default:
Status = STATUS_INVALID_PARAMETER;
break;
}
} else {
Status = STATUS_FILE_INVALID;
}
//
// Abort transaction on error by raising.
//
NtfsCleanupTransaction( IrpContext, Status, FALSE );
} finally {
DebugUnwind( NtfsCommonSetVolumeInfo );
NtfsReleaseVcb( IrpContext, Vcb );
DebugTrace( -1, Dbg, ("NtfsCommonSetVolumeInfo -> %08lx\n", Status) );
}
NtfsCompleteRequest( IrpContext, Irp, Status );
return Status;
}
NTSTATUS
NtfsCommonQueryVolumeInfo (
IN PIRP_CONTEXT IrpContext,
IN PIRP Irp
)
/*++
Routine Description:
This is the common routine for query Volume Information 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;
PFILE_OBJECT FileObject;
TYPE_OF_OPEN TypeOfOpen;
PVCB Vcb;
PFCB Fcb;
PSCB Scb;
PCCB Ccb;
ULONG Length;
FS_INFORMATION_CLASS FsInformationClass;
PVOID Buffer;
BOOLEAN AcquiredVcb = FALSE;
ASSERT_IRP_CONTEXT( IrpContext );
ASSERT_IRP( Irp );
ASSERT( FlagOn( IrpContext->TopLevelIrpContext->State, IRP_CONTEXT_STATE_OWNS_TOP_LEVEL ));
PAGED_CODE();
//
// Get the current stack location
//
IrpSp = IoGetCurrentIrpStackLocation( Irp );
DebugTrace( +1, Dbg, ("NtfsCommonQueryVolumeInfo...\n") );
DebugTrace( 0, Dbg, ("IrpContext = %08lx\n", IrpContext) );
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;
//
// Extract and decode the file object to get the Vcb, we don't really
// care what the type of open is.
//
FileObject = IrpSp->FileObject;
TypeOfOpen = NtfsDecodeFileObject( IrpContext, FileObject, &Vcb, &Fcb, &Scb, &Ccb, TRUE );
//
// Let's kill invalid vol. query requests.
//
if (UnopenedFileObject == TypeOfOpen) {
DebugTrace( 0, Dbg2, ("Invalid file object for write\n") );
DebugTrace( -1, Dbg2, ("NtfsCommonQueryVolume: Exit -> %08lx\n", STATUS_INVALID_DEVICE_REQUEST) );
NtfsCompleteRequest( IrpContext, Irp, STATUS_INVALID_DEVICE_REQUEST );
return STATUS_INVALID_DEVICE_REQUEST;
}
#ifdef __ND_NTFS_SECONDARY__
if (!FlagOn( IrpContext->State, IRP_CONTEXT_STATE_WAIT )) {
return NtfsPostRequest( IrpContext, Irp );
}
#endif
//
// Get the Vcb shared and raise if we can't wait for the resource.
// We're only using $Volume Scb for the query size calls because the info
// it gets is static and we only need to protect against dismount
// Doing this prevents a deadlock with commit extensions from mm which use
// this call. However for system files like the mft we always need the vcb to avoid deadlock
//
if ((FsInformationClass != FileFsSizeInformation) ||
(FlagOn( Scb->Fcb->FcbState, FCB_STATE_SYSTEM_FILE ))) {
NtfsAcquireSharedVcb( IrpContext, Vcb, TRUE );
AcquiredVcb = TRUE;
} else {
NtfsAcquireSharedScb( IrpContext, Scb );
}
try {
//
// Make sure the volume is mounted.
//
if ((AcquiredVcb && !FlagOn( Vcb->VcbState, VCB_STATE_VOLUME_MOUNTED )) ||
(!AcquiredVcb && FlagOn( Scb->ScbState, SCB_STATE_VOLUME_DISMOUNTED))) {
Irp->IoStatus.Information = 0;
Status = STATUS_VOLUME_DISMOUNTED;
leave;
}
#ifdef __ND_NTFS_SECONDARY__
if(IoGetCurrentIrpStackLocation(Irp)->FileObject == NULL) {
DebugTrace( 0, DEBUG_TRACE_ALL, ("IrpSp->FileObject is NULL, IrpSp->MajorFunction = %x, IrpSp->MinorFunction = %x\n", IrpSp->MajorFunction, IrpSp->MinorFunction) );
}
if (IS_SECONDARY_FILEOBJECT(IoGetCurrentIrpStackLocation(Irp)->FileObject)) {
Status = NdNtfsSecondaryCommonQueryVolumeInfo( IrpContext, Irp );
leave;
}
#endif
//
// 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:
Status = NtfsQueryFsVolumeInfo( IrpContext, Vcb, Buffer, &Length );
break;
case FileFsSizeInformation:
Status = NtfsQueryFsSizeInfo( IrpContext, Vcb, Buffer, &Length );
break;
case FileFsDeviceInformation:
Status = NtfsQueryFsDeviceInfo( IrpContext, Vcb, Buffer, &Length );
break;
case FileFsAttributeInformation:
Status = NtfsQueryFsAttributeInfo( IrpContext, Vcb, Buffer, &Length );
break;
case FileFsControlInformation:
Status = NtfsQueryFsControlInfo( IrpContext, Vcb, Buffer, &Length );
break;
case FileFsFullSizeInformation:
Status = NtfsQueryFsFullSizeInfo( IrpContext, Vcb, Buffer, &Length );
break;
case FileFsObjectIdInformation:
Status = NtfsQueryFsVolumeObjectIdInfo( IrpContext, Vcb, Buffer, &Length );
break;
default:
Status = STATUS_INVALID_PARAMETER;
break;
}
//
// Set the information field to the number of bytes actually filled in
//
Irp->IoStatus.Information = IrpSp->Parameters.QueryVolume.Length - Length;
//
// Abort transaction on error by raising.
//
NtfsCleanupTransaction( IrpContext, Status, FALSE );
} finally {
DebugUnwind( NtfsCommonQueryVolumeInfo );
if (AcquiredVcb) {
NtfsReleaseVcb( IrpContext, Vcb );
} else {
NtfsReleaseScb( IrpContext, Scb );
}
DebugTrace( -1, Dbg, ("NtfsCommonQueryVolumeInfo -> %08lx\n", Status) );
}
if (Status != STATUS_SUCCESS && Status != STATUS_BUFFER_OVERFLOW)
DebugTrace( 0, Dbg2, ("NtfsCommonQueryVolumeInfo %x, FsInformationClass = %d Vcb = %p\n", Status, FsInformationClass, IrpContext->Vcb) );
NtfsCompleteRequest( IrpContext, Irp, Status );
return Status;
}
NTSTATUS
NtfsCommonQueryVolumeInfo (
IN PIRP_CONTEXT IrpContext,
IN PIRP Irp
)
/*++
Routine Description:
This is the common routine for query Volume Information 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;
PFILE_OBJECT FileObject;
TYPE_OF_OPEN TypeOfOpen;
PVCB Vcb;
PFCB Fcb;
PSCB Scb;
PCCB Ccb;
ULONG Length;
FS_INFORMATION_CLASS FsInformationClass;
PVOID Buffer;
ASSERT_IRP_CONTEXT( IrpContext );
ASSERT_IRP( Irp );
PAGED_CODE();
//
// Get the current stack location
//
IrpSp = IoGetCurrentIrpStackLocation( Irp );
DebugTrace( +1, Dbg, ("NtfsCommonQueryVolumeInfo...\n") );
DebugTrace( 0, Dbg, ("IrpContext = %08lx\n", IrpContext) );
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;
//
// Extract and decode the file object to get the Vcb, we don't really
// care what the type of open is.
//
FileObject = IrpSp->FileObject;
TypeOfOpen = NtfsDecodeFileObject( IrpContext, FileObject, &Vcb, &Fcb, &Scb, &Ccb, TRUE );
//
// We need exclusive access to the Vcb because we are going to verify
// it. After we verify the vcb we'll convert our access to shared
//
NtfsAcquireSharedVcb( IrpContext, Vcb, FALSE );
try {
//
// 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:
Status = NtfsQueryFsVolumeInfo( IrpContext, Vcb, Buffer, &Length );
break;
case FileFsSizeInformation:
Status = NtfsQueryFsSizeInfo( IrpContext, Vcb, Buffer, &Length );
break;
case FileFsDeviceInformation:
Status = NtfsQueryFsDeviceInfo( IrpContext, Vcb, Buffer, &Length );
break;
case FileFsAttributeInformation:
Status = NtfsQueryFsAttributeInfo( IrpContext, Vcb, Buffer, &Length );
break;
#ifdef _CAIRO_
case FileFsControlInformation:
Status = NtfsQueryFsControlInfo( IrpContext, Vcb, Buffer, &Length );
break;
case FileFsQuotaQueryInformation:
Status = NtfsFsQuotaQueryInfo( IrpContext, Vcb, Buffer, &Length );
break;
#endif // _CAIRO_
default:
Status = STATUS_INVALID_PARAMETER;
break;
}
//
// Set the information field to the number of bytes actually filled in
//
Irp->IoStatus.Information = IrpSp->Parameters.QueryVolume.Length - Length;
//
// Abort transaction on error by raising.
//
NtfsCleanupTransaction( IrpContext, Status, FALSE );
} finally {
DebugUnwind( NtfsCommonQueryVolumeInfo );
NtfsReleaseVcb( IrpContext, Vcb );
if (!AbnormalTermination()) {
NtfsCompleteRequest( &IrpContext, &Irp, Status );
}
DebugTrace( -1, Dbg, ("NtfsCommonQueryVolumeInfo -> %08lx\n", Status) );
}
return Status;
}
NTSTATUS
CdProcessException (
_In_opt_ PIRP_CONTEXT IrpContext,
_Inout_ PIRP Irp,
_In_ NTSTATUS ExceptionCode
)
/*++
Routine Description:
This routine processes an exception. It either completes the request
with the exception status in the IrpContext, sends this off to the Fsp
workque or causes it to be retried in the current thread if a verification
is needed.
If the volume needs to be verified (STATUS_VERIFY_REQUIRED) and we can
do the work in the current thread we will translate the status code
to STATUS_CANT_WAIT to indicate that we need to retry the request.
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.
--*/
{
PDEVICE_OBJECT Device = NULL;
PVPB Vpb;
PETHREAD Thread;
ASSERT_OPTIONAL_IRP_CONTEXT( IrpContext );
ASSERT_IRP( Irp );
//
// If there is not an irp context, then complete the request with the
// current status code.
//
if (!ARGUMENT_PRESENT( IrpContext )) {
CdCompleteRequest( NULL, Irp, ExceptionCode );
return ExceptionCode;
}
//
// Get the real exception status from the IrpContext.
//
ExceptionCode = IrpContext->ExceptionStatus;
//
// Check if we are posting this request. One of the following must be true
// if we are to post a request.
//
// - Status code is STATUS_CANT_WAIT and the request is asynchronous
// or we are forcing this to be posted.
//
// - Status code is STATUS_VERIFY_REQUIRED and we are at APC level
// or higher, or within a guarded region. Can't wait for IO in
// the verify path in this case.
//
// Set the MORE_PROCESSING flag in the IrpContext to keep if from being
// deleted if this is a retryable condition.
//
//
// Note that (children of) CdFsdPostRequest can raise (Mdl allocation).
//
try {
if (ExceptionCode == STATUS_CANT_WAIT) {
if (FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_FORCE_POST )) {
ExceptionCode = CdFsdPostRequest( IrpContext, Irp );
}
}
else if ((ExceptionCode == STATUS_VERIFY_REQUIRED) &&
FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_TOP_LEVEL ) &&
KeAreAllApcsDisabled()) {
ExceptionCode = CdFsdPostRequest( IrpContext, Irp );
}
}
except( CdExceptionFilter( IrpContext, GetExceptionInformation() )) {
ExceptionCode = GetExceptionCode();
}
//
// If we posted the request or our caller will retry then just return here.
//
if ((ExceptionCode == STATUS_PENDING) ||
(ExceptionCode == STATUS_CANT_WAIT)) {
return ExceptionCode;
}
ClearFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_MORE_PROCESSING );
//
// If we are not a top level request then we just complete the request
// with the current status code.
//
if (!FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_TOP_LEVEL )) {
CdCompleteRequest( IrpContext, Irp, ExceptionCode );
return ExceptionCode;
}
//
// Store this error into the Irp for posting back to the Io system.
//
Irp->IoStatus.Status = ExceptionCode;
if (IoIsErrorUserInduced( ExceptionCode )) {
//
// Check for the various error conditions that can be caused by,
// and possibly resolved my the user.
//
if (ExceptionCode == STATUS_VERIFY_REQUIRED) {
//
// Now we are at the top level file system entry point.
//
// If we have already posted this request then the device to
// verify is in the original thread. Find this via the Irp.
//
Device = IoGetDeviceToVerify( Irp->Tail.Overlay.Thread );
IoSetDeviceToVerify( Irp->Tail.Overlay.Thread, NULL );
//
// If there is no device in that location then check in the
// current thread.
//
if (Device == NULL) {
Device = IoGetDeviceToVerify( PsGetCurrentThread() );
IoSetDeviceToVerify( PsGetCurrentThread(), NULL );
NT_ASSERT( Device != NULL );
}
//
// It turns out some storage drivers really do set invalid non-NULL device
// objects to verify.
//
// To work around this, completely ignore the device to verify in the thread,
// and just use our real device object instead.
//
if (IrpContext->Vcb) {
Device = IrpContext->Vcb->Vpb->RealDevice;
}
//
// Let's not BugCheck just because the device to verify is somehow still NULL.
//
if (Device == NULL) {
ExceptionCode = STATUS_DRIVER_INTERNAL_ERROR;
CdCompleteRequest( IrpContext, Irp, ExceptionCode );
return ExceptionCode;
}
//
// CdPerformVerify() will do the right thing with the Irp.
// If we return STATUS_CANT_WAIT then the current thread
// can retry the request.
//
return CdPerformVerify( 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 )) {
CdCompleteRequest( IrpContext, Irp, ExceptionCode );
return ExceptionCode;
}
//
// Generate a pop-up.
//
else {
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;
Device = IoGetDeviceToVerify( Thread );
if (Device == NULL) {
Thread = PsGetCurrentThread();
Device = IoGetDeviceToVerify( Thread );
NT_ASSERT( Device != NULL );
}
//
// It turns out some storage drivers really do set invalid non-NULL device
// objects to verify.
//
// To work around this, completely ignore the device to verify in the thread,
// and just use our real device object instead.
//
if (IrpContext->Vcb) {
Device = IrpContext->Vcb->Vpb->RealDevice;
}
//
// Let's not BugCheck just because the device to verify is somehow still NULL.
//
if (Device == NULL) {
CdCompleteRequest( 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, Device );
//
// 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.
//
CdCompleteRequest( IrpContext, NULL, STATUS_SUCCESS );
return STATUS_PENDING;
}
}
//
// This is just a run of the mill error.
//
CdCompleteRequest( IrpContext, Irp, ExceptionCode );
return ExceptionCode;
}
NTSTATUS
NtfsFsdLockControl (
IN PVOLUME_DEVICE_OBJECT VolumeDeviceObject,
IN PIRP Irp
)
/*++
Routine Description:
This routine implements the FSD part of Lock Control.
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
--*/
{
TOP_LEVEL_CONTEXT TopLevelContext;
PTOP_LEVEL_CONTEXT ThreadTopLevelContext;
NTSTATUS Status = STATUS_SUCCESS;
PIRP_CONTEXT IrpContext = NULL;
ASSERT_IRP( Irp );
UNREFERENCED_PARAMETER( VolumeDeviceObject );
PAGED_CODE();
DebugTrace( +1, Dbg, ("NtfsFsdLockControl\n") );
//
// Call the common Lock Control routine
//
FsRtlEnterFileSystem();
ThreadTopLevelContext = NtfsSetTopLevelIrp( &TopLevelContext, FALSE, FALSE );
do {
try {
//
// We are either initiating this request or retrying it.
//
if (IrpContext == NULL) {
IrpContext = NtfsCreateIrpContext( Irp, CanFsdWait( Irp ) );
NtfsUpdateIrpContextWithTopLevel( IrpContext, ThreadTopLevelContext );
} else if (Status == STATUS_LOG_FILE_FULL) {
NtfsCheckpointForLogFileFull( IrpContext );
}
Status = NtfsCommonLockControl( IrpContext, Irp );
break;
} except(NtfsExceptionFilter( 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
//
Status = NtfsProcessException( IrpContext, Irp, GetExceptionCode() );
}
} while (Status == STATUS_CANT_WAIT ||
Status == STATUS_LOG_FILE_FULL);
if (ThreadTopLevelContext == &TopLevelContext) {
NtfsRestoreTopLevelIrp( ThreadTopLevelContext );
}
FsRtlExitFileSystem();
//
// And return to our caller
//
DebugTrace( -1, Dbg, ("NtfsFsdLockControl -> %08lx\n", Status) );
return Status;
}
NTSTATUS
NtfsCommonSetSecurityInfo (
IN PIRP_CONTEXT IrpContext,
IN PIRP Irp
)
/*++
Routine Description:
This is the common routine for Setting security information 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;
PFILE_OBJECT FileObject;
#ifdef _CAIRO_
PQUOTA_CONTROL_BLOCK OldQuotaControl;
ULONG OldOwnerId;
ULONG LargeStdInfo;
#endif // _CAIRO_
TYPE_OF_OPEN TypeOfOpen;
PVCB Vcb;
PFCB Fcb;
PSCB Scb;
PCCB Ccb;
ASSERT_IRP_CONTEXT( IrpContext );
ASSERT_IRP( Irp );
PAGED_CODE();
//
// Get the current Irp stack location
//
IrpSp = IoGetCurrentIrpStackLocation( Irp );
DebugTrace( +1, Dbg, ("NtfsCommonSetSecurityInfo") );
DebugTrace( 0, Dbg, ("IrpContext = %08lx\n", IrpContext) );
DebugTrace( 0, Dbg, ("Irp = %08lx\n", Irp) );
//
// Extract and decode the file object
//
FileObject = IrpSp->FileObject;
TypeOfOpen = NtfsDecodeFileObject( IrpContext, FileObject, &Vcb, &Fcb, &Scb, &Ccb, TRUE );
//
// The only type of opens we accept are user file and directory opens
//
if ((TypeOfOpen != UserFileOpen)
&& (TypeOfOpen != UserDirectoryOpen)) {
Status = STATUS_INVALID_PARAMETER;
//
// If the this handle does not open the entire file then refuse access.
//
} else if (!FlagOn( Ccb->Flags, CCB_FLAG_OPEN_AS_FILE )) {
Status = STATUS_INVALID_PARAMETER;
} else {
//
// Our operation is to acquire the fcb, do the operation and then
// release the fcb
//
NtfsAcquireExclusiveFcb( IrpContext, Fcb, NULL, FALSE, FALSE );
try {
#ifdef _CAIRO_
//
// Capture the current OwnerId, Qutoa Control Block and
// size of standard information.
//
OldQuotaControl = Fcb->QuotaControl;
OldOwnerId = Fcb->OwnerId;
LargeStdInfo = Fcb->FcbState & FCB_STATE_LARGE_STD_INFO;
#endif // _CAIRO_
Status = NtfsModifySecurity( IrpContext,
Fcb,
&IrpSp->Parameters.SetSecurity.SecurityInformation,
IrpSp->Parameters.SetSecurity.SecurityDescriptor );
if (NT_SUCCESS( Status )) {
#ifdef _CAIRO_
//
// Make sure the new security descriptor Id is written out.
//
NtfsUpdateStandardInformation( IrpContext, Fcb );
#endif
}
//
// Abort transaction on error by raising.
//
NtfsCleanupTransaction( IrpContext, Status, FALSE );
//
// Set the flag in the Ccb to indicate this change occurred.
//
SetFlag( Ccb->Flags,
CCB_FLAG_UPDATE_LAST_CHANGE | CCB_FLAG_SET_ARCHIVE );
} finally {
DebugUnwind( NtfsCommonSetSecurityInfo );
#ifdef _CAIRO_
if (AbnormalTermination()) {
//
// The request failed. Restore the owner and
// QuotaControl are restored.
//
if (Fcb->QuotaControl != OldQuotaControl &&
Fcb->QuotaControl != NULL) {
//
// A new quota control block was assigned.
// Dereference it.
//
NtfsDereferenceQuotaControlBlock( Fcb->Vcb,
&Fcb->QuotaControl );
}
Fcb->QuotaControl = OldQuotaControl;
Fcb->OwnerId = OldOwnerId;
if (LargeStdInfo == 0) {
//
// The standard information has be returned to
// its orginal size.
//
ClearFlag( Fcb->FcbState, FCB_STATE_LARGE_STD_INFO );
}
} else {
//
// The request succeed. If the quota control block was
// changed then derefence the old block.
//
if (Fcb->QuotaControl != OldQuotaControl &&
OldQuotaControl != NULL) {
NtfsDereferenceQuotaControlBlock( Fcb->Vcb,
&OldQuotaControl);
}
}
#endif // _CAIRO_
NtfsReleaseFcb( IrpContext, Fcb );
}
}
//
// Now complete the request and return to our caller
//
NtfsCompleteRequest( &IrpContext, &Irp, Status );
DebugTrace( -1, Dbg, ("NtfsCommonSetSecurityInfo -> %08lx", Status) );
return Status;
}
NTSTATUS
NtfsCommonQuerySecurityInfo (
IN PIRP_CONTEXT IrpContext,
IN PIRP Irp
)
/*++
Routine Description:
This is the common routine for querying security information 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;
PFILE_OBJECT FileObject;
TYPE_OF_OPEN TypeOfOpen;
PVCB Vcb;
PFCB Fcb;
PSCB Scb;
PCCB Ccb;
BOOLEAN AcquiredFcb = TRUE;
ASSERT_IRP_CONTEXT( IrpContext );
ASSERT_IRP( Irp );
PAGED_CODE();
//
// Get the current Irp stack location
//
IrpSp = IoGetCurrentIrpStackLocation( Irp );
DebugTrace( +1, Dbg, ("NtfsCommonQuerySecurityInfo") );
DebugTrace( 0, Dbg, ("IrpContext = %08lx\n", IrpContext) );
DebugTrace( 0, Dbg, ("Irp = %08lx\n", Irp) );
//
// Extract and decode the file object
//
FileObject = IrpSp->FileObject;
TypeOfOpen = NtfsDecodeFileObject( IrpContext, FileObject, &Vcb, &Fcb, &Scb, &Ccb, TRUE );
//
// The only type of opens we accept are user file and directory opens
//
if ((TypeOfOpen != UserFileOpen)
&& (TypeOfOpen != UserDirectoryOpen)) {
Status = STATUS_INVALID_PARAMETER;
//
// If the this handle does not open the entire file then refuse access.
//
} else if (!FlagOn( Ccb->Flags, CCB_FLAG_OPEN_AS_FILE )) {
Status = STATUS_INVALID_PARAMETER;
} else {
//
// Our operation is to acquire the fcb, do the operation and then
// release the fcb. If the security descriptor for this file is
// not already loaded we will release the Fcb and then acquire both
// the Vcb and Fcb. We must have the Vcb to examine our parent's
// security descriptor.
//
NtfsAcquireSharedFcb( IrpContext, Fcb, NULL, FALSE );
try {
if (Fcb->SharedSecurity == NULL) {
NtfsReleaseFcb( IrpContext, Fcb );
AcquiredFcb = FALSE;
NtfsAcquireExclusiveFcb( IrpContext, Fcb, NULL, FALSE, FALSE );
AcquiredFcb = TRUE;
}
Status = NtfsQuerySecurity( IrpContext,
Fcb,
&IrpSp->Parameters.QuerySecurity.SecurityInformation,
(PSECURITY_DESCRIPTOR)Irp->UserBuffer,
&IrpSp->Parameters.QuerySecurity.Length );
if ( Status == STATUS_BUFFER_TOO_SMALL ) {
Irp->IoStatus.Information = IrpSp->Parameters.QuerySecurity.Length;
Status = STATUS_BUFFER_OVERFLOW;
}
//
// Abort transaction on error by raising.
//
NtfsCleanupTransaction( IrpContext, Status, FALSE );
} finally {
DebugUnwind( NtfsCommonQuerySecurityInfo );
if (AcquiredFcb) {
NtfsReleaseFcb( IrpContext, Fcb );
}
}
}
//
// Now complete the request and return to our caller
//
NtfsCompleteRequest( &IrpContext, &Irp, Status );
DebugTrace( -1, Dbg, ("NtfsCommonQuerySecurityInfo -> %08lx", Status) );
return Status;
}
VOID
NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */
CdPrePostIrp (
_Inout_ PIRP_CONTEXT IrpContext,
_Inout_ PIRP Irp
)
/*++
Routine Description:
This routine performs any neccessary work before STATUS_PENDING is
returned with the Fsd thread. This routine is called within the
filesystem and by the oplock package.
Arguments:
Context - Pointer to the IrpContext to be queued to the Fsp
Irp - I/O Request Packet.
Return Value:
None.
--*/
{
PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation( Irp );
BOOLEAN RemovedFcb;
PAGED_CODE();
ASSERT_IRP_CONTEXT( IrpContext );
ASSERT_IRP( Irp );
//
// Case on the type of the operation.
//
switch (IrpContext->MajorFunction) {
case IRP_MJ_CREATE :
//
// If called from the oplock package then there is an
// Fcb to possibly teardown. We will call the teardown
// routine and release the Fcb if still present. The cleanup
// code in create will know not to release this Fcb because
// we will clear the pointer.
//
if ((IrpContext->TeardownFcb != NULL) &&
*(IrpContext->TeardownFcb) != NULL) {
CdTeardownStructures( IrpContext, *(IrpContext->TeardownFcb), &RemovedFcb );
if (!RemovedFcb) {
_Analysis_assume_lock_held_((*IrpContext->TeardownFcb)->FcbNonpaged->FcbResource);
CdReleaseFcb( IrpContext, *(IrpContext->TeardownFcb) );
}
*(IrpContext->TeardownFcb) = NULL;
IrpContext->TeardownFcb = NULL;
}
break;
//
// We need to lock the user's buffer, unless this is an MDL read/write,
// in which case there is no user buffer.
//
case IRP_MJ_READ :
if (!FlagOn( IrpContext->MinorFunction, IRP_MN_MDL )) {
CdLockUserBuffer( IrpContext, IrpSp->Parameters.Read.Length, IoWriteAccess );
}
break;
case IRP_MJ_WRITE :
if (!FlagOn( IrpContext->MinorFunction, IRP_MN_MDL )) {
CdLockUserBuffer( IrpContext, IrpSp->Parameters.Read.Length, IoReadAccess );
}
break;
//
// We also need to check whether this is a query file operation.
//
case IRP_MJ_DIRECTORY_CONTROL :
if (IrpContext->MinorFunction == IRP_MN_QUERY_DIRECTORY) {
CdLockUserBuffer( IrpContext, IrpSp->Parameters.QueryDirectory.Length, IoWriteAccess );
}
break;
}
//
// Cleanup the IrpContext for the post.
//
SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_MORE_PROCESSING );
CdCleanupIrpContext( IrpContext, TRUE );
//
// Mark the Irp to show that we've already returned pending to the user.
//
IoMarkIrpPending( Irp );
return;
}
NTSTATUS
NtfsCommonSetVolumeInfo (
IN PIRP_CONTEXT IrpContext,
IN PIRP Irp
)
/*++
Routine Description:
This is the common routine for set Volume Information 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;
PMyIO_STACK_LOCATION IrpSp;
PFILE_OBJECT FileObject;
TYPE_OF_OPEN TypeOfOpen;
PVCB Vcb;
PFCB Fcb;
PSCB Scb;
PCCB Ccb;
ULONG Length;
FS_INFORMATION_CLASS FsInformationClass;
PVOID Buffer;
ASSERT_IRP_CONTEXT( IrpContext );
ASSERT_IRP( Irp );
PAGED_CODE();
//
// Get the current Irp stack location
//
IrpSp = (PMyIO_STACK_LOCATION)IoGetCurrentIrpStackLocation( Irp );
DebugTrace( +1, Dbg, ("NtfsCommonSetVolumeInfo\n") );
DebugTrace( 0, Dbg, ("IrpContext = %08lx\n", IrpContext) );
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;
//
// Extract and decode the file object to get the Vcb, we don't really
// care what the type of open is.
//
FileObject = IrpSp->FileObject;
TypeOfOpen = NtfsDecodeFileObject( IrpContext, FileObject, &Vcb, &Fcb, &Scb, &Ccb, TRUE );
if (TypeOfOpen != UserVolumeOpen) {
NtfsCompleteRequest( &IrpContext, &Irp, STATUS_ACCESS_DENIED );
DebugTrace( -1, Dbg, ("NtfsCommonSetVolumeInfo -> STATUS_ACCESS_DENIED\n") );
return STATUS_ACCESS_DENIED;
}
//
// Acquire exclusive access to the Vcb
//
NtfsAcquireExclusiveVcb( IrpContext, Vcb, TRUE );
try {
//
// Proceed only if the volume is mounted.
//
if (FlagOn( Vcb->VcbState, VCB_STATE_VOLUME_MOUNTED )) {
//
// 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 = NtfsSetFsLabelInfo( IrpContext, Vcb, Buffer );
break;
#ifdef _CAIRO_
case FileFsQuotaSetInformation:
Status = NtfsFsQuotaSetInfo( IrpContext, Vcb, Buffer, Length );
break;
case FileFsControlInformation:
Status = NtfsSetFsControlInfo( IrpContext, Vcb, Buffer );
break;
#endif // _CAIRO_
default:
Status = STATUS_INVALID_PARAMETER;
break;
}
} else {
Status = STATUS_FILE_INVALID;
}
//
// Abort transaction on error by raising.
//
NtfsCleanupTransaction( IrpContext, Status, FALSE );
} finally {
DebugUnwind( NtfsCommonSetVolumeInfo );
NtfsReleaseVcb( IrpContext, Vcb );
if (!AbnormalTermination()) {
NtfsCompleteRequest( &IrpContext, &Irp, Status );
}
DebugTrace( -1, Dbg, ("NtfsCommonSetVolumeInfo -> %08lx\n", Status) );
}
return Status;
}
static NTSTATUS
NdasNtfsSecondaryUserFsRequest (
IN PIRP_CONTEXT IrpContext,
IN PIRP Irp
)
{
NTSTATUS Status = STATUS_SUCCESS;
ULONG FsControlCode;
ULONG FsControlCodeFunction;
PIO_STACK_LOCATION IrpSp;
PVOLUME_DEVICE_OBJECT volDo = CONTAINING_RECORD( IrpContext->Vcb, VOLUME_DEVICE_OBJECT, Vcb );
BOOLEAN secondarySessionResourceAcquired = FALSE;
TYPE_OF_OPEN typeOfOpen;
PVCB vcb;
PFCB fcb;
PSCB scb;
PCCB ccb;
PSECONDARY_REQUEST secondaryRequest = NULL;
PNDFS_REQUEST_HEADER ndfsRequestHeader;
PNDFS_WINXP_REQUEST_HEADER ndfsWinxpRequestHeader;
PNDFS_WINXP_REPLY_HEADER ndfsWinxpReplytHeader;
_U8 *ndfsWinxpRequestData;
LARGE_INTEGER timeOut;
struct FileSystemControl fileSystemControl;
PVOID inputBuffer = NULL;
ULONG inputBufferLength;
PVOID outputBuffer = NULL;
ULONG outputBufferLength;
ULONG bufferLength;
ASSERT_IRP_CONTEXT( IrpContext );
ASSERT_IRP( Irp );
PAGED_CODE();
ASSERT( KeGetCurrentIrql() == PASSIVE_LEVEL );
IrpSp = IoGetCurrentIrpStackLocation( Irp );
FsControlCode = IrpSp->Parameters.FileSystemControl.FsControlCode;
FsControlCodeFunction = (FsControlCode & 0x00003FFC) >> 2;
DebugTrace( +1, Dbg, ("NtfsUserFsRequest, FsControlCode = %08lx, FsControlCodeFunction = %d\n", FsControlCode, FsControlCodeFunction) );
switch ( FsControlCode ) {
case FSCTL_REQUEST_OPLOCK_LEVEL_1:
case FSCTL_REQUEST_OPLOCK_LEVEL_2:
case FSCTL_REQUEST_BATCH_OPLOCK:
case FSCTL_REQUEST_FILTER_OPLOCK:
case FSCTL_OPLOCK_BREAK_ACKNOWLEDGE:
case FSCTL_OPLOCK_BREAK_NOTIFY:
case FSCTL_OPBATCH_ACK_CLOSE_PENDING :
case FSCTL_OPLOCK_BREAK_ACK_NO_2:
ASSERT( FALSE );
//Status = NtfsOplockRequest( IrpContext, Irp );
break;
case FSCTL_LOCK_VOLUME:
NtfsCompleteRequest( IrpContext, Irp, Status = STATUS_ACCESS_DENIED );
DebugTrace( -1, Dbg, ("NtfsUserFsRequest -> %08lx\n", Status) );
return Status;
//Status = NtfsLockVolume( IrpContext, Irp );
break;
case FSCTL_UNLOCK_VOLUME:
NtfsCompleteRequest( IrpContext, Irp, Status = STATUS_ACCESS_DENIED );
DebugTrace( -1, Dbg, ("NtfsUserFsRequest -> %08lx\n", Status) );
return Status;
//Status = NtfsUnlockVolume( IrpContext, Irp );
break;
case FSCTL_DISMOUNT_VOLUME: {
#if 0
NtfsCompleteRequest( IrpContext, Irp, Status = STATUS_ACCESS_DENIED );
DebugTrace( -1, Dbg, ("NtfsUserFsRequest -> %08lx\n", Status) );
return Status;
#else
BOOLEAN secondaryCreateResourceAcquired = FALSE;
ASSERT( IS_WINDOWSVISTA_OR_LATER() );
do {
BOOLEAN secondaryRecoveryResourceAcquired;
DebugTrace( 0, Dbg, ("%s: IRP_MN_QUERY_REMOVE_DEVICE volDo = %p, NetdiskEnableMode = %d\n",
__FUNCTION__, volDo, volDo->NetdiskEnableMode) );
secondaryRecoveryResourceAcquired
= SecondaryAcquireResourceExclusiveLite( IrpContext,
&volDo->RecoveryResource,
FALSE );
if (secondaryRecoveryResourceAcquired == FALSE) {
Status = STATUS_ACCESS_DENIED;
break;
}
SecondaryReleaseResourceLite( IrpContext, &volDo->RecoveryResource );
ExAcquireFastMutex( &volDo->Secondary->FastMutex );
if (!volDo->Secondary->TryCloseActive) {
volDo->Secondary->TryCloseActive = TRUE;
ExReleaseFastMutex( &volDo->Secondary->FastMutex );
Secondary_Reference( volDo->Secondary );
//NtfsDebugTraceLevel |= DEBUG_TRACE_CLOSE;
SecondaryTryClose( &IrpContext, volDo->Secondary );
//NtfsDebugTraceLevel &= ~DEBUG_TRACE_CLOSE;
} else {
ExReleaseFastMutex( &volDo->Secondary->FastMutex );
}
if (volDo->Vcb.SecondaryCloseCount) {
LARGE_INTEGER interval;
// Wait all files closed
interval.QuadPart = (-1 * HZ); //delay 1 seconds
KeDelayExecutionThread(KernelMode, FALSE, &interval);
}
CcWaitForCurrentLazyWriterActivity();
secondaryCreateResourceAcquired
= SecondaryAcquireResourceExclusiveLite( IrpContext,
&volDo->CreateResource,
BooleanFlagOn(IrpContext->State, IRP_CONTEXT_STATE_WAIT) );
if (secondaryCreateResourceAcquired == FALSE) {
Status = STATUS_ACCESS_DENIED;
break;
}
if (volDo->Vcb.SecondaryCloseCount) {
LONG ccbCount;
PLIST_ENTRY ccbListEntry;
PVOID restartKey;
PFCB fcb;
ExAcquireFastMutex( &volDo->Secondary->RecoveryCcbQMutex );
for (ccbCount = 0, ccbListEntry = volDo->Secondary->RecoveryCcbQueue.Flink;
ccbListEntry != &volDo->Secondary->RecoveryCcbQueue;
ccbListEntry = ccbListEntry->Flink, ccbCount++);
ExReleaseFastMutex( &volDo->Secondary->RecoveryCcbQMutex );
ASSERT( !IsListEmpty(&volDo->Secondary->RecoveryCcbQueue) );
ASSERT( ccbCount == volDo->Vcb.SecondaryCloseCount );
DebugTrace( 0, Dbg, ("IRP_MN_QUERY_REMOVE_DEVICE: Vcb->SecondaryCloseCount = %d, Vcb->SecondaryCleanupCount = %d, Vcb->CloseCount = %d, ccbCount = %d\n",
volDo->Vcb.SecondaryCloseCount, volDo->Vcb.SecondaryCleanupCount, volDo->Vcb.CloseCount, ccbCount) );
restartKey = NULL;
fcb = NdasNtfsGetNextFcbTableEntry( &volDo->Vcb, &restartKey );
ASSERT( fcb != NULL || !IsListEmpty(&volDo->Secondary->DeletedFcbQueue) );
Status = STATUS_ACCESS_DENIED;
break;
} else {
Status = STATUS_SUCCESS;
SetFlag( volDo->Secondary->Flags, SECONDARY_FLAG_DISMOUNTING );
}
} while(0);
if (Status != STATUS_SUCCESS) {
if (secondaryCreateResourceAcquired) {
SecondaryReleaseResourceLite( IrpContext, &volDo->CreateResource );
secondaryCreateResourceAcquired = FALSE;
}
NtfsCompleteRequest( IrpContext, Irp, Status );
DebugTrace( -1, Dbg, ("NtfsUserFsRequest -> %08lx\n", Status) );
return Status;
}
Status = NtfsDismountVolume( IrpContext, Irp );
SecondaryReleaseResourceLite( IrpContext, &volDo->CreateResource );
return Status;
#endif
break;
}
case FSCTL_IS_VOLUME_MOUNTED:
Status = NtfsIsVolumeMounted( IrpContext, Irp );
DebugTrace( -1, Dbg, ("NtfsUserFsRequest -> %08lx\n", Status) );
return Status;
break;
case FSCTL_MARK_VOLUME_DIRTY:
NtfsCompleteRequest( IrpContext, Irp, Status = STATUS_ACCESS_DENIED );
DebugTrace( -1, Dbg, ("NtfsUserFsRequest -> %08lx\n", Status) );
return Status;
//Status = NtfsDirtyVolume( IrpContext, Irp );
break;
case FSCTL_IS_PATHNAME_VALID:
NtfsCompleteRequest( IrpContext, Irp, Status = STATUS_SUCCESS );
DebugTrace( -1, Dbg, ("NtfsUserFsRequest -> %08lx\n", Status) );
return Status;
break;
case FSCTL_QUERY_RETRIEVAL_POINTERS:
Status = NtfsQueryRetrievalPointers( IrpContext, Irp );
break;
case FSCTL_GET_COMPRESSION:
//NtfsCompleteRequest( IrpContext, Irp, Status = STATUS_INVALID_DEVICE_REQUEST );
//DebugTrace( -1, Dbg, ("NtfsUserFsRequest -> %08lx\n", Status) );
//return Status;
Status = NtfsGetCompression( IrpContext, Irp );
break;
case FSCTL_SET_COMPRESSION:
NtfsCompleteRequest( IrpContext, Irp, Status = STATUS_INVALID_DEVICE_REQUEST );
DebugTrace( -1, Dbg, ("NtfsUserFsRequest -> %08lx\n", Status) );
return Status;
Status = NtfsSetCompression( IrpContext, Irp );
break;
case FSCTL_MARK_AS_SYSTEM_HIVE:
Status = NtfsMarkAsSystemHive( IrpContext, Irp );
DebugTrace( -1, Dbg, ("NtfsUserFsRequest -> %08lx\n", Status) );
return Status;
break;
case FSCTL_FILESYSTEM_GET_STATISTICS:
Status = NtfsGetStatistics( IrpContext, Irp );
break;
case FSCTL_GET_NTFS_VOLUME_DATA:
Status = NtfsGetVolumeData( IrpContext, Irp );
break;
case FSCTL_GET_VOLUME_BITMAP:
Status = NtfsGetVolumeBitmap( IrpContext, Irp );
break;
case FSCTL_GET_RETRIEVAL_POINTERS:
Status = NtfsGetRetrievalPointers( IrpContext, Irp );
break;
case FSCTL_GET_NTFS_FILE_RECORD:
Status = NtfsGetMftRecord( IrpContext, Irp );
break;
case FSCTL_MOVE_FILE:
NtfsCompleteRequest( IrpContext, Irp, Status = STATUS_ACCESS_DENIED );
DebugTrace( -1, Dbg, ("NtfsUserFsRequest -> %08lx\n", Status) );
return Status;
Status = NtfsDefragFile( IrpContext, Irp );
if (Status == STATUS_SUCCESS) {
PMOVE_FILE_DATA moveFileData = IrpContext->InputBuffer;
PFILE_OBJECT moveFileObject;
Status = ObReferenceObjectByHandle( moveFileData->FileHandle,
FILE_READ_DATA,
0,
KernelMode,
&moveFileObject,
NULL );
if (Status != STATUS_SUCCESS) {
break;
}
ObDereferenceObject( moveFileObject );
if (!IS_SECONDARY_FILEOBJECT(moveFileObject)) {
ASSERT( FALSE );
Status = STATUS_INVALID_PARAMETER;
}
}
if (Status != STATUS_SUCCESS)
DebugTrace( 0, Dbg2, ("NtfsDefragFile: status = %x\n", Status) );
break;
case FSCTL_IS_VOLUME_DIRTY:
Status = NtfsIsVolumeDirty( IrpContext, Irp );
break;
case FSCTL_ALLOW_EXTENDED_DASD_IO:
Status = NtfsSetExtendedDasdIo( IrpContext, Irp );
break;
case FSCTL_SET_REPARSE_POINT:
Status = NtfsSetReparsePoint( IrpContext, Irp );
break;
case FSCTL_GET_REPARSE_POINT:
Status = NtfsGetReparsePoint( IrpContext, Irp );
break;
case FSCTL_DELETE_REPARSE_POINT:
Status = NtfsDeleteReparsePoint( IrpContext, Irp );
break;
case FSCTL_SET_OBJECT_ID:
Status = NtfsSetObjectId( IrpContext, Irp ); // In ObjIdSup.c
break;
case FSCTL_GET_OBJECT_ID:
Status = NtfsGetObjectId( IrpContext, Irp ); // In ObjIdSup.c
break;
case FSCTL_DELETE_OBJECT_ID:
Status = NtfsDeleteObjectId( IrpContext, Irp ); // In ObjIdSup.c
break;
case FSCTL_SET_OBJECT_ID_EXTENDED:
Status = NtfsSetObjectIdExtendedInfo( IrpContext, Irp ); // In ObjIdSup.c
break;
case FSCTL_CREATE_OR_GET_OBJECT_ID:
Status = NtfsCreateOrGetObjectId( IrpContext, Irp );
if (IrpSp->Parameters.FileSystemControl.InputBufferLength)
IrpContext->InputBuffer = Irp->AssociatedIrp.SystemBuffer;
else
IrpContext->InputBuffer = NULL;
break;
case FSCTL_READ_USN_JOURNAL:
Status = NtfsReadUsnJournal( IrpContext, Irp, TRUE ); // In UsnSup.c
break;
case FSCTL_CREATE_USN_JOURNAL:
Status = NtfsCreateUsnJournal( IrpContext, Irp );
break;
case FSCTL_ENUM_USN_DATA:
Status = NtfsReadFileRecordUsnData( IrpContext, Irp );
break;
case FSCTL_READ_FILE_USN_DATA:
Status = NtfsReadFileUsnData( IrpContext, Irp );
break;
case FSCTL_WRITE_USN_CLOSE_RECORD:
Status = NtfsWriteUsnCloseRecord( IrpContext, Irp );
break;
case FSCTL_QUERY_USN_JOURNAL:
Status = NtfsQueryUsnJournal( IrpContext, Irp );
break;
case FSCTL_DELETE_USN_JOURNAL:
Status = NtfsDeleteUsnJournal( IrpContext, Irp );
break;
case FSCTL_MARK_HANDLE:
Status = NtfsMarkHandle( IrpContext, Irp );
if (Status == STATUS_SUCCESS) {
PMARK_HANDLE_INFO markHandleInfo = inputBuffer;
PFILE_OBJECT volumeFileObject;
Status = ObReferenceObjectByHandle( markHandleInfo->VolumeHandle,
FILE_READ_DATA,
0,
KernelMode,
&volumeFileObject,
NULL );
if (Status != STATUS_SUCCESS) {
break;
}
ObDereferenceObject( volumeFileObject );
if (!IS_SECONDARY_FILEOBJECT(volumeFileObject)) {
Status = STATUS_INVALID_PARAMETER;
}
}
break;
case FSCTL_SECURITY_ID_CHECK:
Status = NtfsBulkSecurityIdCheck( IrpContext, Irp );
break;
case FSCTL_FIND_FILES_BY_SID:
Status = NtfsFindFilesOwnedBySid( IrpContext, Irp );
break;
case FSCTL_SET_SPARSE :
NtfsCompleteRequest( IrpContext, Irp, Status = STATUS_ACCESS_DENIED );
DebugTrace( -1, Dbg, ("NtfsUserFsRequest -> %08lx\n", Status) );
return Status;
//Status = NtfsSetSparse( IrpContext, Irp );
break;
case FSCTL_SET_ZERO_DATA :
NtfsCompleteRequest( IrpContext, Irp, Status = STATUS_ACCESS_DENIED );
DebugTrace( -1, Dbg, ("NtfsUserFsRequest -> %08lx\n", Status) );
return Status;
Status = NtfsZeroRange( IrpContext, Irp );
break;
case FSCTL_QUERY_ALLOCATED_RANGES :
Status = NtfsQueryAllocatedRanges( IrpContext, Irp );
break;
case FSCTL_ENCRYPTION_FSCTL_IO :
NtfsCompleteRequest( IrpContext, Irp, Status = STATUS_ACCESS_DENIED );
DebugTrace( -1, Dbg, ("NtfsUserFsRequest -> %08lx\n", Status) );
return Status;
//Status = NtfsEncryptionFsctl( IrpContext, Irp );
break;
case FSCTL_SET_ENCRYPTION :
NtfsCompleteRequest( IrpContext, Irp, Status = STATUS_ACCESS_DENIED );
DebugTrace( -1, Dbg, ("NtfsUserFsRequest -> %08lx\n", Status) );
return Status;
//Status = NtfsSetEncryption( IrpContext, Irp );
break;
case FSCTL_READ_RAW_ENCRYPTED:
NtfsCompleteRequest( IrpContext, Irp, Status = STATUS_ACCESS_DENIED );
DebugTrace( -1, Dbg, ("NtfsUserFsRequest -> %08lx\n", Status) );
return Status;
//Status = NtfsReadRawEncrypted( IrpContext, Irp );
break;
case FSCTL_WRITE_RAW_ENCRYPTED:
NtfsCompleteRequest( IrpContext, Irp, Status = STATUS_ACCESS_DENIED );
DebugTrace( -1, Dbg, ("NtfsUserFsRequest -> %08lx\n", Status) );
return Status;
//Status = NtfsWriteRawEncrypted( IrpContext, Irp );
break;
case FSCTL_EXTEND_VOLUME:
NtfsCompleteRequest( IrpContext, Irp, Status = STATUS_ACCESS_DENIED );
DebugTrace( -1, Dbg, ("NtfsUserFsRequest -> %08lx\n", Status) );
return Status;
//Status = NtfsExtendVolume( IrpContext, Irp );
break;
case FSCTL_READ_FROM_PLEX:
Status = NtfsReadFromPlex( IrpContext, Irp );
DebugTrace( -1, Dbg, ("NtfsUserFsRequest -> %08lx\n", Status) );
return Status;
break;
case FSCTL_FILE_PREFETCH:
Status = NtfsPrefetchFile( IrpContext, Irp );
break;
default :
DebugTrace( 0, DEBUG_TRACE_ALL, ("NtfsUserFsRequest: Invalid control code FsControlCode = %08lx, FsControlCodeFunction = %d\n",
FsControlCode, FsControlCodeFunction) );
NtfsCompleteRequest( IrpContext, Irp, Status = STATUS_INVALID_DEVICE_REQUEST );
break;
}
ASSERT( !ExIsResourceAcquiredSharedLite(&volDo->Vcb.Resource) );
if (Status != STATUS_SUCCESS) {
DebugTrace( -1, Dbg, ("NtfsUserFsRequest -> %08lx\n", Status) );
return Status;
}
if (IrpSp->Parameters.FileSystemControl.InputBufferLength >= volDo->Secondary->Thread.SessionContext.SecondaryMaxDataSize ||
IrpSp->Parameters.FileSystemControl.OutputBufferLength >= volDo->Secondary->Thread.SessionContext.PrimaryMaxDataSize) {
ASSERT( FALSE );
NtfsCompleteRequest( IrpContext, Irp, Status = STATUS_INVALID_DEVICE_REQUEST );
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->State, IRP_CONTEXT_STATE_WAIT)) {
return NtfsPostRequest( IrpContext, Irp );
}
try {
secondarySessionResourceAcquired
= SecondaryAcquireResourceExclusiveLite( IrpContext,
&volDo->SessionResource,
BooleanFlagOn(IrpContext->State, IRP_CONTEXT_STATE_WAIT) );
if (FlagOn(volDo->Secondary->Thread.Flags, SECONDARY_THREAD_FLAG_REMOTE_DISCONNECTED) ) {
PrintIrp( Dbg2, "SECONDARY_THREAD_FLAG_REMOTE_DISCONNECTED", NULL, IrpContext->OriginatingIrp );
NtfsRaiseStatus( IrpContext, STATUS_CANT_WAIT, NULL, NULL );
}
ASSERT( IS_SECONDARY_FILEOBJECT(IrpSp->FileObject) );
typeOfOpen = NtfsDecodeFileObject( IrpContext, IrpSp->FileObject, &vcb, &fcb, &scb, &ccb, TRUE );
if (FlagOn(ccb->NdasNtfsFlags, ND_NTFS_CCB_FLAG_UNOPENED)) {
ASSERT( FlagOn(ccb->NdasNtfsFlags, ND_NTFS_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) {
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 (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 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 = (_U8 *)(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 = -NDASNTFS_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 );
DebugTrace( 0, Dbg2, ("secondaryRequest->ExecuteStatus != STATUS_SUCCESS file = %s, line = %d\n", __FILE__, __LINE__) );
NtfsRaiseStatus( IrpContext, STATUS_CANT_WAIT, NULL, NULL );
}
ndfsWinxpReplytHeader = (PNDFS_WINXP_REPLY_HEADER)secondaryRequest->NdfsReplyData;
Status = Irp->IoStatus.Status = ndfsWinxpReplytHeader->Status;
Irp->IoStatus.Information = ndfsWinxpReplytHeader->Information;
if (FsControlCode == FSCTL_GET_NTFS_VOLUME_DATA && Status != STATUS_SUCCESS)
DebugTrace( 0, Dbg2, ("FSCTL_GET_NTFS_VOLUME_DATA: Status = %x, Irp->IoStatus.Information = %d\n", Status, Irp->IoStatus.Information) );
if (secondaryRequest->NdfsReplyHeader.MessageSize - 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,
(_U8 *)(ndfsWinxpReplytHeader+1),
Irp->IoStatus.Information );
}
if (fileSystemControl.FsControlCode == FSCTL_MOVE_FILE && Status != STATUS_SUCCESS)
DebugTrace( 0, Dbg2, ("NtfsDefragFile: status = %x\n", Status) );
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 && ndfsWinxpReplytHeader->FileInformationSet && ndfsWinxpReplytHeader->AllocationSize) {
PNDFS_NTFS_MCB_ENTRY mcbEntry;
ULONG index;
VCN testVcn;
SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_ACQUIRE_PAGING );
NtfsAcquireFcbWithPaging( IrpContext, moveFcb, 0 );
NtfsAcquireNtfsMcbMutex( &moveScb->Mcb );
mcbEntry = (PNDFS_NTFS_MCB_ENTRY)( ndfsWinxpReplytHeader+1 );
if (moveScb->Header.AllocationSize.QuadPart) {
NtfsRemoveNtfsMcbEntry( &moveScb->Mcb, 0, 0xFFFFFFFF );
}
for (index=0, testVcn=0; index < ndfsWinxpReplytHeader->NumberOfMcbEntry; index++) {
ASSERT( mcbEntry[index].Vcn == testVcn );
testVcn += (LONGLONG)mcbEntry[index].ClusterCount;
NtfsAddNtfsMcbEntry( &moveScb->Mcb,
mcbEntry[index].Vcn,
mcbEntry[index].Lcn,
(LONGLONG)mcbEntry[index].ClusterCount,
TRUE );
}
ASSERT( LlBytesFromClusters(vcb, testVcn) == ndfsWinxpReplytHeader->AllocationSize );
if (moveScb->Header.AllocationSize.QuadPart != ndfsWinxpReplytHeader->AllocationSize)
SetFlag( moveScb->ScbState, SCB_STATE_TRUNCATE_ON_CLOSE );
moveScb->Header.FileSize.QuadPart = ndfsWinxpReplytHeader->FileSize;
moveScb->Header.AllocationSize.QuadPart = ndfsWinxpReplytHeader->AllocationSize;
ASSERT( moveScb->Header.AllocationSize.QuadPart >= moveScb->Header.FileSize.QuadPart );
if (moveFileObject->SectionObjectPointer->DataSectionObject != NULL && moveFileObject->PrivateCacheMap == NULL) {
CcInitializeCacheMap( moveFileObject,
(PCC_FILE_SIZES)&moveScb->Header.AllocationSize,
FALSE,
&NtfsData.CacheManagerCallbacks,
moveScb );
}
if (CcIsFileCached(moveFileObject)) {
NtfsSetBothCacheSizes( moveFileObject,
(PCC_FILE_SIZES)&scb->Header.AllocationSize,
moveScb );
}
NtfsReleaseNtfsMcbMutex( &moveScb->Mcb );
NtfsReleaseFcb( IrpContext, moveFcb );
}
}
try_exit: NOTHING;
} finally {
if (secondarySessionResourceAcquired == TRUE) {
SecondaryReleaseResourceLite( IrpContext, &volDo->SessionResource );
}
if (secondaryRequest)
DereferenceSecondaryRequest( secondaryRequest );
}
NtfsCompleteRequest( IrpContext, Irp, Status );
return Status;
}
NTSTATUS
NtfsCommonLockControl (
IN PIRP_CONTEXT IrpContext,
IN PIRP Irp
)
/*++
Routine Description:
This is the common routine for Lock Control 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;
PFILE_OBJECT FileObject;
TYPE_OF_OPEN TypeOfOpen;
PVCB Vcb;
PFCB Fcb;
PSCB Scb;
PCCB Ccb;
BOOLEAN FcbAcquired = FALSE;
BOOLEAN OplockPostIrp;
ASSERT_IRP_CONTEXT( IrpContext );
ASSERT_IRP( Irp );
PAGED_CODE();
//
// Get a pointer to the current Irp stack location
//
IrpSp = IoGetCurrentIrpStackLocation( Irp );
DebugTrace( +1, Dbg, ("NtfsCommonLockControl\n") );
DebugTrace( 0, Dbg, ("IrpContext = %08lx\n", IrpContext) );
DebugTrace( 0, Dbg, ("Irp = %08lx\n", Irp) );
DebugTrace( 0, Dbg, ("MinorFunction = %08lx\n", IrpSp->MinorFunction) );
//
// Extract and decode the type of file object we're being asked to process
//
FileObject = IrpSp->FileObject;
TypeOfOpen = NtfsDecodeFileObject( IrpContext, FileObject, &Vcb, &Fcb, &Scb, &Ccb, TRUE );
//
// If the file is not a user file open then we reject the request
// as an invalid parameter
//
if (TypeOfOpen != UserFileOpen) {
NtfsCompleteRequest( &IrpContext, &Irp, STATUS_INVALID_PARAMETER );
DebugTrace( -1, Dbg, ("NtfsCommonLockControl -> STATUS_INVALID_PARAMETER\n") );
return STATUS_INVALID_PARAMETER;
}
//
// Acquire exclusive access to the Fcb
//
if (Scb->ScbType.Data.FileLock == NULL) {
NtfsAcquireExclusiveFcb( IrpContext, Fcb, Scb, FALSE, FALSE );
FcbAcquired = TRUE;
} else {
//NtfsAcquireSharedFcb( IrpContext, Fcb, Scb );
}
OplockPostIrp = FALSE;
try {
//
// We check whether we can proceed based on the state of the file oplocks.
// This call might post the irp for us.
//
Status = FsRtlCheckOplock( &Scb->ScbType.Data.Oplock,
Irp,
IrpContext,
NtfsOplockComplete,
NULL );
if (Status != STATUS_SUCCESS) {
OplockPostIrp = TRUE;
try_return( NOTHING );
}
//
// If we don't have a file lock, then get one now.
//
if (Scb->ScbType.Data.FileLock == NULL) {
NtfsCreateFileLock( Scb, TRUE );
}
//
// Now call the FsRtl routine to do the actual processing of the
// Lock request
//
Status = FsRtlProcessFileLock( Scb->ScbType.Data.FileLock, Irp, NULL );
//
// Set the flag indicating if Fast I/O is possible
//
NtfsAcquireFsrtlHeader( Scb );
Scb->Header.IsFastIoPossible = NtfsIsFastIoPossible( Scb );
NtfsReleaseFsrtlHeader( Scb );
try_exit: NOTHING;
} finally {
DebugUnwind( NtfsCommonLockControl );
//
// Release the Fcb, and return to our caller
//
if (FcbAcquired) {
NtfsReleaseFcb( IrpContext, Fcb );
}
//
// Only if this is not an abnormal termination and we did not post the irp
// do we delete the irp context
//
if (!AbnormalTermination() && !OplockPostIrp) {
NtfsCompleteRequest( &IrpContext, NULL, 0 );
}
DebugTrace( -1, Dbg, ("NtfsCommonLockControl -> %08lx\n", Status) );
}
return Status;
}
NTSTATUS
CdPerformVerify (
IN PIRP_CONTEXT IrpContext,
IN PIRP Irp,
IN PDEVICE_OBJECT DeviceToVerify
)
/*++
Routine Description:
This routines performs an IoVerifyVolume operation and takes the
appropriate action. If the verify is successful then we send the originating
Irp off to an Ex Worker Thread. This routine is called from the exception handler.
No file system resources are held when this routine is called.
Arguments:
Irp - The irp to send off after all is well and done.
Device - The real device needing verification.
Return Value:
None.
--*/
{
PVCB Vcb;
NTSTATUS Status = STATUS_SUCCESS;
PIO_STACK_LOCATION IrpSp;
ASSERT_IRP_CONTEXT( IrpContext );
ASSERT_IRP( Irp );
//
// Check if this Irp has a status of Verify required and if it does
// then call the I/O system to do a verify.
//
// Skip the IoVerifyVolume if this is a mount or verify request
// itself. Trying a recursive mount will cause a deadlock with
// the DeviceObject->DeviceLock.
//
if ((IrpContext->MajorFunction == IRP_MJ_FILE_SYSTEM_CONTROL) &&
((IrpContext->MinorFunction == IRP_MN_MOUNT_VOLUME) ||
(IrpContext->MinorFunction == IRP_MN_VERIFY_VOLUME))) {
return CdFsdPostRequest( IrpContext, Irp );
}
//
// Extract a pointer to the Vcb from the VolumeDeviceObject.
// Note that since we have specifically excluded mount,
// requests, we know that IrpSp->DeviceObject is indeed a
// volume device object.
//
IrpSp = IoGetCurrentIrpStackLocation( Irp );
Vcb = &CONTAINING_RECORD( IrpSp->DeviceObject,
VOLUME_DEVICE_OBJECT,
DeviceObject )->Vcb;
try {
//
// Send down the verify FSCTL. Note that this is sent to the
// currently mounted volume, which may not be this one.
//
// We will allow Raw to mount this volume if we were doing a
// an absolute DASD open.
//
Status = IoVerifyVolume( DeviceToVerify, CdOperationIsDasdOpen( IrpContext));
//
// Acquire the Vcb so we're working with a stable VcbCondition.
//
CdAcquireVcbShared( IrpContext, Vcb, FALSE);
//
// If the verify operation completed it will return
// either STATUS_SUCCESS or STATUS_WRONG_VOLUME, exactly.
//
// If CdVerifyVolume encountered an error during
// processing, it will return that error. If we got
// STATUS_WRONG_VOLUME from the verify, and our volume
// is now mounted, commute the status to STATUS_SUCCESS.
//
if ((Status == STATUS_WRONG_VOLUME) &&
(Vcb->VcbCondition == VcbMounted)) {
Status = STATUS_SUCCESS;
}
else if ((STATUS_SUCCESS == Status) && (Vcb->VcbCondition != VcbMounted)) {
//
// If the verify succeeded, but our volume is not mounted,
// then some other volume is on the device.
//
Status = STATUS_WRONG_VOLUME;
}
//
// Do a quick unprotected check here. The routine will do
// a safe check. After here we can release the resource.
// Note that if the volume really went away, we will be taking
// the Reparse path.
//
//
// If the device might need to go away then call our dismount routine.
//
if (((Vcb->VcbCondition == VcbNotMounted) ||
(Vcb->VcbCondition == VcbInvalid) ||
(Vcb->VcbCondition == VcbDismountInProgress)) &&
(Vcb->VcbReference <= CDFS_RESIDUAL_REFERENCE)) {
CdReleaseVcb( IrpContext, Vcb);
CdAcquireCdData( IrpContext );
CdCheckForDismount( IrpContext, Vcb, FALSE );
CdReleaseCdData( IrpContext );
}
else {
CdReleaseVcb( IrpContext, Vcb);
}
//
// If this is a create and the verify succeeded then complete the
// request with a REPARSE status.
//
if ((IrpContext->MajorFunction == IRP_MJ_CREATE) &&
(IrpSp->FileObject->RelatedFileObject == NULL) &&
((Status == STATUS_SUCCESS) || (Status == STATUS_WRONG_VOLUME))) {
Irp->IoStatus.Information = IO_REMOUNT;
CdCompleteRequest( IrpContext, Irp, STATUS_REPARSE );
Status = STATUS_REPARSE;
Irp = NULL;
IrpContext = NULL;
//
// If there is still an error to process then call the Io system
// for a popup.
//
} else if ((Irp != NULL) && !NT_SUCCESS( Status )) {
//
// Fill in the device object if required.
//
if (IoIsErrorUserInduced( Status ) ) {
IoSetHardErrorOrVerifyDevice( Irp, DeviceToVerify );
}
CdNormalizeAndRaiseStatus( IrpContext, Status );
}
//
// If there is still an Irp, send it off to an Ex Worker thread.
//
if (IrpContext != NULL) {
Status = CdFsdPostRequest( IrpContext, Irp );
}
}
except(CdExceptionFilter( IrpContext, GetExceptionInformation() )) {
//
// We had some trouble trying to perform the verify or raised
// an error ourselves. So we'll abort the I/O request with
// the error status that we get back from the execption code.
//
Status = CdProcessException( IrpContext, Irp, GetExceptionCode() );
}
return Status;
}
NTSTATUS
CdCommonClose (
IN PIRP_CONTEXT IrpContext,
IN PIRP Irp
)
/*++
Routine Description:
This routine is the Fsd entry for the close operation. We decode the file
object to find the CDFS structures and type of open. We call our internal
worker routine to perform the actual work. If the work wasn't completed
then we post to one of our worker queues. The Ccb isn't needed after this
point so we delete the Ccb and return STATUS_SUCCESS to our caller in all
cases.
Arguments:
Irp - Supplies the Irp to process
Return Value:
STATUS_SUCCESS
--*/
{
TYPE_OF_OPEN TypeOfOpen;
PVCB Vcb;
PFCB Fcb;
PCCB Ccb;
ULONG UserReference = 0;
BOOLEAN PotentialVcbTeardown = FALSE;
BOOLEAN ForceDismount = FALSE;
PAGED_CODE();
ASSERT_IRP_CONTEXT( IrpContext );
ASSERT_IRP( Irp );
//
// If we were called with our file system device object instead of a
// volume device object, just complete this request with STATUS_SUCCESS.
//
if (IrpContext->Vcb == NULL) {
CdCompleteRequest( IrpContext, Irp, STATUS_SUCCESS );
return STATUS_SUCCESS;
}
//
// Decode the file object to get the type of open and Fcb/Ccb.
//
TypeOfOpen = CdDecodeFileObject( IrpContext,
IoGetCurrentIrpStackLocation( Irp )->FileObject,
&Fcb,
&Ccb );
//
// No work to do for unopened file objects.
//
if (TypeOfOpen == UnopenedFileObject) {
CdCompleteRequest( IrpContext, Irp, STATUS_SUCCESS );
return STATUS_SUCCESS;
}
Vcb = Fcb->Vcb;
//
// Clean up any CCB associated with this open.
//
if (Ccb != NULL) {
UserReference = 1;
//
// Was a FSCTL_DISMOUNT issued on this handle? If so, we need to
// force a dismount of the volume now.
//
ForceDismount = BooleanFlagOn( Ccb->Flags, CCB_FLAG_DISMOUNT_ON_CLOSE);
//
// We can always deallocate the Ccb if present.
//
CdDeleteCcb( IrpContext, Ccb );
}
//
// If this is the last reference to a user file or directory on a
// currently mounted volume, then post it to the delayed close queue. Note
// that the VcbCondition check is unsafe, but it doesn't really matter -
// we just might delay the volume teardown a little by posting this close.
//
if ((Vcb->VcbCondition == VcbMounted) &&
(Fcb->FcbReference == 1) &&
((TypeOfOpen == UserFileOpen) ||
(TypeOfOpen == UserDirectoryOpen))) {
CdQueueClose( IrpContext, Fcb, UserReference, TRUE );
IrpContext = NULL;
//
// Otherwise try to process this close. Post to the async close queue
// if we can't acquire all of the resources.
//
} else {
//
// If we may be dismounting this volume then acquire the CdData
// resource.
//
// Since we now must make volumes go away as soon as reasonable after
// the last user handles closes, key off of the cleanup count. It is
// OK to do this more than neccesary. Since this Fcb could be holding
// a number of other Fcbs (and thus their references), a simple check
// on reference count is not appropriate.
//
// Do an unsafe check first to avoid taking the (global) cddata lock in the
// common case.
//
if (((Vcb->VcbCleanup == 0) || ForceDismount) &&
(Vcb->VcbCondition != VcbMounted)) {
//
// Possible. Acquire CdData to synchronise with the remount path, and
// then repeat the tests.
//
// Note that we must send the notification outside of any locks, since
// the worker that processes the notify could also be calling into our
// pnp path which wants both CdData and VcbResource. For a force dismount
// the volume will be marked invalid (no going back), so we will definitely
// go ahead and dismount below.
//
if (ForceDismount) {
//
// Send notification.
//
FsRtlNotifyVolumeEvent( IoGetCurrentIrpStackLocation( Irp )->FileObject,
FSRTL_VOLUME_DISMOUNT );
}
CdAcquireCdData( IrpContext );
if (((Vcb->VcbCleanup == 0) || ForceDismount) &&
(Vcb->VcbCondition != VcbMounted) &&
(Vcb->VcbCondition != VcbMountInProgress) &&
FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_TOP_LEVEL_CDFS )) {
PotentialVcbTeardown = TRUE;
}
else {
//
// We can't dismount this volume now, there are other references or
// it's just been remounted.
//
CdReleaseCdData( IrpContext);
}
}
if (ForceDismount) {
//
// Physically disconnect this Vcb from the device so a new mount can
// occur. Vcb deletion cannot happen at this time since there is
// a handle on it associated with this very request, but we'll call
// check for dismount again later anyway.
//
CdCheckForDismount( IrpContext, Vcb, TRUE );
}
//
// Call the worker routine to perform the actual work. This routine
// should never raise except for a fatal error.
//
if (!CdCommonClosePrivate( IrpContext, Vcb, Fcb, UserReference, TRUE )) {
//
// If we didn't complete the request then post the request as needed.
//
CdQueueClose( IrpContext, Fcb, UserReference, FALSE );
IrpContext = NULL;
//
// Check whether we should be dismounting the volume and then complete
// the request.
//
} else if (PotentialVcbTeardown) {
CdCheckForDismount( IrpContext, Vcb, FALSE );
}
}
//
// Always complete this request with STATUS_SUCCESS.
//
CdCompleteRequest( IrpContext, Irp, STATUS_SUCCESS );
if (PotentialVcbTeardown) {
CdReleaseCdData( IrpContext );
}
//
// Always return STATUS_SUCCESS for closes.
//
return STATUS_SUCCESS;
}
NTSTATUS
CdCommonCleanup (
IN PIRP_CONTEXT IrpContext,
IN PIRP Irp
)
/*++
Routine Description:
This is the common routine for cleanup of a file/directory called by both
the fsd and fsp threads.
Cleanup is invoked whenever the last handle to a file object is closed.
This is different than the Close operation which is invoked when the last
reference to a file object is deleted.
The function of cleanup is to essentially "cleanup" the file/directory
after a user is done with it. The Fcb/Dcb remains around (because MM
still has the file object referenced) but is now available for another
user to open (i.e., as far as the user is concerned the is now closed).
See close for a more complete description of what close does.
We do no synchronization in this routine until we get to the point
where we modify the counts, share access and volume lock field.
We need to update the Fcb and Vcb to show that a user handle has been closed.
The following structures and fields are affected.
Vcb:
VolumeLockFileObject - Did the user lock the volume with this file object.
VcbState - Check if we are unlocking the volume here.
VcbCleanup - Count of outstanding handles on the volume.
DirNotifyQueue - If this file object has pending DirNotify Irps.
Fcb:
ShareAccess - If this is a user handle.
FcbCleanup - Count of outstanding handles on this Fcb.
Oplock - Any outstanding oplocks on this file object.
FileLock - Any outstanding filelocks on this file object.
Arguments:
Irp - Supplies the Irp to process
Return Value:
NTSTATUS - The return status for the operation.
--*/
{
PFILE_OBJECT FileObject;
TYPE_OF_OPEN TypeOfOpen;
BOOLEAN SendUnlockNotification = FALSE;
BOOLEAN AttemptTeardown;
PVCB Vcb;
PFCB Fcb;
PCCB Ccb;
KIRQL SavedIrql;
ASSERT_IRP_CONTEXT( IrpContext );
ASSERT_IRP( Irp );
//
// If we were called with our file system device object instead of a
// volume device object, just complete this request with STATUS_SUCCESS.
//
if (IrpContext->Vcb == NULL) {
CdCompleteRequest( IrpContext, Irp, STATUS_SUCCESS );
return STATUS_SUCCESS;
}
//
// Get the file object out of the Irp and decode the type of open.
//
FileObject = IoGetCurrentIrpStackLocation( Irp )->FileObject;
TypeOfOpen = CdDecodeFileObject( IrpContext,
FileObject,
&Fcb,
&Ccb );
//
// No work here for either an UnopenedFile object or a StreamFileObject.
//
if (TypeOfOpen <= StreamFileOpen) {
CdCompleteRequest( IrpContext, Irp, STATUS_SUCCESS );
return STATUS_SUCCESS;
}
//
// Keep a local pointer to the Vcb.
//
Vcb = Fcb->Vcb;
//
// Synchronise with reads while we set the cleanup complete
// flag on this fileobject. Once this flag is set, any further
// reads will be rejected (CdVerifyFcbOperation)
//
CdAcquireFileExclusive( IrpContext, Fcb);
//
// Set the flag in the FileObject to indicate that cleanup is complete.
//
SetFlag( FileObject->Flags, FO_CLEANUP_COMPLETE );
CdReleaseFile( IrpContext, Fcb);
//
// Acquire the current file.
//
CdAcquireFcbExclusive( IrpContext, Fcb, FALSE );
//
// Use a try-finally to facilitate cleanup.
//
try {
//
// Case on the type of open that we are trying to cleanup.
//
switch (TypeOfOpen) {
case UserDirectoryOpen:
//
// Check if we need to complete any dir notify Irps on this file object.
//
FsRtlNotifyCleanup( Vcb->NotifySync,
&Vcb->DirNotifyList,
Ccb );
break;
case UserFileOpen:
//
// Coordinate the cleanup operation with the oplock state.
// Oplock cleanup operations can always cleanup immediately so no
// need to check for STATUS_PENDING.
//
FsRtlCheckOplock( &Fcb->Oplock,
Irp,
IrpContext,
NULL,
NULL );
//
// Unlock all outstanding file locks.
//
if (Fcb->FileLock != NULL) {
FsRtlFastUnlockAll( Fcb->FileLock,
FileObject,
IoGetRequestorProcess( Irp ),
NULL );
}
//
// Cleanup the cache map.
//
CcUninitializeCacheMap( FileObject, NULL, NULL );
//
// Check the fast io state.
//
CdLockFcb( IrpContext, Fcb );
Fcb->IsFastIoPossible = CdIsFastIoPossible( Fcb );
CdUnlockFcb( IrpContext, Fcb );
break;
case UserVolumeOpen :
break;
default :
CdBugCheck( TypeOfOpen, 0, 0 );
}
//
// Now lock the Vcb in order to modify the fields in the in-memory
// structures.
//
CdLockVcb( IrpContext, Vcb );
//
// Decrement the cleanup counts in the Vcb and Fcb.
//
CdDecrementCleanupCounts( IrpContext, Fcb );
//
// If the cleanup count hit zero and the volume is not mounted, we
// will want to try to spark teardown.
//
AttemptTeardown = (Vcb->VcbCleanup == 0 && Vcb->VcbCondition == VcbNotMounted);
//
// If this file object has locked the volume then perform the unlock operation.
// We do this regardless of explicit or implicit (no share DASD open) lock.
//
if (FileObject == Vcb->VolumeLockFileObject) {
ASSERT( FlagOn( Vcb->VcbState, VCB_STATE_LOCKED));
IoAcquireVpbSpinLock( &SavedIrql );
ClearFlag( Vcb->Vpb->Flags, VPB_LOCKED);
ClearFlag( Vcb->VcbState, VCB_STATE_LOCKED );
Vcb->VolumeLockFileObject = NULL;
SendUnlockNotification = TRUE;
IoReleaseVpbSpinLock( SavedIrql );
}
CdUnlockVcb( IrpContext, Vcb );
//
// We must clean up the share access at this time, since we may not
// get a Close call for awhile if the file was mapped through this
// File Object.
//
IoRemoveShareAccess( FileObject, &Fcb->ShareAccess );
} finally {
CdReleaseFcb( IrpContext, Fcb );
if (SendUnlockNotification) {
FsRtlNotifyVolumeEvent( FileObject, FSRTL_VOLUME_UNLOCK );
}
}
//
// If appropriate, try to spark teardown by purging the volume. Should
// this very fileobject we were cleaning up be the last reason for the
// volume to remain, teardown will commence on completion of this Irp.
//
if (AttemptTeardown) {
CdAcquireVcbExclusive( IrpContext, Vcb, FALSE );
try {
CdPurgeVolume( IrpContext, Vcb, FALSE );
} finally {
CdReleaseVcb( IrpContext, Vcb );
}
}
//
// If this is a normal termination then complete the request
//
CdCompleteRequest( IrpContext, Irp, STATUS_SUCCESS );
return STATUS_SUCCESS;
}
NTSTATUS
CdCommonClose (
_Inout_ PIRP_CONTEXT IrpContext,
_Inout_ PIRP Irp
)
/*++
Routine Description:
This routine is the Fsd entry for the close operation. We decode the file
object to find the CDFS structures and type of open. We call our internal
worker routine to perform the actual work. If the work wasn't completed
then we post to one of our worker queues. The Ccb isn't needed after this
point so we delete the Ccb and return STATUS_SUCCESS to our caller in all
cases.
Arguments:
Irp - Supplies the Irp to process
Return Value:
STATUS_SUCCESS
--*/
{
TYPE_OF_OPEN TypeOfOpen;
PVCB Vcb;
PFCB Fcb;
PCCB Ccb;
ULONG UserReference = 0;
BOOLEAN PotentialVcbTeardown = FALSE;
PAGED_CODE();
ASSERT_IRP_CONTEXT( IrpContext );
ASSERT_IRP( Irp );
//
// If we were called with our file system device object instead of a
// volume device object, just complete this request with STATUS_SUCCESS.
//
if (IrpContext->Vcb == NULL) {
CdCompleteRequest( IrpContext, Irp, STATUS_SUCCESS );
return STATUS_SUCCESS;
}
//
// Decode the file object to get the type of open and Fcb/Ccb.
//
TypeOfOpen = CdDecodeFileObject( IrpContext,
IoGetCurrentIrpStackLocation( Irp )->FileObject,
&Fcb,
&Ccb );
//
// No work to do for unopened file objects.
//
if (TypeOfOpen == UnopenedFileObject) {
CdCompleteRequest( IrpContext, Irp, STATUS_SUCCESS );
return STATUS_SUCCESS;
}
Vcb = Fcb->Vcb;
//
// Clean up any CCB associated with this open.
//
if (Ccb != NULL) {
UserReference = 1;
//
// We can always deallocate the Ccb if present.
//
CdDeleteCcb( IrpContext, Ccb );
}
//
// If this is the last reference to a user file or directory on a
// currently mounted volume, then post it to the delayed close queue. Note
// that the VcbCondition check is unsafe, but it doesn't really matter -
// we just might delay the volume teardown a little by posting this close.
//
if ((Vcb->VcbCondition == VcbMounted) &&
(Fcb->FcbReference == 1) &&
((TypeOfOpen == UserFileOpen) ||
(TypeOfOpen == UserDirectoryOpen))) {
CdQueueClose( IrpContext, Fcb, UserReference, TRUE );
IrpContext = NULL;
//
// Otherwise try to process this close. Post to the async close queue
// if we can't acquire all of the resources.
//
}
else {
//
// If we may be dismounting this volume then acquire the CdData
// resource.
//
// Since we now must make volumes go away as soon as reasonable after
// the last user handles closes, key off of the cleanup count. It is
// OK to do this more than neccesary. Since this Fcb could be holding
// a number of other Fcbs (and thus their references), a simple check
// on reference count is not appropriate.
//
// Do an unsafe check first to avoid taking the (global) cddata lock in the
// common case.
//
if ((Vcb->VcbCleanup == 0) &&
(Vcb->VcbCondition != VcbMounted)) {
//
// Possible dismount. Acquire CdData to synchronise with the remount path
// before looking at the vcb condition again.
//
CdAcquireCdData( IrpContext );
if ((Vcb->VcbCleanup == 0) &&
(Vcb->VcbCondition != VcbMounted) &&
(Vcb->VcbCondition != VcbMountInProgress) &&
FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_TOP_LEVEL_CDFS )) {
PotentialVcbTeardown = TRUE;
}
else {
//
// We can't dismount this volume now, there are other references or
// it's just been remounted.
//
}
//
// Drop the global lock if we don't need it anymore.
//
if (!PotentialVcbTeardown) {
CdReleaseCdData( IrpContext );
}
}
//
// Call the worker routine to perform the actual work. This routine
// should never raise except for a fatal error.
//
if (!CdCommonClosePrivate( IrpContext, Vcb, Fcb, UserReference, TRUE )) {
//
// If we didn't complete the request then post the request as needed.
//
CdQueueClose( IrpContext, Fcb, UserReference, FALSE );
IrpContext = NULL;
//
// Check whether we should be dismounting the volume and then complete
// the request.
//
}
else if (PotentialVcbTeardown) {
CdCheckForDismount( IrpContext, Vcb, FALSE );
}
}
//
// Always complete this request with STATUS_SUCCESS.
//
CdCompleteRequest( IrpContext, Irp, STATUS_SUCCESS );
if (PotentialVcbTeardown) {
CdReleaseCdData( IrpContext );
}
//
// Always return STATUS_SUCCESS for closes.
//
return STATUS_SUCCESS;
}
