able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/fs/rdr2/rdbss/wrapper.sav/cleanup.c

923 lines
30 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1989 Microsoft Corporation
Module Name:
Cleanup.c
Abstract:
This module implements the File Cleanup routine for Rx called by the
dispatch driver.
Author:
Joe Linn [JoeLinn] 12-sep-94
Revision History:
--*/
#include "precomp.h"
#pragma hdrstop
//
// The Bug check file id for this module
//
#define BugCheckFileId (RDBSS_BUG_CHECK_CLEANUP)
//
// The local debug trace level
//
#define Dbg (DEBUG_TRACE_CLEANUP)
BOOLEAN
RxUninitializeCacheMap(
IN OUT PRX_CONTEXT RxContext,
IN PFILE_OBJECT FileObject,
IN PLARGE_INTEGER TruncateSize
);
#if DBG
//this is just a dbg thing
extern
BOOLEAN
RxLockEnumerator (
IN OUT struct _MRX_SRV_OPEN_ * SrvOpen,
IN OUT PVOID *ContinuationHandle,
OUT PLARGE_INTEGER FileOffset,
OUT PLARGE_INTEGER LockRange,
OUT PBOOLEAN IsLockExclusive
);
BOOLEAN
RxFakeLockEnumerator (
IN OUT struct _SRV_OPEN * SrvOpen,
IN OUT PVOID *ContinuationHandle,
OUT PLARGE_INTEGER FileOffset,
OUT PLARGE_INTEGER LockRange,
OUT PBOOLEAN IsLockExclusive
);
VOID
RxDumpSerializationQueue(
PLIST_ENTRY SQ,
PSZ TagText1,
PSZ TagText2
);
#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE, RxDumpSerializationQueue)
#endif
#endif //if DBG
VOID
RxCleanupPipeQueues (
IN PRX_CONTEXT RxContext
);
#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE, RxCommonCleanup)
#pragma alloc_text(PAGE, RxAdjustFileTimesAndSize)
#pragma alloc_text(PAGE, RxCleanupPipeQueues)
#pragma alloc_text(PAGE, RxUninitializeCacheMap)
#endif
NTSTATUS
RxCommonCleanup ( RXCOMMON_SIGNATURE )
/*++
Routine Description:
This is the common routine for cleanup of a file/directory called by
both the fsd and fsp threads.
Cleanup is invoked whenever the last handle to a file object is
closed. This is different than the Close operation which is invoked
when the last reference to a file object is deleted.
The function of cleanup is to essentially "cleanup" the
file/directory after a user is done with it. The Fcb/Dcb remains
around (because MM still has the file object referenced) but is now
available for another user to open (i.e., as far as the user is
concerned the file object is now closed). See close for a more complete
description of what close does.
Please see the discussion in openclos.txt.
Arguments:
Irp - Supplies the Irp to process
Return Value:
RXSTATUS - The return status for the operation
--*/
{
NTSTATUS Status;
RxCaptureRequestPacket;
RxCaptureFcb;
RxCaptureFobx;
RxCaptureParamBlock;
RxCaptureFileObject;
NODE_TYPE_CODE TypeOfOpen = NodeType(capFcb);
NET_ROOT_TYPE NetRootType;
PNET_ROOT NetRoot;
PSHARE_ACCESS ShareAccess = NULL;
PLARGE_INTEGER TruncateSize = NULL;
LARGE_INTEGER LocalTruncateSize;
BOOLEAN UninitializeCacheMap = FALSE;
BOOLEAN LastUncleanOnGoodFcb = FALSE;
BOOLEAN NeedPurge = FALSE;
BOOLEAN NeedDelete = FALSE;
BOOLEAN AcquiredFcb = FALSE;
BOOLEAN AcquiredTableLock = FALSE;
PAGED_CODE();
RxDbgTrace(+1, Dbg, ("RxCommonCleanup IrpC/Fobx/Fcb/FileObj = %08lx %08lx %08lx %08lx\n",
RxContext,capFobx,capFcb,capFileObject));
RxLog(("CommonCleanup %lx %lx %lx\n",RxContext,capFobx,capFcb));
// If this cleanup is for the case of directories opened for renames etc.,
// where there is no file object cleanup succeeds immediately.
if (!capFobx) {
if (capFcb->UncleanCount > 0) {
InterlockedDecrement(&capFcb->UncleanCount);
}
//RxMarkFcbForScavengingAtCleanup(capFcb);
RxDbgTrace(-1, Dbg, ("Cleanup nullfobx open\n", 0));
return(STATUS_SUCCESS);
}
// Cleanup applies to certain types of opens. If it is not one of those
// abort immediately.
if ((TypeOfOpen != RDBSS_NTC_STORAGE_TYPE_FILE) &&
(TypeOfOpen != RDBSS_NTC_STORAGE_TYPE_DIRECTORY) &&
(TypeOfOpen != RDBSS_NTC_STORAGE_TYPE_UNKNOWN) &&
(TypeOfOpen != RDBSS_NTC_SPOOLFILE)) {
RxLog(("RxCC Invalid Open %lx %lx %lx\n",RxContext,capFobx,capFcb));
RxBugCheck( TypeOfOpen, 0, 0 );
}
// Ensure that the object has not been cleaned up before. This should
// never occur.
ASSERT( !FlagOn( capFileObject->Flags, FO_CLEANUP_COMPLETE ));
RxMarkFobxOnCleanup(capFobx,&NeedPurge);
// Acquire the FCB. In most cases no further resource acquisition is required
// to complete the cleanup operation. The only exceptions are when the file
// was initially opened with the DELETE_ON_CLOSE option. In such cases the
// FCB table lock of the associated NET_ROOT instance is required.
Status = RxAcquireExclusiveFcb( RxContext, capFcb );
if (Status != STATUS_SUCCESS) {
RxDbgTrace(-1, Dbg, ("RxCommonCleanup Failed to acquire FCB -> %lx\n)", Status));
return Status;
}
AcquiredFcb = TRUE;
if (FlagOn(capFcb->FcbState,FCB_STATE_ORPHANED)) {
ASSERT( capFcb->UncleanCount );
InterlockedDecrement(&capFcb->UncleanCount);
if (FlagOn(capFileObject->Flags,FO_NO_INTERMEDIATE_BUFFERING)) {
capFcb->UncachedUncleanCount--;
}
MINIRDR_CALL(Status,RxContext,capFcb->MRxDispatch,MRxCleanupFobx,(RxContext));
ASSERT( capFobx->SrvOpen->UncleanFobxCount );
capFobx->SrvOpen->UncleanFobxCount--;
RxReleaseFcb(RxContext,capFcb);
return STATUS_SUCCESS;
}
NetRootType = capFcb->VNetRoot->NetRoot->Type ;
NetRoot = (PNET_ROOT)capFcb->VNetRoot->NetRoot;
if ( FlagOn(capFobx->Flags, FOBX_FLAG_DELETE_ON_CLOSE) ) {
SetFlag( capFcb->FcbState, FCB_STATE_DELETE_ON_CLOSE );
}
ShareAccess = &capFcb->ShareAccess;
LastUncleanOnGoodFcb = (capFcb->UncleanCount == 1);
if (LastUncleanOnGoodFcb && FlagOn(capFcb->FcbState, FCB_STATE_DELETE_ON_CLOSE)) {
// if we can't get it right way, drop the Fcb and acquire/acquire
// to perserve lock order. No one else can change the counts while we have
// the fcb lock; neither can a file become DELETE_ON_CLOSE or be opened via
// CommonCreate. If we are not deleting, get rid of the tablelock after we
// verify the count.
if ( RxAcquireFcbTableLockExclusive(&NetRoot->FcbTable, FALSE) ) {
// this is the fast way....hope it works
AcquiredTableLock = TRUE;
} else {
// Release the FCB and reqcquire the locks in the correct order.
// PrefixTableLock followed by the FCB.
RxReleaseFcb( RxContext, capFcb );
AcquiredFcb = FALSE;
(VOID)RxAcquireFcbTableLockExclusive(&NetRoot->FcbTable, TRUE);
AcquiredTableLock = TRUE;
Status = RxAcquireExclusiveFcb( RxContext, capFcb );
if (Status != STATUS_SUCCESS) {
RxDbgTrace(-1, Dbg, ("RxCommonCleanup Failed to acquire FCB -> %lx\n)", Status));
return Status;
}
AcquiredFcb = TRUE;
}
if (capFcb->UncleanCount != 1) {
RxReleaseFcbTableLock(&NetRoot->FcbTable);
AcquiredTableLock = FALSE;
NeedDelete = FALSE;
} else {
NeedDelete = TRUE;
}
}
try {
switch (NetRootType) {
case NET_ROOT_PIPE:
case NET_ROOT_PRINT:
{
// If the file object corresponds to a pipe or spool file additional
// cleanup operations are required. This deals with the special
// serialization mechanism for pipes.
RxCleanupPipeQueues(RxContext);
}
break;
case NET_ROOT_DISK:
{
switch (TypeOfOpen) {
case RDBSS_NTC_STORAGE_TYPE_FILE :
{
// If the file object corresponds to a disk file, assert the locks
// and update the associated file times and sizes.
PLOWIO_CONTEXT LowIoContext = &RxContext->LowIoContext;
LowIoContext->Flags |= LOWIO_CONTEXT_FLAG_SAVEUNLOCKS;
FsRtlFastUnlockAll(
&capFcb->Specific.Fcb.FileLock,
capFileObject,
IoGetRequestorProcess( capReqPacket ),
RxContext );
if (LowIoContext->ParamsFor.Locks.LockList != NULL) {
RxDbgTrace(0, Dbg, ("--->before init, locklist=%08lx\n", LowIoContext->ParamsFor.Locks.LockList));
RxInitializeLowIoContext(LowIoContext,LOWIO_OP_UNLOCK_MULTIPLE);
LowIoContext->ParamsFor.Locks.Flags = 0; //no flags
Status = RxLowIoLockControlShell(RxContext);
}
RxAdjustFileTimesAndSize(RXCOMMON_ARGUMENTS);
// If the file object corresponds to a disk file/directory and this
// is the last cleanup call for the FCB additional processing is required.
if (LastUncleanOnGoodFcb) {
try {
// If the file object was marked DELETE_ON_CLOSE set the file size to
// zero ( synchronizing with the paging resource)
if (NeedDelete) {
RxAcquirePagingIoResource( capFcb );
capFcb->Header.FileSize.QuadPart = 0;
if (TypeOfOpen == RDBSS_NTC_STORAGE_TYPE_FILE) {
capFcb->Header.ValidDataLength.QuadPart = 0;
}
RxReleasePagingIoResource( capFcb );
} else {
// If the file object was not marked for deletion and it is not
// a paging file ensure that the portion between the valid data
// length and the file size is zero extended.
if (!FlagOn(capFcb->FcbState, FCB_STATE_PAGING_FILE) &&
(capFcb->Header.ValidDataLength.QuadPart <
capFcb->Header.FileSize.QuadPart)) {
RxDbgTrace(0, Dbg, ("---------->zeroextend!!!!!!!\n", 0));
MINIRDR_CALL(Status,RxContext,capFcb->MRxDispatch,MRxZeroExtend,(RxContext));
capFcb->Header.ValidDataLength.QuadPart =
capFcb->Header.FileSize.QuadPart;
}
}
// If the file object was marked for truncation capture the
// sizes for uninitializing the cache maps subsequently.
if (FlagOn(capFcb->FcbState, FCB_STATE_TRUNCATE_ON_CLOSE)) {
RxDbgTrace(0, Dbg, ("truncate file allocation\n", 0));
MINIRDR_CALL(Status,RxContext,capFcb->MRxDispatch,MRxTruncate,(RxContext));
// Setup to truncate the Cache Map because
// this is the only way we have of trashing the
// truncated pages.
LocalTruncateSize = capFcb->Header.FileSize;
TruncateSize = &LocalTruncateSize;
// Mark the Fcb as having now been truncated, just
// in case we have to reprocess this later.
capFcb->FcbState &= ~FCB_STATE_TRUNCATE_ON_CLOSE;
}
} except ( CATCH_EXPECTED_EXCEPTIONS ) {
DbgPrint("!!! Handling Exceptions\n");
NOTHING;
}
}
// Purging can be done now if this FCB does not support collapsed opens
if (!NeedPurge) {
NeedPurge = (LastUncleanOnGoodFcb &&
(NeedDelete ||
!FlagOn(capFcb->FcbState,FCB_STATE_COLLAPSING_ENABLED)));
}
UninitializeCacheMap = TRUE;
}
break;
case RDBSS_NTC_STORAGE_TYPE_DIRECTORY :
case RDBSS_NTC_STORAGE_TYPE_UNKNOWN :
default:
break;
}
}
break;
default:
break;
}
// We've just finished everything associated with an unclean
// fcb so now decrement the unclean count before releasing
// the resource.
ASSERT( capFcb->UncleanCount );
InterlockedDecrement(&capFcb->UncleanCount);
if (FlagOn(capFileObject->Flags,FO_NO_INTERMEDIATE_BUFFERING)) {
capFcb->UncachedUncleanCount--;
}
MINIRDR_CALL(Status,RxContext,capFcb->MRxDispatch,MRxCleanupFobx,(RxContext));
ASSERT( capFobx->SrvOpen->UncleanFobxCount );
capFobx->SrvOpen->UncleanFobxCount--;
// If this was the last cached open, and there are open
// non-cached handles, attempt a flush and purge operation
// to avoid cache coherency overhead from these non-cached
// handles later. We ignore any I/O errors from the flush.
if (capFcb->NonPaged->SectionObjectPointers.DataSectionObject != NULL) {
RxFlushFile( RxContext, capFcb );
}
if (!FlagOn( capFileObject->Flags, FO_NO_INTERMEDIATE_BUFFERING ) &&
(capFcb->UncachedUncleanCount != 0) &&
(capFcb->UncachedUncleanCount == capFcb->UncleanCount) &&
(capFcb->NonPaged->SectionObjectPointers.DataSectionObject != NULL)) {
RxFlushFile( RxContext, capFcb );
CcPurgeCacheSection(
&capFcb->NonPaged->SectionObjectPointers,
NULL,
0,
FALSE );
}
// do we need a flush?
if (!NeedDelete && NeedPurge) {
RxDbgTrace(0, Dbg, ("CleanupPurge:CCFlush\n", 0));
RxFlushFile( RxContext, capFcb );
}
// cleanup the cache map to get rid of pages that are no longer part
// of the file. amazingly, this works even if we didn't init the Cachemap!!!!!
if (UninitializeCacheMap) {
RxUninitializeCacheMap( RxContext, capFileObject, TruncateSize );
}
// finish up a delete...we have to purge because MM is holding the file open....
// just for the record, NeedPurge is set for files and clear for directories......
if (NeedDelete || NeedPurge) {
RxDbgTrace(0, Dbg, ("CleanupPurge:MmFlushImage\n", 0));
MmFlushImageSection(&capFcb->NonPaged->SectionObjectPointers,
MmFlushForWrite);
ASSERT((AcquiredFcb));
RxReleaseFcb( RxContext, capFcb );
AcquiredFcb = FALSE;
MmForceSectionClosed(&capFcb->NonPaged->SectionObjectPointers, TRUE);
RxAcquireExclusiveFcb(RxContext,capFcb);
AcquiredFcb = TRUE;
RxDbgTrace(0, Dbg, ("CleanupPurge:PurgingFinished\n", 0));
if (NeedDelete) {
RxRemoveNameNetFcb( capFcb );
RxReleaseFcbTableLock(&NetRoot->FcbTable);
AcquiredTableLock = FALSE;
}
}
// The Close Call and the Cleanup Call may be far apart. The share access
// must be cleaned up if the file was mapped through this File Object.
if ((ShareAccess != NULL) &&
(NetRootType == NET_ROOT_DISK)) {
ASSERT (NetRootType == NET_ROOT_DISK);
RxRemoveShareAccess( capFileObject, ShareAccess, "Cleanup the Share access", "ClnUpShr" );
}
if (TypeOfOpen == RDBSS_NTC_STORAGE_TYPE_FILE) {
// Coordinate the cleanup operation with the oplock state.
// Cleanup operations can always cleanup immediately.
FsRtlCheckOplock( &capFcb->Specific.Fcb.Oplock, capReqPacket,
RxContext, NULL, NULL );
//capFcb->Header.IsFastIoPossible = RxIsFastIoPossible( capFcb );
}
if (AcquiredFcb) {
RxReleaseFcb( RxContext, capFcb );
AcquiredFcb = FALSE;
}
// A local filesystem would do this..........
// If the NET_ROOT is on a removeable media, flush the volume. We do
// this in lieu of write through for removeable media for
// performance considerations. That is, data is guaranteed
// to be out when NtCloseFile returns.
// The file needs to be flushed
// The cleanup for this file object has been successfully completed at
// this point.
SetFlag( capFileObject->Flags, FO_CLEANUP_COMPLETE );
Status = STATUS_SUCCESS;
} finally {
DebugUnwind( RxCommonCleanup );
if (AcquiredFcb) {
RxReleaseFcb( RxContext, capFcb );
}
if (AcquiredTableLock) {
RxReleaseFcbTableLock(&NetRoot->FcbTable);
}
IF_DEBUG {
if (AbnormalTermination()) {
RxDbgTrace(-1, Dbg, ("RxCommonCleanup -> Abnormal Termination %08lx\n", Status));
} else {
RxDbgTrace(-1, Dbg, ("RxCommonCleanup -> %08lx\n", Status));
}
}
}
return Status;
}
VOID
RxAdjustFileTimesAndSize ( RXCOMMON_SIGNATURE )
/*++
Routine Description:
This routine is used to adjust the times and the filesize on a cleanup
or a flush.
Arguments:
Irp - Supplies the Irp to process
Return Value:
RXSTATUS - The return status for the operation
--*/
{
RxCaptureFcb;
RxCaptureFobx;
RxCaptureParamBlock;
RxCaptureFileObject;
BOOLEAN UpdateFileSize;
BOOLEAN UpdateLastWriteTime;
BOOLEAN UpdateLastAccessTime;
BOOLEAN UpdateLastChangeTime;
LARGE_INTEGER CurrentTime;
PAGED_CODE();
//if there's no cachemap then we don't have to send because the guy is
//tracking everything on the other end.
//LOCAL.MINI for a localminiFS we would still have to do this; so the answer to this question
// (whether to do it or not) should be exposed in the fcb/fobx
if ( capFileObject->PrivateCacheMap == NULL ) return;
KeQuerySystemTime( &CurrentTime );
//
// Note that we HAVE to use BooleanFlagOn() here because
// FO_FILE_SIZE_CHANGED > 0x80 (i.e., not in the first byte).
//
UpdateFileSize = BooleanFlagOn(capFileObject->Flags, FO_FILE_SIZE_CHANGED);
UpdateLastWriteTime = FlagOn(capFileObject->Flags, FO_FILE_MODIFIED) &&
!FlagOn(capFobx->Flags, FOBX_FLAG_USER_SET_LAST_WRITE);
UpdateLastChangeTime = FlagOn(capFileObject->Flags, FO_FILE_MODIFIED) &&
!FlagOn(capFobx->Flags, FOBX_FLAG_USER_SET_LAST_CHANGE);
UpdateLastAccessTime =
(UpdateLastWriteTime ||
(FlagOn(capFileObject->Flags, FO_FILE_FAST_IO_READ) &&
!FlagOn(capFobx->Flags, FOBX_FLAG_USER_SET_LAST_ACCESS)));
if (UpdateFileSize ||
UpdateLastWriteTime ||
UpdateLastChangeTime ||
UpdateLastAccessTime ) {
ULONG NotifyFilter = 0;
BOOLEAN DoTheTimeUpdate = FALSE;
FILE_BASIC_INFORMATION BasicInformation;
FILE_END_OF_FILE_INFORMATION EofInformation;
RxDbgTrace(0, Dbg, ("Update Time and/or file size on File\n", 0));
RtlZeroMemory(&BasicInformation,sizeof(BasicInformation));
try { //for finally
try { //for exceptions
if (UpdateLastWriteTime) {
//
// Update its time of last write
DoTheTimeUpdate = TRUE;
capFcb->LastWriteTime = CurrentTime;
BasicInformation.LastWriteTime = CurrentTime;
NotifyFilter |= FILE_NOTIFY_CHANGE_ATTRIBUTES
| FILE_NOTIFY_CHANGE_LAST_WRITE;
}
if (UpdateLastChangeTime) {
//
// Update its time of last write
DoTheTimeUpdate = TRUE;
BasicInformation.ChangeTime = capFcb->LastChangeTime;
//NotifyFilter |= FILE_NOTIFY_CHANGE_ATTRIBUTES
// | FILE_NOTIFY_CHANGE_LAST_CHANGE;
}
if (UpdateLastAccessTime) {
DoTheTimeUpdate = TRUE;
capFcb->LastAccessTime = CurrentTime;
BasicInformation.LastAccessTime = CurrentTime;
NotifyFilter |= FILE_NOTIFY_CHANGE_LAST_ACCESS;
}
if (DoTheTimeUpdate) {
NTSTATUS Status; //if it doesn't work.....sigh
RxContext->Info.FileInformationClass = (FileBasicInformation);
RxContext->Info.Buffer = &BasicInformation;
RxContext->Info.Length = sizeof(BasicInformation);
MINIRDR_CALL(Status,RxContext,capFcb->MRxDispatch,MRxSetFileInfoAtCleanup,(RxContext));
}
if (UpdateFileSize) {
NTSTATUS Status; //if it doesn't work.....sigh
EofInformation.EndOfFile = capFcb->Header.FileSize;
RxContext->Info.FileInformationClass = (FileEndOfFileInformation);
RxContext->Info.Buffer = &EofInformation;
RxContext->Info.Length = sizeof(EofInformation);
MINIRDR_CALL(Status,RxContext,capFcb->MRxDispatch,MRxSetFileInfoAtCleanup,(RxContext));
NotifyFilter |= FILE_NOTIFY_CHANGE_SIZE;
}
//RxNotifyReportChange( RxContext, Vcb, Fcb,
// NotifyFilter,
// FILE_ACTION_MODIFIED );
//MINIRDR_CALL(Status,capFcb->MRxDispatch,MRxSetTimeAndSize,(RxContext));
} except( CATCH_EXPECTED_EXCEPTIONS ) {
NOTHING;
}
} finally {
NOTHING;
}
}
}
#define RxMoveAllButFirstToAnotherList(List1,List2) { \
PLIST_ENTRY FrontListEntry = (List1)->Flink; \
if (FrontListEntry->Flink == (List1)) { \
(List2)->Flink = (List2)->Blink = (List2); \
} else { \
(List2)->Blink = (List1)->Blink; \
(List2)->Blink->Flink = (List2); \
(List1)->Blink = FrontListEntry; \
(List2)->Flink = FrontListEntry->Flink; \
FrontListEntry->Flink = (List1); \
(List2)->Flink->Blink = (List2); \
} \
}
#if DBG
PSZ RxDSQTagText[FOBX_NUMBER_OF_SERIALIZATION_QUEUES] = {"read","write"};
VOID
RxDumpSerializationQueue(
PLIST_ENTRY SQ,
PSZ TagText1,
PSZ TagText2
)
{
PLIST_ENTRY ListEntry;
PAGED_CODE();
if (IsListEmpty(SQ)) {
RxDbgTrace(0, Dbg, ("RxDumpSerializationQueue %s%s is empty\n", TagText1, TagText2));
return;
}
RxDbgTrace(0, Dbg, ("RxDumpSerializationQueue %s%s:\n", TagText1, TagText2));
for (ListEntry=SQ->Flink;
ListEntry!=SQ;
ListEntry=ListEntry->Flink) {
//print out the contexts and the major op for validation
PRX_CONTEXT RxContext = CONTAINING_RECORD( ListEntry,RX_CONTEXT,RxContextSerializationQLinks);
RxDbgTrace(0, Dbg, (" rxc=%08lx op=%02lx\n", RxContext, RxContext->MajorFunction));
}
}
#else
#define RxDumpSerializationQueue(___r,___t12,___t13) {NOTHING;}
#endif
VOID
RxCleanupPipeQueues (
IN PRX_CONTEXT RxContext
)
{
RxCaptureFcb; RxCaptureFobx;
LIST_ENTRY SecondaryBlockedQs[FOBX_NUMBER_OF_SERIALIZATION_QUEUES];
PLIST_ENTRY PrimaryBlockedQs = &capFobx->Specific.NamedPipe.ReadSerializationQueue;
ULONG i;
PAGED_CODE();
RxDbgTrace(+1, Dbg, ("RxCleanupPipeQueues \n"));
//for pipes there are two sources of unhappiness...........
//first, we have to get rid of any blocked operations.
//second, if there are blocking operations that have already gone by then we have to send the
// close smb early so that the server will, in turn, complete the outstanding
ExAcquireFastMutexUnsafe(&RxContextPerFileSerializationMutex);
for (i=0;i<FOBX_NUMBER_OF_SERIALIZATION_QUEUES;i++) {
RxDumpSerializationQueue(&PrimaryBlockedQs[i],RxDSQTagText[i],"Primary");
if (!IsListEmpty(&PrimaryBlockedQs[i])) {
RxMoveAllButFirstToAnotherList(
&PrimaryBlockedQs[i],
&SecondaryBlockedQs[i]);
RxDumpSerializationQueue(&PrimaryBlockedQs[i],RxDSQTagText[i],"Primary");
RxDumpSerializationQueue(&SecondaryBlockedQs[i],RxDSQTagText[i],"Secondary");
} else {
InitializeListHead(&SecondaryBlockedQs[i]);
}
}
ExReleaseFastMutexUnsafe(&RxContextPerFileSerializationMutex);
for (i=0;i<FOBX_NUMBER_OF_SERIALIZATION_QUEUES;i++) {
for (;!IsListEmpty(&SecondaryBlockedQs[i]);) {
PLIST_ENTRY FrontListEntry = (&SecondaryBlockedQs[i])->Flink;
PRX_CONTEXT FrontRxContext = CONTAINING_RECORD( FrontListEntry,RX_CONTEXT,RxContextSerializationQLinks);
RemoveEntryList(FrontListEntry);
if (!FlagOn(FrontRxContext->Flags,RX_CONTEXT_FLAG_ASYNC_OPERATION)) {
RxDbgTrace(0, Dbg, (" unblocking %08lx\n",FrontRxContext));
RxContext->StoredStatus = STATUS_PIPE_CLOSING;
RxSignalSynchronousWaiter(FrontRxContext);
} else {
RxDbgTrace(0, Dbg, (" completing %08lx\n",FrontRxContext));
RxCompleteAsynchronousRequest( RxContext, STATUS_PIPE_CLOSING );
}
}
}
RxDbgTrace(-1, Dbg, ("RxCleanupPipeQueues exit\n"));
return;
}
BOOLEAN
RxFakeLockEnumerator (
IN OUT struct _SRV_OPEN * SrvOpen,
IN OUT PVOID *ContinuationHandle,
OUT PLARGE_INTEGER FileOffset,
OUT PLARGE_INTEGER LockRange,
OUT PBOOLEAN IsLockExclusive
)
/*++
Routine Description:
THIS ROUTINE IS A FAKE THAT IS JUST USED FOR TESTING PURPOSES!
This routine is called from a minirdr to enumerate the filelocks on an FCB; it gets
one lock on each call. currently, we just pass thru to the fsrtl routine which is very funky
because it keeps the enumeration state internally; as a result, only one enumeration can be in progress
at any time. we can change over to something better if it's ever required.
Arguments:
SrvOpen - a srvopen on the fcb to be enumerated.
ContinuationHandle - a handle passed back and forth representing the state of the enumeration.
if a NULL is passed in, then we are to start at the beginning.
FileOffset,LockRange,IsLockExclusive - the description of the returned lock
Return Value:
a BOOLEAN. FALSE means you've reached the end of the list; TRUE means the returned lock data is valid
--*/
{
ULONG LockNumber;
LockNumber = (ULONG)(*ContinuationHandle);
if (LockNumber>=12) {
return(FALSE);
}
LockNumber++;
RxDbgTrace(0, Dbg, ("Rxlockenum %08lx\n", LockNumber ));
FileOffset->QuadPart = LockNumber;
LockRange->QuadPart = 1;
*IsLockExclusive = (LockNumber&0x4)==0;
*ContinuationHandle = (PVOID)LockNumber;
}
BOOLEAN
RxUninitializeCacheMap(
IN OUT PRX_CONTEXT RxContext,
IN PFILE_OBJECT FileObject,
IN PLARGE_INTEGER TruncateSize
)
/*++
Routine Description:
This routine is a wrapper for CcUninitializeCacheMap.
Arguments:
IN PFILE_OBJECT FileObject - Supplies the file object for the file to purge.
IN PLARGE_INTEGER TruncateSize - Specifies the new size for the file.
Return Value:
BOOLEAN - TRUE if file has been immediately purged, FALSE if we had to wait.
Note:
The file must be locked exclusively before calling this routine.
--*/
{
BOOLEAN CacheReturnValue;
CACHE_UNINITIALIZE_EVENT PurgeCompleteEvent;
PFCB Fcb = FileObject->FsContext;
PAGED_CODE();
ASSERT ( NodeTypeIsFcb(Fcb) );
//
// Make sure that this thread owns the FCB.
//
ASSERT ( RxIsFcbAcquiredExclusive ( Fcb ) );
#if 0
BUGBUG do we need this part too? [joejoe] of course we do. or something similar. we have to synchronize openers
with this piece of code.
//
// In order to guarantee that only one thread is calling
// RxPurgeCacheFile, we reset this event to the
// not-signalled state before calling CcUninitializeCacheMap,
// and then set it when we exit. If any other threads come in
// while we are waiting on the event, they will find that
// CacheFileObject is NULL, and thus wait until the cache purge
// completes.
//
KeClearEvent(&Fcb->NonPagedFcb->PurgeCacheSynchronizer);
#endif
//
// Now uninitialize the cache managers own file object. This is
// done basically simply to allow us to wait until the cache purge
// is complete.
//
KeInitializeEvent(&PurgeCompleteEvent.Event, SynchronizationEvent, FALSE);
//
// Release the lock on the FCB that our caller applied.
//
RxReleaseFcb( RxContext, Fcb );
//RxLog(( "ccunini1", &Fcb->FileName, 2,
// (TruncateSize == NULL) ? 0xffffffff : TruncateSize->LowPart,
// (ULONG)&PurgeCompleteEvent ));
CacheReturnValue = CcUninitializeCacheMap(FileObject, TruncateSize, &PurgeCompleteEvent);
#if 0
//
// Make sure that this thread doesn't own the FCB.
//
ASSERT (!ExIsResourceAcquiredExclusive(Fcb->Header.Resource));
#endif
//
// Now wait for the cache manager to finish purging the file.
//
KeWaitForSingleObject(&PurgeCompleteEvent.Event,
Executive,
KernelMode,
FALSE,
NULL);
//
// Re-acquire the FCB lock once we've waited for the
// cache manager to finish the uninitialize.
//
RxAcquireExclusiveFcb( RxContext, Fcb );
#if 0
//
// Now set the purge cache event to the signalled state to allow
// other threads waiting on the cache purge to continue.
//
KeSetEvent(&Fcb->NonPagedFcb->PurgeCacheSynchronizer, 0, FALSE);
#endif
return(CacheReturnValue);
}

Reference in a new issue Copy permalink