/*
* FUNCTION: Allocate and fill an NTFS_IRP_CONTEXT struct in order to use it for IRP
* ARGUMENTS:
* DeviceObject = Used to fill in struct
* Irp = The IRP that need IRP_CONTEXT struct
* RETURNS: NULL or PNTFS_IRP_CONTEXT
*/
PNTFS_IRP_CONTEXT
NtfsAllocateIrpContext(PDEVICE_OBJECT DeviceObject,
PIRP Irp)
{
PNTFS_IRP_CONTEXT IrpContext;
PIO_STACK_LOCATION IoStackLocation;
TRACE_(NTFS, "NtfsAllocateIrpContext()\n");
IrpContext = (PNTFS_IRP_CONTEXT)ExAllocatePoolWithTag(NonPagedPool,
sizeof(NTFS_IRP_CONTEXT),
'PRIN');
if (IrpContext == NULL)
return NULL;
RtlZeroMemory(IrpContext, sizeof(NTFS_IRP_CONTEXT));
IrpContext->Identifier.Type = NTFS_TYPE_IRP_CONTEST;
IrpContext->Identifier.Size = sizeof(NTFS_IRP_CONTEXT);
IrpContext->Irp = Irp;
IrpContext->DeviceObject = DeviceObject;
if (Irp)
{
IoStackLocation = IoGetCurrentIrpStackLocation(Irp);
ASSERT(IoStackLocation);
IrpContext->MajorFunction = IoStackLocation->MajorFunction;
IrpContext->MinorFunction = IoStackLocation->MinorFunction;
IrpContext->IsTopLevel = (IoGetTopLevelIrp() == Irp);
}
return IrpContext;
}
BOOLEAN
CdAcquireForCache (
_Inout_ PFCB Fcb,
_In_ BOOLEAN Wait
)
/*++
Routine Description:
The address of this routine is specified when creating a CacheMap for
a file. It is subsequently called by the Lazy Writer for synchronization.
Arguments:
Fcb - The pointer supplied as context to the cache initialization
routine.
Wait - TRUE if the caller is willing to block.
Return Value:
None
--*/
{
PAGED_CODE();
NT_ASSERT(IoGetTopLevelIrp() == NULL);
IoSetTopLevelIrp((PIRP)FSRTL_CACHE_TOP_LEVEL_IRP);
return ExAcquireResourceSharedLite( Fcb->Resource, Wait );
}
VOID
CdReleaseFromCache (
_Inout_ PFCB Fcb
)
/*++
Routine Description:
The address of this routine is specified when creating a CacheMap for
a virtual file. It is subsequently called by the Lazy Writer to release
a resource acquired above.
Arguments:
Fcb - The pointer supplied as context to the cache initialization
routine.
Return Value:
None
--*/
{
PAGED_CODE();
NT_ASSERT(IoGetTopLevelIrp() == (PIRP)FSRTL_CACHE_TOP_LEVEL_IRP);
IoSetTopLevelIrp( NULL );
ExReleaseResourceLite( Fcb->Resource );
}
VOID DokanNoOpRelease(__in PVOID Fcb) {
DDbgPrint("==> DokanNoOpRelease\n");
ASSERT(IoGetTopLevelIrp() == (PIRP)FSRTL_CACHE_TOP_LEVEL_IRP);
IoSetTopLevelIrp(NULL);
UNREFERENCED_PARAMETER(Fcb);
DDbgPrint("<== DokanNoOpRelease\n");
}
VOID
NtfsReleaseScbFromLazyWrite (
IN PVOID OpaqueScb
)
/*++
Routine Description:
The address of this routine is specified when creating a CacheMap for
a file. It is subsequently called by the Lazy Writer after its
performing lazy writes to the file.
Arguments:
Scb - The Scb which was specified as a context parameter for this
routine.
Return Value:
None
--*/
{
ULONG CompressedStream = (ULONG)OpaqueScb & 1;
PSCB Scb = (PSCB)((ULONG)OpaqueScb & ~1);
PFCB Fcb = Scb->Fcb;
ASSERT_SCB(Scb);
PAGED_CODE();
//
// Clear the toplevel at this point, if we set it above.
//
if (IoGetTopLevelIrp() == (PIRP)FSRTL_CACHE_TOP_LEVEL_IRP) {
IoSetTopLevelIrp( NULL );
}
Scb->LazyWriteThread[CompressedStream] = NULL;
if (NtfsSegmentNumber( &Fcb->FileReference ) <= MASTER_FILE_TABLE2_NUMBER) {
NOTHING;
} else if (Scb->Header.PagingIoResource != NULL) {
ExReleaseResource( Scb->Header.PagingIoResource );
} else {
ExReleaseResource( Scb->Header.Resource );
}
return;
}
static void release_from_read_ahead(PVOID Context) {
PFILE_OBJECT FileObject = Context;
fcb* fcb = FileObject->FsContext;
TRACE("(%p)\n", Context);
ExReleaseResourceLite(fcb->Header.Resource);
if (IoGetTopLevelIrp() == (PIRP)FSRTL_CACHE_TOP_LEVEL_IRP)
IoSetTopLevelIrp(NULL);
}
BOOLEAN
NTAPI
FatIsTopLevelIrp(IN PIRP Irp)
{
if (!IoGetTopLevelIrp())
{
IoSetTopLevelIrp(Irp);
return TRUE;
}
return FALSE;
}
BOOLEAN
DokanNoOpAcquire(__in PVOID Fcb, __in BOOLEAN Wait) {
UNREFERENCED_PARAMETER(Fcb);
UNREFERENCED_PARAMETER(Wait);
DDbgPrint("==> DokanNoOpAcquire\n");
ASSERT(IoGetTopLevelIrp() == NULL);
IoSetTopLevelIrp((PIRP)FSRTL_CACHE_TOP_LEVEL_IRP);
DDbgPrint("<== DokanNoOpAcquire\n");
return TRUE;
}
/*
* FUNCTION: Used with IRP to set them to TopLevelIrp field
* ARGUMENTS:
* Irp = The IRP to set
* RETURNS: TRUE if top level was null, else FALSE
*/
BOOLEAN
NtfsIsIrpTopLevel(PIRP Irp)
{
BOOLEAN ReturnCode = FALSE;
TRACE_(NTFS, "NtfsIsIrpTopLevel()\n");
if (IoGetTopLevelIrp() == NULL)
{
IoSetTopLevelIrp(Irp);
ReturnCode = TRUE;
}
return ReturnCode;
}
static void release_from_lazy_write(PVOID Context) {
PFILE_OBJECT FileObject = Context;
fcb* fcb = FileObject->FsContext;
TRACE("(%p)\n", Context);
fcb->lazy_writer_thread = NULL;
ExReleaseResourceLite(fcb->Header.Resource);
ExReleaseResourceLite(&fcb->Vcb->tree_lock);
if (IoGetTopLevelIrp() == (PIRP)FSRTL_CACHE_TOP_LEVEL_IRP)
IoSetTopLevelIrp(NULL);
}
NTSTATUS
DokanBuildRequest(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
BOOLEAN AtIrqlPassiveLevel = FALSE;
BOOLEAN IsTopLevelIrp = FALSE;
NTSTATUS Status = STATUS_UNSUCCESSFUL;
__try {
__try {
AtIrqlPassiveLevel = (KeGetCurrentIrql() == PASSIVE_LEVEL);
if (AtIrqlPassiveLevel) {
FsRtlEnterFileSystem();
}
if (!IoGetTopLevelIrp()) {
IsTopLevelIrp = TRUE;
IoSetTopLevelIrp(Irp);
}
Status = DokanDispatchRequest(DeviceObject, Irp);
}
__except (DokanExceptionFilter(Irp, GetExceptionInformation()))
{
Status = DokanExceptionHandler(DeviceObject, Irp, GetExceptionCode());
}
}
__finally {
if (IsTopLevelIrp) {
IoSetTopLevelIrp(NULL);
}
if (AtIrqlPassiveLevel) {
FsRtlExitFileSystem();
}
}
return Status;
}
VOID
NTAPI
FatQueueRequest(IN PFAT_IRP_CONTEXT IrpContext,
IN PFAT_OPERATION_HANDLER OperationHandler)
{
/* Save the worker routine. */
IrpContext->QueuedOperationHandler = OperationHandler;
/* Indicate if top level IRP was set. */
if (IoGetTopLevelIrp() == IrpContext->Irp)
SetFlag(IrpContext->Flags, IRPCONTEXT_TOPLEVEL);
/* Initialize work item. */
ExInitializeWorkItem(&IrpContext->WorkQueueItem,
FatDequeueRequest,
IrpContext);
ExQueueWorkItem(&IrpContext->WorkQueueItem,
DelayedWorkQueue);
}
VOID FspIopCompleteCanceledIrp(PIRP Irp)
{
PAGED_CODE();
DEBUGLOGIRP(Irp, STATUS_CANCELLED);
/*
* An IRP cancel may happen at any time including when APC's are still enabled.
* For this reason we execute FsRtlEnterFileSystem/FsRtlExitFileSystem here.
* This will protect ERESOURCE operations during Request finalizations.
*/
FsRtlEnterFileSystem();
PIRP TopLevelIrp = IoGetTopLevelIrp();
IoSetTopLevelIrp(Irp);
FspIopCompleteIrpEx(Irp, STATUS_CANCELLED, TRUE);
IoSetTopLevelIrp(TopLevelIrp);
FsRtlExitFileSystem();
}
/*
* FUNCTION: Allocate and fill an NTFS_IRP_CONTEXT struct in order to use it for IRP
* ARGUMENTS:
* DeviceObject = Used to fill in struct
* Irp = The IRP that need IRP_CONTEXT struct
* RETURNS: NULL or PNTFS_IRP_CONTEXT
*/
PNTFS_IRP_CONTEXT
NtfsAllocateIrpContext(PDEVICE_OBJECT DeviceObject,
PIRP Irp)
{
PNTFS_IRP_CONTEXT IrpContext;
TRACE_(NTFS, "NtfsAllocateIrpContext()\n");
IrpContext = (PNTFS_IRP_CONTEXT)ExAllocateFromNPagedLookasideList(&NtfsGlobalData->IrpContextLookasideList);
if (IrpContext == NULL)
return NULL;
RtlZeroMemory(IrpContext, sizeof(NTFS_IRP_CONTEXT));
IrpContext->Identifier.Type = NTFS_TYPE_IRP_CONTEXT;
IrpContext->Identifier.Size = sizeof(NTFS_IRP_CONTEXT);
IrpContext->Irp = Irp;
IrpContext->DeviceObject = DeviceObject;
IrpContext->Stack = IoGetCurrentIrpStackLocation(Irp);
IrpContext->MajorFunction = IrpContext->Stack->MajorFunction;
IrpContext->MinorFunction = IrpContext->Stack->MinorFunction;
IrpContext->FileObject = IrpContext->Stack->FileObject;
IrpContext->IsTopLevel = (IoGetTopLevelIrp() == Irp);
IrpContext->PriorityBoost = IO_NO_INCREMENT;
IrpContext->Flags = IRPCONTEXT_COMPLETE;
if (IrpContext->MajorFunction == IRP_MJ_FILE_SYSTEM_CONTROL ||
IrpContext->MajorFunction == IRP_MJ_DEVICE_CONTROL ||
IrpContext->MajorFunction == IRP_MJ_SHUTDOWN ||
(IrpContext->MajorFunction != IRP_MJ_CLEANUP &&
IrpContext->MajorFunction != IRP_MJ_CLOSE &&
IoIsOperationSynchronous(Irp)))
{
IrpContext->Flags |= IRPCONTEXT_CANWAIT;
}
return IrpContext;
}
__checkReturn
FORCEINLINE
BOOLEAN
IsPassThrough (
__in PCFLT_RELATED_OBJECTS FltObjects,
__in FLT_POST_OPERATION_FLAGS Flags
)
{
if ( FlagOn( Flags, FLTFL_POST_OPERATION_DRAINING ) )
{
return TRUE;
}
if ( !FltObjects->Instance )
{
return TRUE;
}
if ( !FltObjects->FileObject )
{
return TRUE;
}
if ( FlagOn( FltObjects->FileObject->Flags, FO_NAMED_PIPE ) )
{
return TRUE;
}
PIRP pTopLevelIrp = IoGetTopLevelIrp();
if ( pTopLevelIrp )
{
return TRUE;
}
return FALSE;
}
void rnd_reseed_now()
{
seed_data seed;
KeQuerySystemTime(&seed.seed20);
seed.seed1 = PsGetCurrentProcess();
seed.seed2 = PsGetCurrentProcessId();
seed.seed3 = KeGetCurrentThread();
seed.seed4 = PsGetCurrentThreadId();
seed.seed5 = KeGetCurrentProcessorNumber();
seed.seed6 = KeQueryInterruptTime();
seed.seed10 = KeQueryPerformanceCounter(NULL);
seed.seed11 = __rdtsc();
seed.seed12 = ExGetPreviousMode();
seed.seed14 = IoGetTopLevelIrp();
seed.seed15 = MmQuerySystemSize();
seed.seed24 = KeGetCurrentIrql();
if (KeGetCurrentIrql() == PASSIVE_LEVEL) {
seed.seed7 = KeQueryPriorityThread(seed.seed3);
seed.seed17 = ExUuidCreate(&seed.seed18);
seed.seed19 = RtlRandom(&seed.seed8);
}
if (KeGetCurrentIrql() <= APC_LEVEL) {
seed.seed13 = IoGetInitialStack();
seed.seed16 = PsGetProcessExitTime();
IoGetStackLimits(&seed.seed22, &seed.seed23);
}
KeQueryTickCount(&seed.seed21);
rnd_add_buff(&seed, sizeof(seed));
/* Prevent leaks */
zeroauto(&seed, sizeof(seed));
}
VOID
CdSetThreadContext (
_Inout_ PIRP_CONTEXT IrpContext,
_In_ PTHREAD_CONTEXT ThreadContext
)
/*++
Routine Description:
This routine is called at each Fsd/Fsp entry point set up the IrpContext
and thread local storage to track top level requests. If there is
not a Cdfs context in the thread local storage then we use the input one.
Otherwise we use the one already there. This routine also updates the
IrpContext based on the state of the top-level context.
If the TOP_LEVEL flag in the IrpContext is already set when we are called
then we force this request to appear top level.
Arguments:
ThreadContext - Address on stack for local storage if not already present.
ForceTopLevel - We force this request to appear top level regardless of
any previous stack value.
Return Value:
None
--*/
{
PTHREAD_CONTEXT CurrentThreadContext;
PAGED_CODE();
ASSERT_IRP_CONTEXT( IrpContext );
//
// Get the current top-level irp out of the thread storage.
// If NULL then this is the top-level request.
//
CurrentThreadContext = (PTHREAD_CONTEXT) IoGetTopLevelIrp();
if (CurrentThreadContext == NULL) {
SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_TOP_LEVEL );
}
//
// Initialize the input context unless we are using the current
// thread context block. We use the new block if our caller
// specified this or the existing block is invalid.
//
// The following must be true for the current to be a valid Cdfs context.
//
// Structure must lie within current stack.
// Address must be ULONG aligned.
// Cdfs signature must be present.
//
// If this is not a valid Cdfs context then use the input thread
// context and store it in the top level context.
//
#pragma warning(suppress: 6011) // Bug in PREFast around bitflag operations
if (FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_TOP_LEVEL ) ||
(!IoWithinStackLimits( (ULONG_PTR)CurrentThreadContext, sizeof( THREAD_CONTEXT ) ) ||
FlagOn( (ULONG_PTR) CurrentThreadContext, 0x3 ) ||
(CurrentThreadContext->Cdfs != 0x53464443))) {
ThreadContext->Cdfs = 0x53464443;
ThreadContext->SavedTopLevelIrp = (PIRP) CurrentThreadContext;
ThreadContext->TopLevelIrpContext = IrpContext;
IoSetTopLevelIrp( (PIRP) ThreadContext );
IrpContext->TopLevel = IrpContext;
IrpContext->ThreadContext = ThreadContext;
SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_TOP_LEVEL_CDFS );
//
// Otherwise use the IrpContext in the thread context.
//
} else {
IrpContext->TopLevel = CurrentThreadContext->TopLevelIrpContext;
}
return;
}
VOID
NtfsSpecialDispatch (
PVOID Context
)
/*++
Routine Description:
This routine is called when a special operation needs to be posted.
It is called indirectly by NtfsPostSpecial. It is assumes that the
Vcb is protected from going away by incrementing the volemue close
counts for a file. If this routine fails nothing is done except
to clean up the Vcb. This routine also handles issues log file full
and can't wait.
The function to be called is stored in the PostSpecialCallout field
of the Irp Context, and the context is stored int he OriginatingIrp.
Both fields are zeroed before the the callout function is called.
Arguments:
Context - Supplies a pointer to an IrpContext.
Return Value:
--*/
{
PVCB Vcb;
PIRP_CONTEXT IrpContext = Context;
TOP_LEVEL_CONTEXT TopLevelContext;
PTOP_LEVEL_CONTEXT ThreadTopLevelContext;
POST_SPECIAL_CALLOUT PostSpecialCallout;
PVOID SpecialContext;
ULONG LogFileFullCount;
BOOLEAN Retry;
PAGED_CODE();
FsRtlEnterFileSystem();
do {
Vcb = IrpContext->Vcb;
LogFileFullCount = 0;
//
// Capture the funciton pointer and context before using the IrpContext.
//
PostSpecialCallout = IrpContext->Union.PostSpecialCallout;
SpecialContext = IrpContext->OriginatingIrp;
IrpContext->Union.PostSpecialCallout = NULL;
IrpContext->OriginatingIrp = NULL;
ThreadTopLevelContext = NtfsInitializeTopLevelIrp( &TopLevelContext, TRUE, TRUE );
ASSERT( ThreadTopLevelContext == &TopLevelContext );
ASSERT( !FlagOn( IrpContext->State, IRP_CONTEXT_STATE_OWNS_TOP_LEVEL ));
ASSERT( FlagOn( IrpContext->State, IRP_CONTEXT_STATE_ALLOC_FROM_POOL ));
//
// Initialize the thread top level structure, if needed.
//
ASSERT( IoGetTopLevelIrp() != (PIRP) &TopLevelContext );
NtfsUpdateIrpContextWithTopLevel( IrpContext, ThreadTopLevelContext );
//
// Don't let this IrpContext be deleted.
//
SetFlag( IrpContext->State, IRP_CONTEXT_STATE_PERSISTENT );
do {
Retry = FALSE;
try {
//
// See if we failed due to a log file full condition, and
// if so, then do a clean volume checkpoint if we are the
// first ones to get there. If we see a different Lsn and do
// not do the checkpoint, the worst that can happen is that we
// will fail again if the log file is still full.
//
if (IrpContext->LastRestartArea.QuadPart != 0) {
NtfsCheckpointForLogFileFull( IrpContext );
if (++LogFileFullCount >= 2) {
SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_EXCESS_LOG_FULL );
}
}
//
// Call the requested function.
//
ASSERT( FlagOn( IrpContext->TopLevelIrpContext->State, IRP_CONTEXT_STATE_OWNS_TOP_LEVEL ));
PostSpecialCallout( IrpContext, SpecialContext );
NtfsCompleteRequest( IrpContext, NULL, STATUS_SUCCESS );
} except(NtfsExceptionFilter( IrpContext, GetExceptionInformation() )) {
NTSTATUS ExceptionCode;
ExceptionCode = GetExceptionCode();
ExceptionCode = NtfsProcessException( IrpContext, NULL, ExceptionCode );
if ((ExceptionCode == STATUS_CANT_WAIT) ||
(ExceptionCode == STATUS_LOG_FILE_FULL)) {
Retry = TRUE;
}
}
} while (Retry);
//
// Ok to let this IrpContext be deleted.
//
ClearFlag( IrpContext->State, IRP_CONTEXT_STATE_PERSISTENT );
//
// At this point regardless of the status the volume needs to
// be cleaned up and the IrpContext freed.
// Dereference the Vcb and check to see if it needs to be deleted.
// since this call might raise wrap it with a try/execpt.
//
try {
//
// Acquire the volume exclusive so the counts can be
// updated.
//
ASSERT( FlagOn( IrpContext->State, IRP_CONTEXT_STATE_WAIT ));
NtfsAcquireExclusiveVcb( IrpContext, Vcb, TRUE );
InterlockedDecrement( &Vcb->SystemFileCloseCount );
InterlockedDecrement( &Vcb->CloseCount );
NtfsReleaseVcb( IrpContext, Vcb );
} except( EXCEPTION_EXECUTE_HANDLER ) {
ASSERT( FsRtlIsNtstatusExpected( GetExceptionCode() ) );
}
//
// Free the irp context.
//
NtfsCleanupIrpContext( IrpContext, TRUE );
//
// See if there is more work on the scavenger list.
//
ExAcquireFastMutexUnsafe( &NtfsScavengerLock );
ASSERT( NtfsScavengerRunning );
IrpContext = NtfsScavengerWorkList;
if (IrpContext != NULL) {
//
// Remove the entry from the list.
//
NtfsScavengerWorkList = (PIRP_CONTEXT) IrpContext->WorkQueueItem.List.Flink;
IrpContext->WorkQueueItem.List.Flink = NULL;
} else {
NtfsScavengerRunning = FALSE;
}
ExReleaseFastMutexUnsafe( &NtfsScavengerLock );
} while ( IrpContext != NULL );
FsRtlExitFileSystem();
}
NTSTATUS
CdFsdDispatch (
_In_ PDEVICE_OBJECT DeviceObject,
_Inout_ PIRP Irp
)
/*++
Routine Description:
This is the driver entry to all of the Fsd dispatch points.
Conceptually the Io routine will call this routine on all requests
to the file system. We case on the type of request and invoke the
correct handler for this type of request. There is an exception filter
to catch any exceptions in the CDFS code as well as the CDFS process
exception routine.
This routine allocates and initializes the IrpContext for this request as
well as updating the top-level thread context as necessary. We may loop
in this routine if we need to retry the request for any reason. The
status code STATUS_CANT_WAIT is used to indicate this. Suppose the disk
in the drive has changed. An Fsd request will proceed normally until it
recognizes this condition. STATUS_VERIFY_REQUIRED is raised at that point
and the exception code will handle the verify and either return
STATUS_CANT_WAIT or STATUS_PENDING depending on whether the request was
posted.
Arguments:
DeviceObject - Supplies the volume device object for this request
Irp - Supplies the Irp being processed
Return Value:
NTSTATUS - The FSD status for the IRP
--*/
{
THREAD_CONTEXT ThreadContext = {0};
PIRP_CONTEXT IrpContext = NULL;
BOOLEAN Wait;
#ifdef CD_SANITY
PVOID PreviousTopLevel;
#endif
NTSTATUS Status;
#if DBG
KIRQL SaveIrql = KeGetCurrentIrql();
#endif
ASSERT_OPTIONAL_IRP( Irp );
UNREFERENCED_PARAMETER( DeviceObject );
FsRtlEnterFileSystem();
#ifdef CD_SANITY
PreviousTopLevel = IoGetTopLevelIrp();
#endif
//
// Loop until this request has been completed or posted.
//
do {
//
// Use a try-except to handle the exception cases.
//
try {
//
// If the IrpContext is NULL then this is the first pass through
// this loop.
//
if (IrpContext == NULL) {
//
// Decide if this request is waitable an allocate the IrpContext.
// If the file object in the stack location is NULL then this
// is a mount which is always waitable. Otherwise we look at
// the file object flags.
//
if (IoGetCurrentIrpStackLocation( Irp )->FileObject == NULL) {
Wait = TRUE;
} else {
Wait = CanFsdWait( Irp );
}
IrpContext = CdCreateIrpContext( Irp, Wait );
//
// Update the thread context information.
//
CdSetThreadContext( IrpContext, &ThreadContext );
#ifdef CD_SANITY
NT_ASSERT( !CdTestTopLevel ||
SafeNodeType( IrpContext->TopLevel ) == CDFS_NTC_IRP_CONTEXT );
#endif
//
// Otherwise cleanup the IrpContext for the retry.
//
} else {
//
// Set the MORE_PROCESSING flag to make sure the IrpContext
// isn't inadvertently deleted here. Then cleanup the
// IrpContext to perform the retry.
//
SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_MORE_PROCESSING );
CdCleanupIrpContext( IrpContext, FALSE );
}
//
// Case on the major irp code.
//
switch (IrpContext->MajorFunction) {
case IRP_MJ_CREATE :
Status = CdCommonCreate( IrpContext, Irp );
break;
case IRP_MJ_CLOSE :
Status = CdCommonClose( IrpContext, Irp );
break;
case IRP_MJ_READ :
//
// If this is an Mdl complete request, don't go through
// common read.
//
if (FlagOn( IrpContext->MinorFunction, IRP_MN_COMPLETE )) {
Status = CdCompleteMdl( IrpContext, Irp );
} else {
Status = CdCommonRead( IrpContext, Irp );
}
break;
case IRP_MJ_WRITE :
Status = CdCommonWrite( IrpContext, Irp );
break;
case IRP_MJ_QUERY_INFORMATION :
Status = CdCommonQueryInfo( IrpContext, Irp );
break;
case IRP_MJ_SET_INFORMATION :
Status = CdCommonSetInfo( IrpContext, Irp );
break;
case IRP_MJ_QUERY_VOLUME_INFORMATION :
Status = CdCommonQueryVolInfo( IrpContext, Irp );
break;
case IRP_MJ_DIRECTORY_CONTROL :
Status = CdCommonDirControl( IrpContext, Irp );
break;
case IRP_MJ_FILE_SYSTEM_CONTROL :
Status = CdCommonFsControl( IrpContext, Irp );
break;
case IRP_MJ_DEVICE_CONTROL :
Status = CdCommonDevControl( IrpContext, Irp );
break;
case IRP_MJ_LOCK_CONTROL :
Status = CdCommonLockControl( IrpContext, Irp );
break;
case IRP_MJ_CLEANUP :
Status = CdCommonCleanup( IrpContext, Irp );
break;
case IRP_MJ_PNP :
Status = CdCommonPnp( IrpContext, Irp );
break;
case IRP_MJ_SHUTDOWN :
Status = CdCommonShutdown( IrpContext, Irp );
break;
default :
Status = STATUS_INVALID_DEVICE_REQUEST;
CdCompleteRequest( IrpContext, Irp, Status );
}
} except( CdExceptionFilter( IrpContext, GetExceptionInformation() )) {
Status = CdProcessException( IrpContext, Irp, GetExceptionCode() );
}
} while (Status == STATUS_CANT_WAIT);
#ifdef CD_SANITY
NT_ASSERT( !CdTestTopLevel ||
(PreviousTopLevel == IoGetTopLevelIrp()) );
#endif
FsRtlExitFileSystem();
NT_ASSERT( SaveIrql == KeGetCurrentIrql( ));
return Status;
}
VOID
CloseOpenFiles (
IN PPRIMARY_SESSION PrimarySession,
IN BOOLEAN Remove
)
{
PLIST_ENTRY openFileEntry;
for (openFileEntry = PrimarySession->Thread.OpenedFileQueue.Flink;
openFileEntry != &PrimarySession->Thread.OpenedFileQueue; ) {
POPEN_FILE openFile;
NTSTATUS closeStatus;
openFile = CONTAINING_RECORD( openFileEntry, OPEN_FILE, ListEntry );
openFileEntry = openFileEntry->Flink;
//ASSERT( FALSE );
if (openFile->CleanUp == FALSE) {
TYPE_OF_OPEN typeOfOpen;
PVCB vcb;
PFCB fcb;
//PSCB scb;
PCCB ccb;
typeOfOpen = FatDecodeFileObject( openFile->FileObject, &vcb, &fcb, &ccb );
if (typeOfOpen == UserFileOpen) {
PIRP irp;
PFILE_OBJECT fileObject;
PDEVICE_OBJECT deviceObject;
KPROCESSOR_MODE requestorMode;
PIO_STACK_LOCATION irpSp;
BOOLEAN synchronousIo;
PKEVENT eventObject = (PKEVENT) NULL;
ULONG keyValue = 0;
LARGE_INTEGER fileOffset = {0,0};
PULONG majorFunction;
PETHREAD currentThread;
KEVENT event;
NDFS_WINXP_REQUEST_HEADER ndfsWinxpRequestHeader;
PIRP topLevelIrp;
PRIMARY_REQUEST_INFO primaryRequestInfo;
NTSTATUS cleanupStatus;
do {
synchronousIo = openFile->FileObject ? BooleanFlagOn(openFile->FileObject->Flags, FO_SYNCHRONOUS_IO) : TRUE;
ASSERT( synchronousIo == TRUE );
deviceObject = &PrimarySession->VolDo->DeviceObject;
fileObject = openFile->FileObject;
currentThread = PsGetCurrentThread ();
ASSERT( deviceObject->StackSize >= 1 );
irp = IoAllocateIrp( deviceObject->StackSize, TRUE );
requestorMode = KernelMode;
if (!irp) {
ASSERT( NDASFAT_INSUFFICIENT_RESOURCES );
break;
}
irp->Tail.Overlay.OriginalFileObject = fileObject;
irp->Tail.Overlay.Thread = currentThread;
irp->Tail.Overlay.AuxiliaryBuffer = (PVOID) NULL;
irp->RequestorMode = requestorMode;
irp->PendingReturned = FALSE;
irp->Cancel = FALSE;
irp->CancelRoutine = (PDRIVER_CANCEL) NULL;
irp->UserEvent = eventObject;
irp->UserIosb = NULL; //&ioStatusBlock;
irp->Overlay.AsynchronousParameters.UserApcRoutine = NULL; //ApcRoutine;
irp->Overlay.AsynchronousParameters.UserApcContext = NULL; //ApcContext;
KeInitializeEvent( &event, NotificationEvent, FALSE );
IoSetCompletionRoutine( irp,
PrimaryCompletionRoutine,
&event,
TRUE,
TRUE,
TRUE );
IoSetNextIrpStackLocation( irp );
irpSp = IoGetCurrentIrpStackLocation( irp ); // = ¤tIrpSp; // = IoGetNextIrpStackLocation( irp );
majorFunction = (PULONG) (&irpSp->MajorFunction);
*majorFunction = IRP_MJ_CLEANUP;
irpSp->Control = (SL_INVOKE_ON_SUCCESS | SL_INVOKE_ON_ERROR | SL_INVOKE_ON_CANCEL);
irpSp->MinorFunction = IRP_MJ_CLEANUP;
irpSp->FileObject = fileObject;
irpSp->DeviceObject = deviceObject;
irp->AssociatedIrp.SystemBuffer = (PVOID) NULL;
irp->MdlAddress = (PMDL) NULL;
ndfsWinxpRequestHeader.CleanUp.AllocationSize = fcb->Header.AllocationSize.QuadPart;
ndfsWinxpRequestHeader.CleanUp.FileSize = fcb->Header.FileSize.LowPart;
ndfsWinxpRequestHeader.CleanUp.ValidDataLength = fcb->Header.FileSize.LowPart;
ndfsWinxpRequestHeader.CleanUp.VaildDataToDisk = fcb->Header.FileSize.LowPart;
primaryRequestInfo.PrimaryTag = 0xe2027482;
primaryRequestInfo.PrimarySession = PrimarySession;
primaryRequestInfo.NdfsWinxpRequestHeader = &ndfsWinxpRequestHeader;
topLevelIrp = IoGetTopLevelIrp();
ASSERT( topLevelIrp == NULL );
IoSetTopLevelIrp( (PIRP)&primaryRequestInfo );
cleanupStatus = FatFsdCleanup( PrimarySession->VolDo, irp );
if (cleanupStatus == STATUS_PENDING) {
KeWaitForSingleObject( &event,
Executive,
KernelMode,
FALSE,
NULL );
}
IoSetTopLevelIrp( topLevelIrp );
cleanupStatus = irp->IoStatus.Status;
ASSERT( cleanupStatus == STATUS_SUCCESS );
if (irp->MdlAddress != NULL) {
MmUnlockPages( irp->MdlAddress );
IoFreeMdl( irp->MdlAddress );
}
IoFreeIrp( irp );
} while (0);
}
openFile->CleanUp = TRUE;
}
if (openFile->FileObject) {
ObDereferenceObject( openFile->FileObject );
openFile->FileObject = NULL;
}
if (openFile->FileHandle) {
closeStatus = ZwClose( openFile->FileHandle );
openFile->FileHandle = NULL;
ASSERT( closeStatus == STATUS_SUCCESS );
}
if (openFile->EventHandle) {
closeStatus = ZwClose( openFile->EventHandle );
openFile->EventHandle = NULL;
ASSERT(closeStatus == STATUS_SUCCESS);
}
if (Remove) {
RemoveEntryList( &openFile->ListEntry );
InitializeListHead( &openFile->ListEntry );
PrimarySession_FreeOpenFile( PrimarySession, openFile );
}
}
return;
}
NTSTATUS
ReadonlyDismountVolume (
IN PLFS_DEVICE_EXTENSION LfsDeviceExt
)
{
NTSTATUS status;
HANDLE eventHandle;
HANDLE fileHandle = NULL;
ACCESS_MASK desiredAccess;
ULONG attributes;
OBJECT_ATTRIBUTES objectAttributes;
IO_STATUS_BLOCK ioStatusBlock;
LARGE_INTEGER allocationSize;
ULONG fileAttributes;
ULONG shareAccess;
ULONG createDisposition;
ULONG createOptions;
PVOID eaBuffer;
ULONG eaLength;
PIRP topLevelIrp;
READONLY_REDIRECT_REQUEST readonlyRedirectRequest;
ASSERT( KeGetCurrentIrql() == PASSIVE_LEVEL );
SPY_LOG_PRINT( LFS_DEBUG_READONLY_INFO,
("ReadonlyDismountVolume: LfsDeviceExt = %p, LfsDeviceExt->FileSystemType = %d LfsDeviceExt->Vpb->ReferenceCount = %d\n",
LfsDeviceExt, LfsDeviceExt->FileSystemType, LfsDeviceExt->Vpb->ReferenceCount) );
desiredAccess = SYNCHRONIZE | READ_CONTROL | FILE_WRITE_ATTRIBUTES | FILE_READ_ATTRIBUTES;
desiredAccess |= FILE_WRITE_EA | FILE_READ_DATA | FILE_WRITE_DATA | FILE_APPEND_DATA | FILE_READ_EA;
ASSERT( desiredAccess == 0x0012019F );
attributes = OBJ_KERNEL_HANDLE;
attributes |= OBJ_CASE_INSENSITIVE;
InitializeObjectAttributes( &objectAttributes,
&LfsDeviceExt->NetdiskPartitionInformation.VolumeName,
attributes,
NULL,
NULL );
allocationSize.LowPart = 0;
allocationSize.HighPart = 0;
fileAttributes = 0;
shareAccess = FILE_SHARE_READ | FILE_SHARE_WRITE;
createDisposition = FILE_OPEN;
createOptions = FILE_SYNCHRONOUS_IO_NONALERT | FILE_NON_DIRECTORY_FILE;
eaBuffer = NULL;
eaLength = 0;
RtlZeroMemory( &ioStatusBlock, sizeof(ioStatusBlock) );
topLevelIrp = IoGetTopLevelIrp();
ASSERT( topLevelIrp == NULL );
readonlyRedirectRequest.Tag = READONLY_REDIRECT_REQUEST_TAG;
#if DBG
readonlyRedirectRequest.DebugTag = READONLY_REDIRECT_REQUEST_TAG;
#endif
readonlyRedirectRequest.DevExt = CONTAINING_RECORD( LfsDeviceExt, FILESPY_DEVICE_EXTENSION, LfsDeviceExt );
readonlyRedirectRequest.OriginalTopLevelIrp = topLevelIrp;
readonlyRedirectRequest.ReadonlyDismount = 1;
IoSetTopLevelIrp( (PIRP)&readonlyRedirectRequest );
status = ZwCreateFile( &fileHandle,
desiredAccess,
&objectAttributes,
&ioStatusBlock,
&allocationSize,
fileAttributes,
shareAccess,
createDisposition,
createOptions,
eaBuffer,
eaLength );
ASSERT( readonlyRedirectRequest.DebugTag == (READONLY_REDIRECT_REQUEST_TAG - 4) );
IoSetTopLevelIrp( topLevelIrp );
SPY_LOG_PRINT( LFS_DEBUG_READONLY_TRACE,
("ReadonlyDismountVolume: LfsDeviceExt = %p ZwCreateFile fileHandle =%p, status = %X, ioStatusBlock = %X\n",
LfsDeviceExt, fileHandle, status, ioStatusBlock.Information) );
if (status != STATUS_SUCCESS) {
return status;
} else {
ASSERT( ioStatusBlock.Information == FILE_OPENED );
}
do {
status = ZwCreateEvent( &eventHandle,
GENERIC_READ,
NULL,
SynchronizationEvent,
FALSE );
if (status != STATUS_SUCCESS) {
ASSERT( LFS_UNEXPECTED );
break;
}
RtlZeroMemory( &ioStatusBlock, sizeof(ioStatusBlock) );
topLevelIrp = IoGetTopLevelIrp();
ASSERT( topLevelIrp == NULL );
readonlyRedirectRequest.Tag = READONLY_REDIRECT_REQUEST_TAG;
#if DBG
readonlyRedirectRequest.DebugTag = READONLY_REDIRECT_REQUEST_TAG;
#endif
readonlyRedirectRequest.DevExt = CONTAINING_RECORD( LfsDeviceExt, FILESPY_DEVICE_EXTENSION, LfsDeviceExt );
readonlyRedirectRequest.OriginalTopLevelIrp = topLevelIrp;
readonlyRedirectRequest.ReadonlyDismount = 1;
IoSetTopLevelIrp( (PIRP)&readonlyRedirectRequest );
status = ZwFsControlFile( fileHandle,
eventHandle,
NULL,
NULL,
&ioStatusBlock,
FSCTL_LOCK_VOLUME,
NULL,
0,
NULL,
0 );
if (status == STATUS_PENDING) {
status = ZwWaitForSingleObject( eventHandle, TRUE, NULL );
if (status != STATUS_SUCCESS) {
NDAS_ASSERT( FALSE );
} else {
status = ioStatusBlock.Status;
}
}
ASSERT( readonlyRedirectRequest.DebugTag == (READONLY_REDIRECT_REQUEST_TAG - 4) );
IoSetTopLevelIrp( topLevelIrp );
ZwClose( eventHandle );
if (status != STATUS_SUCCESS) {
SPY_LOG_PRINT( LFS_DEBUG_READONLY_INFO,
("ReadonlyDismountVolume: LfsDeviceExt = %p ZwFsControlFile FSCTL_LOCK_VOLUME fileHandle =%p, status = %X, ioStatusBlock = %X\n",
LfsDeviceExt, fileHandle, status, ioStatusBlock.Information) );
#if 0
status = ZwCreateEvent( &eventHandle,
GENERIC_READ,
NULL,
SynchronizationEvent,
FALSE );
if (status != STATUS_SUCCESS) {
ASSERT( LFS_UNEXPECTED );
break;
}
RtlZeroMemory( &ioStatusBlock, sizeof(ioStatusBlock) );
status = ZwFsControlFile( fileHandle,
eventHandle,
NULL,
NULL,
&ioStatusBlock,
FSCTL_DISMOUNT_VOLUME,
NULL,
0,
NULL,
0 );
if (status == STATUS_PENDING) {
status = ZwWaitForSingleObject( eventHandle, TRUE, NULL );
if (status != STATUS_SUCCESS)
NDAS_ASSERT( FALSE );
else
status = ioStatusBlock.Status;
}
ZwClose( eventHandle );
SPY_LOG_PRINT( LFS_DEBUG_READONLY_INFO,
("ReadonlyDismountVolume: LfsDeviceExt = %p ZwFsControlFile FSCTL_DISMOUNT_VOLUME fileHandle =%p, status = %X, ioStatusBlock = %X\n",
LfsDeviceExt, fileHandle, status, ioStatusBlock.Information) );
if (status != STATUS_SUCCESS) {
break;
}
break;
#endif
break;
}
status = ZwCreateEvent( &eventHandle,
GENERIC_READ,
NULL,
SynchronizationEvent,
FALSE );
if (status != STATUS_SUCCESS) {
ASSERT( LFS_UNEXPECTED );
break;
}
RtlZeroMemory( &ioStatusBlock, sizeof(ioStatusBlock) );
readonlyRedirectRequest.Tag = READONLY_REDIRECT_REQUEST_TAG;
#if DBG
readonlyRedirectRequest.DebugTag = READONLY_REDIRECT_REQUEST_TAG;
#endif
readonlyRedirectRequest.DevExt = CONTAINING_RECORD( LfsDeviceExt, FILESPY_DEVICE_EXTENSION, LfsDeviceExt );
readonlyRedirectRequest.OriginalTopLevelIrp = topLevelIrp;
readonlyRedirectRequest.ReadonlyDismount = 1;
IoSetTopLevelIrp( (PIRP)&readonlyRedirectRequest );
status = ZwFsControlFile( fileHandle,
eventHandle,
NULL,
NULL,
&ioStatusBlock,
FSCTL_UNLOCK_VOLUME,
NULL,
0,
NULL,
0 );
if (status == STATUS_PENDING) {
status = ZwWaitForSingleObject( eventHandle, TRUE, NULL );
if (status != STATUS_SUCCESS) {
NDAS_ASSERT( FALSE );
break;
}
status = ioStatusBlock.Status;
}
ASSERT( readonlyRedirectRequest.DebugTag == (READONLY_REDIRECT_REQUEST_TAG - 4) );
IoSetTopLevelIrp( topLevelIrp );
ZwClose( eventHandle );
if (status != STATUS_SUCCESS) {
SPY_LOG_PRINT( LFS_DEBUG_READONLY_TRACE,
("ReadonlyDismountVolume: LfsDeviceExt = %p ZwFsControlFile FSCTL_UNLOCK_VOLUME fileHandle =%p, status = %X, ioStatusBlock = %X\n",
LfsDeviceExt, fileHandle, status, ioStatusBlock.Information) );
break;
}
} while(0);
ZwClose( fileHandle );
SPY_LOG_PRINT( LFS_DEBUG_READONLY_INFO,
("ReadonlyDismountVolume: LfsDeviceExt = %p status = %X\n",
LfsDeviceExt, status) );
if (status != STATUS_SUCCESS)
return status;
#if 0
do {
UNICODE_STRING fileName;
PWCHAR fileNameBuffer;
fileNameBuffer = ExAllocatePool(PagedPool,NDFS_MAX_PATH);
if(GlobalLfs.ShutdownOccured == TRUE)
break;
RtlInitEmptyUnicodeString( &fileName,
fileNameBuffer,
NDFS_MAX_PATH );
RtlCopyUnicodeString( &fileName, &LfsDeviceExt->NetdiskPartitionInformation.VolumeName );
ioStatusBlock.Information = 0;
status = RtlAppendUnicodeToString( &fileName, REMOUNT_VOLUME_FILE_NAME );
if (status != STATUS_SUCCESS) {
ExFreePool( fileNameBuffer );
ASSERT( LFS_UNEXPECTED );
status = STATUS_SUCCESS;
break;
}
desiredAccess = SYNCHRONIZE | READ_CONTROL | FILE_WRITE_ATTRIBUTES | FILE_READ_ATTRIBUTES | FILE_WRITE_EA;
desiredAccess |= FILE_READ_DATA | FILE_WRITE_DATA | FILE_APPEND_DATA | FILE_READ_EA;
ASSERT( desiredAccess == 0x0012019F );
attributes = OBJ_KERNEL_HANDLE;
attributes |= OBJ_CASE_INSENSITIVE;
InitializeObjectAttributes( &objectAttributes,
&fileName,
attributes,
NULL,
NULL );
allocationSize.LowPart = 0;
allocationSize.HighPart = 0;
fileAttributes = 0;
shareAccess = FILE_SHARE_READ | FILE_SHARE_WRITE;
createDisposition = FILE_OPEN;
createOptions = FILE_SYNCHRONOUS_IO_NONALERT | FILE_NON_DIRECTORY_FILE;
eaBuffer = NULL;
eaLength = 0;
status = ZwCreateFile( &fileHandle,
desiredAccess,
&objectAttributes,
&ioStatusBlock,
NULL,
fileAttributes,
shareAccess,
createDisposition,
createOptions,
NULL,
0 );
SPY_LOG_PRINT( LFS_DEBUG_READONLY_TRACE,
("ReadonlyDismountVolume: New Volume Create %p %wZ, status = %x, ioStatusBlock.Information = %d\n",
LfsDeviceExt, &LfsDeviceExt->NetdiskPartitionInformation.VolumeName, status, ioStatusBlock.Information) );
if (status == STATUS_SUCCESS) {
ASSERT( ioStatusBlock.Information == FILE_OPENED );
ZwClose( fileHandle );
} else {
NDAS_ASSERT( FALSE );
}
status = STATUS_SUCCESS;
ExFreePool( fileNameBuffer );
} while(0);
#endif
return status;
}
PFFS_IRP_CONTEXT
FFSAllocateIrpContext(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
{
PIO_STACK_LOCATION IoStackLocation;
PFFS_IRP_CONTEXT IrpContext;
ASSERT(DeviceObject != NULL);
ASSERT(Irp != NULL);
IoStackLocation = IoGetCurrentIrpStackLocation(Irp);
ExAcquireResourceExclusiveLite(
&FFSGlobal->LAResource,
TRUE);
IrpContext = (PFFS_IRP_CONTEXT)(ExAllocateFromNPagedLookasideList(&(FFSGlobal->FFSIrpContextLookasideList)));
ExReleaseResourceForThreadLite(
&FFSGlobal->LAResource,
ExGetCurrentResourceThread());
if (IrpContext == NULL)
{
IrpContext = ExAllocatePool(NonPagedPool, sizeof(FFS_IRP_CONTEXT));
//
// Zero out the irp context and indicate that it is from pool and
// not region allocated
//
RtlZeroMemory(IrpContext, sizeof(FFS_IRP_CONTEXT));
SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_FROM_POOL);
}
else
{
//
// Zero out the irp context and indicate that it is from zone and
// not pool allocated
//
RtlZeroMemory(IrpContext, sizeof(FFS_IRP_CONTEXT));
}
if (!IrpContext)
{
return NULL;
}
IrpContext->Identifier.Type = FFSICX;
IrpContext->Identifier.Size = sizeof(FFS_IRP_CONTEXT);
IrpContext->Irp = Irp;
IrpContext->MajorFunction = IoStackLocation->MajorFunction;
IrpContext->MinorFunction = IoStackLocation->MinorFunction;
IrpContext->DeviceObject = DeviceObject;
IrpContext->FileObject = IoStackLocation->FileObject;
if (IrpContext->FileObject != NULL)
{
IrpContext->RealDevice = IrpContext->FileObject->DeviceObject;
}
else if (IrpContext->MajorFunction == IRP_MJ_FILE_SYSTEM_CONTROL)
{
if (IoStackLocation->Parameters.MountVolume.Vpb)
{
IrpContext->RealDevice =
IoStackLocation->Parameters.MountVolume.Vpb->RealDevice;
}
}
if (IrpContext->MajorFunction == IRP_MJ_FILE_SYSTEM_CONTROL ||
IrpContext->MajorFunction == IRP_MJ_DEVICE_CONTROL ||
IrpContext->MajorFunction == IRP_MJ_SHUTDOWN)
{
IrpContext->IsSynchronous = TRUE;
}
else if (IrpContext->MajorFunction == IRP_MJ_CLEANUP ||
IrpContext->MajorFunction == IRP_MJ_CLOSE)
{
IrpContext->IsSynchronous = FALSE;
}
#if (_WIN32_WINNT >= 0x0500)
else if (IrpContext->MajorFunction == IRP_MJ_PNP)
{
if (IoGetCurrentIrpStackLocation(Irp)->FileObject == NULL)
{
IrpContext->IsSynchronous = TRUE;
}
else
{
IrpContext->IsSynchronous = IoIsOperationSynchronous(Irp);
}
}
#endif //(_WIN32_WINNT >= 0x0500)
else
{
IrpContext->IsSynchronous = IoIsOperationSynchronous(Irp);
}
#if 0
//
// Temporary workaround for a bug in close that makes it reference a
// fileobject when it is no longer valid.
//
if (IrpContext->MajorFunction == IRP_MJ_CLOSE)
{
IrpContext->IsSynchronous = TRUE;
}
#endif
IrpContext->IsTopLevel = (IoGetTopLevelIrp() == Irp);
IrpContext->ExceptionInProgress = FALSE;
return IrpContext;
}
NTSTATUS
FatProcessException (
IN PIRP_CONTEXT IrpContext,
IN PIRP Irp,
IN NTSTATUS ExceptionCode
)
/*++
Routine Description:
This routine process an exception. It either completes the request
with the saved exception status or it sends it off to IoRaiseHardError()
Arguments:
Irp - Supplies the Irp being processed
ExceptionCode - Supplies the normalized exception status being handled
Return Value:
NTSTATUS - Returns the results of either posting the Irp or the
saved completion status.
--*/
{
PVCB Vcb;
PIO_STACK_LOCATION IrpSp;
FAT_VOLUME_STATE TransitionState = VolumeDirty;
ULONG SavedFlags;
DebugTrace(0, Dbg, "FatProcessException\n", 0);
//
// If there is not an irp context, we must have had insufficient resources.
//
if ( !ARGUMENT_PRESENT( IrpContext ) ) {
FatCompleteRequest( FatNull, Irp, ExceptionCode );
return ExceptionCode;
}
//
// Get the real exception status from IrpContext->ExceptionStatus, and
// reset it.
//
ExceptionCode = IrpContext->ExceptionStatus;
FatResetExceptionState( IrpContext );
//
// If this is an Mdl write request, then take care of the Mdl
// here so that things get cleaned up properly. Cc now leaves
// the MDL in place so a filesystem can retry after clearing an
// internal condition (FAT does not).
//
#if __NDAS_FAT_WIN2K_SUPPORT__
if (NdFatCcMdlWriteAbort &&
(IrpContext->MajorFunction == IRP_MJ_WRITE) &&
(FlagOn( IrpContext->MinorFunction, IRP_MN_COMPLETE_MDL ) == IRP_MN_COMPLETE_MDL) &&
(Irp->MdlAddress != NULL)) {
PIO_STACK_LOCATION LocalIrpSp = IoGetCurrentIrpStackLocation(Irp);
NdFatCcMdlWriteAbort( LocalIrpSp->FileObject, Irp->MdlAddress );
Irp->MdlAddress = NULL;
}
#else
if ((IrpContext->MajorFunction == IRP_MJ_WRITE) &&
(FlagOn( IrpContext->MinorFunction, IRP_MN_COMPLETE_MDL ) == IRP_MN_COMPLETE_MDL) &&
(Irp->MdlAddress != NULL)) {
PIO_STACK_LOCATION LocalIrpSp = IoGetCurrentIrpStackLocation(Irp);
CcMdlWriteAbort( LocalIrpSp->FileObject, Irp->MdlAddress );
Irp->MdlAddress = NULL;
}
#endif
//
// If we are going to post the request, we may have to lock down the
// user's buffer, so do it here in a try except so that we failed the
// request if the LockPages fails.
//
// Also unpin any repinned Bcbs, protected by the try {} except {} filter.
//
try {
SavedFlags = IrpContext->Flags;
//
// Make sure we don't try to write through Bcbs
//
SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_DISABLE_WRITE_THROUGH);
FatUnpinRepinnedBcbs( IrpContext );
IrpContext->Flags = SavedFlags;
//
// If we will have to post the request, do it here. Note
// that the last thing FatPrePostIrp() does is mark the Irp pending,
// so it is critical that we actually return PENDING. Nothing
// from this point to return can fail, so we are OK.
//
// We cannot do a verify operations at APC level because we
// have to wait for Io operations to complete.
//
#if __NDAS_FAT__
if (!FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_RECURSIVE_CALL) &&
(((ExceptionCode == STATUS_VERIFY_REQUIRED) && (KeGetCurrentIrql() >= APC_LEVEL)) ||
(!FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT) && ExceptionCode == STATUS_CANT_WAIT))) {
ExceptionCode = FatFsdPostRequest( IrpContext, Irp );
}
#else
if (!FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_RECURSIVE_CALL) &&
(((ExceptionCode == STATUS_VERIFY_REQUIRED) && (KeGetCurrentIrql() >= APC_LEVEL)) ||
(ExceptionCode == STATUS_CANT_WAIT))) {
ExceptionCode = FatFsdPostRequest( IrpContext, Irp );
}
#endif
} except( FatExceptionFilter( IrpContext, GetExceptionInformation() ) ) {
ExceptionCode = IrpContext->ExceptionStatus;
IrpContext->ExceptionStatus = 0;
IrpContext->Flags = SavedFlags;
}
//
// If we posted the request, just return here.
//
if (ExceptionCode == STATUS_PENDING) {
return ExceptionCode;
}
Irp->IoStatus.Status = ExceptionCode;
//
// If this request is not a "top-level" irp, just complete it.
//
if (FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_RECURSIVE_CALL)) {
//
// If there is a cache operation above us, commute verify
// to a lock conflict. This will cause retries so that
// we have a chance of getting through without needing
// to return an unaesthetic error for the operation.
//
if (IoGetTopLevelIrp() == (PIRP)FSRTL_CACHE_TOP_LEVEL_IRP &&
ExceptionCode == STATUS_VERIFY_REQUIRED) {
ExceptionCode = STATUS_FILE_LOCK_CONFLICT;
}
FatCompleteRequest( IrpContext, Irp, ExceptionCode );
return ExceptionCode;
}
if (IoIsErrorUserInduced(ExceptionCode)) {
//
// Check for the various error conditions that can be caused by,
// and possibly resolved by the user.
//
if (ExceptionCode == STATUS_VERIFY_REQUIRED) {
PDEVICE_OBJECT Device;
DebugTrace(0, Dbg, "Perform Verify Operation\n", 0);
//
// Now we are at the top level file system entry point.
//
// Grab the device to verify from the thread local storage
// and stick it in the information field for transportation
// to the fsp. We also clear the field at this time.
//
Device = IoGetDeviceToVerify( Irp->Tail.Overlay.Thread );
IoSetDeviceToVerify( Irp->Tail.Overlay.Thread, NULL );
if ( Device == NULL ) {
Device = IoGetDeviceToVerify( PsGetCurrentThread() );
IoSetDeviceToVerify( PsGetCurrentThread(), NULL );
ASSERT( Device != NULL );
}
//
// Let's not BugCheck just because the driver messed up.
//
if (Device == NULL) {
ExceptionCode = STATUS_DRIVER_INTERNAL_ERROR;
FatCompleteRequest( IrpContext, Irp, ExceptionCode );
return ExceptionCode;
}
//
// FatPerformVerify() will do the right thing with the Irp.
return FatPerformVerify( IrpContext, Irp, Device );
}
//
// The other user induced conditions generate an error unless
// they have been disabled for this request.
//
if (FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_DISABLE_POPUPS)) {
FatCompleteRequest( IrpContext, Irp, ExceptionCode );
return ExceptionCode;
} else {
//
// Generate a pop-up
//
PDEVICE_OBJECT RealDevice;
PVPB Vpb;
PETHREAD Thread;
if (IoGetCurrentIrpStackLocation(Irp)->FileObject != NULL) {
Vpb = IoGetCurrentIrpStackLocation(Irp)->FileObject->Vpb;
} else {
Vpb = NULL;
}
//
// The device to verify is either in my thread local storage
// or that of the thread that owns the Irp.
//
Thread = Irp->Tail.Overlay.Thread;
RealDevice = IoGetDeviceToVerify( Thread );
if ( RealDevice == NULL ) {
Thread = PsGetCurrentThread();
RealDevice = IoGetDeviceToVerify( Thread );
ASSERT( RealDevice != NULL );
}
//
// Let's not BugCheck just because the driver messed up.
//
if (RealDevice == NULL) {
FatCompleteRequest( IrpContext, Irp, ExceptionCode );
return ExceptionCode;
}
//
// This routine actually causes the pop-up. It usually
// does this by queuing an APC to the callers thread,
// but in some cases it will complete the request immediately,
// so it is very important to IoMarkIrpPending() first.
//
IoMarkIrpPending( Irp );
IoRaiseHardError( Irp, Vpb, RealDevice );
//
// We will be handing control back to the caller here, so
// reset the saved device object.
//
IoSetDeviceToVerify( Thread, NULL );
//
// The Irp will be completed by Io or resubmitted. In either
// case we must clean up the IrpContext here.
//
FatDeleteIrpContext( IrpContext );
return STATUS_PENDING;
}
}
//
// This is just a run of the mill error. If is a STATUS that we
// raised ourselves, and the information would be use for the
// user, raise an informational pop-up.
//
IrpSp = IoGetCurrentIrpStackLocation( Irp );
Vcb = IrpContext->Vcb;
//
// Now, if the Vcb is unknown to us this means that the error was raised
// in the process of a mount and before we even had a chance to build
// a full Vcb - and was really handled there.
//
if (Vcb != NULL) {
if ( !FatDeviceIsFatFsdo( IrpSp->DeviceObject) &&
!NT_SUCCESS(ExceptionCode) &&
!FsRtlIsTotalDeviceFailure(ExceptionCode) ) {
TransitionState = VolumeDirtyWithSurfaceTest;
}
//
// If this was a STATUS_FILE_CORRUPT or similar error indicating some
// nastiness out on the media, then mark the volume permanently dirty.
//
if (!FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_DISABLE_POPUPS) &&
( TransitionState == VolumeDirtyWithSurfaceTest ||
(ExceptionCode == STATUS_FILE_CORRUPT_ERROR) ||
(ExceptionCode == STATUS_DISK_CORRUPT_ERROR) ||
(ExceptionCode == STATUS_EA_CORRUPT_ERROR) ||
(ExceptionCode == STATUS_INVALID_EA_NAME) ||
(ExceptionCode == STATUS_EA_LIST_INCONSISTENT) ||
(ExceptionCode == STATUS_NO_EAS_ON_FILE) )) {
ASSERT( NodeType(Vcb) == FAT_NTC_VCB );
SetFlag( Vcb->VcbState, VCB_STATE_FLAG_MOUNTED_DIRTY );
//
// Do the "dirty" work, ignoring any error.
//
try {
FatMarkVolume( IrpContext, Vcb, TransitionState );
} except( FatExceptionFilter( IrpContext, GetExceptionInformation() ) ) {
NOTHING;
}
}
}
NTSTATUS
FatFsdCleanup (
IN PVOLUME_DEVICE_OBJECT VolumeDeviceObject,
IN PIRP Irp
)
/*++
Routine Description:
This routine implements the FSD part of closing down a handle to a
file object.
Arguments:
VolumeDeviceObject - Supplies the volume device object where the
file being Cleanup exists
Irp - Supplies the Irp being processed
Return Value:
NTSTATUS - The FSD status for the IRP
--*/
{
NTSTATUS Status;
PIRP_CONTEXT IrpContext = NULL;
BOOLEAN TopLevel;
PAGED_CODE();
#if __NDAS_FAT__
if ((PVOID)FatControlDeviceObject == VolumeDeviceObject) {
Status = Irp->IoStatus.Status = STATUS_SUCCESS;
Irp->IoStatus.Information = FILE_OPENED;
IoCompleteRequest( Irp, IO_DISK_INCREMENT );
return Status;
}
#endif
//
// If we were called with our file system device object instead of a
// volume device object, just complete this request with STATUS_SUCCESS
//
if ( FatDeviceIsFatFsdo( VolumeDeviceObject)) {
Irp->IoStatus.Status = STATUS_SUCCESS;
Irp->IoStatus.Information = FILE_OPENED;
IoCompleteRequest( Irp, IO_DISK_INCREMENT );
return STATUS_SUCCESS;
}
DebugTrace(+1, Dbg, "FatFsdCleanup\n", 0);
//
// Call the common Cleanup routine, with blocking allowed.
//
FsRtlEnterFileSystem();
TopLevel = FatIsIrpTopLevel( Irp );
#if (__NDAS_FAT_PRIMARY__ || __NDAS_FAT_SECONDARY__)
do {
try {
if (IrpContext == NULL) {
IrpContext = FatCreateIrpContext( Irp, TRUE );
IrpContext->TopLevel = TopLevel;
#if __NDAS_FAT_PRIMARY__
{
ULONG_PTR stackBottom;
ULONG_PTR stackTop;
BOOLEAN validPrimaryRequest = FALSE;
PPRIMARY_REQUEST_INFO primaryRequestInfo;
PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation( Irp );
primaryRequestInfo = (PPRIMARY_REQUEST_INFO)IoGetTopLevelIrp();
IoGetStackLimits( &stackTop, &stackBottom );
if ( (ULONG_PTR)primaryRequestInfo <= stackBottom - sizeof(PRIMARY_REQUEST_INFO) &&
(ULONG_PTR) primaryRequestInfo >= stackTop &&
(!FlagOn( (ULONG_PTR) primaryRequestInfo, 0x3 )) &&
primaryRequestInfo->PrimaryTag == 0xe2027482) {
validPrimaryRequest = TRUE;
}
if (validPrimaryRequest) {
//ASSERT( FatIsTopLevelRequest(IrpContext) );
IoSetTopLevelIrp( NULL );
TopLevel = FatIsIrpTopLevel( Irp );
ClearFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_RECURSIVE_CALL );
if (IsListEmpty(&VolumeDeviceObject->PrimarySessionQueue)) {
NDAS_ASSERT( FALSE );
}
IrpContext->PrimaryRequestInfo = *primaryRequestInfo;
DebugTrace2( 0, Dbg, ("primaryRequestInfo = %p\n", primaryRequestInfo) );
}
}
#endif
}
#if __NDAS_FAT_SECONDARY__
if (IS_SECONDARY_FILEOBJECT(IoGetCurrentIrpStackLocation(Irp)->FileObject)) {
BOOLEAN secondaryResourceAcquired = FALSE;
BOOLEAN secondaryRecoveryResourceAcquired = FALSE;
ASSERT( FatIsTopLevelRequest(IrpContext) );
SetFlag( IrpContext->NdasFatFlags, NDAS_FAT_IRP_CONTEXT_FLAG_SECONDARY_CONTEXT );
Status = STATUS_SUCCESS;
while (TRUE) {
ASSERT( secondaryRecoveryResourceAcquired == FALSE );
ASSERT( secondaryResourceAcquired == FALSE );
if (FlagOn(VolumeDeviceObject->Secondary->Flags, SECONDARY_FLAG_RECONNECTING)) {
if (!FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT)) {
Status = FatFsdPostRequest( IrpContext, Irp );
break;
}
}
if (FlagOn(VolumeDeviceObject->Secondary->Thread.Flags, SECONDARY_THREAD_FLAG_REMOTE_DISCONNECTED)) {
if (!FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT)) {
Status = FatFsdPostRequest( IrpContext, Irp );
break;
}
secondaryRecoveryResourceAcquired
= SecondaryAcquireResourceExclusiveLite( IrpContext,
&VolumeDeviceObject->RecoveryResource,
BooleanFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT) );
if (!FlagOn(VolumeDeviceObject->Secondary->Thread.Flags, SECONDARY_THREAD_FLAG_REMOTE_DISCONNECTED) ) {
SecondaryReleaseResourceLite( IrpContext, &VolumeDeviceObject->RecoveryResource );
secondaryRecoveryResourceAcquired = FALSE;
continue;
}
secondaryResourceAcquired
= SecondaryAcquireResourceExclusiveLite( IrpContext,
&VolumeDeviceObject->Resource,
BooleanFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT) );
try {
SecondaryRecoverySessionStart( VolumeDeviceObject->Secondary, IrpContext );
} finally {
SecondaryReleaseResourceLite( IrpContext, &VolumeDeviceObject->Resource );
secondaryResourceAcquired = FALSE;
SecondaryReleaseResourceLite( IrpContext, &VolumeDeviceObject->RecoveryResource );
secondaryRecoveryResourceAcquired = FALSE;
}
continue;
}
secondaryResourceAcquired
= SecondaryAcquireResourceSharedLite( IrpContext,
&VolumeDeviceObject->Resource,
BooleanFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT) );
if (secondaryResourceAcquired == FALSE) {
ASSERT( FlagOn(VolumeDeviceObject->Secondary->Thread.Flags, SECONDARY_THREAD_FLAG_REMOTE_DISCONNECTED) ||
FlagOn(VolumeDeviceObject->Secondary->Flags, SECONDARY_FLAG_RECONNECTING) );
continue;
}
break;
}
if (Status == STATUS_SUCCESS) {
try {
Status = FatCommonCleanup( IrpContext, Irp );
} finally {
ASSERT( ExIsResourceAcquiredSharedLite(&VolumeDeviceObject->Resource) );
SecondaryReleaseResourceLite( NULL, &VolumeDeviceObject->Resource );
}
}
} else
Status = FatCommonCleanup( IrpContext, Irp );
#else
Status = FatCommonCleanup( IrpContext, Irp );
#endif
} except(FatExceptionFilter( IrpContext, GetExceptionInformation() )) {
//
// We had some trouble trying to perform the requested
// operation, so we'll abort the I/O request with
// the error status that we get back from the
// execption code
//
Status = FatProcessException( IrpContext, Irp, GetExceptionCode() );
}
} while (Status == STATUS_CANT_WAIT);
NTSTATUS
SecondaryRecoverySession (
IN PSECONDARY Secondary
)
{
NTSTATUS status;
LONG slotIndex;
LARGE_INTEGER timeOut;
OBJECT_ATTRIBUTES objectAttributes;
ULONG reconnectionTry;
PLIST_ENTRY ccblistEntry;
BOOLEAN isLocalAddress;
SetFlag( Secondary->Flags, SECONDARY_FLAG_RECONNECTING );
ASSERT( FlagOn(Secondary->Thread.Flags, SECONDARY_THREAD_FLAG_REMOTE_DISCONNECTED) );
ASSERT( Secondary->ThreadHandle );
ASSERT( IsListEmpty(&Secondary->RequestQueue) );
for (slotIndex=0; slotIndex < Secondary->Thread.SessionContext.SessionSlotCount; slotIndex++) {
ASSERT( Secondary->Thread.SessionSlot[slotIndex] == NULL );
}
if (Secondary->ThreadHandle) {
ASSERT( Secondary->ThreadObject );
timeOut.QuadPart = -NDASNTFS_TIME_OUT;
status = KeWaitForSingleObject( Secondary->ThreadObject,
Executive,
KernelMode,
FALSE,
&timeOut );
if(status != STATUS_SUCCESS) {
ASSERT( NDASNTFS_BUG );
return status;
}
DebugTrace( 0, Dbg2, ("Secondary_Stop: thread stoped\n") );
ObDereferenceObject( Secondary->ThreadObject );
Secondary->ThreadHandle = 0;
Secondary->ThreadObject = 0;
RtlZeroMemory( &Secondary->Thread.Flags, sizeof(SECONDARY) - FIELD_OFFSET(SECONDARY, Thread.Flags) );
}
for (status = STATUS_UNSUCCESSFUL, reconnectionTry = 0; reconnectionTry < MAX_RECONNECTION_TRY; reconnectionTry++) {
if (FlagOn(Secondary->VolDo->Vcb.VcbState, VCB_STATE_TARGET_DEVICE_STOPPED)) {
ClearFlag( Secondary->Flags, SECONDARY_FLAG_RECONNECTING );
return STATUS_UNSUCCESSFUL;
}
if (FlagOn(Secondary->VolDo->Vcb.VcbState, VCB_STATE_FLAG_SHUTDOWN)) {
ClearFlag( Secondary->Flags, SECONDARY_FLAG_RECONNECTING );
return STATUS_UNSUCCESSFUL;
}
if (FlagOn(Secondary->VolDo->NdasNtfsFlags, NDAS_NTFS_DEVICE_FLAG_SHUTDOWN)) {
//DebugTrace( 0, Dbg2, ("SecondaryToPrimary NDAS_NTFS_DEVICE_FLAG_SHUTDOWN\n") );
//DbgPrint( "SecondaryToPrimary NDAS_NTFS_DEVICE_FLAG_SHUTDOWN\n" );
ClearFlag( Secondary->Flags, SECONDARY_FLAG_RECONNECTING );
return STATUS_UNSUCCESSFUL;
}
if (Secondary->VolDo->NetdiskEnableMode == NETDISK_SECONDARY2PRIMARY) {
status = STATUS_SUCCESS;
} else {
status = ((PVOLUME_DEVICE_OBJECT) NdasNtfsFileSystemDeviceObject)->
NdfsCallback.SecondaryToPrimary( Secondary->VolDo->Vcb.Vpb->RealDevice, TRUE );
if (status == STATUS_NO_SUCH_DEVICE) {
NDAS_ASSERT( FlagOn(Secondary->VolDo->Vcb.VcbState, VCB_STATE_TARGET_DEVICE_STOPPED) );
ClearFlag( Secondary->Flags, SECONDARY_FLAG_RECONNECTING );
return STATUS_UNSUCCESSFUL;
}
}
//NtfsDebugTraceLevel = 0;
DebugTrace( 0, Dbg2, ("SecondaryToPrimary status = %x\n", status) );
if (status == STATUS_SUCCESS) {
PVCB vcb = &Secondary->VolDo->Vcb;
TOP_LEVEL_CONTEXT topLevelContext;
PTOP_LEVEL_CONTEXT threadTopLevelContext;
PIRP_CONTEXT tempIrpContext = NULL;
SetFlag( Secondary->Flags, SECONDARY_FLAG_CLEANUP_VOLUME );
ASSERT( !ExIsResourceAcquiredExclusiveLite(&NtfsData.Resource) );
ASSERT( !ExIsResourceAcquiredSharedLite(&NtfsData.Resource) );
ASSERT( !ExIsResourceAcquiredExclusiveLite(&vcb->Resource) );
ASSERT( !ExIsResourceAcquiredSharedLite(&vcb->Resource) );
DebugTrace( 0, Dbg2, ("Vcb->State = %X\n", vcb->VcbState) );
DebugTrace( 0, Dbg2, ("Vcb->Vpb->ReferenceCount = %X\n", vcb->Vpb->ReferenceCount) );
DebugTrace( 0, Dbg2, ("Vcb->TargetDeviceObject->ReferenceCount = %X\n", vcb->TargetDeviceObject->ReferenceCount) );
tempIrpContext = NULL;
threadTopLevelContext = NtfsInitializeTopLevelIrp( &topLevelContext, TRUE, FALSE );
ASSERT( threadTopLevelContext == &topLevelContext );
NtfsInitializeIrpContext( NULL, TRUE, &tempIrpContext );
NtfsUpdateIrpContextWithTopLevel( tempIrpContext, threadTopLevelContext );
SetFlag( tempIrpContext->NdasNtfsFlags, NDAS_NTFS_IRP_CONTEXT_FLAG_SECONDARY_CONTEXT );
ASSERT( FlagOn(tempIrpContext->State, IRP_CONTEXT_STATE_OWNS_TOP_LEVEL) );
tempIrpContext->MajorFunction = IRP_MJ_FILE_SYSTEM_CONTROL;
tempIrpContext->MinorFunction = IRP_MN_MOUNT_VOLUME;
tempIrpContext->Vcb = vcb;
try {
status = CleanUpVcb( tempIrpContext, vcb );
} finally {
NtfsCompleteRequest( tempIrpContext, NULL, 0 );
ASSERT( IoGetTopLevelIrp() != (PIRP) &topLevelContext );
tempIrpContext = NULL;
}
ASSERT( status == STATUS_SUCCESS );
ASSERT( FlagOn(vcb->VcbState, VCB_STATE_MOUNT_COMPLETED) );
ASSERT( !ExIsResourceAcquiredExclusiveLite(&NtfsData.Resource) );
ASSERT( !ExIsResourceAcquiredSharedLite(&NtfsData.Resource) );
ASSERT( !ExIsResourceAcquiredExclusiveLite(&vcb->Resource) );
ASSERT( !ExIsResourceAcquiredSharedLite(&vcb->Resource) );
ClearFlag( Secondary->Flags, SECONDARY_FLAG_CLEANUP_VOLUME );
DebugTrace( 0, Dbg2, ("Vcb->TargetDeviceObject->ReferenceCount = %X\n", vcb->TargetDeviceObject->ReferenceCount) );
DebugTrace( 0, Dbg2, ("Vcb->Vpb->ReferenceCount = %X\n", vcb->Vpb->ReferenceCount) );
DebugTrace( 0, Dbg2, ("Vcb->CloseCount = %d\n", vcb->CloseCount) );
Secondary->VolDo->NetdiskEnableMode = NETDISK_SECONDARY2PRIMARY;
tempIrpContext = NULL;
threadTopLevelContext = NtfsInitializeTopLevelIrp( &topLevelContext, TRUE, FALSE );
ASSERT( threadTopLevelContext == &topLevelContext );
NtfsInitializeIrpContext( NULL, TRUE, &tempIrpContext );
NtfsUpdateIrpContextWithTopLevel( tempIrpContext, threadTopLevelContext );
ASSERT( FlagOn(tempIrpContext->State, IRP_CONTEXT_STATE_OWNS_TOP_LEVEL) );
//tempIrpContext->TopLevelIrpContext->MajorFunction = IRP_MJ_FILE_SYSTEM_CONTROL;
//tempIrpContext->TopLevelIrpContext->MinorFunction = IRP_MN_MOUNT_VOLUME;
tempIrpContext->MajorFunction = IRP_MJ_FILE_SYSTEM_CONTROL;
tempIrpContext->MinorFunction = IRP_MN_MOUNT_VOLUME;
tempIrpContext->Vcb = vcb;
try {
status = NdasNtfsMountVolume( tempIrpContext, vcb );
} finally {
NtfsCompleteRequest( tempIrpContext, NULL, 0 );
ASSERT( IoGetTopLevelIrp() != (PIRP) &topLevelContext );
tempIrpContext = NULL;
}
NDAS_ASSERT( status == STATUS_SUCCESS );
ASSERT( !ExIsResourceAcquiredExclusiveLite(&NtfsData.Resource) );
ASSERT( !ExIsResourceAcquiredSharedLite(&NtfsData.Resource) );
ASSERT( !ExIsResourceAcquiredExclusiveLite(&vcb->Resource) );
ASSERT( !ExIsResourceAcquiredSharedLite(&vcb->Resource) );
DebugTrace( 0, Dbg2, ("Vcb->TargetDeviceObject->ReferenceCount = %X\n", vcb->TargetDeviceObject->ReferenceCount) );
DebugTrace( 0, Dbg2, ("Vcb->Vpb->ReferenceCount = %X\n", vcb->Vpb->ReferenceCount) );
DebugTrace( 0, Dbg2, ("Vcb->CloseCount = %d\n", vcb->CloseCount) );
if (vcb->MftScb) {
ASSERT( !ExIsResourceAcquiredExclusiveLite(vcb->MftScb->Header.Resource) );
ASSERT( !ExIsResourceAcquiredSharedLite(vcb->MftScb->Header.Resource) );
}
if (vcb->Mft2Scb) {
ASSERT( !ExIsResourceAcquiredExclusiveLite(vcb->Mft2Scb->Header.Resource) );
ASSERT( !ExIsResourceAcquiredSharedLite(vcb->Mft2Scb->Header.Resource) );
}
if (vcb->LogFileScb) {
ASSERT( !ExIsResourceAcquiredExclusiveLite(vcb->LogFileScb->Header.Resource) );
ASSERT( !ExIsResourceAcquiredSharedLite(vcb->LogFileScb->Header.Resource) );
}
if (vcb->VolumeDasdScb) {
ASSERT( !ExIsResourceAcquiredExclusiveLite(vcb->VolumeDasdScb->Header.Resource) );
ASSERT( !ExIsResourceAcquiredSharedLite(vcb->VolumeDasdScb->Header.Resource) );
}
if (vcb->AttributeDefTableScb) {
ASSERT( !ExIsResourceAcquiredExclusiveLite(vcb->AttributeDefTableScb->Header.Resource) );
ASSERT( !ExIsResourceAcquiredSharedLite(vcb->AttributeDefTableScb->Header.Resource) );
}
if (vcb->UpcaseTableScb) {
ASSERT( !ExIsResourceAcquiredExclusiveLite(vcb->UpcaseTableScb->Header.Resource) );
ASSERT( !ExIsResourceAcquiredSharedLite(vcb->UpcaseTableScb->Header.Resource) );
}
if (vcb->RootIndexScb) {
ASSERT( !ExIsResourceAcquiredExclusiveLite(vcb->RootIndexScb->Header.Resource) );
ASSERT( !ExIsResourceAcquiredSharedLite(vcb->RootIndexScb->Header.Resource) );
}
if (vcb->BitmapScb) {
ASSERT( !ExIsResourceAcquiredExclusiveLite(vcb->BitmapScb->Header.Resource) );
ASSERT( !ExIsResourceAcquiredSharedLite(vcb->BitmapScb->Header.Resource) );
}
if (vcb->BadClusterFileScb) {
ASSERT( !ExIsResourceAcquiredExclusiveLite(vcb->BadClusterFileScb->Header.Resource) );
ASSERT( !ExIsResourceAcquiredSharedLite(vcb->BadClusterFileScb->Header.Resource) );
}
if (vcb->MftBitmapScb) {
ASSERT( !ExIsResourceAcquiredExclusiveLite(vcb->MftBitmapScb->Header.Resource) );
ASSERT( !ExIsResourceAcquiredSharedLite(vcb->MftBitmapScb->Header.Resource) );
}
if (vcb->SecurityDescriptorStream) {
ASSERT( !ExIsResourceAcquiredExclusiveLite(vcb->SecurityDescriptorStream->Header.Resource) );
ASSERT( !ExIsResourceAcquiredSharedLite(vcb->SecurityDescriptorStream->Header.Resource) );
}
if (vcb->UsnJournal) {
ASSERT( !ExIsResourceAcquiredExclusiveLite(vcb->UsnJournal->Header.Resource) );
ASSERT( !ExIsResourceAcquiredSharedLite(vcb->UsnJournal->Header.Resource) );
}
if (vcb->ExtendDirectory) {
ASSERT( !ExIsResourceAcquiredExclusiveLite(vcb->ExtendDirectory->Header.Resource) );
ASSERT( !ExIsResourceAcquiredSharedLite(vcb->ExtendDirectory->Header.Resource) );
}
if (vcb->SecurityDescriptorHashIndex) {
ASSERT( !ExIsResourceAcquiredExclusiveLite(vcb->SecurityDescriptorHashIndex->Header.Resource) );
ASSERT( !ExIsResourceAcquiredSharedLite(vcb->SecurityDescriptorHashIndex->Header.Resource) );
}
if (vcb->SecurityIdIndex) {
ASSERT( !ExIsResourceAcquiredExclusiveLite(vcb->SecurityIdIndex->Header.Resource) );
ASSERT( !ExIsResourceAcquiredSharedLite(vcb->SecurityIdIndex->Header.Resource) );
}
}
Secondary->NumberOfPrimaryAddress = 0;
status = ((PVOLUME_DEVICE_OBJECT) NdasNtfsFileSystemDeviceObject)->
NdfsCallback.QueryPrimaryAddress( &Secondary->VolDo->NetdiskPartitionInformation,
Secondary->PrimaryAddressList,
&Secondary->NumberOfPrimaryAddress,
&isLocalAddress );
DebugTrace2( 0, Dbg2, ("RecoverySession: QueryPrimaryAddress status = %X\n", status) );
if (status == STATUS_SUCCESS && !(Secondary->VolDo->NetdiskEnableMode == NETDISK_SECONDARY && isLocalAddress)) {
LONG i;
NDAS_ASSERT( Secondary->NumberOfPrimaryAddress );
for (i = 0; i < Secondary->NumberOfPrimaryAddress; i++) {
DebugTrace2( 0, Dbg,
("RecoverySession: Secondary = %p Found PrimaryAddress[%d] :%02x:%02x:%02x:%02x:%02x:%02x/%d\n",
Secondary, i,
Secondary->PrimaryAddressList[i].Node[0], Secondary->PrimaryAddressList[i].Node[1],
Secondary->PrimaryAddressList[i].Node[2], Secondary->PrimaryAddressList[i].Node[3],
Secondary->PrimaryAddressList[i].Node[4], Secondary->PrimaryAddressList[i].Node[5],
NTOHS(Secondary->PrimaryAddressList[i].Port)) );
}
} else {
continue;
}
KeInitializeEvent( &Secondary->ReadyEvent, NotificationEvent, FALSE );
KeInitializeEvent( &Secondary->RequestEvent, NotificationEvent, FALSE );
InitializeObjectAttributes(&objectAttributes, NULL, OBJ_KERNEL_HANDLE, NULL, NULL);
status = PsCreateSystemThread( &Secondary->ThreadHandle,
THREAD_ALL_ACCESS,
&objectAttributes,
NULL,
NULL,
SecondaryThreadProc,
Secondary );
if (!NT_SUCCESS(status)) {
ASSERT( NDASNTFS_UNEXPECTED );
break;
}
status = ObReferenceObjectByHandle( Secondary->ThreadHandle,
FILE_READ_DATA,
NULL,
KernelMode,
&Secondary->ThreadObject,
NULL );
if (!NT_SUCCESS(status)) {
ASSERT( NDASNTFS_INSUFFICIENT_RESOURCES );
break;
}
timeOut.QuadPart = -NDASNTFS_TIME_OUT;
status = KeWaitForSingleObject( &Secondary->ReadyEvent,
Executive,
KernelMode,
FALSE,
&timeOut );
if(status != STATUS_SUCCESS) {
ASSERT( NDASNTFS_BUG );
break;
}
KeClearEvent( &Secondary->ReadyEvent );
InterlockedIncrement( &Secondary->SessionId );
ExAcquireFastMutex( &Secondary->FastMutex );
if (!FlagOn(Secondary->Thread.Flags, SECONDARY_THREAD_FLAG_START) || FlagOn(Secondary->Thread.Flags, SECONDARY_THREAD_FLAG_STOPED)) {
ExReleaseFastMutex( &Secondary->FastMutex );
if(Secondary->Thread.SessionStatus == STATUS_DISK_CORRUPT_ERROR) {
status = STATUS_SUCCESS;
break;
}
timeOut.QuadPart = -NDASNTFS_TIME_OUT;
status = KeWaitForSingleObject( Secondary->ThreadObject,
Executive,
KernelMode,
FALSE,
&timeOut );
if(status != STATUS_SUCCESS) {
ASSERT( NDASNTFS_BUG );
return status;
}
DebugTrace( 0, Dbg, ("Secondary_Stop: thread stoped\n") );
ObDereferenceObject( Secondary->ThreadObject );
Secondary->ThreadHandle = 0;
Secondary->ThreadObject = 0;
RtlZeroMemory( &Secondary->Thread.Flags, sizeof(SECONDARY) - FIELD_OFFSET(SECONDARY, Thread.Flags) );
continue;
}
ExReleaseFastMutex( &Secondary->FastMutex );
status = STATUS_SUCCESS;
DebugTrace( 0, Dbg2, ("SessionRecovery Success Secondary = %p\n", Secondary) );
break;
}
NTSTATUS
NcGenerateFileName (
_In_ PFLT_INSTANCE Instance,
_In_ PFILE_OBJECT FileObject,
_In_opt_ PFLT_CALLBACK_DATA Data,
_In_ FLT_FILE_NAME_OPTIONS NameOptions,
_Out_ PBOOLEAN CacheFileNameInformation,
_Inout_ PFLT_NAME_CONTROL OutputNameControl
)
{
//
// Status vars
//
NTSTATUS Status;
//
// State lookup vars
//
BOOLEAN Opened = (BOOLEAN)(FileObject->FsContext != NULL); // True if file object is opened.
BOOLEAN ReturnShortName = (BOOLEAN)(FltGetFileNameFormat(NameOptions) == FLT_FILE_NAME_SHORT); // True if the user is requesting short name
BOOLEAN ReturnOpenedName = (BOOLEAN)(FltGetFileNameFormat(NameOptions) == FLT_FILE_NAME_OPENED); // True if user is requesting opened name.
BOOLEAN ReturnNormalizedName = (BOOLEAN)(FltGetFileNameFormat(NameOptions) == FLT_FILE_NAME_NORMALIZED); // True if user is requesting normalized name.
BOOLEAN IgnoreCase;
FLT_FILE_NAME_OPTIONS NameQueryMethod = FltGetFileNameQueryMethod( NameOptions );
FLT_FILE_NAME_OPTIONS NameFlags = FLT_VALID_FILE_NAME_FLAGS & NameOptions;
//
// File name information
//
PFLT_FILE_NAME_INFORMATION LowerNameInfo = NULL; // File name as reported by lower name provider. Will always be down real mapping.
PFLT_FILE_NAME_INFORMATION ShortInfo = NULL; // We will use ShortInfo to store the short name if needed.
//
// Contexts
//
PNC_INSTANCE_CONTEXT InstanceContext = NULL;
//
// Overlap
//
NC_PATH_OVERLAP RealOverlap;
UNICODE_STRING RealRemainder = EMPTY_UNICODE_STRING;
//
// Temp storage
//
UNICODE_STRING MungedName = EMPTY_UNICODE_STRING;
//
// Temp pointer
//
PUNICODE_STRING Name = NULL; // Pointer to the name we are going to use.
PAGED_CODE();
FLT_ASSERT( IoGetTopLevelIrp() == NULL );
//
// This should never happen, but let's be safe.
//
if (!ReturnShortName &&
!ReturnOpenedName &&
!ReturnNormalizedName) {
FLT_ASSERT( FALSE );
Status = STATUS_NOT_SUPPORTED;
goto NcGenerateFileNameCleanup;
}
RealOverlap.EntireFlags = 0;
//
// To prevent infinite recursion, calls to FltGetFileNameInformation
// from generate file name callbacks should not target current provider.
//
ClearFlag( NameFlags, FLT_FILE_NAME_REQUEST_FROM_CURRENT_PROVIDER );
//
// Fetch the instance context.
//
Status = FltGetInstanceContext( Instance, &InstanceContext );
if (!NT_SUCCESS( Status )) {
goto NcGenerateFileNameCleanup;
}
//
// We need to know what the name provider under us thinks the file is called.
// If the caller wants the normalized name we query that, otherwise we query
// the opened name because we have to compare the full path of the file vs.
// the real mapping to determine if the file is mapped.
//
Status = NcGetFileNameInformation( Data,
FileObject,
Instance,
(ReturnNormalizedName ? FLT_FILE_NAME_NORMALIZED
: FLT_FILE_NAME_OPENED) |
NameQueryMethod |
NameFlags,
&LowerNameInfo );
if (!NT_SUCCESS( Status )) {
goto NcGenerateFileNameCleanup;
}
Status = FltParseFileNameInformation( LowerNameInfo );
if (!NT_SUCCESS( Status )) {
goto NcGenerateFileNameCleanup;
}
//
// Issues With Pre-open path:
//
// 1) Poison name cache below name provider:
// If a filter above a name provider calls FltGetFileNameInformation on a
// file object in his precreate callback, fltmgr will call the name
// provider's generate name callback before the name provider's pre create
// callback is invoked. Name providers by their nature change names in their
// pre-create. Because the name provider has not had the opportunity to
// modify the name yet, we need to make sure that fltmgr does not cache the name we
// return below us, so we set the FLT_FILE_NAME_DO_NOT_CACHE flag.
// //TODO: TRY TO GET ACROSS THAT THIS IS A NAME CHANGER PROBLEM, NOT ALL NAME PROVIDERS NEED TO.
//
if (!Opened) {
SetFlag( NameFlags, FLT_FILE_NAME_DO_NOT_CACHE );
if (Data) {
//
// NT supports case sensitive and non-case sensitive naming in file systems.
// This is handled on a per-open basis. Weather an open is case senstive is
// determined by the FO_OPENED_CASE_SENSITIVE flag on the file object.
// In pre-create the SL_CASE_SENSITIVE flag on the create IRP specifies the mode.
//
// If this is on an unopened FileObject, it had better be pre-create so we know
// how to process the operation. If we are queried on an unopened FileObject
// at any other time we have no way to handle the request.
//
FLT_ASSERT( Data->Iopb->MajorFunction == IRP_MJ_CREATE ||
Data->Iopb->MajorFunction == IRP_MJ_NETWORK_QUERY_OPEN );
IgnoreCase = !BooleanFlagOn( Data->Iopb->OperationFlags, SL_CASE_SENSITIVE );
} else {
//
// If people do unsafe queries on preopened IOs, we cannot
// determine if the open is case sensitive or not.
// So we cannot determine if this open is down the mapping.
// fail.
//
FLT_ASSERT( FALSE );
Status = STATUS_INVALID_PARAMETER;
goto NcGenerateFileNameCleanup;
}
} else {
//
// After a file has been opened, the case sensitivity is stored in the file object.
//
IgnoreCase = !BooleanFlagOn( FileObject->Flags, FO_OPENED_CASE_SENSITIVE );
}
//
// Calculate the overlap with the real mapping.
//
NcComparePath( &LowerNameInfo->Name,
&InstanceContext->Mapping.RealMapping,
&RealRemainder,
IgnoreCase,
TRUE,
&RealOverlap );
//
// Whether we munge depends on what name is requested.
//
if (ReturnOpenedName ||
ReturnNormalizedName) {
if (Opened &&
RealOverlap.InMapping) {
//
// We munge the opened name if it overlaps with the real mapping.
// The returned path will be down the user mapping.
//
Status = NcConstructPath( &InstanceContext->Mapping.UserMapping,
&RealRemainder,
TRUE,
&MungedName);
if (!NT_SUCCESS( Status )) {
goto NcGenerateFileNameCleanup;
}
Name = &MungedName;
} else {
//
// We return the queried result if the path is not in the
// mapping.
//
Name = &LowerNameInfo->Name;
}
} else if (ReturnShortName) {
//
// Note that unlike opened names, a query for a shortname only returns
// the final component, not the full path.
//
// TODO: Assert not preopen
if (RealOverlap.Match) {
//
// The opened path is the mapping path.
// This means that if we queried the filesystem
// he would return the wrong path.
//
// Luckily, we can just use the mapping.
//
Name = &InstanceContext->Mapping.UserMapping.ShortNamePath.FinalComponentName;
} else {
//
// We have to query below us to get the short name.
//
Status = NcGetFileNameInformation( Data,
FileObject,
Instance,
FLT_FILE_NAME_SHORT |
NameQueryMethod |
NameFlags,
&ShortInfo );
if (!NT_SUCCESS( Status )) {
goto NcGenerateFileNameCleanup;
}
Status = FltParseFileNameInformation( ShortInfo );
if (!NT_SUCCESS(Status)) {
goto NcGenerateFileNameCleanup;
}
//
// Set name to returned name.
//
Name = &ShortInfo->Name;
}
}
FLT_ASSERT( Name != NULL );
//
// Try to grow the namechanger's record to accommodate the result.
//
Status = FltCheckAndGrowNameControl( OutputNameControl, Name->Length );
if (NT_SUCCESS( Status )) {
//
// Copy the new name into the buffer.
//
RtlCopyUnicodeString( &OutputNameControl->Name, Name );
*CacheFileNameInformation = TRUE;
}
NcGenerateFileNameCleanup:
if (LowerNameInfo != NULL) {
FltReleaseFileNameInformation( LowerNameInfo );
}
if (ShortInfo != NULL) {
FltReleaseFileNameInformation( ShortInfo );
}
if (InstanceContext != NULL) {
FltReleaseContext( InstanceContext );
}
if (MungedName.Buffer != NULL) {
ExFreePoolWithTag( MungedName.Buffer, NC_GENERATE_NAME_TAG );
}
return Status;
}
NC_PATH_OVERLAP ParentOverlap; //overlap between the parent path and the user mapping.
UNICODE_STRING Remainder;
UNICODE_STRING MungedParentPath; // Path we are going to open for query
PCUNICODE_STRING MungedComponent; // File name to enumerate
PWSTR MungedBuffer = NULL;
ULONG MungedBufferLength;
IO_STATUS_BLOCK ParentStatusBlock;
OBJECT_ATTRIBUTES ParentAttributes;
HANDLE ParentHandle = 0;
PFILE_OBJECT ParentFileObject = NULL;
BOOLEAN IgnoreCase = !BooleanFlagOn( Flags, FLTFL_NORMALIZE_NAME_CASE_SENSITIVE );
PAGED_CODE();
FLT_ASSERT( IoGetTopLevelIrp() == NULL );
UNREFERENCED_PARAMETER( NormalizationContext );
UNREFERENCED_PARAMETER( DeviceNameLength );
UNREFERENCED_PARAMETER( FileObject );
Status = FltGetInstanceContext( Instance,
&InstanceContext );
if (!NT_SUCCESS( Status )) {
goto NcNormalizeNameComponentExCleanup;
}
//
// Default to enumerating the component specified by the
NTSTATUS
Ext2BuildRequest (PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
BOOLEAN AtIrqlPassiveLevel = FALSE;
BOOLEAN IsTopLevelIrp = FALSE;
PEXT2_IRP_CONTEXT IrpContext = NULL;
NTSTATUS Status = STATUS_UNSUCCESSFUL;
__try {
__try {
#if EXT2_DEBUG
Ext2DbgPrintCall(DeviceObject, Irp);
#endif
AtIrqlPassiveLevel = (KeGetCurrentIrql() == PASSIVE_LEVEL);
if (AtIrqlPassiveLevel) {
FsRtlEnterFileSystem();
}
if (!IoGetTopLevelIrp()) {
IsTopLevelIrp = TRUE;
IoSetTopLevelIrp(Irp);
}
IrpContext = Ext2AllocateIrpContext(DeviceObject, Irp);
if (!IrpContext) {
Status = STATUS_INSUFFICIENT_RESOURCES;
Irp->IoStatus.Status = Status;
Ext2CompleteRequest(Irp, TRUE, IO_NO_INCREMENT);
} else {
if ((IrpContext->MajorFunction == IRP_MJ_CREATE) &&
!AtIrqlPassiveLevel) {
DbgBreak();
}
Status = Ext2DispatchRequest(IrpContext);
}
} __except (Ext2ExceptionFilter(IrpContext, GetExceptionInformation())) {
Status = Ext2ExceptionHandler(IrpContext);
}
} __finally {
if (IsTopLevelIrp) {
IoSetTopLevelIrp(NULL);
}
if (AtIrqlPassiveLevel) {
FsRtlExitFileSystem();
}
}
return Status;
}
NTSTATUS
Ext2WriteFile(IN PEXT2_IRP_CONTEXT IrpContext)
{
PEXT2_VCB Vcb = NULL;
PEXT2_FCB Fcb = NULL;
PEXT2_CCB Ccb = NULL;
PFILE_OBJECT FileObject = NULL;
PDEVICE_OBJECT DeviceObject = NULL;
PIRP Irp = NULL;
PIO_STACK_LOCATION IoStackLocation = NULL;
PUCHAR Buffer = NULL;
LARGE_INTEGER ByteOffset;
ULONG ReturnedLength = 0;
ULONG Length;
NTSTATUS Status = STATUS_UNSUCCESSFUL;
BOOLEAN OpPostIrp = FALSE;
BOOLEAN PagingIo = FALSE;
BOOLEAN Nocache = FALSE;
BOOLEAN SynchronousIo = FALSE;
BOOLEAN RecursiveWriteThrough = FALSE;
BOOLEAN MainResourceAcquired = FALSE;
BOOLEAN PagingIoResourceAcquired = FALSE;
BOOLEAN bDeferred = FALSE;
BOOLEAN UpdateFileValidSize = FALSE;
BOOLEAN FileSizesChanged = FALSE;
BOOLEAN rc;
__try {
ASSERT(IrpContext);
ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
(IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
DeviceObject = IrpContext->DeviceObject;
Vcb = (PEXT2_VCB) DeviceObject->DeviceExtension;
ASSERT(Vcb != NULL);
ASSERT((Vcb->Identifier.Type == EXT2VCB) &&
(Vcb->Identifier.Size == sizeof(EXT2_VCB)));
FileObject = IrpContext->FileObject;
Fcb = (PEXT2_FCB) FileObject->FsContext;
Ccb = (PEXT2_CCB) FileObject->FsContext2;
ASSERT(Fcb);
ASSERT((Fcb->Identifier.Type == EXT2FCB) &&
(Fcb->Identifier.Size == sizeof(EXT2_FCB)));
Irp = IrpContext->Irp;
IoStackLocation = IoGetCurrentIrpStackLocation(Irp);
Length = IoStackLocation->Parameters.Write.Length;
ByteOffset = IoStackLocation->Parameters.Write.ByteOffset;
PagingIo = IsFlagOn(Irp->Flags, IRP_PAGING_IO);
Nocache = IsFlagOn(Irp->Flags, IRP_NOCACHE);
SynchronousIo = IsFlagOn(FileObject->Flags, FO_SYNCHRONOUS_IO);
if (PagingIo) {
ASSERT(Nocache);
}
DEBUG(DL_INF, ("Ext2WriteFile: %wZ Offset=%I64xh Length=%xh Paging=%xh Nocache=%xh\n",
&Fcb->Mcb->ShortName, ByteOffset.QuadPart, Length, PagingIo, Nocache));
if (IsSpecialFile(Fcb) || IsInodeSymLink(Fcb->Inode) ) {
Status = STATUS_INVALID_DEVICE_REQUEST;
__leave;
}
if (IsFileDeleted(Fcb->Mcb) ||
(IsSymLink(Fcb) && IsFileDeleted(Fcb->Mcb->Target)) ) {
Status = STATUS_FILE_DELETED;
__leave;
}
if (Length == 0) {
Irp->IoStatus.Information = 0;
Status = STATUS_SUCCESS;
__leave;
}
if (ByteOffset.LowPart == FILE_USE_FILE_POINTER_POSITION &&
ByteOffset.HighPart == -1) {
ByteOffset = FileObject->CurrentByteOffset;
} else if (IsWritingToEof(ByteOffset)) {
ByteOffset.QuadPart = Fcb->Header.FileSize.QuadPart;
}
if (Nocache && !PagingIo &&
( (ByteOffset.LowPart & (SECTOR_SIZE - 1)) ||
(Length & (SECTOR_SIZE - 1))) ) {
Status = STATUS_INVALID_PARAMETER;
__leave;
}
if (FlagOn(IrpContext->MinorFunction, IRP_MN_DPC)) {
ClearFlag(IrpContext->MinorFunction, IRP_MN_DPC);
Status = STATUS_PENDING;
__leave;
}
if (!Nocache) {
BOOLEAN bAgain = IsFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_DEFERRED);
BOOLEAN bWait = IsFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT);
BOOLEAN bQueue = IsFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_REQUEUED);
if ( !CcCanIWrite(
FileObject,
Length,
(bWait && bQueue),
bAgain ) ) {
Status = Ext2LockUserBuffer(
IrpContext->Irp,
Length,
IoReadAccess);
if (NT_SUCCESS(Status)) {
SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_DEFERRED);
CcDeferWrite( FileObject,
(PCC_POST_DEFERRED_WRITE)Ext2DeferWrite,
IrpContext,
Irp,
Length,
bAgain );
bDeferred = TRUE;
Status = STATUS_PENDING;
__leave;
}
}
}
if (IsDirectory(Fcb) && !PagingIo) {
Status = STATUS_INVALID_DEVICE_REQUEST;
__leave;
}
if (IsFlagOn(Irp->Flags, IRP_SYNCHRONOUS_PAGING_IO) && !IrpContext->IsTopLevel) {
PIRP TopIrp;
TopIrp = IoGetTopLevelIrp();
if ( (ULONG_PTR)TopIrp > FSRTL_MAX_TOP_LEVEL_IRP_FLAG &&
NodeType(TopIrp) == IO_TYPE_IRP) {
PIO_STACK_LOCATION IrpStack;
IrpStack = IoGetCurrentIrpStackLocation(TopIrp);
if ((IrpStack->MajorFunction == IRP_MJ_WRITE) &&
(IrpStack->FileObject->FsContext == FileObject->FsContext) &&
!FlagOn(TopIrp->Flags, IRP_NOCACHE) ) {
SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_WRITE_THROUGH);
RecursiveWriteThrough = TRUE;
}
}
}
if (PagingIo) {
if (!ExAcquireResourceSharedLite(&Fcb->PagingIoResource, TRUE)) {
Status = STATUS_PENDING;
__leave;
}
PagingIoResourceAcquired = TRUE;
if ( (ByteOffset.QuadPart + Length) > Fcb->Header.FileSize.QuadPart) {
if (ByteOffset.QuadPart >= Fcb->Header.AllocationSize.QuadPart) {
Status = STATUS_SUCCESS;
Irp->IoStatus.Information = 0;
__leave;
} else {
ReturnedLength = (ULONG)(Fcb->Header.FileSize.QuadPart - ByteOffset.QuadPart);
if (ByteOffset.QuadPart + Length > Fcb->Header.AllocationSize.QuadPart)
Length = (ULONG)(Fcb->Header.AllocationSize.QuadPart - ByteOffset.QuadPart);
}
} else {
ReturnedLength = Length;
}
} else {
if (!Ext2CheckFileAccess(Vcb, Fcb->Mcb, Ext2FileCanWrite)) {
Status = STATUS_ACCESS_DENIED;
__leave;
}
if (IsDirectory(Fcb)) {
__leave;
}
if (!ExAcquireResourceExclusiveLite(&Fcb->MainResource, TRUE)) {
Status = STATUS_PENDING;
__leave;
}
MainResourceAcquired = TRUE;
//
// Do flushing for such cases
//
if (Nocache && Ccb != NULL && Fcb->SectionObject.DataSectionObject != NULL) {
ExAcquireSharedStarveExclusive( &Fcb->PagingIoResource, TRUE);
ExReleaseResourceLite(&Fcb->PagingIoResource);
CcFlushCache( &(Fcb->SectionObject),
&ByteOffset,
CEILING_ALIGNED(ULONG, Length, BLOCK_SIZE),
&(Irp->IoStatus));
ClearLongFlag(Fcb->Flags, FCB_FILE_MODIFIED);
if (!NT_SUCCESS(Irp->IoStatus.Status)) {
Status = Irp->IoStatus.Status;
__leave;
}
ExAcquireSharedStarveExclusive( &Fcb->PagingIoResource, TRUE);
ExReleaseResourceLite(&Fcb->PagingIoResource);
CcPurgeCacheSection( &(Fcb->SectionObject),
&(ByteOffset),
CEILING_ALIGNED(ULONG, Length, BLOCK_SIZE),
FALSE );
}
if (!FsRtlCheckLockForWriteAccess(&Fcb->FileLockAnchor, Irp)) {
Status = STATUS_FILE_LOCK_CONFLICT;
__leave;
}
if (Ccb != NULL) {
Status = FsRtlCheckOplock( &Fcb->Oplock,
Irp,
IrpContext,
Ext2OplockComplete,
Ext2LockIrp );
if (Status != STATUS_SUCCESS) {
OpPostIrp = TRUE;
__leave;
}
//
// Set the flag indicating if Fast I/O is possible
//
Fcb->Header.IsFastIoPossible = Ext2IsFastIoPossible(Fcb);
}
//
// Extend the inode size when the i/o is beyond the file end ?
//
if ((ByteOffset.QuadPart + Length) > Fcb->Header.FileSize.QuadPart) {
LARGE_INTEGER AllocationSize, Last;
if (!ExAcquireResourceExclusiveLite(&Fcb->PagingIoResource, TRUE)) {
Status = STATUS_PENDING;
__leave;
}
PagingIoResourceAcquired = TRUE;
/* let this irp wait, since it has to be synchronous */
SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT);
Last.QuadPart = Fcb->Header.AllocationSize.QuadPart;
AllocationSize.QuadPart = (LONGLONG)(ByteOffset.QuadPart + Length);
AllocationSize.QuadPart = CEILING_ALIGNED(ULONGLONG,
(ULONGLONG)AllocationSize.QuadPart,
(ULONGLONG)BLOCK_SIZE);
/* tell Ext2ExpandFile to allocate unwritten extent or NULL blocks
for indirect files, otherwise we might get gabage data in holes */
IrpContext->MajorFunction += IRP_MJ_MAXIMUM_FUNCTION;
Status = Ext2ExpandFile(IrpContext, Vcb, Fcb->Mcb, &AllocationSize);
IrpContext->MajorFunction -= IRP_MJ_MAXIMUM_FUNCTION;
if (AllocationSize.QuadPart > Last.QuadPart) {
Fcb->Header.AllocationSize.QuadPart = AllocationSize.QuadPart;
SetLongFlag(Fcb->Flags, FCB_ALLOC_IN_WRITE);
}
ExReleaseResourceLite(&Fcb->PagingIoResource);
PagingIoResourceAcquired = FALSE;
if (ByteOffset.QuadPart >= Fcb->Header.AllocationSize.QuadPart) {
if (NT_SUCCESS(Status)) {
DbgBreak();
Status = STATUS_UNSUCCESSFUL;
}
__leave;
}
if (ByteOffset.QuadPart + Length > Fcb->Header.AllocationSize.QuadPart) {
Length = (ULONG)(Fcb->Header.AllocationSize.QuadPart - ByteOffset.QuadPart);
}
Fcb->Header.FileSize.QuadPart = Fcb->Inode->i_size = ByteOffset.QuadPart + Length;
Ext2SaveInode(IrpContext, Vcb, Fcb->Inode);
if (CcIsFileCached(FileObject)) {
CcSetFileSizes(FileObject, (PCC_FILE_SIZES)(&(Fcb->Header.AllocationSize)));
}
FileObject->Flags |= FO_FILE_SIZE_CHANGED | FO_FILE_MODIFIED;
FileSizesChanged = TRUE;
if (Fcb->Header.FileSize.QuadPart >= 0x80000000 &&
!IsFlagOn(SUPER_BLOCK->s_feature_ro_compat, EXT2_FEATURE_RO_COMPAT_LARGE_FILE)) {
SetFlag(SUPER_BLOCK->s_feature_ro_compat, EXT2_FEATURE_RO_COMPAT_LARGE_FILE);
Ext2SaveSuper(IrpContext, Vcb);
}
DEBUG(DL_IO, ("Ext2WriteFile: expanding %wZ to FS: %I64xh FA: %I64xh\n",
&Fcb->Mcb->ShortName, Fcb->Header.FileSize.QuadPart,
Fcb->Header.AllocationSize.QuadPart));
}
ReturnedLength = Length;
}
if (!Nocache) {
if (FileObject->PrivateCacheMap == NULL) {
CcInitializeCacheMap(
FileObject,
(PCC_FILE_SIZES)(&Fcb->Header.AllocationSize),
FALSE,
&Ext2Global->CacheManagerCallbacks,
Fcb );
CcSetReadAheadGranularity(
FileObject,
READ_AHEAD_GRANULARITY );
}
if (FlagOn(IrpContext->MinorFunction, IRP_MN_MDL)) {
CcPrepareMdlWrite(
FileObject,
&ByteOffset,
Length,
&Irp->MdlAddress,
&Irp->IoStatus );
Status = Irp->IoStatus.Status;
} else {
Buffer = Ext2GetUserBuffer(Irp);
if (Buffer == NULL) {
DbgBreak();
Status = STATUS_INVALID_USER_BUFFER;
__leave;
}
if (ByteOffset.QuadPart > Fcb->Header.ValidDataLength.QuadPart) {
/* let this irp wait, since it has to be synchronous */
SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT);
rc = Ext2ZeroData(IrpContext, Vcb, FileObject,
&Fcb->Header.ValidDataLength, &ByteOffset);
if (!rc) {
Status = STATUS_PENDING;
DbgBreak();
__leave;
}
}
if (!CcCopyWrite(FileObject, &ByteOffset, Length, Ext2CanIWait(), Buffer)) {
if (Ext2CanIWait() ||
!CcCopyWrite(FileObject, &ByteOffset, Length, TRUE, Buffer)) {
Status = STATUS_PENDING;
DbgBreak();
__leave;
}
}
if (ByteOffset.QuadPart + Length > Fcb->Header.ValidDataLength.QuadPart ) {
if (Fcb->Header.FileSize.QuadPart < ByteOffset.QuadPart + Length) {
Fcb->Header.ValidDataLength.QuadPart = Fcb->Header.FileSize.QuadPart;
} else {
if (Fcb->Header.ValidDataLength.QuadPart < ByteOffset.QuadPart + Length)
Fcb->Header.ValidDataLength.QuadPart = ByteOffset.QuadPart + Length;
}
CcSetFileSizes(FileObject, (PCC_FILE_SIZES)(&(Fcb->Header.AllocationSize)));
FileSizesChanged = TRUE;
}
Status = STATUS_SUCCESS;
}
if (NT_SUCCESS(Status)) {
Irp->IoStatus.Information = Length;
if (IsFlagOn(Vcb->Flags, VCB_FLOPPY_DISK)) {
DEBUG(DL_FLP, ("Ext2WriteFile is starting FlushingDpc...\n"));
Ext2StartFloppyFlushDpc(Vcb, Fcb, FileObject);
}
}
} else {
if (!PagingIo && !RecursiveWriteThrough && !IsLazyWriter(Fcb)) {
if (ByteOffset.QuadPart > Fcb->Header.ValidDataLength.QuadPart) {
/* let this irp wait, since it has to be synchronous */
SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT);
rc = Ext2ZeroData(IrpContext, Vcb, FileObject,
&Fcb->Header.ValidDataLength,
&ByteOffset);
if (!rc) {
Status = STATUS_PENDING;
DbgBreak();
__leave;
}
}
}
Status = Ext2LockUserBuffer(
IrpContext->Irp,
Length,
IoReadAccess );
if (!NT_SUCCESS(Status)) {
__leave;
}
Irp->IoStatus.Status = STATUS_SUCCESS;
Irp->IoStatus.Information = ReturnedLength;
Status = Ext2WriteInode(
IrpContext,
Vcb,
Fcb->Mcb,
(ULONGLONG)(ByteOffset.QuadPart),
NULL,
ReturnedLength,
TRUE,
&Length
);
Irp = IrpContext->Irp;
if (NT_SUCCESS(Status) && !RecursiveWriteThrough && !IsLazyWriter(Fcb)) {
if (ByteOffset.QuadPart + Length > Fcb->Header.ValidDataLength.QuadPart ) {
FileSizesChanged = TRUE;
if (Fcb->Header.FileSize.QuadPart < ByteOffset.QuadPart + Length) {
if (!PagingIo)
Fcb->Header.FileSize.QuadPart = ByteOffset.QuadPart + Length;
Fcb->Header.ValidDataLength.QuadPart = Fcb->Header.FileSize.QuadPart;
} else {
if (Fcb->Header.ValidDataLength.QuadPart < ByteOffset.QuadPart + Length)
Fcb->Header.ValidDataLength.QuadPart = ByteOffset.QuadPart + Length;
}
if (!PagingIo && CcIsFileCached(FileObject)) {
CcSetFileSizes(FileObject, (PCC_FILE_SIZES)(&(Fcb->Header.AllocationSize)));
}
DEBUG(DL_IO, ("Ext2WriteFile: %wZ written FS: %I64xh FA: %I64xh BO: %I64xh LEN: %u\n",
&Fcb->Mcb->ShortName, Fcb->Header.FileSize.QuadPart,
Fcb->Header.AllocationSize.QuadPart, ByteOffset.QuadPart, Length));
}
}
}
if (FileSizesChanged) {
FileObject->Flags |= FO_FILE_SIZE_CHANGED | FO_FILE_MODIFIED;
Ext2NotifyReportChange( IrpContext, Vcb, Fcb->Mcb,
FILE_NOTIFY_CHANGE_SIZE,
FILE_ACTION_MODIFIED );
}
} __finally {
/*
* in case we got excpetions, we need revert MajorFunction
* back to IRP_MJ_WRITE. The reason we do this, is to tell
* Ext2ExpandFile to allocate unwritten extent or don't add
* new blocks for indirect files.
*/
if (IrpContext->MajorFunction > IRP_MJ_MAXIMUM_FUNCTION)
IrpContext->MajorFunction -= IRP_MJ_MAXIMUM_FUNCTION;
if (Irp) {
if (PagingIoResourceAcquired) {
ExReleaseResourceLite(&Fcb->PagingIoResource);
}
if (MainResourceAcquired) {
ExReleaseResourceLite(&Fcb->MainResource);
}
}
if (!OpPostIrp && !IrpContext->ExceptionInProgress) {
if (Irp) {
if (Status == STATUS_PENDING ||
Status == STATUS_CANT_WAIT ) {
if (!bDeferred) {
Status = Ext2QueueRequest(IrpContext);
}
} else {
if (NT_SUCCESS(Status) && !PagingIo) {
if (SynchronousIo) {
FileObject->CurrentByteOffset.QuadPart =
ByteOffset.QuadPart + Irp->IoStatus.Information;
}
SetFlag(FileObject->Flags, FO_FILE_MODIFIED);
SetLongFlag(Fcb->Flags, FCB_FILE_MODIFIED);
}
Ext2CompleteIrpContext(IrpContext, Status);
}
} else {
Ext2FreeIrpContext(IrpContext);
}
}
}
DEBUG(DL_IO, ("Ext2WriteFile: %wZ written at Offset=%I64xh Length=%xh PagingIo=%d Nocache=%d "
"RetLen=%xh VDL=%I64xh FileSize=%I64xh i_size=%I64xh Status=%xh\n",
&Fcb->Mcb->ShortName, ByteOffset, Length, PagingIo, Nocache, ReturnedLength,
Fcb->Header.ValidDataLength.QuadPart,Fcb->Header.FileSize.QuadPart,
Fcb->Inode->i_size, Status));
return Status;
}
VOID
VolDoThreadProc (
IN PVOLUME_DEVICE_OBJECT VolDo
)
{
BOOLEAN volDoThreadTerminate = FALSE;
DebugTrace( 0, Dbg2, ("VolDoThreadProc: Start VolDo = %p\n", VolDo) );
VolDo_Reference( VolDo );
VolDo->Thread.Flags = VOLDO_THREAD_FLAG_INITIALIZING;
ExAcquireFastMutex( &VolDo->FastMutex );
ClearFlag( VolDo->Thread.Flags, VOLDO_THREAD_FLAG_INITIALIZING );
SetFlag( VolDo->Thread.Flags, VOLDO_THREAD_FLAG_START );
ExReleaseFastMutex( &VolDo->FastMutex );
KeSetEvent( &VolDo->ReadyEvent, IO_DISK_INCREMENT, FALSE );
volDoThreadTerminate = FALSE;
while (volDoThreadTerminate == FALSE) {
PKEVENT events[2];
LONG eventCount;
NTSTATUS eventStatus;
LARGE_INTEGER timeOut;
ASSERT( KeGetCurrentIrql() == PASSIVE_LEVEL );
eventCount = 0;
events[eventCount++] = &VolDo->RequestEvent;
timeOut.QuadPart = -NDNTFS_VOLDO_THREAD_FLAG_TIME_OUT;
eventStatus = KeWaitForMultipleObjects( eventCount,
events,
WaitAny,
Executive,
KernelMode,
TRUE,
&timeOut,
NULL );
if (eventStatus == STATUS_TIMEOUT) {
LARGE_INTEGER currentTime;
KeQuerySystemTime( ¤tTime );
if (FlagOn(VolDo->NdasNtfsFlags, NDAS_NTFS_DEVICE_FLAG_SHUTDOWN) ||
!(FlagOn(VolDo->NdasNtfsFlags, NDAS_NTFS_DEVICE_FLAG_MOUNTED) /*&& !FlagOn(LfsDeviceExt->Flags, LFS_DEVICE_STOP)*/)) {
continue;
}
if ((VolDo->NetdiskEnableMode == NETDISK_READ_ONLY &&
(VolDo->TryFlushOrPurgeTime.QuadPart > currentTime.QuadPart ||
(currentTime.QuadPart - VolDo->TryFlushOrPurgeTime.QuadPart) >= NDNTFS_TRY_PURGE_DURATION)) ||
(VolDo->ReceiveWriteCommand == TRUE &&
(VolDo->TryFlushOrPurgeTime.QuadPart > currentTime.QuadPart ||
(currentTime.QuadPart - VolDo->TryFlushOrPurgeTime.QuadPart) >= NDNTFS_TRY_FLUSH_DURATION))) {
if (VolDo->NetdiskEnableMode != NETDISK_READ_ONLY &&
(currentTime.QuadPart - VolDo->CommandReceiveTime.QuadPart) <= NDNTFS_TRY_FLUSH_DURATION /*&&
(currentTime.QuadPart - VolDo->TryFlushOrPurgeTime.QuadPart) <= (100*NDNTFS_TRY_FLUSH_OR_PURGE_DURATION)*/) {
continue;
}
do {
HANDLE eventHandle = NULL;
HANDLE fileHandle = NULL;
ACCESS_MASK desiredAccess;
ULONG attributes;
OBJECT_ATTRIBUTES objectAttributes;
IO_STATUS_BLOCK ioStatusBlock;
LARGE_INTEGER allocationSize;
ULONG fileAttributes;
ULONG shareAccess;
ULONG createDisposition;
ULONG createOptions;
PVOID eaBuffer;
ULONG eaLength;
NTSTATUS createStatus;
NTSTATUS fileSystemControlStatus;
PIRP topLevelIrp;
PRIMARY_REQUEST_INFO primaryRequestInfo;
ASSERT( KeGetCurrentIrql() == PASSIVE_LEVEL );
if (VolDo->NetdiskEnableMode == NETDISK_SECONDARY) {
break;
}
DebugTrace( 0, Dbg2, ("VolDoThreadProc: VolDo = %p, VolDo->NetdiskPartitionInformation.VolumeName = %wZ\n",
VolDo, &VolDo->NetdiskPartitionInformation.VolumeName) );
desiredAccess = SYNCHRONIZE | READ_CONTROL | FILE_WRITE_ATTRIBUTES | FILE_READ_ATTRIBUTES | FILE_WRITE_EA
| FILE_READ_DATA | FILE_WRITE_DATA | FILE_APPEND_DATA | FILE_READ_EA;
ASSERT( desiredAccess == 0x0012019F );
attributes = OBJ_KERNEL_HANDLE;
attributes |= OBJ_CASE_INSENSITIVE;
InitializeObjectAttributes( &objectAttributes,
&VolDo->NetdiskPartitionInformation.VolumeName,
attributes,
NULL,
NULL );
allocationSize.LowPart = 0;
allocationSize.HighPart = 0;
fileAttributes = 0;
shareAccess = FILE_SHARE_READ | FILE_SHARE_WRITE;
createDisposition = FILE_OPEN;
createOptions = FILE_SYNCHRONOUS_IO_NONALERT | FILE_NON_DIRECTORY_FILE;
eaBuffer = NULL;
eaLength = 0;
RtlZeroMemory( &ioStatusBlock, sizeof(ioStatusBlock) );
createStatus = ZwCreateFile( &fileHandle,
desiredAccess,
&objectAttributes,
&ioStatusBlock,
&allocationSize,
fileAttributes,
shareAccess,
createDisposition,
createOptions,
eaBuffer,
eaLength );
if (createStatus != STATUS_SUCCESS)
break;
ASSERT( ioStatusBlock.Information == FILE_OPENED);
createStatus = ZwCreateEvent( &eventHandle,
GENERIC_READ,
NULL,
SynchronizationEvent,
FALSE );
if (createStatus != STATUS_SUCCESS) {
ASSERT( NDASNTFS_UNEXPECTED );
ZwClose( fileHandle );
break;
}
primaryRequestInfo.PrimaryTag = 0xe2027482;
primaryRequestInfo.PrimarySessionId = NDASNTFS_LOCAL_PRMARY_SESSION_ID;
primaryRequestInfo.PrimarySession = NULL;
primaryRequestInfo.NdfsWinxpRequestHeader = NULL;
topLevelIrp = IoGetTopLevelIrp();
ASSERT( topLevelIrp == NULL );
IoSetTopLevelIrp( (PIRP)&primaryRequestInfo );
RtlZeroMemory( &ioStatusBlock, sizeof(ioStatusBlock) );
fileSystemControlStatus = ZwFsControlFile( fileHandle,
NULL, //&eventHandle,
NULL,
NULL,
&ioStatusBlock,
(VolDo->NetdiskEnableMode == NETDISK_READ_ONLY) ?
FSCTL_NDAS_FS_PURGE : FSCTL_NDAS_FS_FLUSH,
NULL,
0,
NULL,
0 );
DebugTrace( 0, Dbg2, ("VolDoThreadProc: VolDo = %p, createStatus = %x, ioStatusBlock = %x\n",
VolDo, fileSystemControlStatus, ioStatusBlock.Information) );
if (fileSystemControlStatus == STATUS_PENDING) {
LARGE_INTEGER timeOut;
timeOut.QuadPart = -3*NANO100_PER_SEC;
ASSERT( FALSE );
//fileSystemControlStatus = ZwWaitForSingleObject( eventHandle, TRUE,NULL /*, &timeOut*/ );
}
IoSetTopLevelIrp( topLevelIrp );
if (fileSystemControlStatus != STATUS_SUCCESS)
DebugTrace( 0, Dbg2, ("VolDoThreadProc: VolDo = %p, fileSystemControlStatus = %x, ioStatusBlock = %x\n",
VolDo, fileSystemControlStatus, ioStatusBlock.Information) );
ZwClose( eventHandle );
ZwClose( fileHandle );
break;
} while (0);
KeQuerySystemTime( &VolDo->TryFlushOrPurgeTime );
VolDo->ReceiveWriteCommand = FALSE;
}
continue;
}
ASSERT( KeGetCurrentIrql() == PASSIVE_LEVEL );
ASSERT( eventCount < THREAD_WAIT_OBJECTS );
if (!NT_SUCCESS( eventStatus ) || eventStatus >= eventCount) {
ASSERT( NDASNTFS_UNEXPECTED );
SetFlag( VolDo->Thread.Flags, VOLDO_THREAD_FLAG_ERROR );
volDoThreadTerminate = TRUE;
continue;
}
KeClearEvent( events[eventStatus] );
if (eventStatus == 0) {
volDoThreadTerminate = TRUE;
break;
} else {
NDAS_ASSERT( NDASNTFS_BUG );
}
}
ASSERT( KeGetCurrentIrql() == PASSIVE_LEVEL );
ExAcquireFastMutex( &VolDo->FastMutex );
SetFlag( VolDo->Thread.Flags, VOLDO_THREAD_FLAG_STOPED );
ExReleaseFastMutex( &VolDo->FastMutex );
DebugTrace( 0, Dbg2, ("VolDoThreadProc: PsTerminateSystemThread VolDo = %p\n", VolDo) );
ExAcquireFastMutex( &VolDo->FastMutex );
SetFlag( VolDo->Thread.Flags, VOLDO_THREAD_FLAG_TERMINATED );
ExReleaseFastMutex( &VolDo->FastMutex );
VolDo_Dereference( VolDo );
ASSERT( KeGetCurrentIrql() == PASSIVE_LEVEL );
PsTerminateSystemThread( STATUS_SUCCESS );
}
