VOID
NTAPI
PopGracefulShutdown(IN PVOID Context)
{
PEPROCESS Process = NULL;
/* Process the registered waits and work items */
PopProcessShutDownLists();
/* Loop every process */
Process = PsGetNextProcess(Process);
while (Process)
{
/* Make sure this isn't the idle or initial process */
if ((Process != PsInitialSystemProcess) && (Process != PsIdleProcess))
{
/* Print it */
DPRINT1("%15s is still RUNNING (%p)\n", Process->ImageFileName, Process->UniqueProcessId);
}
/* Get the next process */
Process = PsGetNextProcess(Process);
}
/* First, the HAL handles any "end of boot" special functionality */
DPRINT("HAL shutting down\n");
HalEndOfBoot();
/* In this step, the I/O manager does first-chance shutdown notification */
DPRINT("I/O manager shutting down in phase 0\n");
IoShutdownSystem(0);
/* In this step, all workers are killed and hives are flushed */
DPRINT("Configuration Manager shutting down\n");
CmShutdownSystem();
/* Note that modified pages should be written here (MiShutdownSystem) */
#ifdef NEWCC
/* Flush all user files before we start shutting down IO */
/* This is where modified pages are written back by the IO manager */
CcShutdownSystem();
#endif
/* In this step, the I/O manager does last-chance shutdown notification */
DPRINT("I/O manager shutting down in phase 1\n");
IoShutdownSystem(1);
CcWaitForCurrentLazyWriterActivity();
/* Note that here, we should broadcast the power IRP to devices */
/* In this step, the HAL disables any wake timers */
DPRINT("Disabling wake timers\n");
HalSetWakeEnable(FALSE);
/* And finally the power request is sent */
DPRINT("Taking the system down\n");
PopShutdownSystem(PopAction.Action);
}
void
ssh_file_close(SshFileIoContext io_ctx)
{
if (io_ctx->wr_cache)
ssh_file_flush_wr_cache(io_ctx);
CcWaitForCurrentLazyWriterActivity();
ZwClose(io_ctx->handle);
}
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;
}
__drv_mustHoldCriticalRegion
NTSTATUS
RfsdLockVolume (IN PRFSD_IRP_CONTEXT IrpContext)
{
PIO_STACK_LOCATION IrpSp;
PDEVICE_OBJECT DeviceObject;
PRFSD_VCB Vcb = 0;
NTSTATUS Status;
BOOLEAN VcbResourceAcquired = FALSE;
PAGED_CODE();
_SEH2_TRY {
ASSERT(IrpContext != NULL);
ASSERT((IrpContext->Identifier.Type == RFSDICX) &&
(IrpContext->Identifier.Size == sizeof(RFSD_IRP_CONTEXT)));
DeviceObject = IrpContext->DeviceObject;
Status = STATUS_UNSUCCESSFUL;
//
// This request is not allowed on the main device object
//
if (DeviceObject == RfsdGlobal->DeviceObject) {
Status = STATUS_INVALID_PARAMETER;
_SEH2_LEAVE;
}
Vcb = (PRFSD_VCB) DeviceObject->DeviceExtension;
ASSERT(Vcb != NULL);
ASSERT((Vcb->Identifier.Type == RFSDVCB) &&
(Vcb->Identifier.Size == sizeof(RFSD_VCB)));
ASSERT(IsMounted(Vcb));
IrpSp = IoGetCurrentIrpStackLocation(IrpContext->Irp);
#if (_WIN32_WINNT >= 0x0500)
CcWaitForCurrentLazyWriterActivity();
#endif
ExAcquireResourceExclusiveLite(
&Vcb->MainResource,
TRUE );
VcbResourceAcquired = TRUE;
Status = RfsdLockVcb(Vcb, IrpSp->FileObject);
} _SEH2_FINALLY {
if (VcbResourceAcquired) {
ExReleaseResourceForThreadLite(
&Vcb->MainResource,
ExGetCurrentResourceThread()
);
}
if (!IrpContext->ExceptionInProgress) {
RfsdCompleteIrpContext(IrpContext, Status);
}
} _SEH2_END;
return Status;
}
NTKERNELAPI
BOOLEAN
CcSetPrivateWriteFile(
PFILE_OBJECT FileObject
)
/*++
Routine Description:
This routine will instruct the cache manager to treat the file as
a private-write stream, so that a caller can implement a private
logging mechanism for it. We will turn on both Mm's modify-no-write
and our disable-write-behind, and disallow non-aware flush/purge for
the file.
Caching must already be initiated on the file.
This routine is only exported to the kernel.
Arguments:
FileObject - File to make private-write.
Return Value:
None.
--*/
{
PSHARED_CACHE_MAP SharedCacheMap;
BOOLEAN Disabled;
KIRQL OldIrql;
PVACB Vacb;
ULONG ActivePage;
ULONG PageIsDirty;
//
// Pick up the file exclusive to synchronize against readahead and
// other purge/map activity.
//
FsRtlAcquireFileExclusive( FileObject );
//
// Get a pointer to the SharedCacheMap. Be sure to release the FileObject
// in case an error condition forces a premature exit.
//
if ((FileObject->SectionObjectPointer == NULL) ||
((SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap) == NULL)){
FsRtlReleaseFile( FileObject );
return FALSE;
}
//
// Unmap all the views in preparation for making the disable mw call.
//
//
// We still need to wait for any dangling cache read or writes.
//
// In fact we have to loop and wait because the lazy writer can
// sneak in and do an CcGetVirtualAddressIfMapped, and we are not
// synchronized.
//
// This is the same bit of code that our purge will do. We assume
// that a private writer has succesfully blocked out other activity.
//
//
// If there is an active Vacb, then delete it now (before waiting!).
//
CcAcquireMasterLock( &OldIrql );
GetActiveVacbAtDpcLevel( SharedCacheMap, Vacb, ActivePage, PageIsDirty );
CcReleaseMasterLock( OldIrql );
if (Vacb != NULL) {
CcFreeActiveVacb( SharedCacheMap, Vacb, ActivePage, PageIsDirty );
}
while ((SharedCacheMap->Vacbs != NULL) &&
!CcUnmapVacbArray( SharedCacheMap, NULL, 0, FALSE )) {
CcWaitOnActiveCount( SharedCacheMap );
}
//
// Knock the file down.
//
CcFlushCache( FileObject->SectionObjectPointer, NULL, 0, NULL );
//
// Now the file is clean and unmapped. We can still have a racing
// lazy writer, though.
//
// We just wait for the lazy writer queue to drain before disabling
// modified write. There may be a better way to do this by having
// an event for the WRITE_QUEUED flag. ? This would also let us
// dispense with the pagingio pick/drop in the FS cache coherency
// paths, but there could be reasons why CcFlushCache shouldn't
// always do such a block. Investigate this.
//
// This wait takes on the order of ~.5s avg. case.
//
CcAcquireMasterLock( &OldIrql );
if (FlagOn( SharedCacheMap->Flags, WRITE_QUEUED ) ||
FlagOn( SharedCacheMap->Flags, READ_AHEAD_QUEUED )) {
CcReleaseMasterLock( OldIrql );
FsRtlReleaseFile( FileObject );
CcWaitForCurrentLazyWriterActivity();
FsRtlAcquireFileExclusive( FileObject );
} else {
CcReleaseMasterLock( OldIrql );
}
//
// Now set the flags and return. We do not set our MODIFIED_WRITE_DISABLED
// since we don't want to fully promote this cache map. Future?
//
Disabled = MmDisableModifiedWriteOfSection( FileObject->SectionObjectPointer );
if (Disabled) {
CcAcquireMasterLock( &OldIrql );
SetFlag(SharedCacheMap->Flags, DISABLE_WRITE_BEHIND | PRIVATE_WRITE);
CcReleaseMasterLock( OldIrql );
}
//
// Now release the file for regular operation.
//
FsRtlReleaseFile( FileObject );
return Disabled;
}
VOID
xixfs_CleanupFlushVCB(
IN PXIXFS_IRPCONTEXT pIrpContext,
IN PXIXFS_VCB pVCB,
IN BOOLEAN DisMountVCB
)
{
//PAGED_CODE();
ASSERT_IRPCONTEXT( pIrpContext );
ASSERT_VCB( pVCB );
ASSERT_EXCLUSIVE_XIFS_GDATA;
ASSERT_EXCLUSIVE_VCB(pVCB);
DebugTrace(DEBUG_LEVEL_INFO, (DEBUG_TARGET_PNP| DEBUG_TARGET_VCB| DEBUG_TARGET_IRPCONTEXT),
("xixfs_CleanupFlushVCB Status(%ld).\n", pVCB->VCBState));
DebugTrace(DEBUG_LEVEL_INFO, (DEBUG_TARGET_PNP| DEBUG_TARGET_VCB| DEBUG_TARGET_IRPCONTEXT),
("11 Current VCB->PtrVPB->ReferenceCount %d \n", pVCB->PtrVPB->ReferenceCount));
XifsdLockVcb( pIrpContext, pVCB );
XIXCORE_SET_FLAGS(pVCB->VCBFlags, XIFSD_VCB_FLAGS_DEFERED_CLOSE);
if(DisMountVCB){
if(pVCB->VolumeDasdFCB != NULL){
pVCB->VolumeDasdFCB->FCBReference -= 1;
pVCB->VolumeDasdFCB->FCBUserReference -= 1;
}
if(pVCB->MetaFCB != NULL){
pVCB->MetaFCB->FCBReference -=1;
pVCB->MetaFCB->FCBUserReference -= 1;
}
if(pVCB->RootDirFCB != NULL){
pVCB->RootDirFCB->FCBReference -=1;
pVCB->RootDirFCB->FCBUserReference -= 1;
}
}
XifsdUnlockVcb(pIrpContext, pVCB);
xixfs_PurgeVolume(pIrpContext, pVCB, DisMountVCB);
DebugTrace(DEBUG_LEVEL_INFO, (DEBUG_TARGET_PNP| DEBUG_TARGET_VCB| DEBUG_TARGET_IRPCONTEXT),
("22 Current VCB->PtrVPB->ReferenceCount %d \n", pVCB->PtrVPB->ReferenceCount));
if(DisMountVCB){
// Added by ILGU HONG
XifsdReleaseVcb(TRUE, pVCB);
DebugTrace(DEBUG_LEVEL_INFO, (DEBUG_TARGET_FSCTL|DEBUG_TARGET_VOLINFO ),
("VCB %d/%d \n", pVCB->VCBReference, pVCB->VCBUserReference));
CcWaitForCurrentLazyWriterActivity();
XifsdAcquireVcbExclusive(TRUE, pVCB, FALSE);
xixfs_RealCloseFCB((PVOID)pVCB);
}
XifsdLockVcb( pIrpContext, pVCB );
XIXCORE_CLEAR_FLAGS(pVCB->VCBFlags, XIFSD_VCB_FLAGS_DEFERED_CLOSE);
XifsdUnlockVcb(pIrpContext, pVCB);
// Added by ILGU HONG END
if(DisMountVCB){
// changed by ILGU HONG for readonly 09052006
if(!pVCB->XixcoreVcb.IsVolumeWriteProtected){
LARGE_INTEGER TimeOut;
//
// Stop Meta Update process
//
KeSetEvent(&pVCB->VCBUmountEvent, 0, FALSE);
TimeOut.QuadPart = - DEFAULT_XIFS_UMOUNTWAIT;
KeWaitForSingleObject(&pVCB->VCBStopOkEvent, Executive, KernelMode, FALSE, &TimeOut);
xixcore_DeregisterHost(&pVCB->XixcoreVcb);
// Added by ILGU HONG for 08312006
if(pVCB->NdasVolBacl_Id){
xixfs_RemoveUserBacl(pVCB->TargetDeviceObject, pVCB->NdasVolBacl_Id);
}
// Added by ILGU HONG End
}
// changed by ILGU HONG for readonly end
}
return;
}
__drv_mustHoldCriticalRegion
NTSTATUS
RfsdPnpSurpriseRemove (
PRFSD_IRP_CONTEXT IrpContext,
PRFSD_VCB Vcb )
{
NTSTATUS Status;
KEVENT Event;
BOOLEAN bDeleted;
PAGED_CODE();
_SEH2_TRY {
RfsdPrint((DBG_PNP, "RfsdPnpSupriseRemove by RfsdPnp ...\n"));
#if (_WIN32_WINNT >= 0x0500)
CcWaitForCurrentLazyWriterActivity();
#endif
ExAcquireResourceExclusiveLite(
&Vcb->MainResource, TRUE );
Status = RfsdLockVcb(Vcb, IrpContext->FileObject);
ExReleaseResourceForThreadLite(
&Vcb->MainResource,
ExGetCurrentResourceThread());
//
// Setup the Irp. We'll send it to the lower disk driver.
//
IoCopyCurrentIrpStackLocationToNext(IrpContext->Irp);
KeInitializeEvent( &Event, NotificationEvent, FALSE );
IoSetCompletionRoutine( IrpContext->Irp,
RfsdPnpCompletionRoutine,
&Event,
TRUE,
TRUE,
TRUE );
Status = IoCallDriver( Vcb->TargetDeviceObject,
IrpContext->Irp);
if (Status == STATUS_PENDING) {
KeWaitForSingleObject( &Event,
Executive,
KernelMode,
FALSE,
NULL );
Status = IrpContext->Irp->IoStatus.Status;
}
ExAcquireResourceExclusiveLite(
&Vcb->MainResource, TRUE );
RfsdPurgeVolume(Vcb, FALSE);
ExReleaseResourceForThreadLite(
&Vcb->MainResource,
ExGetCurrentResourceThread() );
bDeleted = RfsdCheckDismount(IrpContext, Vcb, TRUE);
} _SEH2_FINALLY {
RfsdCompleteRequest(
IrpContext->Irp, FALSE, (CCHAR)(NT_SUCCESS(Status)?
IO_DISK_INCREMENT : IO_NO_INCREMENT) );
IrpContext->Irp = NULL;
} _SEH2_END;
return Status;
}
__drv_mustHoldCriticalRegion
NTSTATUS
RfsdPnpQueryRemove (
PRFSD_IRP_CONTEXT IrpContext,
PRFSD_VCB Vcb
)
{
NTSTATUS Status;
KEVENT Event;
BOOLEAN bDeleted = FALSE;
BOOLEAN VcbAcquired = FALSE;
PAGED_CODE();
_SEH2_TRY {
RfsdPrint((DBG_PNP, "RfsdPnpQueryRemove by RfsdPnp ...\n"));
RfsdPrint((DBG_PNP, "RfsdPnpQueryRemove: RfsdFlushVolume ...\n"));
#if (_WIN32_WINNT >= 0x0500)
CcWaitForCurrentLazyWriterActivity();
#endif
ExAcquireResourceExclusiveLite(
&Vcb->MainResource, TRUE );
VcbAcquired = TRUE;
RfsdFlushFiles(Vcb, FALSE);
RfsdFlushVolume(Vcb, FALSE);
RfsdPrint((DBG_PNP, "RfsdPnpQueryRemove: RfsdLockVcb: Vcb=%xh FileObject=%xh ...\n",
Vcb, IrpContext->FileObject));
Status = RfsdLockVcb(Vcb, IrpContext->FileObject);
RfsdPrint((DBG_PNP, "RfsdPnpQueryRemove: RfsdPurgeVolume ...\n"));
RfsdPurgeVolume(Vcb, TRUE);
if (!NT_SUCCESS(Status)) {
_SEH2_LEAVE;
}
ExReleaseResourceForThreadLite(
&Vcb->MainResource,
ExGetCurrentResourceThread() );
VcbAcquired = FALSE;
IoCopyCurrentIrpStackLocationToNext(IrpContext->Irp);
KeInitializeEvent( &Event, NotificationEvent, FALSE );
IoSetCompletionRoutine( IrpContext->Irp,
RfsdPnpCompletionRoutine,
&Event,
TRUE,
TRUE,
TRUE );
RfsdPrint((DBG_PNP, "RfsdPnpQueryRemove: Call lower level driver...\n"));
Status = IoCallDriver( Vcb->TargetDeviceObject,
IrpContext->Irp);
if (Status == STATUS_PENDING) {
KeWaitForSingleObject( &Event,
Executive,
KernelMode,
FALSE,
NULL );
Status = IrpContext->Irp->IoStatus.Status;
}
if (NT_SUCCESS(Status)) {
RfsdPrint((DBG_PNP, "RfsdPnpQueryRemove: RfsdCheckDismount ...\n"));
bDeleted = RfsdCheckDismount(IrpContext, Vcb, TRUE);
RfsdPrint((DBG_PNP, "RfsdPnpQueryRemove: RfsdFlushVolume bDelted=%xh ...\n", bDeleted));
}
ASSERT( !(NT_SUCCESS(Status) && !bDeleted));
} _SEH2_FINALLY {
if (VcbAcquired) {
ExReleaseResourceForThreadLite(
&Vcb->MainResource,
ExGetCurrentResourceThread() );
}
RfsdCompleteRequest(
IrpContext->Irp, FALSE, (CCHAR)(NT_SUCCESS(Status)?
IO_DISK_INCREMENT : IO_NO_INCREMENT) );
IrpContext->Irp = NULL;
} _SEH2_END;
return Status;
}
