VOID
NtfsReleaseFcbWithPaging (
IN PIRP_CONTEXT IrpContext,
IN PFCB Fcb
)
/*++
Routine Description:
This routine releases access to the Fcb, including its
paging I/O resource if it exists.
Arguments:
Fcb - Supplies the Fcb to acquire
Return Value:
None.
--*/
{
ASSERT_IRP_CONTEXT(IrpContext);
ASSERT_FCB(Fcb);
PAGED_CODE();
//
// We test that we currently hold the paging Io exclusive before releasing
// it. Checking the ExclusivePagingFcb in the IrpContext tells us if
// it is ours.
//
if ((IrpContext->TransactionId == 0) &&
(IrpContext->FcbWithPagingExclusive == Fcb)) {
NtfsReleasePagingIo( IrpContext, Fcb );
}
NtfsReleaseFcb( IrpContext, Fcb );
}
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
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
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
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;
}
BOOLEAN
NtfsAcquireFcbWithPaging (
IN PIRP_CONTEXT IrpContext,
IN PFCB Fcb,
IN BOOLEAN DontWait
)
/*++
Routine Description:
This routine is used in the create path only. It acquires the Fcb
and also the paging IO resource if it exists but only if the create
operation was doing a supersede/overwrite operation.
This routine will raise if it cannot acquire the resource and wait
in the IrpContext is false.
Arguments:
Fcb - Supplies the Fcb to acquire
DontWait - If TRUE this overrides the wait value in the IrpContext.
We won't wait for the resource and return whether the resource
was acquired.
Return Value:
BOOLEAN - TRUE if acquired. FALSE otherwise.
--*/
{
BOOLEAN Status = FALSE;
BOOLEAN Wait = FALSE;
BOOLEAN PagingIoAcquired = FALSE;
ASSERT_IRP_CONTEXT(IrpContext);
ASSERT_FCB(Fcb);
PAGED_CODE();
//
// Sanity check that this is create. The supersede flag is only
// set in the create path and only tested here.
//
ASSERT( IrpContext->MajorFunction == IRP_MJ_CREATE );
if (!DontWait && FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT )) {
Wait = TRUE;
}
//
// Free any exclusive paging I/O resource, we currently have, which
// must presumably be from a directory with a paging I/O resource.
//
// We defer releasing the paging io resource when we have logged
// changes against a stream. The only transaction that should be
// underway at this point is the create file case where we allocated
// a file record. In this case it is OK to release the paging io
// resource for the parent.
//
if (IrpContext->FcbWithPagingExclusive != NULL) {
// ASSERT(IrpContext->TransactionId == 0);
NtfsReleasePagingIo( IrpContext, IrpContext->FcbWithPagingExclusive );
}
//
// Loop until we get it right - worst case is twice through loop.
//
while (TRUE) {
//
// Acquire Paging I/O first. Testing for the PagingIoResource
// is not really safe without holding the main resource, so we
// correct for that below.
//
if (FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_ACQUIRE_PAGING ) &&
(Fcb->PagingIoResource != NULL)) {
if (!ExAcquireResourceExclusive( Fcb->PagingIoResource, Wait )) {
break;
}
IrpContext->FcbWithPagingExclusive = Fcb;
PagingIoAcquired = TRUE;
}
//
// Let's acquire this Fcb exclusively.
//
if (!NtfsAcquireExclusiveFcb( IrpContext, Fcb, NULL, TRUE, DontWait )) {
if (PagingIoAcquired) {
ASSERT(IrpContext->TransactionId == 0);
NtfsReleasePagingIo( IrpContext, Fcb );
}
break;
}
//
// If we now do not see a paging I/O resource we are golden,
// othewise we can absolutely release and acquire the resources
// safely in the right order, since a resource in the Fcb is
// not going to go away.
//
if (!FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_ACQUIRE_PAGING ) ||
PagingIoAcquired ||
(Fcb->PagingIoResource == NULL)) {
Status = TRUE;
break;
}
NtfsReleaseFcb( IrpContext, Fcb );
}
return Status;
}
VOID
NtfsReleaseAllFiles (
IN PIRP_CONTEXT IrpContext,
IN PVCB Vcb,
IN BOOLEAN ReleasePagingIo
)
/*++
Routine Description:
This routine non-recursively requires all files on a volume.
Arguments:
Vcb - Supplies the volume
ReleasePagingIo - Indicates whether we should release the paging io resources
as well.
Return Value:
None
--*/
{
PFCB Fcb;
PSCB *Scb;
PVOID RestartKey;
PAGED_CODE();
//
// Loop to flush all of the prerestart streams, to do the loop
// we cycle through the Fcb Table and for each fcb we acquire it.
//
RestartKey = NULL;
while (TRUE) {
NtfsAcquireFcbTable( IrpContext, Vcb );
Fcb = NtfsGetNextFcbTableEntry(Vcb, &RestartKey);
NtfsReleaseFcbTable( IrpContext, Vcb );
if (Fcb == NULL) {
break;
}
ASSERT_FCB( Fcb );
if (NtfsSegmentNumber( &Fcb->FileReference ) >= FIRST_USER_FILE_NUMBER) {
//
// Release the file.
//
if (ReleasePagingIo && (Fcb->PagingIoResource != NULL)) {
ExReleaseResource( Fcb->PagingIoResource );
}
NtfsReleaseFcb( IrpContext, Fcb );
}
}
//
// Now release the Fcb's in the Vcb.
//
Scb = &Vcb->QuotaTableScb;
while (TRUE) {
if (*Scb != NULL) {
if (ReleasePagingIo && ((*Scb)->Fcb->PagingIoResource != NULL)) {
ExReleaseResource( (*Scb)->Fcb->PagingIoResource );
}
NtfsReleaseFcb( IrpContext, (*Scb)->Fcb );
}
if (Scb == &Vcb->MftScb) {
break;
}
Scb -= 1;
}
NtfsReleaseVcb( IrpContext, Vcb );
return;
}
VOID
NtfsAcquireAllFiles (
IN PIRP_CONTEXT IrpContext,
IN PVCB Vcb,
IN BOOLEAN Exclusive,
IN BOOLEAN AcquirePagingIo
)
/*++
Routine Description:
This routine non-recursively requires all files on a volume.
Arguments:
Vcb - Supplies the volume
Exclusive - Indicates if we should be acquiring all the files exclusively.
If FALSE then we acquire all the files shared except for files with
streams which could be part of transactions.
AcquirePagingIo - Indicates if we need to acquire the paging io resource
exclusively. Only needed if a future call will flush the volume
(i.e. shutdown)
Return Value:
None
--*/
{
PFCB Fcb;
PSCB *Scb;
PSCB NextScb;
PVOID RestartKey;
PAGED_CODE();
SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT );
NtfsAcquireExclusiveVcb( IrpContext, Vcb, TRUE );
RestartKey = NULL;
while (TRUE) {
NtfsAcquireFcbTable( IrpContext, Vcb );
Fcb = NtfsGetNextFcbTableEntry(Vcb, &RestartKey);
NtfsReleaseFcbTable( IrpContext, Vcb );
if (Fcb == NULL) {
break;
}
ASSERT_FCB( Fcb );
//
// We can skip over the Fcb's for any of the Scb's in the Vcb.
// We delay acquiring those to avoid deadlocks.
//
if (NtfsSegmentNumber( &Fcb->FileReference ) >= FIRST_USER_FILE_NUMBER) {
//
// If there is a paging Io resource then acquire this if required.
//
if (AcquirePagingIo && (Fcb->PagingIoResource != NULL)) {
ExAcquireResourceExclusive( Fcb->PagingIoResource, TRUE );
}
//
// Acquire this Fcb whether or not the underlying file has been deleted.
//
if (Exclusive ||
IsDirectory( &Fcb->Info )) {
NtfsAcquireExclusiveFcb( IrpContext, Fcb, NULL, TRUE, FALSE );
} else {
//
// Assume that we only need this file shared. We will then
// look for Lsn related streams.
//
NtfsAcquireSharedFcb( IrpContext, Fcb, NULL, TRUE );
//
// Walk through all of the Scb's for the file and look for
// an Lsn protected stream.
//
NtfsLockFcb( IrpContext, Fcb );
NextScb = NULL;
while (NextScb = NtfsGetNextChildScb( Fcb, NextScb )) {
if (!(NextScb->AttributeTypeCode == $DATA ||
NextScb->AttributeTypeCode == $EA)) {
break;
}
}
NtfsUnlockFcb( IrpContext, Fcb );
//
// If we found a protected Scb then release and reacquire the Fcb
// exclusively.
//
if (NextScb != NULL) {
NtfsReleaseFcb( IrpContext, Fcb );
NtfsAcquireExclusiveFcb( IrpContext, Fcb, NULL, TRUE, FALSE );
}
}
}
}
//
// Now acquire the Fcb's in the Vcb.
//
Scb = &Vcb->QuotaTableScb;
while (TRUE) {
if ((*Scb != NULL)
&& (*Scb != Vcb->BitmapScb)) {
if (AcquirePagingIo && ((*Scb)->Fcb->PagingIoResource != NULL)) {
ExAcquireResourceExclusive( (*Scb)->Fcb->PagingIoResource, TRUE );
}
NtfsAcquireExclusiveFcb( IrpContext, (*Scb)->Fcb, NULL, TRUE, FALSE );
}
if (Scb == &Vcb->MftScb) {
break;
}
Scb -= 1;
}
//
// Treat the bitmap as an end resource and acquire it last.
//
if (Vcb->BitmapScb != NULL) {
if (AcquirePagingIo && (Vcb->BitmapScb->Fcb->PagingIoResource != NULL)) {
ExAcquireResourceExclusive( Vcb->BitmapScb->Fcb->PagingIoResource, TRUE );
}
NtfsAcquireExclusiveFcb( IrpContext, Vcb->BitmapScb->Fcb, NULL, TRUE, FALSE );
}
return;
}
BOOLEAN
NtfsZeroData (
IN PIRP_CONTEXT IrpContext,
IN PSCB Scb,
IN PFILE_OBJECT FileObject,
IN LONGLONG StartingZero,
IN LONGLONG ByteCount,
IN OUT PLONGLONG CommittedFileSize OPTIONAL
)
/*++
Routine Description:
This routine is called to zero a range of a file in order to
advance valid data length.
Arguments:
Scb - Scb for the stream to zero.
FileObject - FileObject for the stream.
StartingZero - Offset to begin the zero operation.
ByteCount - Length of range to zero.
CommittedFileSize - If we write the file sizes and commit the
transaction then we want to let our caller know what
point to roll back file size on a subsequent failure. On entry
it has the size our caller wants to roll back the file size to.
On exit it has the new size to roll back to which takes into
account any updates to the file size which have been logged.
Return Value:
BOOLEAN - TRUE if the entire range was zeroed, FALSE if the request
is broken up or the cache manager would block.
--*/
{
LONGLONG Temp;
#ifdef COMPRESS_ON_WIRE
IO_STATUS_BLOCK IoStatus;
#endif
ULONG SectorSize;
BOOLEAN Finished;
BOOLEAN CompleteZero = TRUE;
BOOLEAN ScbAcquired = FALSE;
PVCB Vcb = Scb->Vcb;
LONGLONG ZeroStart;
LONGLONG BeyondZeroEnd;
ULONG CompressionUnit = Scb->CompressionUnit;
BOOLEAN Wait;
PAGED_CODE();
Wait = (BOOLEAN) FlagOn( IrpContext->State, IRP_CONTEXT_STATE_WAIT );
SectorSize = Vcb->BytesPerSector;
//
// We may be able to simplify the zero operation (sparse file or when writing
// compressed) by deallocating large ranges of the file. Otherwise we have to
// generate zeroes for the entire range. If that is the case we want to split
// this operation up.
//
if ((ByteCount > MAX_ZERO_THRESHOLD) &&
!FlagOn( Scb->ScbState, SCB_STATE_WRITE_COMPRESSED ) &&
!FlagOn( Scb->AttributeFlags, ATTRIBUTE_FLAG_SPARSE )) {
ByteCount = MAX_ZERO_THRESHOLD;
CompleteZero = FALSE;
}
ZeroStart = StartingZero + (SectorSize - 1);
(ULONG)ZeroStart &= ~(SectorSize - 1);
BeyondZeroEnd = StartingZero + ByteCount + (SectorSize - 1);
(ULONG)BeyondZeroEnd &= ~(SectorSize - 1);
//
// We must flush the first compression unit in case it is partially populated
// in the compressed stream.
//
#ifdef COMPRESS_ON_WIRE
if ((Scb->NonpagedScb->SegmentObjectC.DataSectionObject != NULL) &&
((StartingZero & (CompressionUnit - 1)) != 0)) {
(ULONG)StartingZero &= ~(CompressionUnit - 1);
CcFlushCache( &Scb->NonpagedScb->SegmentObjectC,
(PLARGE_INTEGER)&StartingZero,
CompressionUnit,
&IoStatus );
if (!NT_SUCCESS(IoStatus.Status)) {
NtfsNormalizeAndRaiseStatus( IrpContext, IoStatus.Status, STATUS_UNEXPECTED_IO_ERROR );
}
}
#endif
//
// If this is a sparse or compressed file and we are zeroing a lot, then let's
// just delete the space instead of writing tons of zeros and deleting
// the space in the noncached path! If we are currently decompressing
// a compressed file we can't take this path.
//
if ((FlagOn( Scb->ScbState, SCB_STATE_WRITE_COMPRESSED ) ||
FlagOn( Scb->AttributeFlags, ATTRIBUTE_FLAG_SPARSE )) &&
(ByteCount > (Scb->CompressionUnit * 2))) {
//
// Find the end of the first compression unit being zeroed.
//
Temp = ZeroStart + (CompressionUnit - 1);
(ULONG)Temp &= ~(CompressionUnit - 1);
//
// Zero the first compression unit.
//
if ((ULONG)Temp != (ULONG)ZeroStart) {
Finished = CcZeroData( FileObject, (PLARGE_INTEGER)&ZeroStart, (PLARGE_INTEGER)&Temp, Wait );
if (!Finished) {return FALSE;}
ZeroStart = Temp;
}
//
// Now delete all of the compression units in between.
//
//
// Calculate the start of the last compression unit in bytes.
//
Temp = BeyondZeroEnd;
(ULONG)Temp &= ~(CompressionUnit - 1);
//
// If the caller has not already started a transaction (like write.c),
// then let's just do the delete as an atomic action.
//
if (!NtfsIsExclusiveScb( Scb )) {
NtfsAcquireExclusiveScb( IrpContext, Scb );
ScbAcquired = TRUE;
if (ARGUMENT_PRESENT( CommittedFileSize )) {
NtfsMungeScbSnapshot( IrpContext, Scb, *CommittedFileSize );
}
}
try {
//
// Delete the space.
//
NtfsDeleteAllocation( IrpContext,
FileObject,
Scb,
LlClustersFromBytes( Vcb, ZeroStart ),
LlClustersFromBytesTruncate( Vcb, Temp ) - 1,
TRUE,
TRUE );
//
// If we didn't raise then update the Scb values for compressed files.
//
if (FlagOn( Scb->AttributeFlags, ATTRIBUTE_FLAG_COMPRESSION_MASK )) {
Scb->ValidDataToDisk = Temp;
}
//
// If we succeed, commit the atomic action. Release all of the exclusive
// resources if our user explicitly acquired the Fcb here.
//
if (ScbAcquired) {
NtfsCheckpointCurrentTransaction( IrpContext );
if (ARGUMENT_PRESENT( CommittedFileSize )) {
ASSERT( Scb->ScbSnapshot != NULL );
*CommittedFileSize = Scb->ScbSnapshot->FileSize;
}
while (!IsListEmpty( &IrpContext->ExclusiveFcbList )) {
NtfsReleaseFcb( IrpContext,
(PFCB)CONTAINING_RECORD( IrpContext->ExclusiveFcbList.Flink,
FCB,
ExclusiveFcbLinks ));
}
ClearFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_RELEASE_USN_JRNL |
IRP_CONTEXT_FLAG_RELEASE_MFT );
ScbAcquired = FALSE;
}
if (FlagOn( Scb->ScbState, SCB_STATE_UNNAMED_DATA )) {
Scb->Fcb->Info.AllocatedLength = Scb->TotalAllocated;
SetFlag( Scb->Fcb->InfoFlags, FCB_INFO_CHANGED_ALLOC_SIZE );
}
} finally {
if (ScbAcquired) {
NtfsReleaseScb( IrpContext, Scb );
}
}
//
// Zero the beginning of the last compression unit.
//
if ((ULONG)Temp != (ULONG)BeyondZeroEnd) {
Finished = CcZeroData( FileObject, (PLARGE_INTEGER)&Temp, (PLARGE_INTEGER)&BeyondZeroEnd, Wait );
if (!Finished) {return FALSE;}
BeyondZeroEnd = Temp;
}
return TRUE;
}
