/*++ BUILD Version: 0009 // Increment this if a change has global effects Copyright (c) 1987-1993 Microsoft Corporation Module Name: buffring.c Abstract: This module defines the implementation for changing buffering states in the RDBSS Author: Balan Sethu Raman (SethuR) 11-Nov-95 Created Notes: The RDBSS provides a mechanism for providing distributed cache coherency in conjunction with the various mini redirectors. This service is encapsulated in the BUFFERING_MANAGER which processes CHANGE_BUFFERING_STATE_REQUESTS. In the SMB protocol OPLOCK's ( Oppurtunistic Locks ) provide the necessary infrastructure for cache coherency. There are three components in the implementation of cache coherency protocol's in any mini redirector. 1) The first constitutes the modifications to the CREATE/OPEN path. In this path the type of buffering to be requested is determined and the appropriate request is made to the server. On the return path the buffering state associated with the FCB is updated based on the result of the CREATE/OPEN. 2) The receive indication code needs to modified to handle change buffering state notifications from the server. If such a request is detected then the local mechanism to coordinate the buffering states needs to be triggered. 3) The mechanism for changing the buffering state which is implemented as part of the RDBSS. Any change buffering state request must identify the SRV_OPEN to which the request applies. The amount of computational effort involved in identifying the SRV_OPEN depends upon the protocol. In the SMB protocol the Server gets to pick the id's used for identifying files opened at the server. These are relative to the NET_ROOT(share) on which they are opened. Thus every change buffering state request is identified by two keys, the NetRootKey and the SrvOpenKey which need to be translated to the appropriate NET_ROOT and SRV_OPEN instance respectively. In order to provide better integration with the resource acquisition/release mechanism and to avoid duplication of this effort in the various mini redirectors the RDBSS provides this service. There are two mechanisms provided in the wrapper for indicating buffering state changes to SRV_OPEN's. They are 1) RxIndicateChangeOfBufferingState 2) RxIndicateChangeOfBufferingStateForSrvOpen. The mini rediretors that need an auxillary mechanism for establishing the mapping from the id's to the SRV_OPEN instance employ (1) while the mini redirectors that do not require this assistance employ (2). The buffering manager processes these requests in different stages. It maintains the requests received from the various underlying mini redirectors in one of three lists. The Dispatcher list contains all the requests for which the appropriate mapping to a SRV_OPEN instance has not been established. The Handler list contains all the requests for which the appropriate mapping has been established and have not yet been processed. The LastChanceHandlerList contains all the requests for which the initial processing was unsuccessful. This typically happens when the FCB was accquired in a SHARED mode at the time the change buffering state request was received. In such cases the Oplock break request can only be processed by a delayed worker thread. The Change buffering state request processing in the redirector is intertwined with the FCB accqusition/release protocol. This helps in ensuring shorter turn around times. --*/ #include "precomp.h" #pragma hdrstop #ifdef ALLOC_PRAGMA #pragma alloc_text(PAGE, RxTearDownBufferingManager) #pragma alloc_text(PAGE, RxIndicateChangeOfBufferingStateForSrvOpen) #pragma alloc_text(PAGE, RxPrepareRequestForHandling) #pragma alloc_text(PAGE, RxPrepareRequestForReuse) #pragma alloc_text(PAGE, RxpDiscardChangeBufferingStateRequests) #pragma alloc_text(PAGE, RxProcessFcbChangeBufferingStateRequest) #pragma alloc_text(PAGE, RxPurgeChangeBufferingStateRequestsForSrvOpen) #pragma alloc_text(PAGE, RxProcessChangeBufferingStateRequestsForSrvOpen) #pragma alloc_text(PAGE, RxInitiateSrvOpenKeyAssociation) #pragma alloc_text(PAGE, RxpLookupSrvOpenForRequestLite) #pragma alloc_text(PAGE, RxChangeBufferingState) #pragma alloc_text(PAGE, RxFlushFcbInSystemCache) #pragma alloc_text(PAGE, RxPurgeFcbInSystemCache) #endif // // The Bug check file id for this module // #define BugCheckFileId (RDBSS_BUG_CHECK_CACHESUP) // // The local debug trace level // #define Dbg (DEBUG_TRACE_CACHESUP) // // Forward declarations // extern NTSTATUS RxRegisterChangeBufferingStateRequest( PSRV_CALL pSrvCall, PSRV_OPEN pSrvOpen, PVOID SrvOpenKey, PVOID pMRxContext); extern VOID RxDispatchChangeBufferingStateRequests( PSRV_CALL pSrvCall); extern VOID RxpDispatchChangeBufferingStateRequests( IN OUT PSRV_CALL pSrvCall, IN OUT PSRV_OPEN pSrvOpen, OUT PLIST_ENTRY pDiscardedRequests); extern VOID RxpDiscardChangeBufferingStateRequests( IN OUT PLIST_ENTRY pDiscardedRequests); extern VOID RxLastChanceHandlerForChangeBufferingStateRequests( PSRV_CALL pSrvCall); extern NTSTATUS RxpLookupSrvOpenForRequestLite( IN PSRV_CALL pSrvCall, IN OUT PCHANGE_BUFFERING_STATE_REQUEST pRequest); extern VOID RxGatherRequestsForSrvOpen( IN OUT PSRV_CALL pSrvCall, IN PSRV_OPEN pSrvOpen, IN OUT PLIST_ENTRY pRequestsListHead); NTSTATUS RxInitializeBufferingManager( PSRV_CALL pSrvCall) /*++ Routine Description: This routine initializes the buffering manager associated with a SRV_CALL instance. Arguments: pSrvCall - the SRV_CALL instance Return Value: STATUS_SUCCESS if successful Notes: The buffering manager consists of three lists ..... 1) the dispatcher list which contains all the requests that need to be processed. 2) the handler list contains all the requests for which the SRV_OPEN instance has been found and referenced. 3) the last chance handler list contains all the requests for which an unsuccessful attempt to process the request was made, i.e., the FCB could not be acquired exclusively. The manipulation of these lists are done under the control of the spin lock associated with the buffering manager. A Mutex will not suffice since these lists are manipulated at DPC level. All buffering manager operations at non DPC level are serialized using the Mutex associated with the buffering manager. --*/ { PRX_BUFFERING_MANAGER pBufferingManager; pBufferingManager = &pSrvCall->BufferingManager; KeInitializeSpinLock( &pBufferingManager->SpinLock ); InitializeListHead(&pBufferingManager->HandlerList); InitializeListHead(&pBufferingManager->LastChanceHandlerList); InitializeListHead(&pBufferingManager->DispatcherList); pBufferingManager->fNoWaitHandlerActive = FALSE; pBufferingManager->fLastChanceHandlerActive = FALSE; pBufferingManager->fDispatcherActive = FALSE; pBufferingManager->NumberOfOutstandingOpens = 0; InitializeListHead(&pBufferingManager->SrvOpenLists[0]); ExInitializeFastMutex(&pBufferingManager->Mutex); return STATUS_SUCCESS; } NTSTATUS RxTearDownBufferingManager( PSRV_CALL pSrvCall) /*++ Routine Description: This routine tears down the buffering manager associated with a SRV_CALL instance. Arguments: pSrvCall - the SRV_CALL instance Return Value: STATUS_SUCCESS if successful --*/ { PRX_BUFFERING_MANAGER pBufferingManager; PAGED_CODE(); pBufferingManager = &pSrvCall->BufferingManager; // Ensure that all the work items in the buffering manager are not in use. if (pBufferingManager->DispatcherWorkItem.List.Flink != NULL) { //DbgBreakPoint(); } if (pBufferingManager->HandlerWorkItem.List.Flink != NULL) { //DbgBreakPoint(); } if (pBufferingManager->LastChanceHandlerWorkItem.List.Flink != NULL) { //DbgBreakPoint(); } return STATUS_SUCCESS; } VOID RxIndicateChangeOfBufferingState( PMRX_SRV_CALL pSrvCall, PVOID SrvOpenKey, PVOID pMRxContext) /*++ Routine Description: This routine registers an oplock break indication. Arguments: pSrvCall - the SRV_CALL instance SrvOpenKey - the key for the SRV_OPEN instance. pMRxContext - the context to be passed back to the mini rdr during callbacks for processing the oplock break. Return Value: none. Notes: This is an instance in which the buffering state change request from the server identifies the SRV_OPEN instance using the key generated by the server This implies that the key needs to be mapped onto the SRV_OPEN instance locally. --*/ { RxRegisterChangeBufferingStateRequest( (PSRV_CALL)pSrvCall, NULL, SrvOpenKey, pMRxContext); } VOID RxIndicateChangeOfBufferingStateForSrvOpen( PMRX_SRV_CALL pSrvCall, PMRX_SRV_OPEN pMRxSrvOpen, PVOID SrvOpenKey, PVOID pMRxContext) /*++ Routine Description: This routine registers an oplock break indication. If the necessary preconditions are satisfied the oplock is processed further. Arguments: pSrvCall - the SRV_CALL instance pMRxSrvOpen - the SRV_OPEN instance. pMRxContext - the context to be passed back to the mini rdr during callbacks for processing the oplock break. Return Value: none. Notes: This is an instance where in the buffering state change indications from the server use the key generated by the client. ( the SRV_OPEN address in itself is the best key that can be used ). This implies that no further lookup is required. However if this routine is called at DPC level, the indication is processed as if the lookup needs to be done. --*/ { PAGED_CODE(); if (KeGetCurrentIrql() <= APC_LEVEL) { PSRV_OPEN pSrvOpen = (PSRV_OPEN)pMRxSrvOpen; // If the resource for the FCB has already been accquired by this thread // the buffering state change indication can be processed immediately // without further delay. if (ExIsResourceAcquiredExclusiveLite(pSrvOpen->pFcb->Header.Resource)) { RxChangeBufferingState(pSrvOpen,pMRxContext,TRUE); } else { RxRegisterChangeBufferingStateRequest( (PSRV_CALL)pSrvCall, pSrvOpen, pSrvOpen->Key, pMRxContext); } } else { RxRegisterChangeBufferingStateRequest( (PSRV_CALL)pSrvCall, NULL, SrvOpenKey, pMRxContext); } } NTSTATUS RxRegisterChangeBufferingStateRequest( PSRV_CALL pSrvCall, PSRV_OPEN pSrvOpen, PVOID SrvOpenKey, PVOID pMRxContext) /*++ Routine Description: This routine registers a change buffering state requests. If necessary the worker thread routines for further processing are activated. Arguments: pRequest -- change buffering state request to be regsitered Return Value: STATUS_SUCCESS if successful. Notes: This routine registers the change buffering state request by either inserting it in the registration list (DPC Level processing ) or the appropriate(dispatcher/handler list). This is the common routine for processing both kinds of callbacks, i.e, the ones in which the SRV_OPEN instance has been located and the ones in which only the SRV_OPEN key is available. --*/ { NTSTATUS Status; KIRQL SavedIrql; PCHANGE_BUFFERING_STATE_REQUEST pRequest; PRX_BUFFERING_MANAGER pBufferingManager = &pSrvCall->BufferingManager; // Ensure that either the SRV_OPEN instance for this request has not been // passed in or the call is not at DPC level. ASSERT((pSrvOpen == NULL) || (KeGetCurrentIrql() <= APC_LEVEL)); pRequest = RxAllocatePoolWithTag( NonPagedPool, sizeof(CHANGE_BUFFERING_STATE_REQUEST), RX_BUFFERING_MANAGER_POOLTAG); if (pRequest != NULL) { BOOLEAN ActivateHandler = FALSE; BOOLEAN ActivateDispatcher = FALSE; pRequest->Flags = 0; pRequest->pSrvCall = pSrvCall; pRequest->pSrvOpen = pSrvOpen; pRequest->SrvOpenKey = SrvOpenKey; pRequest->pMRxContext = pMRxContext; // If the SRV_OPEN instance for the request is known apriori the request can // be directly inserted into the buffering manager's HandlerList as opposed // to the DispatcherList for those instances in which only the SRV_OPEN key // is available. The insertion into the HandlerList ust be accompanied by an // additional reference to prevent finalization of the instance while a request // is still active. if (pSrvOpen != NULL) { RxReferenceSrvOpen((PSRV_OPEN)pSrvOpen); } KeAcquireSpinLock( &pSrvCall->BufferingManager.SpinLock, &SavedIrql); if (pRequest->pSrvOpen != NULL) { InsertTailList(&pBufferingManager->HandlerList,&pRequest->ListEntry); if (!pBufferingManager->fNoWaitHandlerActive) { pBufferingManager->fNoWaitHandlerActive = TRUE; ActivateHandler = TRUE; } RxLog(("Req %lx SrvOpenKey %lx in Handler List\n",pRequest,pRequest->pSrvOpen)); RxWmiLog(LOG, RxRegisterChangeBufferingStateRequest_1, LOGPTR(pRequest) LOGPTR(pRequest->pSrvOpen)); } else { InsertTailList(&pBufferingManager->DispatcherList,&pRequest->ListEntry); if (!pBufferingManager->fDispatcherActive) { pBufferingManager->fDispatcherActive = TRUE; ActivateDispatcher = TRUE; } RxDbgTrace(0,Dbg,("Request %lx SrvOpenKey %lx in Registartion List\n",pRequest,pRequest->SrvOpenKey)); RxLog(("Req %lx SrvOpenKey %lx in Reg. List\n",pRequest,pRequest->SrvOpenKey)); RxWmiLog(LOG, RxRegisterChangeBufferingStateRequest_2, LOGPTR(pRequest) LOGPTR(pRequest->SrvOpenKey)); } KeReleaseSpinLock( &pSrvCall->BufferingManager.SpinLock, SavedIrql); InterlockedIncrement(&pSrvCall->BufferingManager.CumulativeNumberOfBufferingChangeRequests); if (ActivateHandler) { // Reference the SRV_CALL instance to ensure that it will not be // finalized while the worker thread request is in the scheduler RxReferenceSrvCallAtDpc(pSrvCall); RxPostToWorkerThread( RxFileSystemDeviceObject, HyperCriticalWorkQueue, &pBufferingManager->HandlerWorkItem, RxProcessChangeBufferingStateRequests, pSrvCall); } if (ActivateDispatcher) { // Reference the SRV_CALL instance to ensure that it will not be // finalized while the worker thread request is in the scheduler RxReferenceSrvCallAtDpc(pSrvCall); RxPostToWorkerThread( RxFileSystemDeviceObject, HyperCriticalWorkQueue, &pBufferingManager->DispatcherWorkItem, RxDispatchChangeBufferingStateRequests, pSrvCall); } Status = STATUS_SUCCESS; } else { Status = STATUS_INSUFFICIENT_RESOURCES; RxLog(("!!CBSReq. %lx %lx %lx %lx %lx\n", pSrvCall,pSrvOpen,SrvOpenKey,pMRxContext,Status)); RxWmiLogError(Status, LOG, RxRegisterChangeBufferingStateRequest_3, LOGPTR(pSrvCall) LOGPTR(pSrvOpen) LOGPTR(SrvOpenKey) LOGPTR(pMRxContext) LOGULONG(Status)); RxDbgTrace(0, Dbg, ("Change Buffering State Request Ignored %lx %lx %lx\n", pSrvCall,pSrvOpen,SrvOpenKey,pMRxContext,Status)); } RxDbgTrace(0, Dbg, ("Register SrvCall(%lx) SrvOpen (%lx) Key(%lx) Status(%lx)\n", pSrvCall,pSrvOpen,SrvOpenKey,Status)); return Status; } NTSTATUS RxPrepareRequestForHandling( PCHANGE_BUFFERING_STATE_REQUEST pRequest) /*++ Routine Description: This routine preprocesses the request before initiating buffering state change processing. In addition to obtaining the references on the FCB abd the associated SRV_OPEN, an event is allocated as part of the FCB. This helps establish a priority mechanism for servicing buffering state change requests. The FCB accquisition is a two step process, i.e, wait for this event to be set followed by a wait for the resource. Arguments: pRequest - the buffering state change request Return Value: STATUS_SUCCESS STATUS_INSUFFICIENT_RESOURCES Notes: Not all the FCB's have the space for the buffering state change event allocated when the FCB instance is created. The upside is that space is conserved and the downside is that a separate allocation needs to be made when it is required. This event associated with the FCB provides a two step mechanism for accelerating the processing of buffering state change requests. Ordinary operations get delayed in favour of the buffering state change requests. The details are in resrcsup.c --*/ { NTSTATUS Status = STATUS_SUCCESS; PKEVENT pEvent; PSRV_OPEN pSrvOpen = pRequest->pSrvOpen; PAGED_CODE(); if (!FlagOn(pRequest->Flags,RX_REQUEST_PREPARED_FOR_HANDLING)) { SetFlag(pRequest->Flags,RX_REQUEST_PREPARED_FOR_HANDLING); RxAcquireSerializationMutex(); if ((pEvent = pSrvOpen->Fcb->pBufferingStateChangeCompletedEvent) == NULL) { pEvent = RxAllocatePoolWithTag( NonPagedPool, sizeof(KEVENT), RX_BUFFERING_MANAGER_POOLTAG); if (pEvent != NULL) { pSrvOpen->Fcb->pBufferingStateChangeCompletedEvent = pEvent; KeInitializeEvent( pEvent, NotificationEvent, FALSE ); } } else { KeResetEvent(pEvent); } if (pEvent != NULL) { SetFlag(pSrvOpen->Fcb->FcbState,FCB_STATE_BUFFERING_STATE_CHANGE_PENDING); SetFlag(pSrvOpen->Flags,SRVOPEN_FLAG_BUFFERING_STATE_CHANGE_PENDING); SetFlag(pSrvOpen->Flags,SRVOPEN_FLAG_COLLAPSING_DISABLED); RxDbgTrace(0,Dbg,("3333 Request %lx SrvOpenKey %lx in Handler List\n",pRequest,pRequest->SrvOpenKey)); RxLog(("3333 Req %lx SrvOpenKey %lx in Hndlr List\n",pRequest,pRequest->SrvOpenKey)); RxWmiLog(LOG, RxPrepareRequestForHandling_1, LOGPTR(pRequest) LOGPTR(pRequest->SrvOpenKey)); } else { RxDbgTrace(0,Dbg,("4444 Ignoring Request %lx SrvOpenKey %lx \n",pRequest,pRequest->SrvOpenKey)); RxLog(("Chg. Buf. State Ignored %lx %lx %lx\n", pRequest->SrvOpenKey, pRequest->pMRxContext,STATUS_INSUFFICIENT_RESOURCES)); RxWmiLog(LOG, RxPrepareRequestForHandling_2, LOGPTR(pRequest->SrvOpenKey) LOGPTR(pRequest->pMRxContext)); Status = STATUS_INSUFFICIENT_RESOURCES; } RxReleaseSerializationMutex(); } return Status; } VOID RxPrepareRequestForReuse( PCHANGE_BUFFERING_STATE_REQUEST pRequest) /*++ Routine Description: This routine postprocesses the request before destroying it. This involves dereferencing and setting the appropriate state flags. Arguments: pRequest - the buffering state change request Notes: --*/ { PAGED_CODE(); if (FlagOn(pRequest->Flags,RX_REQUEST_PREPARED_FOR_HANDLING)) { PFCB pFcb = pRequest->pSrvOpen->Fcb; // We should never clear the SrvOpen flag unless we are also clearing the FCB flag // and setting the event! //ClearFlag(pRequest->pSrvOpen->Flags,SRVOPEN_FLAG_BUFFERING_STATE_CHANGE_PENDING); if (RxIsFcbAcquiredExclusive(pFcb)) { RxDereferenceSrvOpen(pRequest->pSrvOpen,LHS_ExclusiveLockHeld); } else { RxDereferenceSrvOpen(pRequest->pSrvOpen,LHS_LockNotHeld); } } else if (pRequest->pSrvOpen != NULL) { RxDereferenceSrvOpen(pRequest->pSrvOpen,LHS_LockNotHeld); } pRequest->pSrvOpen = NULL; } VOID RxpDiscardChangeBufferingStateRequests( PLIST_ENTRY pDiscardedRequests) /*++ Routine Description: This routine discards a list of change buffering state requests one at a time Arguments: pDiscardedRequests - the requests to be discarded Notes: --*/ { PAGED_CODE(); // Process the discarded requests,i.e, free the memory while (!IsListEmpty(pDiscardedRequests)) { PLIST_ENTRY pListEntry; PCHANGE_BUFFERING_STATE_REQUEST pRequest; pListEntry = RemoveHeadList(pDiscardedRequests); pRequest = (PCHANGE_BUFFERING_STATE_REQUEST) CONTAINING_RECORD( pListEntry, CHANGE_BUFFERING_STATE_REQUEST, ListEntry); RxDbgTrace(0,Dbg,("**** (2)Discarding Request(%lx) SrvOpenKey(%lx) \n", pRequest,pRequest->SrvOpenKey)); RxLog(("**** (2)Disc Req(%lx) SOKey(%lx) \n", pRequest,pRequest->SrvOpenKey)); RxWmiLog(LOG, RxpDiscardChangeBufferingStateRequests, LOGPTR(pRequest) LOGPTR(pRequest->SrvOpenKey)); RxPrepareRequestForReuse(pRequest); RxFreePool(pRequest); } } VOID RxpDispatchChangeBufferingStateRequests( PSRV_CALL pSrvCall, PSRV_OPEN pSrvOpen, PLIST_ENTRY pDiscardedRequests) /*++ Routine Description: This routine dispatches the request before destroying it. This involves looking up the SRV_OPEN instance associated with a given SrvOpenKey. Arguments: pSrvCall - the associated SRV_CALL instance pSrvOpen - the associated SRV_OPEN instance. Notes: There are two flavours of this routine. When pSrvOpen is NULL this routine walks through the list of outstanding requests and establishes the mapping between the SrvOpenKey and the SRV_OPEN instance. On the other hand when pSrvOpen is a valid SRV_OPEN instance it merely traverses the list to gather together the requests corresponding to the given SRV_OPEN and transfer them enmasse to to the handler list. The buffering manager mutex must have been accquired on entry to this routine and the mutex ownership will remain invariant on exit. --*/ { NTSTATUS Status; KIRQL SavedIrql; PLIST_ENTRY pListEntry; LIST_ENTRY DispatcherList; LIST_ENTRY HandlerList; BOOLEAN ActivateDispatcher; PRX_BUFFERING_MANAGER pBufferingManager = &pSrvCall->BufferingManager; PCHANGE_BUFFERING_STATE_REQUEST pRequest; InitializeListHead(pDiscardedRequests); InitializeListHead(&HandlerList); ActivateDispatcher = FALSE; // Since the buffering manager lists are subject to modifications while // the requests on the list are being processed, the requests are transferred // enmasse onto a temporary list. This prevents multiple acquisition/release of // the spinlock for each individual request. KeAcquireSpinLock(&pBufferingManager->SpinLock,&SavedIrql); RxTransferList(&DispatcherList,&pBufferingManager->DispatcherList); KeReleaseSpinLock(&pBufferingManager->SpinLock,SavedIrql); // Process the list of requests. pListEntry = DispatcherList.Flink; while (pListEntry != &DispatcherList) { PLIST_ENTRY pListHead; pRequest = (PCHANGE_BUFFERING_STATE_REQUEST) CONTAINING_RECORD( pListEntry, CHANGE_BUFFERING_STATE_REQUEST, ListEntry); pListEntry = pListEntry->Flink; if (pSrvOpen == NULL) { Status = RxpLookupSrvOpenForRequestLite( pSrvCall, pRequest); } else { if (pRequest->SrvOpenKey == pSrvOpen->Key) { pRequest->pSrvOpen = pSrvOpen; RxReferenceSrvOpen(pSrvOpen); Status = STATUS_SUCCESS; } else { Status = STATUS_PENDING; } } // The result of a lookup for a SRV_OPEN instance can yield // either STATUS_PENDING, STATUS_SUCCESS or STATUS_NOT_FOUND. switch (Status) { case STATUS_SUCCESS: { RemoveEntryList(&pRequest->ListEntry); InsertTailList( &HandlerList, &pRequest->ListEntry); } break; default: ASSERT(!"Valid Status Code from RxpLookupSrvOpenForRequestLite"); case STATUS_NOT_FOUND: { RemoveEntryList(&pRequest->ListEntry); InsertTailList( pDiscardedRequests, &pRequest->ListEntry); } break; case STATUS_PENDING: break; } } // Splice back the list of requests that cannot be dispatched onto the // buffering manager's list and prepare for posting to another thread // to resume processing later. KeAcquireSpinLock( &pBufferingManager->SpinLock, &SavedIrql); if (!IsListEmpty(&DispatcherList)) { DispatcherList.Flink->Blink = pBufferingManager->DispatcherList.Blink; pBufferingManager->DispatcherList.Blink->Flink = DispatcherList.Flink; DispatcherList.Blink->Flink = &pBufferingManager->DispatcherList; pBufferingManager->DispatcherList.Blink = DispatcherList.Blink; if (ActivateDispatcher = !pBufferingManager->fDispatcherActive) { pBufferingManager->fDispatcherActive = ActivateDispatcher; } } if (!IsListEmpty(&HandlerList)) { HandlerList.Flink->Blink = pBufferingManager->HandlerList.Blink; pBufferingManager->HandlerList.Blink->Flink = HandlerList.Flink; HandlerList.Blink->Flink = &pBufferingManager->HandlerList; pBufferingManager->HandlerList.Blink = HandlerList.Blink; } KeReleaseSpinLock(&pBufferingManager->SpinLock,SavedIrql); // if resumption at a later time is desired because of unprocessed requests // post to a worker thread. if (ActivateDispatcher) { // Reference the SRV_CALL to ensure that finalization will not occur // while the worker thread request is in the scheduler. RxReferenceSrvCall(pSrvCall); RxLog(("***** Activating Dispatcher\n")); RxWmiLog(LOG, RxpDispatchChangeBufferingStateRequests, LOGPTR(pSrvCall)); RxPostToWorkerThread( RxFileSystemDeviceObject, HyperCriticalWorkQueue, &pBufferingManager->DispatcherWorkItem, RxDispatchChangeBufferingStateRequests, pSrvCall); } } VOID RxDispatchChangeBufferingStateRequests( PSRV_CALL pSrvCall) /*++ Routine Description: This routine dispatches the request. This involves looking up the SRV_OPEN instance associated with a given SrvOpenKey. Arguments: pSrvCall - the associated SRV_CALL instance --*/ { KIRQL SavedIrql; BOOLEAN ActivateHandler = FALSE; LIST_ENTRY DiscardedRequests; PRX_BUFFERING_MANAGER pBufferingManager; RxUndoScavengerFinalizationMarking( pSrvCall); pBufferingManager = &pSrvCall->BufferingManager; RxAcquireBufferingManagerMutex(pBufferingManager); KeAcquireSpinLock(&pBufferingManager->SpinLock,&SavedIrql); pBufferingManager->fDispatcherActive = FALSE; KeReleaseSpinLock(&pBufferingManager->SpinLock,SavedIrql); RxpDispatchChangeBufferingStateRequests(pSrvCall,NULL,&DiscardedRequests); RxReleaseBufferingManagerMutex(pBufferingManager); // If requests have been transferred from the dispatcher list to the handler // list ensure that the handler is activated. KeAcquireSpinLock(&pBufferingManager->SpinLock,&SavedIrql); if (!IsListEmpty(&pBufferingManager->HandlerList) && (ActivateHandler = !pBufferingManager->fNoWaitHandlerActive)) { pBufferingManager->fNoWaitHandlerActive = ActivateHandler; } KeReleaseSpinLock(&pBufferingManager->SpinLock,SavedIrql); // Note that in this case we have a continuation of processing, from the // dispatcher to the handler. The reference that was taken to protect the // dispatcher is transferred to the handling routine. If continuation // is not required the SRV_CALL instance is dereferenced. if (ActivateHandler) { RxProcessChangeBufferingStateRequests(pSrvCall); } else { RxDereferenceSrvCall(pSrvCall,LHS_LockNotHeld); } // Discard the requests for which the SRV_OPEN instance cannot be located. // This will cover all the instances for which a buffering change request // and a close crossed on the wire. RxpDiscardChangeBufferingStateRequests(&DiscardedRequests); } VOID RxpProcessChangeBufferingStateRequests( PSRV_CALL pSrvCall, BOOLEAN UpdateHandlerState) /*++ Routine Description: This routine initiates the actual processing of change buffering state requests. Arguments: pSrvCall - the SRV_CALL instance Return Value: none. Notes: The change buffering requests are received for different FCB's. If the attempt is made to handle these requests in the order they are received teh average response time for completing a change buffering state request can be arbitratily high. This is because the FCB needs to be acquired exclusively to complete processing the request. In order to avoid this case the buffering manager adopts a two pronged strategy -- a first attempt is made to acquire the FCB exclusively without waiting. If this attempt fails the requests are transferred to a last chance handler list. This combined with the processing of change buffering state requests on FCB acquisition/release ensures that most requests are processed with a very short turn around time. --*/ { KIRQL SavedIrql; PLIST_ENTRY pLastChanceHandlerListEntry; PLIST_ENTRY pListEntry; PCHANGE_BUFFERING_STATE_REQUEST pRequest = NULL; PRX_BUFFERING_MANAGER pBufferingManager; PSRV_OPEN pSrvOpen; BOOLEAN ActivateLastChanceHandler; RxLog(("RPCBSR Entry SrvCall(%lx) \n", pSrvCall)); RxWmiLog(LOG, RxpProcessChangeBufferingStateRequests_1, LOGPTR(pSrvCall)); pBufferingManager = &pSrvCall->BufferingManager; pLastChanceHandlerListEntry = pListEntry = NULL; for (;;) { pListEntry = NULL; ActivateLastChanceHandler = FALSE; RxAcquireBufferingManagerMutex(pBufferingManager); KeAcquireSpinLock(&pBufferingManager->SpinLock,&SavedIrql); // Pick a request from the handler list for change buffering state // processing. if (!IsListEmpty(&pBufferingManager->HandlerList)) { pListEntry = RemoveHeadList(&pBufferingManager->HandlerList); } // If the FCB fro the previously picked request could not be acquired // exclusively without waiting it needs to be transferred to the last // chance handler list and the last chance handler activated if // required. if (pLastChanceHandlerListEntry != NULL) { // Insert the entry into the last chance handler list. InsertTailList( &pBufferingManager->LastChanceHandlerList, pLastChanceHandlerListEntry); // reinitialize for the next pass. pLastChanceHandlerListEntry = NULL; // prepare for spinning up the last chance handler. if (!pBufferingManager->fLastChanceHandlerActive && !IsListEmpty(&pBufferingManager->LastChanceHandlerList)) { pBufferingManager->fLastChanceHandlerActive = TRUE; ActivateLastChanceHandler = TRUE; } } // No more requests to be handled. Prepare for wind down. if ((pListEntry == NULL) && UpdateHandlerState) { pBufferingManager->fNoWaitHandlerActive = FALSE; } KeReleaseSpinLock(&pBufferingManager->SpinLock,SavedIrql); RxReleaseBufferingManagerMutex(pBufferingManager); // spin up the last chance handler for processing the requests if required. if (ActivateLastChanceHandler) { // Reference the SRV_CALL instance to ensure that it will not be // finalized while the worker thread request is in the scheduler RxReferenceSrvCall(pSrvCall); RxPostToWorkerThread( RxFileSystemDeviceObject, DelayedWorkQueue, &pBufferingManager->LastChanceHandlerWorkItem, RxLastChanceHandlerForChangeBufferingStateRequests, pSrvCall); ActivateLastChanceHandler = FALSE; } if (pListEntry == NULL) { break; } pRequest = (PCHANGE_BUFFERING_STATE_REQUEST) CONTAINING_RECORD( pListEntry, CHANGE_BUFFERING_STATE_REQUEST, ListEntry); RxLog(("Proc. Req. SrvOpen (%lx) \n",pRequest->pSrvOpen)); RxWmiLog(LOG, RxpProcessChangeBufferingStateRequests_2, LOGPTR(pRequest->pSrvOpen)); if (RxPrepareRequestForHandling(pRequest) == STATUS_SUCCESS) { // Try to acquire the FCB without waiting. If the FCB is currently unavailable // then it is guaranteed that this request will be processed when the FCB // resource is released. ASSERT(pRequest->pSrvOpen != NULL); if (RxAcquireExclusiveFcb( CHANGE_BUFFERING_STATE_CONTEXT, pRequest->pSrvOpen->Fcb) == STATUS_SUCCESS) { BOOLEAN FcbFinalized; PFCB pFcb; RxLog(("Proc. Req. SrvOpen FCB (%lx) \n",pRequest->pSrvOpen->Fcb)); RxWmiLog(LOG, RxpProcessChangeBufferingStateRequests_3, LOGPTR(pRequest->pSrvOpen->Fcb)); pSrvOpen = pRequest->pSrvOpen; pFcb = pSrvOpen->Fcb; RxReferenceNetFcb(pFcb); if (!FlagOn(pSrvOpen->Flags,SRVOPEN_FLAG_CLOSED)) { RxDbgTrace(0,Dbg,("SrvOpenKey(%lx) being processed(Last Resort)\n",pRequest->SrvOpenKey)); RxLog(("SOKey(%lx) processed(Last Resort)\n",pRequest->SrvOpenKey)); RxWmiLog(LOG, RxpProcessChangeBufferingStateRequests_4, LOGPTR(pRequest->SrvOpenKey)); RxChangeBufferingState(pSrvOpen,pRequest->pMRxContext,TRUE); } RxAcquireSerializationMutex(); ClearFlag(pSrvOpen->Flags,SRVOPEN_FLAG_BUFFERING_STATE_CHANGE_PENDING); ClearFlag(pSrvOpen->Fcb->FcbState,FCB_STATE_BUFFERING_STATE_CHANGE_PENDING); KeSetEvent(pSrvOpen->Fcb->pBufferingStateChangeCompletedEvent,IO_NETWORK_INCREMENT,FALSE); RxReleaseSerializationMutex(); RxPrepareRequestForReuse(pRequest); FcbFinalized = RxDereferenceAndFinalizeNetFcb( pFcb, CHANGE_BUFFERING_STATE_CONTEXT_WAIT, FALSE, FALSE); if (!FcbFinalized) { RxReleaseFcb(CHANGE_BUFFERING_STATE_CONTEXT,pFcb); } RxFreePool(pRequest); } else { // The FCB has been currently accquired. Transfer the change buffering state // request to the last chance handler list. This will ensure that the // change buffering state request is processed in all cases, i.e., // accquisition of the resource in shared mode as well as the acquistion // of the FCB resource by other components ( cache manager/memory manager ) // without going through the wrapper. pLastChanceHandlerListEntry = &pRequest->ListEntry; } } else { RxPrepareRequestForReuse(pRequest); RxFreePool(pRequest); } } // Dereference the SRV_CALL instance. RxDereferenceSrvCall(pSrvCall,LHS_LockNotHeld); RxLog(("RPCBSR Exit SrvCall(%lx)\n",pSrvCall)); RxWmiLog(LOG, RxpProcessChangeBufferingStateRequests_5, LOGPTR(pSrvCall)); } VOID RxProcessChangeBufferingStateRequests( PSRV_CALL pSrvCall) /*++ Routine Description: This routine is the last chance handler for processing change buffering state requests Arguments: pSrvCall -- the SrvCall instance Notes: Since the reference for the srv call instance was accquired at DPC undo the scavenger marking if required. --*/ { RxUndoScavengerFinalizationMarking( pSrvCall); RxpProcessChangeBufferingStateRequests( pSrvCall, TRUE); } VOID RxLastChanceHandlerForChangeBufferingStateRequests( PSRV_CALL pSrvCall) /*++ Routine Description: This routine is the last chance handler for processing change buffering state requests Arguments: Return Value: none. Notes: This routine exists because Mm/Cache manager manipulate the header resource associated with the FCB directly in some cases. In such cases it is not possible to determine whether the release is done through the wrapper. In such cases it is important to have a thread actually wait on the FCB resource to be released and subsequently process the buffering state request as a last resort mechanism. This also handles the case when the FCB is accquired shared. In such cases the change buffering state has to be completed in the context of a thread which can accquire it exclusively. The filtering of the requests must be further optimized by marking the FCB state during resource accquisition by the wrapper so that requests do not get downgraded easily. ( TO BE IMPLEMENTED ) --*/ { KIRQL SavedIrql; PLIST_ENTRY pListEntry; LIST_ENTRY FinalizationList; PRX_BUFFERING_MANAGER pBufferingManager; PCHANGE_BUFFERING_STATE_REQUEST pRequest = NULL; PSRV_OPEN pSrvOpen; BOOLEAN FcbFinalized,FcbAcquired; PFCB pFcb; RxLog(("RLCHCBSR Entry SrvCall(%lx)\n",pSrvCall)); RxWmiLog(LOG, RxLastChanceHandlerForChangeBufferingStateRequests_1, LOGPTR(pSrvCall)); InitializeListHead(&FinalizationList); pBufferingManager = &pSrvCall->BufferingManager; for (;;) { RxAcquireBufferingManagerMutex(pBufferingManager); KeAcquireSpinLock(&pBufferingManager->SpinLock,&SavedIrql); if (!IsListEmpty(&pBufferingManager->LastChanceHandlerList)) { pListEntry = RemoveHeadList(&pBufferingManager->LastChanceHandlerList); } else { pListEntry = NULL; pBufferingManager->fLastChanceHandlerActive = FALSE; } KeReleaseSpinLock(&pBufferingManager->SpinLock,SavedIrql); RxReleaseBufferingManagerMutex(pBufferingManager); if (pListEntry == NULL) { break; } pRequest = (PCHANGE_BUFFERING_STATE_REQUEST) CONTAINING_RECORD( pListEntry, CHANGE_BUFFERING_STATE_REQUEST, ListEntry); pSrvOpen = pRequest->pSrvOpen; pFcb = pSrvOpen->Fcb; RxReferenceNetFcb(pFcb); FcbAcquired = (RxAcquireExclusiveFcb( CHANGE_BUFFERING_STATE_CONTEXT_WAIT, pRequest->pSrvOpen->Fcb) == STATUS_SUCCESS); if (FcbAcquired && !FlagOn(pSrvOpen->Flags,SRVOPEN_FLAG_CLOSED)) { RxDbgTrace(0,Dbg,("SrvOpenKey(%lx) being processed(Last Resort)\n",pRequest->SrvOpenKey)); RxLog(("SOKey(%lx) processed(Last Resort)\n",pRequest->SrvOpenKey)); RxWmiLog(LOG, RxLastChanceHandlerForChangeBufferingStateRequests_2, LOGPTR(pRequest->SrvOpenKey)); RxChangeBufferingState(pSrvOpen,pRequest->pMRxContext,TRUE); } RxAcquireSerializationMutex(); ClearFlag(pSrvOpen->Flags,SRVOPEN_FLAG_BUFFERING_STATE_CHANGE_PENDING); ClearFlag(pSrvOpen->Fcb->FcbState,FCB_STATE_BUFFERING_STATE_CHANGE_PENDING); KeSetEvent(pSrvOpen->Fcb->pBufferingStateChangeCompletedEvent,IO_NETWORK_INCREMENT,FALSE); RxReleaseSerializationMutex(); InsertTailList(&FinalizationList,pListEntry); if (FcbAcquired) { RxReleaseFcb(CHANGE_BUFFERING_STATE_CONTEXT,pFcb); } } while (!IsListEmpty(&FinalizationList)) { pListEntry = RemoveHeadList(&FinalizationList); pRequest = (PCHANGE_BUFFERING_STATE_REQUEST) CONTAINING_RECORD( pListEntry, CHANGE_BUFFERING_STATE_REQUEST, ListEntry); pSrvOpen = pRequest->pSrvOpen; pFcb = pSrvOpen->Fcb; FcbAcquired = (RxAcquireExclusiveFcb( CHANGE_BUFFERING_STATE_CONTEXT_WAIT, pRequest->pSrvOpen->Fcb) == STATUS_SUCCESS); ASSERT(FcbAcquired == TRUE); RxPrepareRequestForReuse(pRequest); FcbFinalized = RxDereferenceAndFinalizeNetFcb( pFcb, CHANGE_BUFFERING_STATE_CONTEXT_WAIT, FALSE, FALSE); if (!FcbFinalized && FcbAcquired) { RxReleaseFcb(CHANGE_BUFFERING_STATE_CONTEXT,pFcb); } RxFreePool(pRequest); } RxLog(("RLCHCBSR Exit SrvCall(%lx)\n",pSrvCall)); RxWmiLog(LOG, RxLastChanceHandlerForChangeBufferingStateRequests_3, LOGPTR(pSrvCall)); // Dereference the SRV_CALL instance. RxDereferenceSrvCall(pSrvCall, LHS_LockNotHeld); } VOID RxProcessFcbChangeBufferingStateRequest( PFCB pFcb) /*++ Routine Description: This routine processes all the outstanding change buffering state request for a FCB. Arguments: pFcb - the FCB instance Return Value: none. Notes: The FCB instance must be acquired exclusively on entry to this routine and its ownership will remain invariant on exit. --*/ { PSRV_CALL pSrvCall; LIST_ENTRY FcbRequestList; PLIST_ENTRY pListEntry; PRX_BUFFERING_MANAGER pBufferingManager; PCHANGE_BUFFERING_STATE_REQUEST pRequest = NULL; PAGED_CODE(); RxLog(("RPFcbCBSR Entry FCB(%lx)\n",pFcb)); RxWmiLog(LOG, RxProcessFcbChangeBufferingStateRequest_1, LOGPTR(pFcb)); pSrvCall = (PSRV_CALL)pFcb->VNetRoot->NetRoot->SrvCall; pBufferingManager = &pSrvCall->BufferingManager; InitializeListHead(&FcbRequestList); // Walk through the list of SRV_OPENS associated with this FCB and pick up // the requests that can be dispatched. RxAcquireBufferingManagerMutex(pBufferingManager); pListEntry = pFcb->SrvOpenList.Flink; while (pListEntry != &pFcb->SrvOpenList) { PSRV_OPEN pSrvOpen; pSrvOpen = (PSRV_OPEN) (CONTAINING_RECORD( pListEntry, SRV_OPEN, SrvOpenQLinks)); pListEntry = pListEntry->Flink; RxGatherRequestsForSrvOpen(pSrvCall,pSrvOpen,&FcbRequestList); } RxReleaseBufferingManagerMutex(pBufferingManager); if (!IsListEmpty(&FcbRequestList)) { // Initiate buffering state change processing. pListEntry = FcbRequestList.Flink; while (pListEntry != &FcbRequestList) { NTSTATUS Status = STATUS_SUCCESS; pRequest = (PCHANGE_BUFFERING_STATE_REQUEST) CONTAINING_RECORD( pListEntry, CHANGE_BUFFERING_STATE_REQUEST, ListEntry); pListEntry = pListEntry->Flink; if (RxPrepareRequestForHandling(pRequest) == STATUS_SUCCESS) { if (!FlagOn(pRequest->pSrvOpen->Flags,SRVOPEN_FLAG_CLOSED)) { RxDbgTrace(0,Dbg,("****** SrvOpenKey(%lx) being processed\n",pRequest->SrvOpenKey)); RxLog(("****** SOKey(%lx) being processed\n",pRequest->SrvOpenKey)); RxWmiLog(LOG, RxProcessFcbChangeBufferingStateRequest_2, LOGPTR(pRequest->SrvOpenKey)); RxChangeBufferingState(pRequest->pSrvOpen,pRequest->pMRxContext,TRUE); } else { RxDbgTrace(0,Dbg,("****** 123 SrvOpenKey(%lx) being ignored\n",pRequest->SrvOpenKey)); RxLog(("****** 123 SOKey(%lx) ignored\n",pRequest->SrvOpenKey)); RxWmiLog(LOG, RxProcessFcbChangeBufferingStateRequest_3, LOGPTR(pRequest->SrvOpenKey)); } } } // Discard the requests. RxpDiscardChangeBufferingStateRequests(&FcbRequestList); } RxLog(("RPFcbCBSR Exit FCB(%lx)\n",pFcb)); RxWmiLog(LOG, RxProcessFcbChangeBufferingStateRequest_4, LOGPTR(pFcb)); // All buffering state change requests have been processed, clear the flag // and signal the event as necessary. RxAcquireSerializationMutex(); // update the FCB state. ClearFlag(pFcb->FcbState,FCB_STATE_BUFFERING_STATE_CHANGE_PENDING); if( pFcb->pBufferingStateChangeCompletedEvent ) KeSetEvent(pFcb->pBufferingStateChangeCompletedEvent,IO_NETWORK_INCREMENT,FALSE); RxReleaseSerializationMutex(); } VOID RxGatherRequestsForSrvOpen( IN OUT PSRV_CALL pSrvCall, IN PSRV_OPEN pSrvOpen, IN OUT PLIST_ENTRY pRequestsListHead) /*++ Routine Description: This routine gathers all the change buffering state requests associated with a SRV_OPEN. This routine provides the mechanism for gathering all the requests for a SRV_OPEN which is then used bu routines which process them Arguments: pSrvCall - the SRV_CALL instance pSrvOpen - the SRV_OPEN instance pRequestsListHead - the list of requests which is constructed by this routine Notes: On Entry to thir routine the buffering manager Mutex must have been acquired and the ownership remains invariant on exit --*/ { PLIST_ENTRY pListEntry; LIST_ENTRY DiscardedRequests; PCHANGE_BUFFERING_STATE_REQUEST pRequest; PRX_BUFFERING_MANAGER pBufferingManager; PVOID SrvOpenKey; KIRQL SavedIrql; pBufferingManager = &pSrvCall->BufferingManager; SrvOpenKey = pSrvOpen->Key; // gather all the requests from the dispatcher list RxpDispatchChangeBufferingStateRequests(pSrvCall,pSrvOpen,&DiscardedRequests); KeAcquireSpinLock( &pSrvCall->BufferingManager.SpinLock, &SavedIrql); // gather all the requests with the given SrvOpenKey in the handler list pListEntry = pBufferingManager->HandlerList.Flink; while (pListEntry != &pBufferingManager->HandlerList) { pRequest = (PCHANGE_BUFFERING_STATE_REQUEST) CONTAINING_RECORD( pListEntry, CHANGE_BUFFERING_STATE_REQUEST, ListEntry); pListEntry = pListEntry->Flink; if (pRequest->SrvOpenKey == SrvOpenKey) { RemoveEntryList(&pRequest->ListEntry); InsertHeadList(pRequestsListHead,&pRequest->ListEntry); } } KeReleaseSpinLock( &pSrvCall->BufferingManager.SpinLock, SavedIrql); // gather all the requests from the last chance handler list pListEntry = pBufferingManager->LastChanceHandlerList.Flink; while (pListEntry != &pBufferingManager->LastChanceHandlerList) { pRequest = (PCHANGE_BUFFERING_STATE_REQUEST) CONTAINING_RECORD( pListEntry, CHANGE_BUFFERING_STATE_REQUEST, ListEntry); pListEntry = pListEntry->Flink; if (pRequest->SrvOpenKey == pSrvOpen->Key) { RemoveEntryList(&pRequest->ListEntry); InsertHeadList(pRequestsListHead,&pRequest->ListEntry); } } RxpDiscardChangeBufferingStateRequests(&DiscardedRequests); } VOID RxPurgeChangeBufferingStateRequestsForSrvOpen( IN PSRV_OPEN pSrvOpen) /*++ Routine Description: The routine purges all the requests associated with a given SRV_OPEN. This will ensure that all buffering state change requests received while the SRV_OPEN was being closed will be flushed out. Arguments: pSrvOpen - the SRV_OPEN instance Notes: --*/ { PSRV_CALL pSrvCall = (PSRV_CALL)pSrvOpen->Fcb->VNetRoot->NetRoot->SrvCall; PRX_BUFFERING_MANAGER pBufferingManager = &pSrvCall->BufferingManager; LIST_ENTRY DiscardedRequests; PAGED_CODE(); ASSERT(RxIsFcbAcquiredExclusive(pSrvOpen->Fcb)); InitializeListHead(&DiscardedRequests); RxAcquireBufferingManagerMutex(pBufferingManager); RemoveEntryList(&pSrvOpen->SrvOpenKeyList); InitializeListHead(&pSrvOpen->SrvOpenKeyList); SetFlag(pSrvOpen->Flags,SRVOPEN_FLAG_BUFFERING_STATE_CHANGE_REQUESTS_PURGED); RxGatherRequestsForSrvOpen(pSrvCall,pSrvOpen,&DiscardedRequests); RxReleaseBufferingManagerMutex(pBufferingManager); if (!IsListEmpty(&DiscardedRequests)) { if (BooleanFlagOn(pSrvOpen->Flags,SRVOPEN_FLAG_BUFFERING_STATE_CHANGE_PENDING)) { RxAcquireSerializationMutex(); ClearFlag( pSrvOpen->Fcb->FcbState, FCB_STATE_BUFFERING_STATE_CHANGE_PENDING); if (pSrvOpen->Fcb->pBufferingStateChangeCompletedEvent != NULL) { KeSetEvent( pSrvOpen->Fcb->pBufferingStateChangeCompletedEvent, IO_NETWORK_INCREMENT, FALSE); } RxReleaseSerializationMutex(); } RxpDiscardChangeBufferingStateRequests(&DiscardedRequests); } } VOID RxProcessChangeBufferingStateRequestsForSrvOpen( PSRV_OPEN pSrvOpen) /*++ Routine Description: The routine processes all the requests associated with a given SRV_OPEN. Since this routine is called from a fastio path it tries to defer lock accquistion till it is required Arguments: pSrvOpen - the SRV_OPEN instance Notes: --*/ { LONG OldBufferingToken; PSRV_CALL pSrvCall; PFCB pFcb; pSrvCall = (PSRV_CALL)pSrvOpen->pVNetRoot->pNetRoot->pSrvCall; pFcb = (PFCB)pSrvOpen->pFcb; // If change buffering state requests have been received for this srvcall // since the last time the request was processed ensure that we process // all these requests now. OldBufferingToken = pSrvOpen->BufferingToken; if (InterlockedCompareExchange( &pSrvOpen->BufferingToken, pSrvCall->BufferingManager.CumulativeNumberOfBufferingChangeRequests, pSrvCall->BufferingManager.CumulativeNumberOfBufferingChangeRequests) != OldBufferingToken) { if (RxAcquireExclusiveFcb(NULL,pFcb) == STATUS_SUCCESS) { RxProcessFcbChangeBufferingStateRequest(pFcb); RxReleaseFcb(NULL,pFcb); } } } VOID RxInitiateSrvOpenKeyAssociation( IN OUT PSRV_OPEN pSrvOpen) /*++ Routine Description: This routine prepares a SRV_OPEN instance for SrvOpenKey association. Arguments: pSrvOpen - the SRV_OPEN instance Notes: The process of key association is a two phase protocol. In the initialization process a sequence number is stowed away in the SRV_OPEN. When the RxCompleteSrvOpenKeyAssociation routine is called the sequence number is used to update the data structures associated with the SRV_CALL instance. This is required because of the asynchronous nature of receiving buffering state change indications (oplock breaks in SMB terminology ) before the open is completed. --*/ { KIRQL SavedIrql; PSRV_CALL pSrvCall = (PSRV_CALL)pSrvOpen->Fcb->VNetRoot->NetRoot->SrvCall; PRX_BUFFERING_MANAGER pBufferingManager = &pSrvCall->BufferingManager; PAGED_CODE(); pSrvOpen->Key = NULL; InterlockedIncrement(&pBufferingManager->NumberOfOutstandingOpens); InitializeListHead(&pSrvOpen->SrvOpenKeyList); } VOID RxCompleteSrvOpenKeyAssociation( IN OUT PSRV_OPEN pSrvOpen) /*++ Routine Description: The routine associates the given key with the SRV_OPEN instance Arguments: pMRxSrvOpen - the SRV_OPEN instance SrvOpenKey - the key to be associated with the instance Notes: This routine in addition to establishing the mapping also ensures that any pending buffering state change requests are handled correctly. This ensures that change buffering state requests received during the duration of SRV_OPEN construction will be handled immediately. --*/ { KIRQL SavedIrql; BOOLEAN ActivateHandler = FALSE; ULONG Index = 0; PSRV_CALL pSrvCall = (PSRV_CALL)pSrvOpen->Fcb->VNetRoot->NetRoot->SrvCall; PRX_BUFFERING_MANAGER pBufferingManager = &pSrvCall->BufferingManager; LIST_ENTRY DiscardedRequests; // Associate the SrvOpenKey with the SRV_OPEN instance and also dispatch the // associated change buffering state request if any. InterlockedDecrement(&pBufferingManager->NumberOfOutstandingOpens); if (pSrvOpen->Condition == Condition_Good) { InitializeListHead(&DiscardedRequests); RxAcquireBufferingManagerMutex(pBufferingManager); InsertTailList( &pBufferingManager->SrvOpenLists[Index], &pSrvOpen->SrvOpenKeyList); RxpDispatchChangeBufferingStateRequests( pSrvCall, pSrvOpen, &DiscardedRequests); RxReleaseBufferingManagerMutex(pBufferingManager); KeAcquireSpinLock( &pBufferingManager->SpinLock, &SavedIrql); if (!IsListEmpty(&pBufferingManager->HandlerList) && (ActivateHandler = !pBufferingManager->fNoWaitHandlerActive)) { pBufferingManager->fNoWaitHandlerActive = ActivateHandler; } KeReleaseSpinLock( &pBufferingManager->SpinLock, SavedIrql); if (ActivateHandler) { // Reference the SRV_CALL instance to ensure that it will not be // finalized while the worker thread request is in the scheduler RxReferenceSrvCall(pSrvCall); RxPostToWorkerThread( RxFileSystemDeviceObject, HyperCriticalWorkQueue, &pBufferingManager->HandlerWorkItem, RxProcessChangeBufferingStateRequests, pSrvCall); } RxpDiscardChangeBufferingStateRequests(&DiscardedRequests); } } NTSTATUS RxpLookupSrvOpenForRequestLite( IN PSRV_CALL pSrvCall, IN PCHANGE_BUFFERING_STATE_REQUEST pRequest) /*++ Routine Description: The routine looks up the SRV_OPEN instance associated with a buffering state change request. Arguments: pSrvCall - the SRV_CALL instance pRequest - the buffering state change request Return Value: STATUS_SUCCESS - the SRV_OPEN instance was found STATUS_PENDING - the SRV_OPEN instance was not found but there are open requests outstanding STATUS_NOT_FOUND - the SRV_OPEN instance was not found. Notes: --*/ { NTSTATUS Status = STATUS_SUCCESS; PRX_BUFFERING_MANAGER pBufferingManager = &pSrvCall->BufferingManager; ULONG Index = 0; PSRV_OPEN pSrvOpen = NULL; PLIST_ENTRY pListHead,pListEntry; PAGED_CODE(); pListHead = &pBufferingManager->SrvOpenLists[Index]; pListEntry = pListHead->Flink; while (pListEntry != pListHead) { pSrvOpen = (PSRV_OPEN) CONTAINING_RECORD( pListEntry, SRV_OPEN, SrvOpenKeyList); if ((pSrvOpen->Key == pRequest->SrvOpenKey) && (!FlagOn(pSrvOpen->pFcb->FcbState,FCB_STATE_ORPHANED))) { RxReferenceSrvOpen(pSrvOpen); break; } pListEntry = pListEntry->Flink; } if (pListEntry == pListHead) { pSrvOpen = NULL; if (pBufferingManager->NumberOfOutstandingOpens == 0) { Status = STATUS_NOT_FOUND; } else { Status = STATUS_PENDING; } } pRequest->pSrvOpen = pSrvOpen; return Status; } #define RxIsFcbOpenedExclusively(FCB) ( ((FCB)->ShareAccess.SharedRead \ + (FCB)->ShareAccess.SharedWrite \ + (FCB)->ShareAccess.SharedDelete) == 0 ) NTSTATUS RxChangeBufferingState ( PSRV_OPEN SrvOpen, PVOID Context, BOOLEAN ComputeNewState) /*++ Routine Description: This routine is called to process a buffering state change request. Arguments: SrvOpen - the SrvOpen to be changed; Context - the context parameter for mini rdr callback. ComputeNewState - determines if the new state is to be computed. Return Value: Notes: On entry to this routine the FCB must have been accquired exclusive. On exit there is no change in resource ownership --*/ { ULONG NewBufferingState, OldBufferingState; PFCB Fcb = SrvOpen->Fcb; NTSTATUS FlushStatus = STATUS_SUCCESS; PAGED_CODE(); #define LOSING_CAPABILITY(a) ((NewBufferingState&(a))<(OldBufferingState&(a))) RxDbgTrace(+1, Dbg, ("RxChangeBufferingState SrvOpen=%08lx, Context=%08lx\n", SrvOpen, Context )); RxLog(("ChangeBufferState %lx %lx\n", SrvOpen, Context )); RxWmiLog(LOG, RxChangeBufferingState_1, LOGPTR(SrvOpen) LOGPTR(Context)); ASSERT ( NodeTypeIsFcb(Fcb) ); SetFlag(Fcb->FcbState,FCB_STATE_BUFFERSTATE_CHANGING); //this is informational for error recovery try { if (ComputeNewState) { NTSTATUS Status; RxDbgTrace(0,Dbg,("RxChangeBufferingState FCB(%lx) Compute New State\n",Fcb)); // Compute the new buffering state with the help of the mini redirector MINIRDR_CALL_THROUGH( Status, Fcb->MRxDispatch, MRxComputeNewBufferingState, ((PMRX_SRV_OPEN)SrvOpen,Context,&NewBufferingState)); if (Status != STATUS_SUCCESS) { NewBufferingState = 0; } } else { NewBufferingState = SrvOpen->BufferingFlags; } if (RxIsFcbOpenedExclusively(Fcb) && !ComputeNewState){ NewBufferingState |= (FCB_STATE_WRITECACHEING_ENABLED | FCB_STATE_FILESIZECACHEING_ENABLED | FCB_STATE_FILETIMECACHEING_ENABLED | FCB_STATE_WRITEBUFFERING_ENABLED | FCB_STATE_LOCK_BUFFERING_ENABLED | FCB_STATE_READBUFFERING_ENABLED | FCB_STATE_READCACHEING_ENABLED); } if (Fcb->OutstandingLockOperationsCount != 0) { NewBufferingState &= ~FCB_STATE_LOCK_BUFFERING_ENABLED; } OldBufferingState = Fcb->FcbState & FCB_STATE_BUFFERING_STATE_MASK; RxDbgTrace(0, Dbg, ("--> OldBS=%08lx, NewBS=%08lx, SrvOBS = %08lx\n", OldBufferingState, NewBufferingState, SrvOpen->BufferingFlags )); RxLog(("CBS-2 %lx %lx %lx\n", OldBufferingState, NewBufferingState, SrvOpen->BufferingFlags )); RxWmiLog(LOG, RxChangeBufferingState_2, LOGULONG(OldBufferingState) LOGULONG(NewBufferingState) LOGULONG(SrvOpen->BufferingFlags)); RxDbgTrace(0,Dbg,("RxChangeBufferingState FCB(%lx) Old (%lx) New (%lx)\n",Fcb,OldBufferingState,NewBufferingState)); // Fcb->FcbState &= ~FCB_STATE_BUFFERING_STATE_MASK; if(LOSING_CAPABILITY(FCB_STATE_WRITECACHEING_ENABLED)){ RxDbgTrace(0, Dbg, ("-->flush\n", 0 )); RxLog(("CBS-Flush")); RxWmiLog(LOG, RxChangeBufferingState_3, LOGPTR(Fcb)); //CcFlushCache(&Fcb->NonPaged->SectionObjectPointers,NULL,0,NULL ); FlushStatus = RxFlushFcbInSystemCache(Fcb,FALSE); } // If there are no handles to this file or it the read caching capability // is lost the file needs to be purged. This will force the memory // manager to relinquish the additional reference on the file. if ((Fcb->UncleanCount == 0) || (LOSING_CAPABILITY(FCB_STATE_READCACHEING_ENABLED) || FlagOn(NewBufferingState, MINIRDR_BUFSTATE_COMMAND_FORCEPURGE))) { RxDbgTrace(0, Dbg, ("-->purge\n", 0 )); RxLog(("CBS-purge\n")); RxWmiLog(LOG, RxChangeBufferingState_4, LOGPTR(Fcb)); if( !NT_SUCCESS(FlushStatus) ) { RxCcLogError( (PDEVICE_OBJECT)Fcb->RxDeviceObject, &Fcb->PrivateAlreadyPrefixedName, IO_LOST_DELAYED_WRITE, FlushStatus, IRP_MJ_WRITE, Fcb ); } CcPurgeCacheSection( &Fcb->NonPaged->SectionObjectPointers, NULL, 0, FALSE ); } // the wrapper does not use these flags yet if(LOSING_CAPABILITY(FCB_STATE_WRITEBUFFERING_ENABLED)) NOTHING; if(LOSING_CAPABILITY(FCB_STATE_READBUFFERING_ENABLED)) NOTHING; if(LOSING_CAPABILITY(FCB_STATE_OPENSHARING_ENABLED)) NOTHING; if(LOSING_CAPABILITY(FCB_STATE_COLLAPSING_ENABLED)) NOTHING; if(LOSING_CAPABILITY(FCB_STATE_FILESIZECACHEING_ENABLED)) NOTHING; if(LOSING_CAPABILITY(FCB_STATE_FILETIMECACHEING_ENABLED)) NOTHING; if (ComputeNewState && FlagOn(SrvOpen->Flags,SRVOPEN_FLAG_BUFFERING_STATE_CHANGE_PENDING) && !IsListEmpty(&SrvOpen->FobxList)) { NTSTATUS Status; PRX_CONTEXT RxContext = NULL; RxContext = RxCreateRxContext( NULL, SrvOpen->Fcb->RxDeviceObject, RX_CONTEXT_FLAG_WAIT|RX_CONTEXT_FLAG_MUST_SUCCEED_NONBLOCKING); if (RxContext != NULL) { RxContext->pFcb = (PMRX_FCB)Fcb; RxContext->pFobx = (PMRX_FOBX) (CONTAINING_RECORD( SrvOpen->FobxList.Flink, FOBX, FobxQLinks)); RxContext->pRelevantSrvOpen = RxContext->pFobx->pSrvOpen; if (FlagOn(SrvOpen->Flags,SRVOPEN_FLAG_CLOSE_DELAYED)) { RxLog((" ##### Oplock brk close %lx\n",RxContext->pFobx)); RxWmiLog(LOG, RxChangeBufferingState_4, LOGPTR(RxContext->pFobx)); Status = RxCloseAssociatedSrvOpen( (PFOBX)RxContext->pFobx, RxContext); } else { MINIRDR_CALL_THROUGH( Status, Fcb->MRxDispatch, MRxCompleteBufferingStateChangeRequest, (RxContext,(PMRX_SRV_OPEN)SrvOpen,Context)); } RxDereferenceAndDeleteRxContext(RxContext); } RxDbgTrace(0,Dbg,("RxChangeBuffering State FCB(%lx) Completeing buffering state change\n",Fcb)); } Fcb->FcbState = ((Fcb->FcbState & ~(FCB_STATE_BUFFERING_STATE_MASK)) | (FCB_STATE_BUFFERING_STATE_MASK & NewBufferingState)); } finally { ClearFlag(Fcb->FcbState,FCB_STATE_BUFFERSTATE_CHANGING); //this is informational for error recovery ClearFlag(Fcb->FcbState,FCB_STATE_TIME_AND_SIZE_ALREADY_SET); } RxDbgTrace(-1, Dbg, ("-->exit\n")); RxLog(("Exit-CBS\n")); RxWmiLog(LOG, RxChangeBufferingState_5, LOGPTR(Fcb)); return STATUS_SUCCESS; } NTSTATUS RxFlushFcbInSystemCache( IN PFCB Fcb, IN BOOLEAN SynchronizeWithLazyWriter ) /*++ Routine Description: This routine simply flushes the data section on a file. Then, it does an acquire-release on the pagingIO resource in order to synchronize behind any other outstanding writes if such synchronization is desired by the caller Arguments: Fcb - Supplies the file being flushed SynchronizeWithLazyWriter -- set to TRUE if the flush needs to be synchronous Return Value: NTSTATUS - The Status from the flush. --*/ { IO_STATUS_BLOCK Iosb; PAGED_CODE(); // Make sure that this thread owns the FCB. // This assert is not valid because the flushing of the cache can be called from a routine // that was posted to a worker thread. Thus the FCB is acquired exclusively, but not by the // current thread and this will fail. // ASSERT ( RxIsFcbAcquiredExclusive ( Fcb ) ); CcFlushCache( &Fcb->NonPaged->SectionObjectPointers, NULL, 0, &Iosb ); //ok4flush if (SynchronizeWithLazyWriter && NT_SUCCESS(Iosb.Status)) { RxAcquirePagingIoResource(Fcb,NULL); RxReleasePagingIoResource(Fcb,NULL); } RxLog(("Flushing %lx Status %lx\n",Fcb,Iosb.Status)); RxWmiLogError(Iosb.Status, LOG, RxFlushFcbInSystemCache, LOGPTR(Fcb) LOGULONG(Iosb.Status)); return Iosb.Status; } NTSTATUS RxPurgeFcbInSystemCache( IN PFCB Fcb, IN PLARGE_INTEGER FileOffset OPTIONAL, IN ULONG Length, IN BOOLEAN UninitializeCacheMaps, IN BOOLEAN FlushFile ) /*++ Routine Description: This routine purges the data section on a file. Before purging it flushes the file and ensures that there are no outstanding writes by Then, it does an acquire-release on the pagingIO resource in order to synchronize behind any other outstanding writes if such synchronization is desired by the caller Arguments: Fcb - Supplies the file being flushed SynchronizeWithLazyWriter -- set to TRUE if the flush needs to be synchronous Return Value: NTSTATUS - The Status from the flush. --*/ { BOOLEAN fResult; NTSTATUS Status; IO_STATUS_BLOCK Iosb; PAGED_CODE(); // Make sure that this thread owns the FCB. ASSERT( RxIsFcbAcquiredExclusive ( Fcb ) ); // Flush if we need to if( FlushFile ) { Status = RxFlushFcbInSystemCache( Fcb, TRUE); if( !NT_SUCCESS(Status) ) { PVOID p1, p2; RtlGetCallersAddress( &p1, &p2 ); RxLogRetail(("Flush failed %x %x, Purging anyway\n", Fcb, Status )); RxLogRetail(("Purge Caller = %x %x\n", p1, p2 )); RxCcLogError( (PDEVICE_OBJECT)Fcb->RxDeviceObject, &Fcb->PrivateAlreadyPrefixedName, IO_LOST_DELAYED_WRITE, Status, IRP_MJ_WRITE, Fcb ); } } // if (Status == STATUS_SUCCESS) { fResult = CcPurgeCacheSection( &Fcb->NonPaged->SectionObjectPointers, FileOffset, Length, UninitializeCacheMaps); if (!fResult) { MmFlushImageSection( &Fcb->NonPaged->SectionObjectPointers, MmFlushForWrite); RxReleaseFcb( NULL, Fcb ); fResult = MmForceSectionClosed(&Fcb->NonPaged->SectionObjectPointers, TRUE); RxAcquireExclusiveFcb(NULL,Fcb); } Status = (fResult ? STATUS_SUCCESS : STATUS_UNSUCCESSFUL); // } RxLog(("Purging %lx Status %lx\n",Fcb,Status)); RxWmiLogError(Status, LOG, RxPurgeFcbInSystemCache, LOGPTR(Fcb) LOGULONG(Status)); return Status; }