able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/fs/rdr2/rxce/fcbstruc.c
CryptoAlgo Inc b3cac27891 Add source files
2020-09-26 16:20:57 +08:00

4525 lines
134 KiB
C
Raw Permalink Blame History

/*++
Copyright (c) 1989 Microsoft Corporation
Module Name:
FcbStruc.c
Abstract:
This module implements functions for to create and dereference fcbs
and all of the surrounding paraphenalia. Please read the abstract in
fcb.h. Please see the note about what locks to need to call what.
There are asserts to enforce these conventions.
Author:
Joe Linn (JoeLinn) 8-8-94
Revision History:
Balan Sethu Raman --
--*/
#include "precomp.h"
#pragma hdrstop
#include <ntddnfs2.h>
#include <ntddmup.h>
#ifdef RDBSSLOG
#include <stdio.h>
#endif
#include <dfsfsctl.h>
#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE, RxDereference)
#pragma alloc_text(PAGE, RxReference)
#pragma alloc_text(PAGE, RxpReferenceNetFcb)
#pragma alloc_text(PAGE, RxpDereferenceNetFcb)
#pragma alloc_text(PAGE, RxpDereferenceAndFinalizeNetFcb)
#pragma alloc_text(PAGE, RxWaitForStableCondition)
#pragma alloc_text(PAGE, RxUpdateCondition)
#pragma alloc_text(PAGE, RxAllocateObject)
#pragma alloc_text(PAGE, RxFreeObject)
#pragma alloc_text(PAGE, RxFinalizeNetTable)
#pragma alloc_text(PAGE, RxFinalizeConnection)
#pragma alloc_text(PAGE, RxInitializeSrvCallParameters)
#pragma alloc_text(PAGE, RxCreateSrvCall)
#pragma alloc_text(PAGE, RxSetSrvCallDomainName)
#pragma alloc_text(PAGE, RxFinalizeSrvCall)
#pragma alloc_text(PAGE, RxCreateNetRoot)
#pragma alloc_text(PAGE, RxFinalizeNetRoot)
#pragma alloc_text(PAGE, RxAddVirtualNetRootToNetRoot)
#pragma alloc_text(PAGE, RxRemoveVirtualNetRootFromNetRoot)
#pragma alloc_text(PAGE, RxInitializeVNetRootParameters)
#pragma alloc_text(PAGE, RxUninitializeVNetRootParameters)
#pragma alloc_text(PAGE, RxCreateVNetRoot)
#pragma alloc_text(PAGE, RxOrphanSrvOpens)
#pragma alloc_text(PAGE, RxFinalizeVNetRoot)
#pragma alloc_text(PAGE, RxAllocateFcbObject)
#pragma alloc_text(PAGE, RxFreeFcbObject)
#pragma alloc_text(PAGE, RxCreateNetFcb)
#pragma alloc_text(PAGE, RxInferFileType)
#pragma alloc_text(PAGE, RxFinishFcbInitialization)
#pragma alloc_text(PAGE, RxRemoveNameNetFcb)
#pragma alloc_text(PAGE, RxPurgeFcb)
#pragma alloc_text(PAGE, RxFinalizeNetFcb)
#pragma alloc_text(PAGE, RxSetFileSizeWithLock)
#pragma alloc_text(PAGE, RxGetFileSizeWithLock)
#pragma alloc_text(PAGE, RxCreateSrvOpen)
#pragma alloc_text(PAGE, RxFinalizeSrvOpen)
#pragma alloc_text(PAGE, RxCreateNetFobx)
#pragma alloc_text(PAGE, RxFinalizeNetFobx)
#pragma alloc_text(PAGE, RxCheckFcbStructuresForAlignment)
#pragma alloc_text(PAGE, RxOrphanThisFcb)
#pragma alloc_text(PAGE, RxOrphanSrvOpensForThisFcb)
#pragma alloc_text(PAGE, RxForceFinalizeAllVNetRoots)
#endif
//
// The Bug check file id for this module
//
#define BugCheckFileId (RDBSS_BUG_CHECK_FCBSTRUC)
//struct _RX_PREFIX_TABLE RxNetNameTable;
ULONG SerialNumber = 1; //zero doesn't work!!!
//
// The debug trace level
//
#define Dbg (DEBUG_TRACE_FCBSTRUCTS)
// SRV_CALL,NET_ROOT,VNET_ROOT,FCB,SRV_OPEN,FOBX are the six key data structures in the RDBSS
// They are organized in the following hierarchy
//
// SRV_CALL
// NET_ROOT
// VNET_ROOT
// FCB
// SRV_OPEN
// FOBX
//
// All these data structures are reference counted. The reference count associated with
// any data structure is atleast 1 + the number of instances of the data structure at the next
// level associated with it, e.g., the reference count associated with a SRV_CALL which
// has two NET_ROOT's associated with it is atleast 3. In addition to the references held
// by the NameTable and the data structure at the next level there are additional references
// acquired as and when required.
//
// These restrictions ensure that a data structure at any given level cannot be finalized till
// all the data structures at the next level have been finalized or have released their
// references, i.e., if a reference to a FCB is held, then it is safe to access the VNET_ROOT,
// NET_ROOT and SRV_CALL associated with it.
//
// The SRV_CALL,NET_ROOT and VNET_ROOT creation/finalization are governed by the acquistion/
// release of the RxNetNameTable lock.
//
// The FCB creation/finalization is governed by the acquistion/release of the NetNameTable
// lock associated with the NET_ROOT.
//
// The FOBX/SRVOPEN creation/finalization is governed by the acquistion/release of the FCB
// resource.
//
// The following table summarizes the locks and the modes in which they need to be acquired
// for creation/finalization of the various data structures.
//
//
// L O C K I N G R E Q U I R E M E N T S
//
// Locking requirements are as follows:
//
// where Xy means Exclusive-on-Y, Sy mean at least Shared-on-Y
// and NNT means global NetNameTable, TL means NetRoot TableLock, and FCB means FCBlock
//
//
//
// SRVCALL NETROOT FCB SRVOPEN FOBX
//
// Create XNNT XNNT XTL XFCB XFCB
// Finalize XNNT XNNT XFCB XFCB XFCB
// & XTL
//
// Referencing and Dereferencing these data structures need to adhere to certain conventions
// as well.
//
// When the reference count associated with any of these data structures drops to 1 ( the sole
// reference being held by the name table in most cases) the data structure is a potential
// candidate for finalization. The data structure can be either finalized immediately or it
// can be marked for scavenging. Both of these methods are implemented. When the locking
// requirements are met during dereferencing the data structures are finalized immediately
// ( the one exception being that when delayed operation optimization is implemented, e.g., FCB)
// otherwise the data structure is marked for scavenging.
//
//
// You are supposed to have the tablelock exclusive to be calling this routine.......I can't
// take it here because you are already supposed to have it. To do a create, you should
// done something like
//
// getshared();lookup();
// if (failed) {
// release(); getexclusive(); lookup();
// if ((failed) { create(); }
// }
// deref();
// release();
//
// so you will already have the lock. what you do is to insert the node into the table, release
// the lock, and then go and see if the server's there. if so, set up the rest of the stuff and unblock
// anyone who's waiting on the same server (or netroot)...i guess i could enforce this by releasing here
// but i do not.
// Forward declarations -- These routines are not meant for use in other
// modules
BOOLEAN
RxFinalizeNetFcb (
OUT PFCB ThisFcb,
IN BOOLEAN RecursiveFinalize,
IN BOOLEAN ForceFinalize,
IN LONG ReferenceCount
);
VOID
RxPurgeFcb(
IN PFCB pFcb);
BOOLEAN
RxIsThisACscAgentOpen(
IN PRX_CONTEXT RxContext
);
VOID
RxDereference(
IN OUT PVOID pInstance,
IN LOCK_HOLDING_STATE LockHoldingState)
/*++
Routine Description:
The routine adjust the reference count on an instance of the reference counted data
structures in RDBSS exlcuding the FCB.
Arguments:
pInstance - the instance being dereferenced
LockHoldingState - the mode in which the appropriate lock is held.
Return Value:
none.
--*/
{
LONG FinalRefCount;
NODE_TYPE_CODE_AND_SIZE *pNode = (PNODE_TYPE_CODE_AND_SIZE)pInstance;
BOOLEAN fFinalizeInstance = FALSE;
PAGED_CODE();
RxAcquireScavengerMutex();
ASSERT((NodeType(pInstance) == RDBSS_NTC_SRVCALL ) ||
(NodeType(pInstance) == RDBSS_NTC_NETROOT ) ||
(NodeType(pInstance) == RDBSS_NTC_V_NETROOT ) ||
(NodeType(pInstance) == RDBSS_NTC_SRVOPEN ) ||
(NodeType(pInstance) == RDBSS_NTC_FOBX ));
FinalRefCount = InterlockedDecrement(&pNode->NodeReferenceCount);
ASSERT(FinalRefCount >= 0);
IF_DEBUG {
switch (NodeType(pInstance)) {
case RDBSS_NTC_SRVCALL :
{
PSRV_CALL ThisSrvCall = (PSRV_CALL)pInstance;
PRINT_REF_COUNT(SRVCALL,ThisSrvCall->NodeReferenceCount);
RxDbgTrace( 0, Dbg, (" RxDereferenceSrvCall %08lx %wZ RefCount=%lx\n", ThisSrvCall
, &ThisSrvCall->PrefixEntry.Prefix
, ThisSrvCall->NodeReferenceCount));
}
break;
case RDBSS_NTC_NETROOT :
{
PNET_ROOT ThisNetRoot = (PNET_ROOT)pInstance;
PRINT_REF_COUNT(NETROOT,ThisNetRoot->NodeReferenceCount);
RxDbgTrace( 0, Dbg, (" RxDereferenceNetRoot %08lx %wZ RefCount=%lx\n", ThisNetRoot
, &ThisNetRoot->PrefixEntry.Prefix
, ThisNetRoot->NodeReferenceCount));
}
break;
case RDBSS_NTC_V_NETROOT:
{
PV_NET_ROOT ThisVNetRoot = (PV_NET_ROOT)pInstance;
PRINT_REF_COUNT(VNETROOT,ThisVNetRoot->NodeReferenceCount);
RxDbgTrace( 0, Dbg, (" RxDereferenceVNetRoot %08lx %wZ RefCount=%lx\n", ThisVNetRoot
, &ThisVNetRoot->PrefixEntry.Prefix
, ThisVNetRoot->NodeReferenceCount));
}
break;
case RDBSS_NTC_SRVOPEN :
{
PSRV_OPEN ThisSrvOpen = (PSRV_OPEN)pInstance;
PRINT_REF_COUNT(SRVOPEN,ThisSrvOpen->NodeReferenceCount);
RxDbgTrace( 0, Dbg, (" RxDereferenceSrvOpen %08lx %wZ RefCount=%lx\n", ThisSrvOpen
, &ThisSrvOpen->Fcb->FcbTableEntry.Path
, ThisSrvOpen->NodeReferenceCount));
}
break;
case RDBSS_NTC_FOBX:
{
PFOBX ThisFobx = (PFOBX)pInstance;
PRINT_REF_COUNT(NETFOBX,ThisFobx->NodeReferenceCount);
RxDbgTrace( 0, Dbg, (" RxDereferenceFobx %08lx %wZ RefCount=%lx\n", ThisFobx
, &ThisFobx->SrvOpen->Fcb->FcbTableEntry.Path
, ThisFobx->NodeReferenceCount));
}
break;
default:
break;
}
}
// if the final reference count was greater then one no finalization is required.
if (FinalRefCount <= 1) {
if (LockHoldingState == LHS_ExclusiveLockHeld) {
// if the reference count was 1 and the lock modes were satisfactory,
// the instance can be finalized immediately.
fFinalizeInstance = TRUE;
if ((pNode->NodeTypeCode & RX_SCAVENGER_MASK) != 0) {
RxpUndoScavengerFinalizationMarking(pInstance);
}
} else {
switch (NodeType(pInstance)) {
case RDBSS_NTC_FOBX:
if (FinalRefCount != 0) {
break;
}
// fall thru intentional if refcount == 1 for FOBXs
case RDBSS_NTC_SRVCALL:
case RDBSS_NTC_NETROOT:
case RDBSS_NTC_V_NETROOT:
// the data structure cannot be freed at this time owing to the mode in which
// the lock has been acquired ( or not having the lock at all ).
RxpMarkInstanceForScavengedFinalization(pInstance);
break;
default:
break;
}
}
}
RxReleaseScavengerMutex();
if (fFinalizeInstance) {
switch (NodeType(pInstance)) {
case RDBSS_NTC_SRVCALL:
{
//ASSERT( RxIsPrefixTableLockAcquired( &RxNetNameTable ));
IF_DEBUG {
PRDBSS_DEVICE_OBJECT RxDeviceObject = ((PSRV_CALL)pInstance)->RxDeviceObject;
ASSERT( RxDeviceObject != NULL );
ASSERT( RxIsPrefixTableLockAcquired( RxDeviceObject->pRxNetNameTable ));
}
RxFinalizeSrvCall((PSRV_CALL)pInstance,TRUE,TRUE);
}
break;
case RDBSS_NTC_NETROOT:
{
//ASSERT( RxIsPrefixTableLockAcquired( &RxNetNameTable ));
IF_DEBUG {
PSRV_CALL SrvCall = ((PNET_ROOT)pInstance)->SrvCall;
PRDBSS_DEVICE_OBJECT RxDeviceObject = SrvCall->RxDeviceObject;
ASSERT( RxDeviceObject != NULL );
ASSERT( RxIsPrefixTableLockAcquired( RxDeviceObject->pRxNetNameTable ));
}
RxFinalizeNetRoot((PNET_ROOT)pInstance,TRUE,TRUE);
}
break;
case RDBSS_NTC_V_NETROOT:
{
//ASSERT( RxIsPrefixTableLockAcquired( &RxNetNameTable ));
IF_DEBUG {
PSRV_CALL SrvCall = ((PV_NET_ROOT)pInstance)->NetRoot->SrvCall;
PRDBSS_DEVICE_OBJECT RxDeviceObject = SrvCall->RxDeviceObject;
ASSERT( RxDeviceObject != NULL );
ASSERT( RxIsPrefixTableLockAcquired( RxDeviceObject->pRxNetNameTable ));
}
RxFinalizeVNetRoot((PV_NET_ROOT)pInstance,TRUE,TRUE);
}
break;
case RDBSS_NTC_SRVOPEN:
{
PSRV_OPEN ThisSrvOpen = (PSRV_OPEN)pInstance;
ASSERT(RxIsFcbAcquired(ThisSrvOpen->Fcb));
if (ThisSrvOpen->OpenCount == 0) {
RxFinalizeSrvOpen(ThisSrvOpen,FALSE,FALSE);
}
}
break;
case RDBSS_NTC_FOBX:
{
PFOBX ThisFobx = (PFOBX)pInstance;
ASSERT(RxIsFcbAcquired( ThisFobx->SrvOpen->Fcb));
RxFinalizeNetFobx(ThisFobx,TRUE,FALSE);
}
break;
default:
break;
}
}
}
VOID
RxReference(
OUT PVOID pInstance)
/*++
Routine Description:
The routine adjusts the reference count on the instance.
Arguments:
pInstance - the instance being referenced
Return Value:
RxStatus(SUCESS) is successful
RxStatus(UNSUCCESSFUL) otherwise.
--*/
{
LONG FinalRefCount;
NODE_TYPE_CODE_AND_SIZE *pNode = (PNODE_TYPE_CODE_AND_SIZE)pInstance;
USHORT InstanceType;
PAGED_CODE();
RxAcquireScavengerMutex();
InstanceType = pNode->NodeTypeCode & ~RX_SCAVENGER_MASK;
ASSERT((InstanceType == RDBSS_NTC_SRVCALL ) ||
(InstanceType == RDBSS_NTC_NETROOT ) ||
(InstanceType == RDBSS_NTC_V_NETROOT ) ||
(InstanceType == RDBSS_NTC_SRVOPEN ) ||
(InstanceType == RDBSS_NTC_FOBX ));
FinalRefCount = InterlockedIncrement(&pNode->NodeReferenceCount);
IF_DEBUG {
if (pNode->NodeTypeCode & RX_SCAVENGER_MASK) {
RxDbgTrace(0,Dbg,("Referencing Scavenged instance -- Type %lx\n",InstanceType));
}
switch (InstanceType) {
case RDBSS_NTC_SRVCALL :
{
PSRV_CALL ThisSrvCall = (PSRV_CALL)pInstance;
PRINT_REF_COUNT(SRVCALL,ThisSrvCall->NodeReferenceCount);
RxDbgTrace( 0, Dbg, (" RxReferenceSrvCall %08lx %wZ RefCount=%lx\n", ThisSrvCall
, &ThisSrvCall->PrefixEntry.Prefix
, ThisSrvCall->NodeReferenceCount));
}
break;
case RDBSS_NTC_NETROOT :
{
PNET_ROOT ThisNetRoot = (PNET_ROOT)pInstance;
PRINT_REF_COUNT(NETROOT,ThisNetRoot->NodeReferenceCount);
RxDbgTrace( 0, Dbg, (" RxReferenceNetRoot %08lx %wZ RefCount=%lx\n", ThisNetRoot
, &ThisNetRoot->PrefixEntry.Prefix
, ThisNetRoot->NodeReferenceCount));
}
break;
case RDBSS_NTC_V_NETROOT:
{
PV_NET_ROOT ThisVNetRoot = (PV_NET_ROOT)pInstance;
PRINT_REF_COUNT(VNETROOT,ThisVNetRoot->NodeReferenceCount);
RxDbgTrace( 0, Dbg, (" RxReferenceVNetRoot %08lx %wZ RefCount=%lx\n", ThisVNetRoot
, &ThisVNetRoot->PrefixEntry.Prefix
, ThisVNetRoot->NodeReferenceCount));
}
break;
case RDBSS_NTC_SRVOPEN :
{
PSRV_OPEN ThisSrvOpen = (PSRV_OPEN)pInstance;
PRINT_REF_COUNT(SRVOPEN,ThisSrvOpen->NodeReferenceCount);
RxDbgTrace( 0, Dbg, (" RxReferenceSrvOpen %08lx %wZ RefCount=%lx\n", ThisSrvOpen
, &ThisSrvOpen->Fcb->FcbTableEntry.Path
, ThisSrvOpen->NodeReferenceCount));
}
break;
case RDBSS_NTC_FOBX:
{
PFOBX ThisFobx = (PFOBX)pInstance;
PRINT_REF_COUNT(NETFOBX,ThisFobx->NodeReferenceCount);
RxDbgTrace( 0, Dbg, (" RxReferenceFobx %08lx %wZ RefCount=%lx\n", ThisFobx
, &ThisFobx->SrvOpen->Fcb->FcbTableEntry.Path
, ThisFobx->NodeReferenceCount));
}
break;
default:
{
ASSERT(!"Valid node type for referencing");
}
break;
}
}
RxpUndoScavengerFinalizationMarking(pInstance);
RxReleaseScavengerMutex();
}
VOID
RxpReferenceNetFcb(
PFCB pFcb)
/*++
Routine Description:
The routine adjusts the reference count on the FCB.
Arguments:
pFcb - the SrvCall being referenced
Return Value:
RxStatus(SUCESS) is successful
RxStatus(UNSUCCESSFUL) otherwise.
--*/
{
LONG FinalRefCount;
PAGED_CODE();
ASSERT(NodeTypeIsFcb(pFcb));
FinalRefCount = InterlockedIncrement(&pFcb->NodeReferenceCount);
IF_DEBUG {
PRINT_REF_COUNT(NETFCB,pFcb->NodeReferenceCount);
RxDbgTrace( 0, Dbg, (" RxReferenceNetFcb %08lx %wZ RefCount=%lx\n", pFcb
, &pFcb->FcbTableEntry.Path
, pFcb->NodeReferenceCount));
}
}
LONG
RxpDereferenceNetFcb(
PFCB pFcb)
/*++
Routine Description:
The routine adjust the reference count on an instance of the reference counted data
structures in RDBSS exlcuding the FCB.
Arguments:
pFcb -- the FCB being dereferenced
Return Value:
none.
Notes:
The referencing and dereferencing of FCB's is different from those of the other data
structures because of the embedded resource in the FCB. This implies that the caller
requires information regarding the status of the FCB ( whether it was finalized or not )
In order to finalize the FCB two locks need to be held, the NET_ROOT's name table lock as
well as the FCB resource.
These considerations lead us to adopt a different approach in dereferencing FCB's. The
dereferencing routine does not even attempt to finalize the FCB
--*/
{
LONG FinalRefCount;
PAGED_CODE();
ASSERT(NodeTypeIsFcb(pFcb));
FinalRefCount = InterlockedDecrement(&pFcb->NodeReferenceCount);
ASSERT(FinalRefCount >= 0);
IF_DEBUG {
PRINT_REF_COUNT(NETFCB,pFcb->NodeReferenceCount);
RxDbgTrace( 0, Dbg, (" RxDereferenceNetFcb %08lx %wZ RefCount=%lx\n", pFcb
, &pFcb->FcbTableEntry.Path
, pFcb->NodeReferenceCount));
}
return(FinalRefCount);
}
BOOLEAN
RxpDereferenceAndFinalizeNetFcb(
PFCB pFcb,
PRX_CONTEXT RxContext,
BOOLEAN RecursiveFinalize,
BOOLEAN ForceFinalize)
/*++
Routine Description:
The routine adjust the reference count aw well as finalizes the FCB if required
Arguments:
pFcb -- the FCB being dereferenced
RxContext -- the context for releasing/acquiring FCB.
RecursiveFinalize -- recursive finalization
ForceFinalize -- force finalization
Return Value:
none.
Notes:
The referencing and dereferencing of FCB's is different from those of the other data
structures because of the embedded resource in the FCB. This implies that the caller
requires information regarding the status of the FCB ( whether it was finalized or not )
In order to finalize the FCB two locks need to be held, the NET_ROOT's name table lock as
well as the FCB resource.
This routine acquires the additional lock if required.
--*/
{
BOOLEAN NodeActuallyFinalized = FALSE;
LONG FinalRefCount;
PAGED_CODE();
ASSERT(!ForceFinalize);
ASSERT(NodeTypeIsFcb(pFcb));
ASSERT(RxIsFcbAcquiredExclusive(pFcb));
FinalRefCount = InterlockedDecrement(&pFcb->NodeReferenceCount);
if (ForceFinalize ||
RecursiveFinalize ||
((pFcb->OpenCount == 0) &&
(pFcb->UncleanCount == 0) &&
(FinalRefCount <= 1))) {
BOOLEAN PrefixTableLockAcquired = FALSE;
PNET_ROOT pNetRoot;
NTSTATUS Status = (STATUS_SUCCESS);
if (!FlagOn(pFcb->FcbState,FCB_STATE_ORPHANED)) {
pNetRoot = (PNET_ROOT)pFcb->VNetRoot->NetRoot;
// An insurance reference to ensure that the NET ROOT does not dissapear
RxReferenceNetRoot(pNetRoot);
// In all these cases the FCB is likely to be finalized
if (!RxIsFcbTableLockExclusive(&pNetRoot->FcbTable)) {
RxReferenceNetFcb(pFcb); // get ready to refresh the finalrefcount after we get the tablelock
if (!RxAcquireFcbTableLockExclusive(&pNetRoot->FcbTable, FALSE) ) {
if ((RxContext != NULL) &&
(RxContext != CHANGE_BUFFERING_STATE_CONTEXT) &&
(RxContext != CHANGE_BUFFERING_STATE_CONTEXT_WAIT)) {
SetFlag(RxContext->Flags,RX_CONTEXT_FLAG_BYPASS_VALIDOP_CHECK);
}
RxReleaseFcb(RxContext,pFcb );
(VOID)RxAcquireFcbTableLockExclusive(&pNetRoot->FcbTable, TRUE);
Status = RxAcquireExclusiveFcb(RxContext, pFcb);
}
FinalRefCount = RxDereferenceNetFcb(pFcb);
PrefixTableLockAcquired = TRUE;
}
} else {
pNetRoot = NULL;
}
if (Status == (STATUS_SUCCESS)) {
NodeActuallyFinalized = RxFinalizeNetFcb(pFcb,RecursiveFinalize,ForceFinalize,FinalRefCount);
}
if (PrefixTableLockAcquired) {
RxReleaseFcbTableLock(&pNetRoot->FcbTable);
}
if (pNetRoot != NULL) {
RxDereferenceNetRoot(pNetRoot,LHS_LockNotHeld);
}
}
return NodeActuallyFinalized;
}
VOID
RxWaitForStableCondition(
IN PRX_BLOCK_CONDITION pCondition,
IN OUT PLIST_ENTRY pTransitionWaitList,
IN OUT PRX_CONTEXT pRxContext,
OUT NTSTATUS *AsyncStatus OPTIONAL)
/*++
Routine Description:
The routine checks to see if the condition is stable. If not, it
is suspended till a stable condition is attained. when a stable condition is
obtained, either the rxcontext sync event is set or the context is posted...depending
on the POST_ON_STABLE_CONDITION context flag. the flag is cleared on a post.
Arguments:
Condition - the condition variable we're waiting on
Resource - the resrouce used to control access to the containing block
RxContext - the RX context
Return Value:
RXSTATUS - PENDING if notstable and the context will be posted
SUCCESS otherwise
--*/
{
NTSTATUS DummyStatus;
BOOLEAN Wait = FALSE;
PAGED_CODE();
if (AsyncStatus == NULL) {
AsyncStatus = &DummyStatus;
}
*AsyncStatus = (STATUS_SUCCESS);
if (StableCondition(*pCondition))
return; //early out could macroize
#ifndef WIN9X
RxAcquireSerializationMutex();
#endif
if (!StableCondition(*pCondition)) {
RxInsertContextInSerializationQueue(pTransitionWaitList,pRxContext);
if (!FlagOn(pRxContext->Flags,RX_CONTEXT_FLAG_POST_ON_STABLE_CONDITION)){
Wait = TRUE;
} else {
*AsyncStatus = (STATUS_PENDING);
}
}
#ifndef WIN9X
RxReleaseSerializationMutex();
#endif WIN9X
if (Wait) {
RxWaitSync(pRxContext);
}
return;
}
VOID
RxUpdateCondition (
IN RX_BLOCK_CONDITION NewCondition,
OUT PRX_BLOCK_CONDITION pCondition,
IN OUT PLIST_ENTRY pTransitionWaitList)
/*++
Routine Description:
The routine unwaits the guys waiting on the transition event and the condition is set
according to the parameter passed.
Arguments:
NewConditionValue - the new value of the condition variable
pCondition - variable (i.e. a ptr) to the transitioning condition
pTransitionWaitList - list of contexts waiting for the transition.
Notes:
The resource associated with the data structure instance being modified must have been
acquired exclusively before invoking this routine, i.e., for SRV_CALL,NET_ROOT and V_NET_ROOT
the net name table lock must be acquired and for FCB's the associated resource.
--*/
{
LIST_ENTRY TargetListHead;
PRX_CONTEXT pRxContext;
PAGED_CODE();
#ifndef WIN9X
RxAcquireSerializationMutex();
#endif
ASSERT(NewCondition != Condition_InTransition);
*pCondition = NewCondition;
RxTransferList(&TargetListHead,pTransitionWaitList);
#ifndef WIN9X
RxReleaseSerializationMutex();
#endif
while (pRxContext = RxRemoveFirstContextFromSerializationQueue(&TargetListHead)) {
if (!FlagOn(pRxContext->Flags,RX_CONTEXT_FLAG_POST_ON_STABLE_CONDITION)){
RxSignalSynchronousWaiter(pRxContext);
} else {
ClearFlag(pRxContext->Flags,RX_CONTEXT_FLAG_POST_ON_STABLE_CONDITION);
RxFsdPostRequest(pRxContext);
}
}
}
PVOID
RxAllocateObject(
NODE_TYPE_CODE NodeType,
PMINIRDR_DISPATCH pMRxDispatch,
ULONG NameLength)
/*++
Routine Description:
The routine allocates and constructs the skeleton of a SRV_CALL/NET_ROOT/V_NET_ROOT
instance.
Arguments:
NodeType - the node type
pMRxDispatch - the Mini redirector dispatch vector
NameLength - name size.
Notes:
The reasons as to why the allocation/freeing of these data structures have been
centralized are as follows
1) The construction of these three data types have a lot in common with the exception
of the initial computation of sizes. Therefore centralization minimizes the footprint.
2) It allows us to experiment with different clustering/allocation strategies.
3) It allows the incorporation of debug support in an easy way.
There are two special cases of interest in the allocation strategy ...
1) The data structures for the wrapper as well as the corresponding mini redirector
are allocated adjacent to each other. This ensures spatial locality.
2) The one exception to the above rule is the SRV_CALL data structure. This is because
of the bootstrapping problem. A SRV_CALL skeleton needs to be created which is then passed
around to each of the mini redirectors. Therefore adoption of rule (1) is not possible.
Further there can be more than one mini redirector laying claim to a particular server. In
consideration of these things SRV_CALL's need to be treated as an exception to (1). However
once a particular mini redirector has been selected as the winner it would be advantageous
to colocate the data structure to derive the associated performance benefits. This has not
been implemented as yet.
--*/
{
ULONG PoolTag;
ULONG RdbssNodeSize,MRxNodeSize;
BOOLEAN fInitializeContextFields = FALSE;
PNODE_TYPE_CODE_AND_SIZE pNode;
PAGED_CODE();
RdbssNodeSize = MRxNodeSize = 0;
switch (NodeType) {
case RDBSS_NTC_SRVCALL :
{
PoolTag = RX_SRVCALL_POOLTAG;
RdbssNodeSize = QuadAlign(sizeof(SRV_CALL));
if (pMRxDispatch != NULL) {
if (pMRxDispatch->MRxFlags & RDBSS_MANAGE_SRV_CALL_EXTENSION) {
MRxNodeSize = QuadAlign(pMRxDispatch->MRxSrvCallSize);
}
}
}
break;
case RDBSS_NTC_NETROOT:
{
PoolTag = RX_NETROOT_POOLTAG;
RdbssNodeSize = QuadAlign(sizeof(NET_ROOT));
if (pMRxDispatch->MRxFlags & RDBSS_MANAGE_NET_ROOT_EXTENSION) {
MRxNodeSize = QuadAlign(pMRxDispatch->MRxNetRootSize);
}
}
break;
case RDBSS_NTC_V_NETROOT:
{
PoolTag = RX_V_NETROOT_POOLTAG;
RdbssNodeSize = QuadAlign(sizeof(V_NET_ROOT));
if (pMRxDispatch->MRxFlags & RDBSS_MANAGE_V_NET_ROOT_EXTENSION) {
MRxNodeSize = QuadAlign(pMRxDispatch->MRxVNetRootSize);
}
}
break;
default:
ASSERT(!"Invalid Node Type for allocation/Initialization");
return NULL;
}
pNode = RxAllocatePoolWithTag(
NonPagedPool,
(RdbssNodeSize + MRxNodeSize + NameLength),
PoolTag);
if (pNode != NULL) {
ULONG NodeSize;
PVOID *pContextPtr;
PRX_PREFIX_ENTRY pPrefixEntry = NULL;
NodeSize = RdbssNodeSize + MRxNodeSize;
ZeroAndInitializeNodeType(pNode, NodeType, (NodeSize + NameLength));
switch (NodeType) {
case RDBSS_NTC_SRVCALL:
{
PSRV_CALL pSrvCall = (PSRV_CALL)pNode;
pContextPtr = &pSrvCall->Context;
pPrefixEntry = &pSrvCall->PrefixEntry;
// Set up the name pointer in the MRX_SRV_CALL structure ..
pSrvCall->pSrvCallName = &pSrvCall->PrefixEntry.Prefix;
}
break;
case RDBSS_NTC_NETROOT:
{
PNET_ROOT pNetRoot = (PNET_ROOT)pNode;
pContextPtr = &pNetRoot->Context;
pPrefixEntry = &pNetRoot->PrefixEntry;
// Set up the net root name pointer in the MRX_NET_ROOT structure
pNetRoot->pNetRootName = &pNetRoot->PrefixEntry.Prefix;
}
break;
case RDBSS_NTC_V_NETROOT:
{
PV_NET_ROOT pVNetRoot = (PV_NET_ROOT)pNode;
pContextPtr = &pVNetRoot->Context;
pPrefixEntry = &pVNetRoot->PrefixEntry;
}
break;
default:
break;
}
if (pPrefixEntry != NULL) {
ZeroAndInitializeNodeType(
pPrefixEntry,
RDBSS_NTC_PREFIX_ENTRY,
sizeof( RX_PREFIX_ENTRY ));
pPrefixEntry->Prefix.Buffer = (PWCH)((PCHAR)pNode + NodeSize);
pPrefixEntry->Prefix.Length = (USHORT)NameLength;
pPrefixEntry->Prefix.MaximumLength = (USHORT)NameLength;
}
if (MRxNodeSize > 0) {
*pContextPtr = (PBYTE)pNode + RdbssNodeSize;
}
}
return pNode;
}
VOID
RxFreeObject(PVOID pObject)
/*++
Routine Description:
The routine frees a SRV_CALL/V_NET_ROOT/NET_ROOT instance
Arguments:
pObject - the instance to be freed
Notes:
--*/
{
PAGED_CODE();
IF_DEBUG {
switch (NodeType(pObject)) {
case RDBSS_NTC_SRVCALL :
{
PSRV_CALL pSrvCall = (PSRV_CALL)pObject;
if (pSrvCall->RxDeviceObject != NULL) {
if (!(pSrvCall->RxDeviceObject->Dispatch->MRxFlags & RDBSS_MANAGE_SRV_CALL_EXTENSION)) {
ASSERT(pSrvCall->Context == NULL);
}
ASSERT(pSrvCall->Context2 == NULL);
pSrvCall->RxDeviceObject = NULL;
}
}
break;
case RDBSS_NTC_NETROOT :
{
PNET_ROOT pNetRoot = (PNET_ROOT)pObject;
pNetRoot->SrvCall = NULL;
//pNetRoot->Dispatch = NULL;
pNetRoot->NodeTypeCode |= 0xf000;
}
break;
case RDBSS_NTC_V_NETROOT :
{
}
break;
default:
break;
}
}
RxFreePool(pObject);
}
VOID
RxFinalizeNetTable (
PRDBSS_DEVICE_OBJECT RxDeviceObject,
BOOLEAN fForceFinalization
)
/*++
Routine Description:
This routine finalizes the net table.
--*/
{
BOOLEAN fMorePassesRequired = TRUE;
PLIST_ENTRY pListEntry;
NODE_TYPE_CODE DesiredNodeType;
PRX_PREFIX_TABLE pRxNetNameTable = RxDeviceObject->pRxNetNameTable;
PAGED_CODE();
RxDbgTrace(+1, Dbg, ("RxForceNetTableFinalization at the TOP\n"));
RxLog(("FINALNETT\n"));
RxWmiLog(LOG,
RxFinalizeNetTable_1,
LOGPTR(RxDeviceObject));
RxAcquirePrefixTableLockExclusive( pRxNetNameTable, TRUE); //could be hosed if rogue!
DesiredNodeType = RDBSS_NTC_V_NETROOT;
RxAcquireScavengerMutex();
while (fMorePassesRequired) {
for (pListEntry = pRxNetNameTable->MemberQueue.Flink;
pListEntry != &(pRxNetNameTable->MemberQueue); ) {
BOOLEAN NodeFinalized;
PVOID pContainer;
PRX_PREFIX_ENTRY PrefixEntry;
PLIST_ENTRY pPrevEntry;
PrefixEntry = CONTAINING_RECORD( pListEntry, RX_PREFIX_ENTRY, MemberQLinks );
ASSERT (NodeType(PrefixEntry) == RDBSS_NTC_PREFIX_ENTRY);
pContainer = (PrefixEntry->ContainingRecord);
RxDbgTrace(0, Dbg, ("RxForceNetTableFinalization ListEntry PrefixEntry Container"
"=--> %08lx %08lx %08lx\n", pListEntry, PrefixEntry, pContainer));
RxLog(("FINALNETT: %lx %wZ\n", pContainer, &PrefixEntry->Prefix));
RxWmiLog(LOG,
RxFinalizeNetTable_2,
LOGPTR(pContainer)
LOGUSTR(PrefixEntry->Prefix));
pListEntry = pListEntry->Flink;
if (pContainer != NULL) {
RxpUndoScavengerFinalizationMarking(pContainer);
if (NodeType(pContainer) == DesiredNodeType) {
switch (NodeType(pContainer)) {
case RDBSS_NTC_SRVCALL :
NodeFinalized = RxFinalizeSrvCall((PSRV_CALL)pContainer,TRUE,fForceFinalization);
break;
case RDBSS_NTC_NETROOT :
NodeFinalized = RxFinalizeNetRoot((PNET_ROOT)pContainer,TRUE,fForceFinalization);
break;
case RDBSS_NTC_V_NETROOT :
{
PV_NET_ROOT pVNetRoot = (PV_NET_ROOT)pContainer;
ULONG AdditionalReferenceTaken;
AdditionalReferenceTaken = InterlockedCompareExchange(
&pVNetRoot->AdditionalReferenceForDeleteFsctlTaken,
0,
1);
if (AdditionalReferenceTaken) {
RxDereferenceVNetRoot(pVNetRoot,LHS_ExclusiveLockHeld);
NodeFinalized = TRUE;
} else {
NodeFinalized = RxFinalizeVNetRoot((PV_NET_ROOT)pContainer,TRUE,fForceFinalization);
}
}
break;
}
}
}
}
switch (DesiredNodeType) {
case RDBSS_NTC_SRVCALL :
fMorePassesRequired = FALSE;
break;
case RDBSS_NTC_NETROOT :
DesiredNodeType = RDBSS_NTC_SRVCALL;
break;
case RDBSS_NTC_V_NETROOT :
DesiredNodeType = RDBSS_NTC_NETROOT;
break;
}
}
RxDbgTrace(-1,Dbg,("RxFinalizeNetTable -- Done\n"));
RxReleaseScavengerMutex();
RxReleasePrefixTableLock( pRxNetNameTable );
}
NTSTATUS
RxFinalizeConnection(
IN OUT PNET_ROOT NetRoot,
IN OUT PV_NET_ROOT VNetRoot,
IN BOOLEAN Level
)
/*++
Routine Description:
The routine deletes a connection FROM THE USER's PERSPECTIVE. It doesn't disconnect
but it does (with force) close open files. disconnecting is handled either by timeout or by
srvcall finalization.
Arguments:
NetRoot - the NetRoot being finalized
VNetRoot - the VNetRoot being finalized
Level - This is a tri-state
FALSE - fail if files or changenotifications are open
TRUE - succeed no matter waht. orphan files and remove change notifies forcefully
0xff - take away extra reference on the vnetroot due to add_connection
but otherwise act like FALSE
Return Value:
RxStatus(SUCCESS) if successful.
--*/
{
NTSTATUS Status = STATUS_SUCCESS;
ULONG NumberOfOpenDirectories = 0;
ULONG NumberOfOpenNonDirectories = 0;
ULONG NumberOfFobxs = 0;
LONG AdditionalReferenceForDeleteFsctlTaken = 0;
PLIST_ENTRY ListEntry, NextListEntry;
BOOLEAN PrefixTableLockAcquired,FcbTableLockAcquired;
PRX_PREFIX_TABLE pRxNetNameTable;
BOOLEAN ForceFilesClosed = FALSE;
if (Level==TRUE)
{
ForceFilesClosed = TRUE;
}
PAGED_CODE();
ASSERT( NodeType(NetRoot) == RDBSS_NTC_NETROOT );
pRxNetNameTable = NetRoot->SrvCall->RxDeviceObject->pRxNetNameTable;
Status = RxCancelNotifyChangeDirectoryRequestsForVNetRoot(VNetRoot, ForceFilesClosed);
// either changenotifications were cancelled, or they weren't but we still want to
// do go through in order to either forceclose the files or atleast deref the vnetroot
// of the extra ref taken during ADD_CONNECTION
if ((Status == STATUS_SUCCESS) || (Level != FALSE))
{
// reset the status
Status = STATUS_SUCCESS;
PrefixTableLockAcquired = RxAcquirePrefixTableLockExclusive(
pRxNetNameTable,
TRUE);
//don't let the netroot be finalized yet.......
RxReferenceNetRoot(NetRoot);
FcbTableLockAcquired = RxAcquireFcbTableLockExclusive(
&NetRoot->FcbTable,
TRUE);
try {
if ((Status == STATUS_SUCCESS) && (!VNetRoot->ConnectionFinalizationDone)) {
USHORT BucketNumber;
RxDbgTrace(+1, Dbg, ("RxFinalizeConnection<+> NR= %08lx VNR= %08lx %wZ\n",
NetRoot,VNetRoot,&NetRoot->PrefixEntry.Prefix));
RxLog(("FINALCONN: %lx %wZ\n",NetRoot,&NetRoot->PrefixEntry.Prefix));
RxWmiLog(LOG,
RxFinalizeConnection,
LOGPTR(NetRoot)
LOGUSTR(NetRoot->PrefixEntry.Prefix));
for (BucketNumber = 0;
(BucketNumber < NetRoot->FcbTable.NumberOfBuckets);
BucketNumber++) {
PLIST_ENTRY ListHeader;
ListHeader = &NetRoot->FcbTable.HashBuckets[BucketNumber];
for (ListEntry = ListHeader->Flink;
ListEntry != ListHeader;
ListEntry = NextListEntry ) {
PFCB Fcb;
PRX_FCB_TABLE_ENTRY FcbTableEntry;
NextListEntry = ListEntry->Flink;
FcbTableEntry = CONTAINING_RECORD(
ListEntry,
RX_FCB_TABLE_ENTRY,
HashLinks );
Fcb = CONTAINING_RECORD(
FcbTableEntry,
FCB,
FcbTableEntry);
if (Fcb->VNetRoot != VNetRoot) {
continue;
}
if (Fcb->UncleanCount>0 && !ForceFilesClosed) {
Status = STATUS_CONNECTION_IN_USE; //this is changed later
if (NodeType(Fcb)==RDBSS_NTC_STORAGE_TYPE_DIRECTORY) {
NumberOfOpenDirectories++;
} else {
NumberOfOpenNonDirectories++;
}
continue;
}
ASSERT( NodeTypeIsFcb(Fcb));
RxDbgTrace( 0, Dbg, (" AcquiringFcbLock%c!!\n", '!'));
Status = RxAcquireExclusiveFcb(NULL,Fcb);
ASSERT(Status == STATUS_SUCCESS);
RxDbgTrace( 0, Dbg, (" AcquiredFcbLock%c!!\n", '!'));
// Ensure that no more file objects will be marked for a delayed close
// on this FCB.
ClearFlag(Fcb->FcbState,FCB_STATE_COLLAPSING_ENABLED);
RxScavengeRelatedFobxs(Fcb);
// a small complication here is that this fcb MAY have an open
// section against it caused by our cacheing the file. if so,
// we need to purge to get to the close
RxPurgeFcb(Fcb);
}
}
if (VNetRoot->NumberOfFobxs == 0) {
VNetRoot->ConnectionFinalizationDone = TRUE;
}
}
NumberOfFobxs = VNetRoot->NumberOfFobxs;
AdditionalReferenceForDeleteFsctlTaken = VNetRoot->AdditionalReferenceForDeleteFsctlTaken;
if (ForceFilesClosed) {
RxFinalizeVNetRoot(VNetRoot,FALSE,TRUE);
}
} finally {
if (FcbTableLockAcquired) {
RxReleaseFcbTableLock( &NetRoot->FcbTable );
}
// We should not delete the remote connection with the file opened.
if (!ForceFilesClosed && (Status == STATUS_SUCCESS) && (NumberOfFobxs > 0)) {
Status = STATUS_FILES_OPEN;
}
if (Status != STATUS_SUCCESS) {
if (NumberOfOpenNonDirectories) {
Status = STATUS_FILES_OPEN;
}
}
if ((Status == STATUS_SUCCESS)||(Level==0xff)){
// the corresponding reference for this is in RxCreateTreeConnect...
// please see the comment there...
if (AdditionalReferenceForDeleteFsctlTaken != 0) {
VNetRoot->AdditionalReferenceForDeleteFsctlTaken = 0;
RxDereferenceVNetRoot(VNetRoot,LHS_ExclusiveLockHeld);
}
}
if (PrefixTableLockAcquired) {
RxDereferenceNetRoot(NetRoot,LHS_ExclusiveLockHeld);
RxReleasePrefixTableLock( pRxNetNameTable );
}
}
RxDbgTrace(-1, Dbg, ("RxFinalizeConnection<-> Status=%08lx\n", Status));
}
return(Status);
}
NTSTATUS
RxInitializeSrvCallParameters(
PRX_CONTEXT RxContext,
PSRV_CALL SrvCall)
/*++
Routine Description:
This routine initializes the server call parameters passed in through EA's
Currently this routine initializes the Server principal name which is passed
in by the DFS driver.
Arguments:
RxContext -- the associated context
SrvCall -- the Srv Call Instance
Return Value:
RxStatus(SUCCESS) if successfull
Notes:
The current implementation maps out of memory situations into an error and
passes it back. If the global strategy is to raise an exception this
redundant step can be avoided.
--*/
{
NTSTATUS Status = (STATUS_SUCCESS);
RxCaptureRequestPacket;
RxCaptureParamBlock;
ULONG EaInformationLength;
PAGED_CODE();
SrvCall->pPrincipalName = NULL;
if (RxContext->MajorFunction != IRP_MJ_CREATE) {
return STATUS_SUCCESS;
}
EaInformationLength = RxContext->Create.EaLength;
if (EaInformationLength > 0) {
PFILE_FULL_EA_INFORMATION pEaEntry;
pEaEntry = (PFILE_FULL_EA_INFORMATION)RxContext->Create.EaBuffer;
ASSERT(pEaEntry != NULL);
for(;;) {
RxDbgTrace(0,Dbg,("RxExtractSrvCallParams: Processing EA name %s\n",
pEaEntry->EaName));
if (strcmp(pEaEntry->EaName, EA_NAME_PRINCIPAL) == 0) {
if (pEaEntry->EaValueLength > 0) {
SrvCall->pPrincipalName = (PUNICODE_STRING)
RxAllocatePoolWithTag(
NonPagedPool,
(sizeof(UNICODE_STRING) + pEaEntry->EaValueLength),
RX_SRVCALL_PARAMS_POOLTAG);
if (SrvCall->pPrincipalName != NULL) {
SrvCall->pPrincipalName->Length = pEaEntry->EaValueLength;
SrvCall->pPrincipalName->MaximumLength = pEaEntry->EaValueLength;
SrvCall->pPrincipalName->Buffer = (PWCHAR)((PCHAR)SrvCall->pPrincipalName + sizeof(UNICODE_STRING));
RtlCopyMemory(
SrvCall->pPrincipalName->Buffer,
pEaEntry->EaName + pEaEntry->EaNameLength + 1,
SrvCall->pPrincipalName->Length);
} else {
Status = (STATUS_INSUFFICIENT_RESOURCES);
}
}
break;
}
if (pEaEntry->NextEntryOffset == 0) {
break;
} else {
pEaEntry = (PFILE_FULL_EA_INFORMATION)
((PCHAR) pEaEntry + pEaEntry->NextEntryOffset);
}
}
}
return Status;
}
PSRV_CALL
RxCreateSrvCall (
IN PRX_CONTEXT RxContext,
IN PUNICODE_STRING Name,
IN PUNICODE_STRING InnerNamePrefix OPTIONAL,
IN PRX_CONNECTION_ID RxConnectionId
)
/*++
Routine Description:
The routine builds a node representing a server call context and inserts the name into the net
name table. Optionally, it "co-allocates" a netroot structure as well. Appropriate alignment is
respected for the enclosed netroot. The name(s) is(are) allocated at the end of the block. The
reference count on the block is set to 1 (2 if enclosed netroot) on this create to account for
ptr returned.
Arguments:
RxContext - the RDBSS context
Name - the name to be inserted
Dispatch - pointer to the minirdr dispatch table
Return Value:
Ptr to the created srvcall.
--*/
{
PSRV_CALL ThisSrvCall;
PRX_PREFIX_ENTRY ThisEntry;
ULONG NameSize,PrefixNameSize;
PAGED_CODE();
RxDbgTrace(+1, Dbg, ("RxSrvCallCreate--> Name = %wZ\n", Name));
ASSERT ( RxIsPrefixTableLockExclusive ( RxContext->RxDeviceObject->pRxNetNameTable ) );
NameSize = Name->Length + sizeof(WCHAR) * 2;
if (InnerNamePrefix) {
PrefixNameSize = InnerNamePrefix->Length;
} else {
PrefixNameSize = 0;
}
ThisSrvCall = RxAllocateObject(RDBSS_NTC_SRVCALL,NULL,(NameSize + PrefixNameSize));
if (ThisSrvCall != NULL) {
ThisSrvCall->SerialNumberForEnum = SerialNumber++;
ThisSrvCall->RxDeviceObject = RxContext->RxDeviceObject;
RxInitializeBufferingManager(ThisSrvCall);
InitializeListHead(&ThisSrvCall->ScavengerFinalizationList);
InitializeListHead(&ThisSrvCall->TransitionWaitList);
RxInitializePurgeSyncronizationContext(
&ThisSrvCall->PurgeSyncronizationContext);
#ifndef WIN9X
RxInitializeSrvCallParameters(RxContext,ThisSrvCall);
#endif
RtlMoveMemory(
ThisSrvCall->PrefixEntry.Prefix.Buffer,
Name->Buffer,
Name->Length);
ThisEntry = &ThisSrvCall->PrefixEntry;
ThisEntry->Prefix.MaximumLength = (USHORT)NameSize;
ThisEntry->Prefix.Length = Name->Length;
RxPrefixTableInsertName (
RxContext->RxDeviceObject->pRxNetNameTable,
ThisEntry,
(PVOID)ThisSrvCall,
&ThisSrvCall->NodeReferenceCount,
Name->Length,
RxConnectionId); //make the whole srvcallname case insensitive
RxDbgTrace(-1, Dbg, ("RxSrvCallCreate -> RefCount = %08lx\n", ThisSrvCall->NodeReferenceCount));
}
return ThisSrvCall;
}
NTSTATUS
RxSetSrvCallDomainName(
PMRX_SRV_CALL pSrvCall,
PUNICODE_STRING pDomainName)
/*++
Routine Description:
The routine sets the domain name associated with any given server.
Arguments:
pSrvCall - the SrvCall
pDomainName - the DOMAIN to which the server belongs.
Return Value:
RxStatus(SUCCESS) if successful
Notes:
This is one of the callback routines provided in the wrapper for the mini redirectors.
Since the Domain name is not often known at the beginning this mechanism has to be
adopted once it is found.
--*/
{
NTSTATUS Status = (STATUS_SUCCESS);
PAGED_CODE();
if (pSrvCall->pDomainName != NULL) {
RxFreePool(pSrvCall->pDomainName);
}
if (pDomainName != NULL && pDomainName->Length > 0) {
pSrvCall->pDomainName = (PUNICODE_STRING)
RxAllocatePoolWithTag(
NonPagedPool,
sizeof(UNICODE_STRING) + pDomainName->Length + sizeof(WCHAR),
RX_SRVCALL_PARAMS_POOLTAG);
if (pSrvCall->pDomainName != NULL) {
pSrvCall->pDomainName->Buffer = (PWCHAR)((PCHAR)pSrvCall->pDomainName + sizeof(UNICODE_STRING));
pSrvCall->pDomainName->Length = pDomainName->Length;
pSrvCall->pDomainName->MaximumLength = pDomainName->Length;
*pSrvCall->pDomainName->Buffer = 0;
if (pSrvCall->pDomainName->Length > 0) {
RtlCopyMemory(
pSrvCall->pDomainName->Buffer,
pDomainName->Buffer,
pDomainName->Length);
}
} else {
Status = (STATUS_INSUFFICIENT_RESOURCES);
}
} else {
pSrvCall->pDomainName = NULL;
}
return Status;
}
VOID
RxpDestroySrvCall(
PSRV_CALL ThisSrvCall)
/*++
Routine Description:
This routine is used to tear down a SRV_CALL entry. This code is offloaded
from the RxFinalizeCall routine to avoid having to hold the Name Table Lock
for extended periods of time while the mini redirector is finalizing its
data structures.
Arguments:
ThisSrvCall - the SrvCall being finalized
Notes:
there is no recursive part because i don't have a list of srvcalls and a list
of netroots i only have a combined list. thus, recursive finalization of
netroots is directly from the top level. however, all netroots should already
have been done when i get here..
--*/
{
NTSTATUS Status;
BOOLEAN ForceFinalize;
PRDBSS_DEVICE_OBJECT RxDeviceObject = ThisSrvCall->RxDeviceObject;
PRX_PREFIX_TABLE pRxNetNameTable = RxDeviceObject->pRxNetNameTable;
ASSERT(ThisSrvCall->UpperFinalizationDone);
ForceFinalize = BooleanFlagOn(
ThisSrvCall->Flags,
SRVCALL_FLAG_FORCE_FINALIZED);
//we have to protect this call since the srvcall may never have been claimed
MINIRDR_CALL_THROUGH(
Status,
RxDeviceObject->Dispatch,
MRxFinalizeSrvCall,((PMRX_SRV_CALL)ThisSrvCall,ForceFinalize)
);
RxAcquirePrefixTableLockExclusive( pRxNetNameTable, TRUE);
InterlockedDecrement(&ThisSrvCall->NodeReferenceCount);
RxFinalizeSrvCall(
ThisSrvCall,
FALSE,
ForceFinalize);
RxReleasePrefixTableLock(pRxNetNameTable);
}
BOOLEAN
RxFinalizeSrvCall (
OUT PSRV_CALL ThisSrvCall,
IN BOOLEAN RecursiveFinalize,
IN BOOLEAN ForceFinalize
)
/*++
Routine Description:
The routine finalizes the given netroot. You should have exclusive on
the netname tablelock.
Arguments:
ThisSrvCall - the SrvCall being finalized
Return Value:
BOOLEAN - tells whether finalization actually occured
Notes:
there is no recursive part because i don't have a list of srvcalls and a list
of netroots i only have a combined list. thus, recursive finalization of
netroots is directly from the top level. however, all netroots should already
have been done when i get here..
--*/
{
BOOLEAN NodeActuallyFinalized = FALSE;
PRX_PREFIX_TABLE pRxNetNameTable;
PAGED_CODE();
ASSERT( NodeType(ThisSrvCall) == RDBSS_NTC_SRVCALL );
pRxNetNameTable = ThisSrvCall->RxDeviceObject->pRxNetNameTable;
ASSERT( RxIsPrefixTableLockExclusive( pRxNetNameTable ));
RxDbgTrace(+1, Dbg, ("RxFinalizeSrvCall<+> %08lx %wZ RefC=%ld\n",
ThisSrvCall,&ThisSrvCall->PrefixEntry.Prefix,
ThisSrvCall->NodeReferenceCount));
if( ThisSrvCall->NodeReferenceCount == 1 || ForceFinalize ) {
BOOLEAN DeferFinalizationToWorkerThread = FALSE;
RxLog(("FINALSRVC: %lx %wZ\n",ThisSrvCall,&ThisSrvCall->PrefixEntry.Prefix));
RxWmiLog(LOG,
RxFinalizeSrvCall,
LOGPTR(ThisSrvCall)
LOGUSTR(ThisSrvCall->PrefixEntry.Prefix));
if (!ThisSrvCall->UpperFinalizationDone) {
NTSTATUS Status;
RxRemovePrefixTableEntry ( pRxNetNameTable, &ThisSrvCall->PrefixEntry);
if (ForceFinalize) {
ThisSrvCall->Flags |= SRVCALL_FLAG_FORCE_FINALIZED;
}
ThisSrvCall->UpperFinalizationDone = TRUE;
if (ThisSrvCall->NodeReferenceCount == 1) {
NodeActuallyFinalized = TRUE;
}
if (ThisSrvCall->RxDeviceObject != NULL) {
if (IoGetCurrentProcess() != RxGetRDBSSProcess()) {
InterlockedIncrement(&ThisSrvCall->NodeReferenceCount);
RxDispatchToWorkerThread(
ThisSrvCall->RxDeviceObject,
DelayedWorkQueue,
RxpDestroySrvCall,
ThisSrvCall);
DeferFinalizationToWorkerThread = TRUE;
} else {
MINIRDR_CALL_THROUGH(
Status,
ThisSrvCall->RxDeviceObject->Dispatch,
MRxFinalizeSrvCall,((PMRX_SRV_CALL)ThisSrvCall,ForceFinalize)
);
}
}
}
if (!DeferFinalizationToWorkerThread) {
if( ThisSrvCall->NodeReferenceCount == 1 ) {
if (ThisSrvCall->pDomainName != NULL) {
RxFreePool(ThisSrvCall->pDomainName);
}
RxTearDownBufferingManager(ThisSrvCall);
RxFreeObject(ThisSrvCall);
NodeActuallyFinalized = TRUE;
}
}
} else {
RxDbgTrace(0, Dbg, (" NODE NOT ACTUALLY FINALIZED!!!%C\n", '!'));
}
RxDbgTrace(-1, Dbg, ("RxFinalizeSrvCall<-> %08lx\n", ThisSrvCall, NodeActuallyFinalized));
return NodeActuallyFinalized;
}
PNET_ROOT
RxCreateNetRoot (
IN PSRV_CALL SrvCall,
IN PUNICODE_STRING Name,
IN ULONG NetRootFlags,
IN PRX_CONNECTION_ID RxConnectionId
)
/*++
Routine Description:
The routine builds a node representing a netroot and inserts the name into the net
name table. The name is allocated at the end of the block. The reference count on the block
is set to 1 on this create....
Arguments:
SrvCall - the associated server call context; may be NULL!! (but not right now.........)
Dispatch - the minirdr dispatch table
Name - the name to be inserted
Return Value:
Ptr to the created net root.
--*/
{
PNET_ROOT ThisNetRoot;
PRX_PREFIX_TABLE pRxNetNameTable;
ULONG NameSize,SrvCallNameSize;
PAGED_CODE();
RxDbgTrace(+1, Dbg, ("RxNetRootCreate--> Name = %wZ\n", Name));
ASSERT (SrvCall != NULL);
pRxNetNameTable = SrvCall->RxDeviceObject->pRxNetNameTable;
ASSERT ( RxIsPrefixTableLockExclusive ( pRxNetNameTable ) );
SrvCallNameSize = SrvCall->PrefixEntry.Prefix.Length;
NameSize = Name->Length + SrvCallNameSize;
ThisNetRoot = RxAllocateObject(
RDBSS_NTC_NETROOT,
SrvCall->RxDeviceObject->Dispatch,
NameSize);
if (ThisNetRoot != NULL) {
USHORT CaseInsensitiveLength;
RtlMoveMemory(
(PCHAR)(ThisNetRoot->PrefixEntry.Prefix.Buffer) + SrvCallNameSize,
Name->Buffer,
Name->Length);
if (SrvCallNameSize) {
RtlMoveMemory(
ThisNetRoot->PrefixEntry.Prefix.Buffer,
SrvCall->PrefixEntry.Prefix.Buffer,
SrvCallNameSize);
}
if (FlagOn(SrvCall->Flags,SRVCALL_FLAG_CASE_INSENSITIVE_NETROOTS)) {
CaseInsensitiveLength = (USHORT)NameSize;
} else {
CaseInsensitiveLength = SrvCall->PrefixEntry.CaseInsensitiveLength;
}
RxPrefixTableInsertName (
pRxNetNameTable,
&ThisNetRoot->PrefixEntry,
(PVOID)ThisNetRoot,
&ThisNetRoot->NodeReferenceCount,
CaseInsensitiveLength,
RxConnectionId);
RxInitializeFcbTable(&ThisNetRoot->FcbTable, TRUE);
InitializeListHead(&ThisNetRoot->VirtualNetRoots);
InitializeListHead(&ThisNetRoot->TransitionWaitList);
InitializeListHead(&ThisNetRoot->ScavengerFinalizationList);
RxInitializePurgeSyncronizationContext(
&ThisNetRoot->PurgeSyncronizationContext);
ThisNetRoot->SerialNumberForEnum = SerialNumber++;
ThisNetRoot->Flags |= NetRootFlags;
ThisNetRoot->DiskParameters.ClusterSize = 1;
ThisNetRoot->DiskParameters.ReadAheadGranularity = DEFAULT_READ_AHEAD_GRANULARITY;
ThisNetRoot->SrvCall = SrvCall;
//already have the lock
RxReferenceSrvCall((PSRV_CALL)ThisNetRoot->SrvCall);
}
return ThisNetRoot;
}
BOOLEAN
RxFinalizeNetRoot (
OUT PNET_ROOT ThisNetRoot,
IN BOOLEAN RecursiveFinalize,
IN BOOLEAN ForceFinalize
)
/*++
Routine Description:
The routine finalizes the given netroot. You must be exclusive on
the NetName tablelock.
Arguments:
ThisNetRoot - the NetRoot being dereferenced
Return Value:
BOOLEAN - tells whether finalization actually occured
--*/
{
NTSTATUS Status;
BOOLEAN NodeActuallyFinalized = FALSE;
PRX_PREFIX_TABLE pRxNetNameTable;
PAGED_CODE();
ASSERT( NodeType(ThisNetRoot) == RDBSS_NTC_NETROOT );
pRxNetNameTable = ThisNetRoot->SrvCall->RxDeviceObject->pRxNetNameTable;
ASSERT ( RxIsPrefixTableLockExclusive ( pRxNetNameTable ) );
if (ThisNetRoot->Flags & NETROOT_FLAG_FINALIZATION_IN_PROGRESS) {
return FALSE;
}
// Since the table lock has been acquired exclusive the flags can be modified
// without any further synchronization since the protection is against recursive
// invocations.
ThisNetRoot->Flags |= NETROOT_FLAG_FINALIZATION_IN_PROGRESS;
RxDbgTrace(+1, Dbg, ("RxFinalizeNetRoot<+> %08lx %wZ RefC=%ld\n",
ThisNetRoot,&ThisNetRoot->PrefixEntry.Prefix,
ThisNetRoot->NodeReferenceCount));
if (RecursiveFinalize) {
PLIST_ENTRY ListEntry;
USHORT BucketNumber;
RxAcquireFcbTableLockExclusive(&ThisNetRoot->FcbTable,TRUE);
IF_DEBUG{
if ( FALSE && ThisNetRoot->NodeReferenceCount){
RxDbgTrace(0, Dbg, (" BAD!!!!!ReferenceCount = %08lx\n", ThisNetRoot->NodeReferenceCount));
}
}
for (BucketNumber = 0;
(BucketNumber < ThisNetRoot->FcbTable.NumberOfBuckets);
BucketNumber++) {
PLIST_ENTRY ListHeader;
ListHeader = &ThisNetRoot->FcbTable.HashBuckets[BucketNumber];
for (ListEntry = ListHeader->Flink;
ListEntry != ListHeader;
) {
PFCB Fcb;
PRX_FCB_TABLE_ENTRY pFcbTableEntry;
pFcbTableEntry = CONTAINING_RECORD(
ListEntry,
RX_FCB_TABLE_ENTRY,
HashLinks);
Fcb = CONTAINING_RECORD(
pFcbTableEntry,
FCB,
FcbTableEntry);
ListEntry = ListEntry->Flink;
ASSERT( NodeTypeIsFcb(Fcb));
if (!FlagOn(Fcb->FcbState,FCB_STATE_ORPHANED)) {
Status = RxAcquireExclusiveFcb(NULL,Fcb);
ASSERT(Status == (STATUS_SUCCESS));
// a small complication here is that this fcb MAY have an open section against it caused
// by our cacheing the file. if so, we need to purge to get to the close
// wrong//if so, we have to get rid of it and then standoff to let
// the close go thru. sigh.............
RxPurgeFcb(Fcb);
}
}
}
RxReleaseFcbTableLock( &ThisNetRoot->FcbTable );
}
if ( ThisNetRoot->NodeReferenceCount == 1 || ForceFinalize ){
RxLog(("FINALNETROOT: %lx %wZ\n",ThisNetRoot,&ThisNetRoot->PrefixEntry.Prefix));
RxWmiLog(LOG,
RxFinalizeNetRoot,
LOGPTR(ThisNetRoot)
LOGUSTR(ThisNetRoot->PrefixEntry.Prefix));
//if (!ThisNetRoot->UpperFinalizationDone) {
// NOTHING;
// ThisNetRoot->UpperFinalizationDone = TRUE;
//}
if ( ThisNetRoot->NodeReferenceCount == 1 ){
PSRV_CALL SrvCall = (PSRV_CALL)ThisNetRoot->SrvCall;
RxFinalizeFcbTable(&ThisNetRoot->FcbTable);
if (!FlagOn(ThisNetRoot->Flags,NETROOT_FLAG_NAME_ALREADY_REMOVED)) {
RxRemovePrefixTableEntry ( pRxNetNameTable, &ThisNetRoot->PrefixEntry);
}
RxFreeObject(ThisNetRoot);
if (SrvCall != NULL) {
RxDereferenceSrvCall(SrvCall,LHS_ExclusiveLockHeld); //already have the lock
}
NodeActuallyFinalized = TRUE;
}
} else {
RxDbgTrace(0, Dbg, (" NODE NOT ACTUALLY FINALIZED!!!%C\n", '!'));
}
RxDbgTrace(-1, Dbg, ("RxFinalizeNetRoot<-> %08lx\n", ThisNetRoot, NodeActuallyFinalized));
return NodeActuallyFinalized;
}
VOID
RxAddVirtualNetRootToNetRoot(
PNET_ROOT pNetRoot,
PV_NET_ROOT pVNetRoot)
/*++
Routine Description:
The routine adds a VNetRoot to the list of VNetRoot's associated with a NetRoot
Arguments:
pNetRoot - the NetRoot
pVNetRoot - the new VNetRoot to be added to the list.
Notes:
The reference count associated with a NetRoot will be equal to the number of VNetRoot's
associated with it plus 1. the last one being for the prefix name table. This ensures
that a NetRoot cannot be finalized till all the VNetRoots associated with it have been
finalized.
--*/
{
PAGED_CODE();
ASSERT(RxIsPrefixTableLockExclusive( pNetRoot->SrvCall->RxDeviceObject->pRxNetNameTable ));
pVNetRoot->NetRoot = pNetRoot;
pNetRoot->NumberOfVirtualNetRoots++;
if (pNetRoot->DefaultVNetRoot == NULL) {
//pNetRoot->DefaultVNetRoot = pVNetRoot;
}
InsertTailList(&pNetRoot->VirtualNetRoots,&pVNetRoot->NetRootListEntry);
}
VOID
RxRemoveVirtualNetRootFromNetRoot(
PNET_ROOT pNetRoot,
PV_NET_ROOT pVNetRoot)
/*++
Routine Description:
The routine removes a VNetRoot to the list of VNetRoot's associated with a NetRoot
Arguments:
pNetRoot - the NetRoot
pVNetRoot - the VNetRoot to be removed from the list.
Notes:
The reference count associated with a NetRoot will be equal to the number of VNetRoot's
associated with it plus 1. the last one being for the prefix name table. This ensures
that a NetRoot cannot be finalized till all the VNetRoots associated with it have been
finalized.
--*/
{
PRX_PREFIX_TABLE pRxNetNameTable = pNetRoot->SrvCall->RxDeviceObject->pRxNetNameTable;
PAGED_CODE();
ASSERT(RxIsPrefixTableLockExclusive( pRxNetNameTable ));
pNetRoot->NumberOfVirtualNetRoots--;
RemoveEntryList(&pVNetRoot->NetRootListEntry);
if (pNetRoot->DefaultVNetRoot == pVNetRoot) {
if (!IsListEmpty(&pNetRoot->VirtualNetRoots)) {
// Traverse the list and pick another default net root.
PV_NET_ROOT pTempVNetRoot;
pTempVNetRoot = (PV_NET_ROOT)
CONTAINING_RECORD(
pNetRoot->VirtualNetRoots.Flink,
V_NET_ROOT,
NetRootListEntry);
pNetRoot->DefaultVNetRoot = pTempVNetRoot;
} else {
pNetRoot->DefaultVNetRoot = NULL;
}
}
if (IsListEmpty(&pNetRoot->VirtualNetRoots)) {
NTSTATUS Status;
if (!FlagOn(pNetRoot->Flags,NETROOT_FLAG_NAME_ALREADY_REMOVED)) {
RxRemovePrefixTableEntry(pRxNetNameTable, &pNetRoot->PrefixEntry);
SetFlag(pNetRoot->Flags,NETROOT_FLAG_NAME_ALREADY_REMOVED);
}
//ASSERT(pNetRoot->Dispatch != NULL);
if ((pNetRoot->SrvCall != NULL)
&& (pNetRoot->SrvCall->RxDeviceObject!=NULL)) {
MINIRDR_CALL_THROUGH(
Status,
pNetRoot->SrvCall->RxDeviceObject->Dispatch,
MRxFinalizeNetRoot,((PMRX_NET_ROOT)pNetRoot,NULL)
);
}
}
}
NTSTATUS
RxInitializeVNetRootParameters(
PRX_CONTEXT RxContext,
LUID *pLogonId,
ULONG *pSessionId,
PUNICODE_STRING *pUserNamePtr,
PUNICODE_STRING *pUserDomainNamePtr,
PUNICODE_STRING *pPasswordPtr,
ULONG *pFlags
)
/*++
Routine Description:
This routine extracts the ea parameters specified
Arguments:
RxContext -- the RxContext
pLogonId -- the logon Id.
pUserNamePtr -- pointer to the User Name
pUserDomainNamePtr -- pointer to the user domain name
pPasswordPtr -- the password.
Return Value:
STATUS_SUCCESS -- successful,
appropriate NTSTATUS code otherwise
Notes:
--*/
{
NTSTATUS Status = STATUS_SUCCESS;
RxCaptureRequestPacket;
RxCaptureParamBlock;
PIO_SECURITY_CONTEXT pSecurityContext;
PACCESS_TOKEN pAccessToken;
PAGED_CODE();
pSecurityContext = RxContext->Create.NtCreateParameters.SecurityContext;
pAccessToken = SeQuerySubjectContextToken(
&pSecurityContext->AccessState->SubjectSecurityContext);
*pPasswordPtr = NULL;
*pUserDomainNamePtr = NULL;
*pUserNamePtr = NULL;
*pFlags &= ~VNETROOT_FLAG_CSCAGENT_INSTANCE;
if (!SeTokenIsRestricted(pAccessToken)) {
Status = SeQueryAuthenticationIdToken(
pAccessToken,
pLogonId);
if (Status == STATUS_SUCCESS) {
Status = SeQuerySessionIdToken(
pAccessToken,
pSessionId);
}
if ((Status == STATUS_SUCCESS) &&
(RxContext->Create.UserName.Buffer != NULL)) {
PUNICODE_STRING pTargetString;
pTargetString = RxAllocatePoolWithTag(
NonPagedPool,
(sizeof(UNICODE_STRING) + RxContext->Create.UserName.Length),
RX_SRVCALL_PARAMS_POOLTAG);
if (pTargetString != NULL) {
pTargetString->Length = RxContext->Create.UserName.Length;
pTargetString->MaximumLength = RxContext->Create.UserName.MaximumLength;
if (pTargetString->Length > 0) {
pTargetString->Buffer = (PWCHAR)((PCHAR)pTargetString + sizeof(UNICODE_STRING));
RtlCopyMemory(
pTargetString->Buffer,
RxContext->Create.UserName.Buffer,
pTargetString->Length);
} else {
pTargetString->Buffer = NULL;
}
*pUserNamePtr = pTargetString;
} else {
Status = STATUS_INSUFFICIENT_RESOURCES;
}
}
if ((RxContext->Create.UserDomainName.Buffer != NULL) && (Status == STATUS_SUCCESS)) {
PUNICODE_STRING pTargetString;
pTargetString = RxAllocatePoolWithTag(
NonPagedPool,
(sizeof(UNICODE_STRING) + RxContext->Create.UserDomainName.Length + sizeof(WCHAR)),
RX_SRVCALL_PARAMS_POOLTAG);
if (pTargetString != NULL) {
pTargetString->Length = RxContext->Create.UserDomainName.Length;
pTargetString->MaximumLength = RxContext->Create.UserDomainName.MaximumLength;
pTargetString->Buffer = (PWCHAR)((PCHAR)pTargetString + sizeof(UNICODE_STRING));
// in case of UPN name, domain name will be a NULL string
*pTargetString->Buffer = 0;
if (pTargetString->Length > 0) {
RtlCopyMemory(
pTargetString->Buffer,
RxContext->Create.UserDomainName.Buffer,
pTargetString->Length);
}
*pUserDomainNamePtr = pTargetString;
} else {
Status = STATUS_INSUFFICIENT_RESOURCES;
}
}
if ((RxContext->Create.Password.Buffer != NULL) && (Status == STATUS_SUCCESS)) {
PUNICODE_STRING pTargetString;
pTargetString = RxAllocatePoolWithTag(
NonPagedPool,
(sizeof(UNICODE_STRING) + RxContext->Create.Password.Length),
RX_SRVCALL_PARAMS_POOLTAG);
if (pTargetString != NULL) {
pTargetString->Length = RxContext->Create.Password.Length;
pTargetString->MaximumLength = RxContext->Create.Password.MaximumLength;
if (pTargetString->Length > 0) {
pTargetString->Buffer = (PWCHAR)((PCHAR)pTargetString + sizeof(UNICODE_STRING));
RtlCopyMemory(
pTargetString->Buffer,
RxContext->Create.Password.Buffer,
pTargetString->Length);
} else {
pTargetString->Buffer = NULL;
}
*pPasswordPtr = pTargetString;
} else {
Status = STATUS_INSUFFICIENT_RESOURCES;
}
}
if (Status == STATUS_SUCCESS)
{
if(RxIsThisACscAgentOpen(RxContext))
{
*pFlags |= VNETROOT_FLAG_CSCAGENT_INSTANCE;
}
}
if (Status != STATUS_SUCCESS) {
if (*pUserNamePtr != NULL) {
RxFreePool(*pUserNamePtr);
*pUserNamePtr = NULL;
}
if (*pUserDomainNamePtr != NULL) {
RxFreePool(*pUserDomainNamePtr);
*pUserDomainNamePtr = NULL;
}
if (*pPasswordPtr != NULL) {
RxFreePool(*pPasswordPtr);
*pPasswordPtr = NULL;
}
}
} else {
Status = STATUS_ACCESS_DENIED;
}
return Status;
}
VOID
RxUninitializeVNetRootParameters(
PUNICODE_STRING pUserName,
PUNICODE_STRING pUserDomainName,
PUNICODE_STRING pPassword,
ULONG *lpFlags
)
/*++
Routine Description:
This routine unintializes the parameters ( logon ) associated with a VNetRoot
Arguments:
pVNetRoot -- the VNetRoot
--*/
{
PAGED_CODE();
if (pUserName != NULL) {
RxFreePool(pUserName);
}
if (pUserDomainName != NULL) {
RxFreePool(pUserDomainName);
}
if (pPassword != NULL) {
RxFreePool(pPassword);
}
if (lpFlags)
{
*lpFlags &= ~VNETROOT_FLAG_CSCAGENT_INSTANCE;
}
}
PV_NET_ROOT
RxCreateVNetRoot (
IN PRX_CONTEXT RxContext,
IN PNET_ROOT NetRoot,
IN PUNICODE_STRING CanonicalName,
IN PUNICODE_STRING LocalNetRootName,
IN PUNICODE_STRING FilePath,
IN PRX_CONNECTION_ID RxConnectionId
)
/*++
Routine Description:
The routine builds a node representing a virtual netroot and inserts the name into
the net name table. The name is allocated at the end of the block. The reference
count on the block is set to 1 on this create....
Virtual netroots provide a mechanism for mapping "into" a share....i.e. having a
user drive that points not at the root of the associated share point. The format
of a name is either
\server\share\d1\d2.....
or
\;m:\server\share\d1\d2.....
depending on whether there is a local device ("m:") associated with this vnetroot.
In the latter case is that \d1\d2.. gets prefixed onto each createfile that is
opened on this vnetroot.
vnetroot's are also used to supply alternate credentials. the point of the former
kind of vnetroot is to propagate the credentials into the netroot as the default.
for this to work, there must be no other references.
You need to have the lock exclusive to call....see RxCreateSrvCall.......
Arguments:
RxContext - the RDBSS context
NetRoot - the associated net root context
Name - the name to be inserted
NamePrefixOffsetInBytes - offset into the name where the prefix starts
Return Value:
Ptr to the created v net root.
--*/
{
NTSTATUS Status = STATUS_SUCCESS;
PV_NET_ROOT ThisVNetRoot;
UNICODE_STRING VNetRootName;
PUNICODE_STRING ThisNamePrefix;
ULONG NameSize;
BOOLEAN fCscAgent = FALSE;
PRX_PREFIX_ENTRY ThisEntry;
PAGED_CODE();
ASSERT (RxIsPrefixTableLockExclusive( RxContext->RxDeviceObject->pRxNetNameTable ));
NameSize = NetRoot->PrefixEntry.Prefix.Length + LocalNetRootName->Length;
ThisVNetRoot = RxAllocateObject(RDBSS_NTC_V_NETROOT,NetRoot->SrvCall->RxDeviceObject->Dispatch,NameSize);
if (ThisVNetRoot != NULL) {
USHORT CaseInsensitiveLength;
PMRX_SRV_CALL SrvCall;
if (Status == STATUS_SUCCESS) {
// Initialize the Create Parameters
Status = RxInitializeVNetRootParameters(
RxContext,
&ThisVNetRoot->LogonId,
&ThisVNetRoot->SessionId,
&ThisVNetRoot->pUserName,
&ThisVNetRoot->pUserDomainName,
&ThisVNetRoot->pPassword,
&ThisVNetRoot->Flags
);
}
if (Status == STATUS_SUCCESS) {
VNetRootName = ThisVNetRoot->PrefixEntry.Prefix;
RtlMoveMemory(
VNetRootName.Buffer,
CanonicalName->Buffer,
VNetRootName.Length);
ThisVNetRoot->PrefixOffsetInBytes = LocalNetRootName->Length +
NetRoot->PrefixEntry.Prefix.Length;
RxDbgTrace(+1, Dbg, ("RxVNetRootCreate--> Name = <%wZ>, offs=%08lx\n",
CanonicalName, ThisVNetRoot->PrefixOffsetInBytes));
ThisNamePrefix = &ThisVNetRoot->NamePrefix;
ThisNamePrefix->Buffer = (PWCH)((PCHAR)VNetRootName.Buffer + ThisVNetRoot->PrefixOffsetInBytes);
ThisNamePrefix->Length =
ThisNamePrefix->MaximumLength =
VNetRootName.Length - (USHORT)ThisVNetRoot->PrefixOffsetInBytes;
InitializeListHead(&ThisVNetRoot->TransitionWaitList);
InitializeListHead(&ThisVNetRoot->ScavengerFinalizationList);
// Now, insert into the netrootQ and the net name table
ThisEntry = &ThisVNetRoot->PrefixEntry;
SrvCall = NetRoot->pSrvCall;
if (FlagOn(SrvCall->Flags,SRVCALL_FLAG_CASE_INSENSITIVE_FILENAMES)) {
//here is insensitive length is the whole thing
CaseInsensitiveLength = (USHORT)NameSize;
} else {
//here is insensitive length is determined by the netroot or srvcall
//plus we have to account for the device, if present
ULONG ComponentsToUpcase,wcLength,i;
if (FlagOn(SrvCall->Flags,SRVCALL_FLAG_CASE_INSENSITIVE_NETROOTS)) {
CaseInsensitiveLength = NetRoot->PrefixEntry.CaseInsensitiveLength;
} else {
CaseInsensitiveLength = ((PSRV_CALL)SrvCall)->PrefixEntry.CaseInsensitiveLength;
}
wcLength = CanonicalName->Length/sizeof(WCHAR);
for (i=1;;i++) { //note: don't start at zero
if (i>=wcLength)
break;
if (CanonicalName->Buffer[i]!=OBJ_NAME_PATH_SEPARATOR)
break;
}
CaseInsensitiveLength += (USHORT)(i*sizeof(WCHAR));
}
RxPrefixTableInsertName(
RxContext->RxDeviceObject->pRxNetNameTable,
ThisEntry,
(PVOID)ThisVNetRoot,
&ThisVNetRoot->NodeReferenceCount,
CaseInsensitiveLength,
RxConnectionId);
RxReferenceNetRoot(NetRoot);
RxAddVirtualNetRootToNetRoot(NetRoot,ThisVNetRoot);
ThisVNetRoot->SerialNumberForEnum = SerialNumber++;
ThisVNetRoot->UpperFinalizationDone = FALSE;
ThisVNetRoot->ConnectionFinalizationDone = FALSE;
ThisVNetRoot->AdditionalReferenceForDeleteFsctlTaken = 0;
RxDbgTrace(-1, Dbg, ("RxVNetRootCreate -> RefCount = %08lx\n", ThisVNetRoot->NodeReferenceCount));
}
if (Status != STATUS_SUCCESS) {
RxUninitializeVNetRootParameters(
ThisVNetRoot->pUserName,
ThisVNetRoot->pUserDomainName,
ThisVNetRoot->pPassword,
&ThisVNetRoot->Flags
);
RxFreeObject(ThisVNetRoot);
ThisVNetRoot = NULL;
}
}
return ThisVNetRoot;
}
VOID
RxOrphanSrvOpens(
IN PV_NET_ROOT ThisVNetRoot
)
/*++
Routine Description:
The routine iterates through all the FCBs that belong to the netroot to which this VNetRoot
belongs and orphans all SrvOpens that belong to the VNetRoot. The caller must have acquired
the NetName tablelock.
Arguments:
ThisVNetRoot - the VNetRoot
Return Value:
None
Notes:
On Entry -- RxNetNameTable lock must be acquired exclusive.
On Exit -- no change in lock ownership.
--*/
{
PLIST_ENTRY pListEntry;
USHORT BucketNumber;
PNET_ROOT NetRoot = (PNET_ROOT)(ThisVNetRoot->NetRoot);
PRX_PREFIX_TABLE pRxNetNameTable = NetRoot->SrvCall->RxDeviceObject->pRxNetNameTable;
PAGED_CODE();
//
// MAILSLOT FCBs don't have SrvOpens
//
if(NetRoot->Type == NET_ROOT_MAILSLOT) return;
ASSERT(RxIsPrefixTableLockExclusive(pRxNetNameTable));
RxAcquireFcbTableLockExclusive( &NetRoot->FcbTable, TRUE);
try {
for (BucketNumber = 0;
(BucketNumber < NetRoot->FcbTable.NumberOfBuckets);
BucketNumber++) {
PLIST_ENTRY pListHeader;
pListHeader = &NetRoot->FcbTable.HashBuckets[BucketNumber];
pListEntry = pListHeader->Flink;
while (pListEntry != pListHeader) {
PFCB pFcb;
PRX_FCB_TABLE_ENTRY pFcbTableEntry;
pFcbTableEntry = CONTAINING_RECORD(
pListEntry,
RX_FCB_TABLE_ENTRY,
HashLinks );
pListEntry = pListEntry->Flink;
pFcb = CONTAINING_RECORD(
pFcbTableEntry,
FCB,
FcbTableEntry);
ASSERT(NodeTypeIsFcb(pFcb));
RxOrphanSrvOpensForThisFcb(pFcb, ThisVNetRoot, FALSE); // don't force orphan the FCB
// orphan only those srvopens
// that belong to this VNetRoot
}
}
if (NetRoot->FcbTable.pTableEntryForNull)
{
PFCB pFcb;
pFcb = CONTAINING_RECORD(
NetRoot->FcbTable.pTableEntryForNull,
FCB,
FcbTableEntry);
ASSERT(NodeTypeIsFcb(pFcb));
RxOrphanSrvOpensForThisFcb(pFcb, ThisVNetRoot, FALSE);
}
} finally {
RxReleaseFcbTableLock( &NetRoot->FcbTable );
}
}
BOOLEAN
RxFinalizeVNetRoot(
OUT PV_NET_ROOT ThisVNetRoot,
IN BOOLEAN RecursiveFinalize,
IN BOOLEAN ForceFinalize
)
/*++
Routine Description:
The routine finalizes the given netroot. You must be exclusive on
the NetName tablelock.
Arguments:
ThisVNetRoot - the VNetRoot being dereferenced
Return Value:
BOOLEAN - tells whether finalization actually occured
--*/
{
NTSTATUS Status = STATUS_SUCCESS;
BOOLEAN NodeActuallyFinalized = FALSE;
PRX_PREFIX_TABLE pRxNetNameTable;
PAGED_CODE();
ASSERT( NodeType(ThisVNetRoot) == RDBSS_NTC_V_NETROOT );
pRxNetNameTable = ThisVNetRoot->NetRoot->SrvCall->RxDeviceObject->pRxNetNameTable;
ASSERT ( RxIsPrefixTableLockExclusive ( pRxNetNameTable ) );
RxDbgTrace(+1, Dbg, ("RxFinalizeVNetRoot<+> %08lx %wZ RefC=%ld\n",
ThisVNetRoot,&ThisVNetRoot->PrefixEntry.Prefix,
ThisVNetRoot->NodeReferenceCount));
//The actual finalization is divided into two parts:
// 1) if we're at the end (refcount==1) or being forced, we do the one-time only stuff
// 2) if the refcount goes to zero, we actually do the free
if( ThisVNetRoot->NodeReferenceCount == 1 || ForceFinalize ){
PNET_ROOT NetRoot = (PNET_ROOT)ThisVNetRoot->NetRoot;
RxLog(("FINALVNETROOT: %lx %wZ\n",ThisVNetRoot,&ThisVNetRoot->PrefixEntry.Prefix));
RxWmiLog(LOG,
RxFinalizeVNetRoot,
LOGPTR(ThisVNetRoot)
LOGUSTR(ThisVNetRoot->PrefixEntry.Prefix));
if (!ThisVNetRoot->UpperFinalizationDone) {
ASSERT( NodeType(NetRoot) == RDBSS_NTC_NETROOT );
RxReferenceNetRoot(NetRoot);
RxOrphanSrvOpens(ThisVNetRoot);
RxRemoveVirtualNetRootFromNetRoot(NetRoot,ThisVNetRoot);
RxDereferenceNetRoot(NetRoot,LHS_ExclusiveLockHeld);
RxDbgTrace(0, Dbg, ("Mini Rdr VNetRoot finalization returned %lx\n", Status));
RxRemovePrefixTableEntry ( pRxNetNameTable, &ThisVNetRoot->PrefixEntry);
ThisVNetRoot->UpperFinalizationDone = TRUE;
}
if (ThisVNetRoot->NodeReferenceCount == 1) {
if (NetRoot->SrvCall->RxDeviceObject != NULL) {
MINIRDR_CALL_THROUGH(
Status,
NetRoot->SrvCall->RxDeviceObject->Dispatch,
MRxFinalizeVNetRoot,((PMRX_V_NET_ROOT)ThisVNetRoot,NULL)
);
}
RxUninitializeVNetRootParameters(
ThisVNetRoot->pUserName,
ThisVNetRoot->pUserDomainName,
ThisVNetRoot->pPassword,
&ThisVNetRoot->Flags
);
RxDereferenceNetRoot(NetRoot,LHS_ExclusiveLockHeld);
RxFreePool(ThisVNetRoot);
NodeActuallyFinalized = TRUE;
}
} else {
RxDbgTrace(0, Dbg, (" NODE NOT ACTUALLY FINALIZED!!!%C\n", '!'));
}
RxDbgTrace(-1, Dbg, ("RxFinalizeVNetRoot<-> %08lx\n", ThisVNetRoot, NodeActuallyFinalized));
return NodeActuallyFinalized;
}
PVOID
RxAllocateFcbObject(
PRDBSS_DEVICE_OBJECT RxDeviceObject,
NODE_TYPE_CODE NodeType,
POOL_TYPE PoolType,
ULONG NameSize,
PVOID pAlreadyAllocatedObject)
/*++
Routine Description:
The routine allocates and constructs the skeleton of a FCB/SRV_OPEN and FOBX instance
Arguments:
pMRxDispatch - the Mini redirector dispatch vector
NodeType - the node type
PoolType - the pool type to be used ( for paging file data structures NonPagedPool is
used.
NameLength - name size.
Notes:
The reasons as to why the allocation/freeing of these data structures have been
centralized are as follows
1) The construction of these three data types have a lot in common with the exception
of the initial computation of sizes. Therefore centralization minimizes the footprint.
2) It allows us to experiment with different clustering/allocation strategies.
3) It allows the incorporation of debug support in an easy way.
--*/
{
ULONG FcbSize,NonPagedFcbSize,SrvOpenSize,FobxSize;
PMINIRDR_DISPATCH pMRxDispatch = RxDeviceObject->Dispatch;
PVOID pObject;
PNON_PAGED_FCB pNonPagedFcb = NULL;
PFCB pFcb = NULL;
PSRV_OPEN pSrvOpen = NULL;
PFOBX pFobx = NULL;
PWCH pName = NULL;
PAGED_CODE();
FcbSize = SrvOpenSize = FobxSize = NonPagedFcbSize = 0;
switch (NodeType) {
default:
{
FcbSize = QuadAlign(sizeof(FCB));
if (pMRxDispatch->MRxFlags & RDBSS_MANAGE_FCB_EXTENSION) {
FcbSize += QuadAlign(pMRxDispatch->MRxFcbSize);
}
if (PoolType == NonPagedPool) {
NonPagedFcbSize = QuadAlign(sizeof(NON_PAGED_FCB));
}
if (NodeType == RDBSS_NTC_OPENTARGETDIR_FCB) {
break;
}
}
// lack of break intentional
case RDBSS_NTC_SRVOPEN :
case RDBSS_NTC_INTERNAL_SRVOPEN:
{
SrvOpenSize = QuadAlign(sizeof(SRV_OPEN));
if (pMRxDispatch->MRxFlags & RDBSS_MANAGE_SRV_OPEN_EXTENSION) {
SrvOpenSize += QuadAlign(pMRxDispatch->MRxSrvOpenSize);
}
}
// lack of break intentional
case RDBSS_NTC_FOBX :
{
FobxSize = QuadAlign(sizeof(FOBX));
if (pMRxDispatch->MRxFlags & RDBSS_MANAGE_FOBX_EXTENSION) {
FobxSize += QuadAlign(pMRxDispatch->MRxFobxSize);
}
}
}
if (pAlreadyAllocatedObject == NULL) {
pObject = RxAllocatePoolWithTag(
PoolType,
(FcbSize + SrvOpenSize + FobxSize + NonPagedFcbSize + NameSize),
RX_FCB_POOLTAG);
//ASSERT(pObject != NULL);
if (pObject==NULL) {
return(NULL);
}
} else {
pObject = pAlreadyAllocatedObject;
}
switch (NodeType) {
case RDBSS_NTC_FOBX:
{
pFobx = (PFOBX)pObject;
}
break;
case RDBSS_NTC_SRVOPEN:
{
pSrvOpen = (PSRV_OPEN)pObject;
pFobx = (PFOBX)((PBYTE)pSrvOpen + SrvOpenSize);
}
break;
case RDBSS_NTC_INTERNAL_SRVOPEN:
{
pSrvOpen = (PSRV_OPEN)pObject;
}
break;
default :
{
pFcb = (PFCB)pObject;
if (NodeType != RDBSS_NTC_OPENTARGETDIR_FCB) {
pSrvOpen = (PSRV_OPEN)((PBYTE)pFcb + FcbSize);
pFobx = (PFOBX)((PBYTE)pSrvOpen + SrvOpenSize);
}
if (PoolType == NonPagedPool) {
pNonPagedFcb = (PNON_PAGED_FCB)((PBYTE)pFobx + FobxSize);
pName = (PWCH)((PBYTE)pNonPagedFcb + NonPagedFcbSize);
} else {
pName = (PWCH)((PBYTE)pFcb + FcbSize + SrvOpenSize + FobxSize);
pNonPagedFcb = RxAllocatePoolWithTag(
NonPagedPool,
sizeof(NON_PAGED_FCB),
RX_NONPAGEDFCB_POOLTAG);
if (pNonPagedFcb == NULL) {
RxFreePool(pFcb);
return NULL;
}
}
}
break;
}
if (pFcb != NULL) {
ZeroAndInitializeNodeType(pFcb, RDBSS_NTC_STORAGE_TYPE_UNKNOWN, (NODE_BYTE_SIZE) FcbSize);
pFcb->NonPaged = pNonPagedFcb;
ZeroAndInitializeNodeType(pFcb->NonPaged, RDBSS_NTC_NONPAGED_FCB, ((NODE_BYTE_SIZE) sizeof( NON_PAGED_FCB )));
IF_DEBUG {
//make a copy of NonPaged so we can zap the real pointer and still find it
DbgDoit(pFcb->CopyOfNonPaged = pNonPagedFcb);
DbgDoit(pNonPagedFcb->FcbBackPointer = pFcb);
}
// Set up the pointers to the preallocated SRV_OPEN and FOBX if required
pFcb->InternalSrvOpen = pSrvOpen;
pFcb->InternalFobx = pFobx;
pFcb->PrivateAlreadyPrefixedName.Buffer = pName;
pFcb->PrivateAlreadyPrefixedName.Length = (USHORT)NameSize;
pFcb->PrivateAlreadyPrefixedName.MaximumLength = pFcb->PrivateAlreadyPrefixedName.Length;
if (pMRxDispatch->MRxFlags & RDBSS_MANAGE_FCB_EXTENSION) {
pFcb->Context = ((PBYTE)pFcb + QuadAlign(sizeof(FCB)));
}
ZeroAndInitializeNodeType(
&pFcb->FcbTableEntry,
RDBSS_NTC_FCB_TABLE_ENTRY,
sizeof(RX_FCB_TABLE_ENTRY));
InterlockedIncrement(&RxNumberOfActiveFcbs);
InterlockedIncrement(&RxDeviceObject->NumberOfActiveFcbs);
// Initialize the Advanced FCB header
ExInitializeFastMutex(&pNonPagedFcb->AdvancedFcbHeaderMutex);
FsRtlSetupAdvancedHeader(&pFcb->Header,&pNonPagedFcb->AdvancedFcbHeaderMutex);
}
if (pSrvOpen != NULL) {
ZeroAndInitializeNodeType(
pSrvOpen,
RDBSS_NTC_SRVOPEN,
(NODE_BYTE_SIZE)SrvOpenSize);
if ((NodeType != RDBSS_NTC_SRVOPEN) ) {
//here the srvopen has no internal fobx....set the "used" flag
SetFlag(pSrvOpen->Flags,SRVOPEN_FLAG_FOBX_USED);
pSrvOpen->InternalFobx = NULL;
} else {
pSrvOpen->InternalFobx = pFobx;
}
if (pMRxDispatch->MRxFlags & RDBSS_MANAGE_SRV_OPEN_EXTENSION) {
pSrvOpen->Context = ((PBYTE)pSrvOpen + QuadAlign(sizeof(SRV_OPEN)));
}
InitializeListHead( &pSrvOpen->SrvOpenQLinks);
}
if (pFobx != NULL) {
ZeroAndInitializeNodeType(
pFobx,
RDBSS_NTC_FOBX,
(NODE_BYTE_SIZE)FobxSize);
if (pMRxDispatch->MRxFlags & RDBSS_MANAGE_FOBX_EXTENSION) {
pFobx->Context = ((PBYTE)pFobx + QuadAlign(sizeof(FOBX)));
}
}
return pObject;
}
VOID
RxFreeFcbObject(PVOID pObject)
/*++
Routine Description:
The routine frees a FCB/SRV_OPEN and FOBX instance
Arguments:
pObject - the instance to be freed
Notes:
--*/
{
PAGED_CODE();
switch (NodeType(pObject)) {
case RDBSS_NTC_FOBX:
case RDBSS_NTC_SRVOPEN:
{
RxFreePool(pObject);
}
break;
default:
if (NodeTypeIsFcb(pObject)) {
PFCB pFcb = (PFCB)pObject;
PRDBSS_DEVICE_OBJECT RxDeviceObject = pFcb->RxDeviceObject;
// Release any Filter Context structures associated with this structure
FsRtlTeardownPerStreamContexts( &pFcb->Header );
DbgDoit((pFcb->Header.NodeTypeCode |= 0x1000));
if (pFcb->FcbState & FCB_STATE_PAGING_FILE) {
RxFreePool(pFcb);
} else {
RxFreePool(pFcb->NonPaged);
RxFreePool(pFcb);
}
InterlockedDecrement(&RxNumberOfActiveFcbs);
InterlockedDecrement(&RxDeviceObject->NumberOfActiveFcbs);
} else {
//ASSERT(!"Valid Object Type for RxFreeFcbObject");
}
}
}
PFCB
RxCreateNetFcb (
OUT PRX_CONTEXT RxContext,
IN PV_NET_ROOT VNetRoot,
IN PUNICODE_STRING Name
)
/*++
Routine Description:
This routine allocates, initializes, and inserts a new Fcb record into
the in memory data structures. The structure allocated has space for a srvopen
and a fobx. The size for all these things comes from the net root; they have
already been aligned.
An additional complication is that i use the same routine to initialize a
fake fcb for renames. in this case, i don't want it inserted into the tree.
You get a fake FCB with IrpSp->Flags|SL_OPEN_TAGET_DIRECTORY.
Arguments:
RxContext - an RxContext describing a create............
NetRoot - the net root that this FCB is being opened on
Name - The name of the FCB. the netroot MAY contain a nameprefix that is to be prepended here.
Return Value:
PFCB - Returns a pointer to the newly allocated FCB
--*/
{
PFCB Fcb;
POOL_TYPE PoolType;
NODE_TYPE_CODE NodeType;
RxCaptureRequestPacket;
RxCaptureParamBlock;
BOOLEAN IsPagingFile;
BOOLEAN FakeFcb;
PNET_ROOT NetRoot;
PRDBSS_DEVICE_OBJECT RxDeviceObject;
PRX_FCB_TABLE_ENTRY ThisEntry;
ULONG NameSize;
PAGED_CODE();
RxDbgTrace(+1, Dbg, ("RxCreateNetFcb\n", 0));
ASSERT( VNetRoot && (NodeType(VNetRoot) == RDBSS_NTC_V_NETROOT) );
NetRoot = (PNET_ROOT)VNetRoot->NetRoot;
ASSERT( NodeType(NetRoot) == RDBSS_NTC_NETROOT );
ASSERT( ((PMRX_NET_ROOT)NetRoot) == RxContext->Create.pNetRoot );
RxDeviceObject = NetRoot->SrvCall->RxDeviceObject;
ASSERT( RxDeviceObject == RxContext->RxDeviceObject);
IsPagingFile = BooleanFlagOn( capPARAMS->Flags, SL_OPEN_PAGING_FILE );
FakeFcb = (BooleanFlagOn(capPARAMS->Flags,SL_OPEN_TARGET_DIRECTORY) &&
!BooleanFlagOn(NetRoot->Flags,NETROOT_FLAG_SUPPORTS_SYMBOLIC_LINKS));
ASSERT( FakeFcb || RxIsFcbTableLockExclusive ( &NetRoot->FcbTable ) );
NodeType = (FakeFcb) ? RDBSS_NTC_OPENTARGETDIR_FCB : RDBSS_NTC_STORAGE_TYPE_UNKNOWN;
PoolType = (IsPagingFile) ? NonPagedPool : PagedPool;
NameSize = Name->Length + NetRoot->InnerNamePrefix.Length;
Fcb = RxAllocateFcbObject(RxDeviceObject, NodeType, PoolType, NameSize, NULL);
if (Fcb != NULL) {
Fcb->CachedNetRootType = NetRoot->Type;
//Fcb->MRxDispatch = NetRoot->Dispatch;
Fcb->RxDeviceObject = RxDeviceObject;
Fcb->MRxDispatch = RxDeviceObject->Dispatch;
Fcb->VNetRoot = VNetRoot;
Fcb->pNetRoot = (PMRX_NET_ROOT)VNetRoot->pNetRoot;
InitializeListHead(&Fcb->SrvOpenList);
Fcb->SrvOpenListVersion = 0;
Fcb->FcbTableEntry.Path.Buffer = (PWCH)((PCHAR)Fcb->PrivateAlreadyPrefixedName.Buffer
+ NetRoot->InnerNamePrefix.Length);
Fcb->FcbTableEntry.Path.Length = Name->Length;
Fcb->FcbTableEntry.Path.MaximumLength = Name->Length;
// finally, copy in the name, including the netroot prefix
ThisEntry = &Fcb->FcbTableEntry;
RxDbgTrace(0, Dbg, ("RxCreateNetFcb name buffer/length %08lx/%08lx\n",
ThisEntry->Path.Buffer, ThisEntry->Path.Length));
RxDbgTrace(0, Dbg, ("RxCreateNetFcb prefix/name %wZ/%wZ\n",
&NetRoot->InnerNamePrefix, Name));
RtlMoveMemory(
Fcb->PrivateAlreadyPrefixedName.Buffer,
NetRoot->InnerNamePrefix.Buffer,
NetRoot->InnerNamePrefix.Length);
RtlMoveMemory(
ThisEntry->Path.Buffer,
Name->Buffer,
Name->Length);
RxDbgTrace(0, Dbg, ("RxCreateNetFcb apname %wZ\n", &Fcb->PrivateAlreadyPrefixedName));
RxDbgTrace(0, Dbg, ("RxCreateNetFcb finalname %wZ\n", &Fcb->FcbTableEntry.Path));
if (FlagOn(RxContext->Create.Flags,RX_CONTEXT_CREATE_FLAG_ADDEDBACKSLASH)) {
SetFlag(Fcb->FcbState,FCB_STATE_ADDEDBACKSLASH);
}
InitializeListHead(&Fcb->NonPaged->TransitionWaitList);
// Check to see if we need to set the Fcb state to indicate that this
// is a paging file
if (IsPagingFile) {
Fcb->FcbState |= FCB_STATE_PAGING_FILE;
}
// Check to see whether this was marked for reparse
if( (RxContext->MajorFunction == IRP_MJ_CREATE) &&
(RxContext->Create.Flags & RX_CONTEXT_CREATE_FLAG_SPECIAL_PATH) )
{
Fcb->FcbState |= FCB_STATE_SPECIAL_PATH;
}
// The initial state, open count, and segment objects fields are already
// zero so we can skip setting them
//
//Initialize the resources
Fcb->Header.Resource = &Fcb->NonPaged->HeaderResource;
ExInitializeResourceLite(Fcb->Header.Resource);
Fcb->Header.PagingIoResource = &Fcb->NonPaged->PagingIoResource;
ExInitializeResourceLite(Fcb->Header.PagingIoResource);
//Initialize the filesize lock
FILESIZE_LOCK_DISABLED(
Fcb->Specific.Fcb.FileSizeLock = &Fcb->NonPaged->FileSizeLock;
ExInitializeFastMutex(Fcb->Specific.Fcb.FileSizeLock);
)
if (!FakeFcb) {
// everything worked.... insert into netroot table
RxFcbTableInsertFcb(
&NetRoot->FcbTable,
Fcb);
} else {
Fcb->FcbState |= FCB_STATE_FAKEFCB|FCB_STATE_NAME_ALREADY_REMOVED;
InitializeListHead(&Fcb->FcbTableEntry.HashLinks);
RxLog(("FakeFinally %lx\n",RxContext));
RxWmiLog(LOG,
RxCreateNetFcb_1,
LOGPTR(RxContext));
RxDbgTrace(0, Dbg, ("FakeFcb !!!!!!! Irpc=%08lx\n", RxContext));
}
RxReferenceVNetRoot(VNetRoot);
InterlockedIncrement(&Fcb->pNetRoot->NumberOfFcbs);
Fcb->ulFileSizeVersion=0;
#ifdef RDBSSLOG
RxLog(("Fcb nm %lx %wZ",Fcb,&(Fcb->FcbTableEntry.Path)));
RxWmiLog(LOG,
RxCreateNetFcb_2,
LOGPTR(Fcb)
LOGUSTR(Fcb->FcbTableEntry.Path));
{
char buffer[20];
ULONG len,remaining;
UNICODE_STRING jPrefix,jSuffix;
sprintf(buffer,"Fxx nm %p ",Fcb);
len = strlen(buffer);
remaining = MAX_RX_LOG_ENTRY_SIZE -1 - len;
if (remaining<Fcb->FcbTableEntry.Path.Length) {
jPrefix.Buffer = Fcb->FcbTableEntry.Path.Buffer;
jPrefix.Length = (USHORT)(sizeof(WCHAR)*(remaining-17));
jSuffix.Buffer = Fcb->FcbTableEntry.Path.Buffer-15+(Fcb->FcbTableEntry.Path.Length/sizeof(WCHAR));
jSuffix.Length = sizeof(WCHAR)*15;
RxLog(("%s%wZ..%wZ",buffer,&jPrefix,&jSuffix));
RxWmiLog(LOG,
RxCreateNetFcb_3,
LOGARSTR(buffer)
LOGUSTR(jPrefix)
LOGUSTR(jSuffix));
}
}
#endif
RxLoudFcbMsg("Create: ",&(Fcb->FcbTableEntry.Path));
RxDbgTrace(0, Dbg, ("RxCreateNetFcb nm.iso.ifox %08lx %08lx %08lx\n",
Fcb->FcbTableEntry.Path.Buffer, Fcb->InternalSrvOpen, Fcb->InternalFobx));
RxDbgTrace(-1, Dbg, ("RxCreateNetFcb %08lx %wZ\n", Fcb, &(Fcb->FcbTableEntry.Path)));
}
if (Fcb != NULL) {
RxReferenceNetFcb(Fcb);
#ifdef RX_WJ_DBG_SUPPORT
RxdInitializeFcbWriteJournalDebugSupport(Fcb);
#endif
}
return Fcb;
}
RX_FILE_TYPE
RxInferFileType(
IN PRX_CONTEXT RxContext
)
/*++
Routine Description:
This routine tries to infer the filetype from the createoptions.
Arguments:
RxContext - the context of the Open
Return Value:
the storagetype implied by the open.
--*/
{
ULONG CreateOptions = RxContext->Create.NtCreateParameters.CreateOptions;
PAGED_CODE();
switch (CreateOptions & (FILE_DIRECTORY_FILE|FILE_NON_DIRECTORY_FILE)) {
case FILE_DIRECTORY_FILE:
return(FileTypeDirectory);
case FILE_NON_DIRECTORY_FILE:
return(FileTypeFile);
default:
case 0:
return(FileTypeNotYetKnown); //0 => i don't know the storage type
}
}
VOID
RxFinishFcbInitialization(
IN OUT PMRX_FCB MrxFcb,
IN RDBSS_STORAGE_TYPE_CODES RdbssStorageType,
IN PFCB_INIT_PACKET InitPacket OPTIONAL
)
/*++
Routine Description:
This routine is used to finish initializing an FCB after
we find out what kind it is.
Arguments:
Fcb - the Fcb being initialzed
StorageType - the type of entity that the FCB refers to
InitPacket - extra data that is required depending on the type of entity
Return Value:
none.
--*/
{
PFCB Fcb = (PFCB)MrxFcb;
USHORT OldStorageType;
PAGED_CODE();
RxDbgTrace( 0, Dbg, ("RxFcbInit %x %08lx %wZ\n",
RdbssStorageType, Fcb, &(Fcb->FcbTableEntry.Path)));
OldStorageType = Fcb->Header.NodeTypeCode;
Fcb->Header.NodeTypeCode = (CSHORT)RdbssStorageType;
// only update the information in the Fcb if it's not already set
if ( !FlagOn(Fcb->FcbState,FCB_STATE_TIME_AND_SIZE_ALREADY_SET) ) {
if (InitPacket != NULL) {
Fcb->Attributes = *(InitPacket->pAttributes);
Fcb->NumberOfLinks = *(InitPacket->pNumLinks);
Fcb->CreationTime = *(InitPacket-> pCreationTime);
Fcb->LastAccessTime = *(InitPacket->pLastAccessTime);
Fcb->LastWriteTime = *(InitPacket->pLastWriteTime);
Fcb->LastChangeTime = *(InitPacket->pLastChangeTime);
Fcb->ActualAllocationLength = InitPacket->pAllocationSize->QuadPart;
Fcb->Header.AllocationSize = *(InitPacket->pAllocationSize);
Fcb->Header.FileSize = *(InitPacket->pFileSize);
Fcb->Header.ValidDataLength = *(InitPacket->pValidDataLength);
//don't do this yet RxAdjustAllocationSizeforCC(Fcb);
SetFlag(Fcb->FcbState,FCB_STATE_TIME_AND_SIZE_ALREADY_SET);
}
} else {
if (RdbssStorageType == RDBSS_NTC_MAILSLOT){
Fcb->Attributes = 0;
Fcb->NumberOfLinks = 0;
Fcb->CreationTime.QuadPart = 0;
Fcb->LastAccessTime.QuadPart = 0;
Fcb->LastWriteTime.QuadPart = 0;
Fcb->LastChangeTime.QuadPart = 0;
Fcb->ActualAllocationLength = 0;
Fcb->Header.AllocationSize.QuadPart = 0;
Fcb->Header.FileSize.QuadPart = 0;
Fcb->Header.ValidDataLength.QuadPart = 0;
SetFlag(Fcb->FcbState,FCB_STATE_TIME_AND_SIZE_ALREADY_SET);
}
}
switch (RdbssStorageType) {
case RDBSS_NTC_MAILSLOT:
case RDBSS_NTC_SPOOLFILE:
break;
case RDBSS_STORAGE_NTC(FileTypeDirectory):
case RDBSS_STORAGE_NTC(FileTypeNotYetKnown):
break;
case RDBSS_STORAGE_NTC(FileTypeFile):
if (OldStorageType == RDBSS_STORAGE_NTC(FileTypeFile)) break;
RxInitializeLowIoPerFcbInfo(&Fcb->Specific.Fcb.LowIoPerFcbInfo);
FsRtlInitializeFileLock(
&Fcb->Specific.Fcb.FileLock,
RxLockOperationCompletion,
RxUnlockOperation );
//
// Initialize the oplock structure. NOT YET IMPLEMENTED!!!
//FsRtlInitializeOplock( &Fcb->Specific.Fcb.Oplock );
//
// Indicate that we want to be consulted on whether Fast I/O is possible
Fcb->Header.IsFastIoPossible = FastIoIsQuestionable;
break;
default:
ASSERT(FALSE);
break;
}
return;
}
VOID
RxRemoveNameNetFcb (
OUT PFCB ThisFcb
)
/*++
Routine Description:
The routine removes the name from the table and sets a flag indicateing
that it has done so. You must have already acquired the netroot
tablelock and have the fcblock as well.
Arguments:
ThisFcb - the Fcb being dereferenced
Return Value:
none.
--*/
{
PNET_ROOT NetRoot;
PAGED_CODE();
RxDbgTrace(+1, Dbg, ("RxRemoveNameNetFcb<+> %08lx %wZ RefC=%ld\n",
ThisFcb,&ThisFcb->FcbTableEntry.Path,
ThisFcb->NodeReferenceCount));
ASSERT( NodeTypeIsFcb(ThisFcb));
NetRoot = (PNET_ROOT)ThisFcb->VNetRoot->NetRoot;
ASSERT( RxIsFcbTableLockExclusive( &NetRoot->FcbTable ));
ASSERT( RxIsFcbAcquiredExclusive( ThisFcb ));
RxFcbTableRemoveFcb(
&NetRoot->FcbTable,
ThisFcb);
RxLoudFcbMsg("RemoveName: ",&(ThisFcb->FcbTableEntry.Path));
SetFlag(ThisFcb->FcbState, FCB_STATE_NAME_ALREADY_REMOVED);
RxDbgTrace(-1, Dbg, ("RxRemoveNameNetFcb<-> %08lx\n", ThisFcb));
}
VOID
RxPurgeFcb(
PFCB pFcb)
/*++
Routine Description:
The routine purges a given FCB instance. If the FCB has an open section
against it caused by cacheing the file then we need to purge to get
the close
Arguments:
pFcb - the Fcb being dereferenced
Notes:
On Entry to this routine the FCB must be accquired exclusive.
On Exit the FCB resource will be released and the FCB finalized if possible
--*/
{
PAGED_CODE();
ASSERT(RxIsFcbAcquiredExclusive(pFcb));
//make sure that it doesn't disappear
RxReferenceNetFcb(pFcb);
if (pFcb->OpenCount) {
RxPurgeFcbInSystemCache(
pFcb,
NULL,
0,
TRUE,
TRUE);
}
if (!RxDereferenceAndFinalizeNetFcb(pFcb,NULL,FALSE,FALSE)) {
//if it remains, then release else, you can't!!
RxReleaseFcb(NULL,pFcb);
}
}
BOOLEAN
RxFinalizeNetFcb (
OUT PFCB ThisFcb,
IN BOOLEAN RecursiveFinalize,
IN BOOLEAN ForceFinalize,
IN LONG ReferenceCount
)
/*++
Routine Description:
The routine finalizes the given Fcb. This routine needs
the netroot tablelock; get it beforehand.
Arguments:
ThisFcb - the Fcb being dereferenced
Return Value:
BOOLEAN - tells whether finalization actually occured
--*/
{
BOOLEAN NodeActuallyFinalized = FALSE;
PAGED_CODE();
RxDbgTrace(+1, Dbg, ("RxFinalizeNetFcb<+> %08lx %wZ RefC=%ld\n",
ThisFcb,&ThisFcb->FcbTableEntry.Path,
ReferenceCount));
RxLoudFcbMsg("Finalize: ",&(ThisFcb->FcbTableEntry.Path));
ASSERT_CORRECT_FCB_STRUCTURE(ThisFcb);
ASSERT(RxIsFcbAcquiredExclusive( ThisFcb ));
ASSERT(!ForceFinalize);
if (!RecursiveFinalize) {
if ((ThisFcb->OpenCount != 0) || (ThisFcb->UncleanCount != 0)) {
// The FCB cannot be finalized because there are outstanding refrences to it.
ASSERT(ReferenceCount > 0);
return NodeActuallyFinalized;
}
} else {
PSRV_OPEN SrvOpen;
PLIST_ENTRY ListEntry;
IF_DEBUG{
if ( FALSE && ReferenceCount){
RxDbgTrace(0, Dbg, (" BAD!!!!!ReferenceCount = %08lx\n", ReferenceCount));
}
}
ListEntry = ThisFcb->SrvOpenList.Flink;
while (ListEntry != &ThisFcb->SrvOpenList) {
SrvOpen = CONTAINING_RECORD( ListEntry, SRV_OPEN, SrvOpenQLinks );
ListEntry = ListEntry->Flink;
RxFinalizeSrvOpen(SrvOpen,TRUE,ForceFinalize);
}
}
RxDbgTrace(0, Dbg, (" After Recursive Part, REfC=%lx\n", ReferenceCount));
// After the recursive finalization the reference count associated with the FCB
// could be atmost 1 for further finalization to occur. This final reference count
// belongs to the prefix name table of the NetRoot.
//The actual finalization is divided into two parts:
// 1) if we're at the end (refcount==1) or being forced, we do the one-time only stuff
// 2) if the refcount goes to zero, we actually do the free
ASSERT(ReferenceCount >= 1);
if (ReferenceCount == 1 || ForceFinalize ) {
PV_NET_ROOT VNetRoot = ThisFcb->VNetRoot;
ASSERT(ForceFinalize ||
(ThisFcb->OpenCount == 0) && (ThisFcb->UncleanCount == 0));
RxLog(("FinalFcb %lx %lx %lx %lx",
ThisFcb,ForceFinalize,ReferenceCount,ThisFcb->OpenCount));
RxWmiLog(LOG,
RxFinalizeNetFcb,
LOGPTR(ThisFcb)
LOGUCHAR(ForceFinalize)
LOGULONG(ReferenceCount)
LOGULONG(ThisFcb->OpenCount));
RxDbgTrace(0, Dbg, (" Before Phase 1, REfC=%lx\n", ReferenceCount));
if (!ThisFcb->UpperFinalizationDone) {
switch (NodeType(ThisFcb)) {
case RDBSS_STORAGE_NTC(FileTypeFile):
//FsRtlUninitializeOplock( &ThisFcb->Specific.Fcb.Oplock ); //NOT YET IMPLEMENTED
FsRtlUninitializeFileLock( &ThisFcb->Specific.Fcb.FileLock );
break;
default:
break;
}
if (!FlagOn(ThisFcb->FcbState,FCB_STATE_ORPHANED)) {
PNET_ROOT NetRoot = VNetRoot->NetRoot;
ASSERT(RxIsFcbTableLockExclusive ( &NetRoot->FcbTable ));
if (!FlagOn(ThisFcb->FcbState, FCB_STATE_NAME_ALREADY_REMOVED)){
RxFcbTableRemoveFcb(
&NetRoot->FcbTable,
ThisFcb);
}
}
RxDbgTrace(0, Dbg, (" EndOf Phase 1, REfC=%lx\n", ReferenceCount));
ThisFcb->UpperFinalizationDone = TRUE;
}
RxDbgTrace(0, Dbg, (" After Phase 1, REfC=%lx\n", ReferenceCount));
ASSERT(ReferenceCount >= 1);
if (ReferenceCount==1) {
if (ThisFcb->pBufferingStateChangeCompletedEvent != NULL) {
RxFreePool(ThisFcb->pBufferingStateChangeCompletedEvent);
}
if (ThisFcb->MRxDispatch != NULL) {
ThisFcb->MRxDispatch->MRxDeallocateForFcb((PMRX_FCB)ThisFcb);
}
DbgDoit(ThisFcb->NonPaged->NodeTypeCode &= ~0x4000);
ExDeleteResourceLite(ThisFcb->Header.Resource);
ExDeleteResourceLite(ThisFcb->Header.PagingIoResource);
InterlockedDecrement(&ThisFcb->pNetRoot->NumberOfFcbs);
RxDereferenceVNetRoot(VNetRoot,LHS_LockNotHeld);
ASSERT(IsListEmpty(&ThisFcb->FcbTableEntry.HashLinks));
#ifdef RX_WJ_DBG_SUPPORT
RxdTearDownFcbWriteJournalDebugSupport(ThisFcb);
#endif
NodeActuallyFinalized = TRUE;
ASSERT(!(ThisFcb->fMiniInited));
RxFreeFcbObject(ThisFcb);
}
} else {
RxDbgTrace(0, Dbg, (" NODE NOT ACTUALLY FINALIZED!!!%C\n", '!'));
}
RxDbgTrace(-1, Dbg, ("RxFinalizeNetFcb<-> %08lx\n", ThisFcb, NodeActuallyFinalized));
return NodeActuallyFinalized;
}
VOID
RxSetFileSizeWithLock (
IN OUT PFCB Fcb,
IN PLONGLONG FileSize
)
/*++
Routine Description:
This routine sets the filesize in the fcb header, taking a lock to ensure
that the 64-bit value is set and read consistently.
Arguments:
Fcb - the associated fcb
FileSize - ptr to the new filesize
Return Value:
none
Notes:
--*/
{
PAGED_CODE();
FILESIZE_LOCK_DISABLED(RxAcquireFileSizeLock(Fcb);)
Fcb->Header.FileSize.QuadPart = *FileSize;
Fcb->ulFileSizeVersion++;
FILESIZE_LOCK_DISABLED(RxReleaseFileSizeLock(Fcb);)
}
VOID
RxGetFileSizeWithLock (
IN PFCB Fcb,
OUT PLONGLONG FileSize
)
/*++
Routine Description:
This routine gets the filesize in the fcb header, taking a lock to ensure
that the 64-bit value is set and read consistently.
Arguments:
Fcb - the associated fcb
FileSize - ptr to the new filesize
Return Value:
none
Notes:
--*/
{
PAGED_CODE();
FILESIZE_LOCK_DISABLED(RxAcquireFileSizeLock(Fcb);)
*FileSize = Fcb->Header.FileSize.QuadPart;
FILESIZE_LOCK_DISABLED(RxReleaseFileSizeLock(Fcb);)
}
PSRV_OPEN
RxCreateSrvOpen (
IN PV_NET_ROOT pVNetRoot,
IN OUT PFCB Fcb)
/*++
Routine Description:
This routine allocates, initializes, and inserts a new srv_open record into
the in memory data structures. If a new structure has to be allocated, it
has space for a fobx. This routine sets the refcount to 1 and leaves the
srv_open in Condition_InTransition.
Arguments:
pVNetRoot - the V_NET_ROOT instance
Fcb - the associated fcb
Return Value:
the new SRV_OPEN instance
Notes:
On Entry : The FCB associated with the SRV_OPEN must have been acquired exclusive
On Exit : No change in resource ownership
--*/
{
PSRV_OPEN SrvOpen = NULL;
PNET_ROOT NetRoot;
POOL_TYPE PoolType;
ULONG SrvOpenFlags;
PAGED_CODE();
RxDbgTrace(+1, Dbg, ("RxCreateNetSrvOpen\n", 0));
ASSERT ( NodeTypeIsFcb(Fcb) );
ASSERT ( RxIsFcbAcquiredExclusive ( Fcb ) );
NetRoot = (PNET_ROOT)Fcb->VNetRoot->NetRoot;
try {
PoolType = (Fcb->FcbState & FCB_STATE_PAGING_FILE) ? NonPagedPool : PagedPool;
SrvOpen = Fcb->InternalSrvOpen;
if ((SrvOpen != NULL) &&
!(FlagOn(Fcb->FcbState,FCB_STATE_SRVOPEN_USED)) &&
!(FlagOn(SrvOpen->Flags,SRVOPEN_FLAG_ENCLOSED_ALLOCATED)) &&
IsListEmpty(&SrvOpen->SrvOpenQLinks)) {
RxAllocateFcbObject(
NetRoot->SrvCall->RxDeviceObject,
RDBSS_NTC_INTERNAL_SRVOPEN,
PoolType,
0,
SrvOpen); //this just initializes
SetFlag(Fcb->FcbState,FCB_STATE_SRVOPEN_USED);
SrvOpenFlags = SRVOPEN_FLAG_FOBX_USED | SRVOPEN_FLAG_ENCLOSED_ALLOCATED;
} else {
SrvOpen = RxAllocateFcbObject(NetRoot->SrvCall->RxDeviceObject,RDBSS_NTC_SRVOPEN,PoolType,0, NULL);
SrvOpenFlags = 0;
}
if (SrvOpen != NULL) {
SrvOpen->Flags = SrvOpenFlags;
SrvOpen->Fcb = Fcb;
SrvOpen->pAlreadyPrefixedName = &Fcb->PrivateAlreadyPrefixedName;
SrvOpen->pVNetRoot = (PMRX_V_NET_ROOT)pVNetRoot;
RxReferenceVNetRoot(pVNetRoot);
InterlockedIncrement(&pVNetRoot->pNetRoot->NumberOfSrvOpens);
SrvOpen->NodeReferenceCount = 1;
RxReferenceNetFcb(Fcb); //already have the lock
InsertTailList(&Fcb->SrvOpenList,&SrvOpen->SrvOpenQLinks);
Fcb->SrvOpenListVersion++;
InitializeListHead(&SrvOpen->FobxList);
InitializeListHead(&SrvOpen->TransitionWaitList);
InitializeListHead(&SrvOpen->ScavengerFinalizationList);
InitializeListHead(&SrvOpen->SrvOpenKeyList);
}
} finally {
DebugUnwind( RxCreateFcb );
if (AbnormalTermination()) {
// If this is an abnormal termination then undo our work; this is
// one of those happy times when the existing code will work
if (SrvOpen != NULL) {
RxFinalizeSrvOpen( SrvOpen,TRUE,TRUE );
}
} else {
if (SrvOpen != NULL) {
RxLog(("SrvOp %lx %lx\n",SrvOpen,SrvOpen->Fcb));
RxWmiLog(LOG,
RxCreateSrvOpen,
LOGPTR(SrvOpen)
LOGPTR(SrvOpen->Fcb));
}
}
}
RxDbgTrace(-1, Dbg, ("RxCreateNetSrvOpen -> %08lx\n", SrvOpen));
return SrvOpen;
}
BOOLEAN
RxFinalizeSrvOpen (
OUT PSRV_OPEN ThisSrvOpen,
IN BOOLEAN RecursiveFinalize,
IN BOOLEAN ForceFinalize
)
/*++
Routine Description:
The routine finalizes the given SrvOpen.
Arguments:
ThisSrvOpen - the SrvOpen being dereferenced
Return Value:
BOOLEAN - tells whether finalization actually occured
Notes:
On Entry : 1) The FCB associated with the SRV_OPEN must have been acquired exclusive
2) The tablelock associated with FCB's NET_ROOT instance must have been
acquired shared(atleast)
On Exit : No change in resource ownership
--*/
{
NTSTATUS Status;
BOOLEAN NodeActuallyFinalized = FALSE;
PAGED_CODE();
RxDbgTrace(+1, Dbg, ("RxFinalizeSrvOpen<+> %08lx %wZ RefC=%ld\n",
ThisSrvOpen,&ThisSrvOpen->Fcb->FcbTableEntry.Path,
ThisSrvOpen->NodeReferenceCount));
ASSERT(NodeType(ThisSrvOpen) == RDBSS_NTC_SRVOPEN );
if (RecursiveFinalize) {
PFOBX Fobx;
PLIST_ENTRY ListEntry;
IF_DEBUG{
if ( FALSE && ThisSrvOpen->NodeReferenceCount){
RxDbgTrace(0, Dbg, (" BAD!!!!!ReferenceCount = %08lx\n", ThisSrvOpen->NodeReferenceCount));
}
}
ListEntry = ThisSrvOpen->FobxList.Flink;
while (ListEntry != &ThisSrvOpen->FobxList) {
Fobx = CONTAINING_RECORD( ListEntry, FOBX, FobxQLinks );
ListEntry = ListEntry->Flink;
RxFinalizeNetFobx(Fobx,TRUE,ForceFinalize);
}
}
if( ThisSrvOpen->NodeReferenceCount == 0 || ForceFinalize ){
BOOLEAN FreeSrvOpen;
PFCB Fcb;
Fcb = ThisSrvOpen->Fcb;
RxLog(("FinalSrvOp %lx %lx %lx",
ThisSrvOpen,ForceFinalize,ThisSrvOpen->NodeReferenceCount
));
RxWmiLog(LOG,
RxFinalizeSrvOpen,
LOGPTR(ThisSrvOpen)
LOGUCHAR(ForceFinalize)
LOGULONG(ThisSrvOpen->NodeReferenceCount));
FreeSrvOpen = !FlagOn(ThisSrvOpen->Flags,SRVOPEN_FLAG_ENCLOSED_ALLOCATED);
if ((!ThisSrvOpen->UpperFinalizationDone) &&
((ThisSrvOpen->Condition != Condition_Good) ||
(ThisSrvOpen->Flags & SRVOPEN_FLAG_CLOSED))) {
ASSERT(NodeType(Fcb) != RDBSS_NTC_OPENTARGETDIR_FCB );
ASSERT(RxIsFcbAcquiredExclusive ( Fcb ) );
RxPurgeChangeBufferingStateRequestsForSrvOpen(ThisSrvOpen);
if (!FlagOn(Fcb->FcbState,FCB_STATE_ORPHANED)) {
// close the file.
MINIRDR_CALL_THROUGH(Status,Fcb->MRxDispatch,MRxForceClosed,((PMRX_SRV_OPEN)ThisSrvOpen));
}
RemoveEntryList ( &ThisSrvOpen->SrvOpenQLinks);
InitializeListHead( &ThisSrvOpen->SrvOpenQLinks);
Fcb->SrvOpenListVersion++;
if (ThisSrvOpen->pVNetRoot != NULL) {
InterlockedDecrement(&ThisSrvOpen->pVNetRoot->pNetRoot->NumberOfSrvOpens);
RxDereferenceVNetRoot(
(PV_NET_ROOT)ThisSrvOpen->pVNetRoot,
LHS_LockNotHeld);
ThisSrvOpen->pVNetRoot = NULL;
}
ThisSrvOpen->UpperFinalizationDone = TRUE;
}
if (ThisSrvOpen->NodeReferenceCount == 0) {
ASSERT(IsListEmpty(&ThisSrvOpen->SrvOpenKeyList));
if (!IsListEmpty(&ThisSrvOpen->SrvOpenQLinks)) {
RemoveEntryList(&ThisSrvOpen->SrvOpenQLinks);
InitializeListHead(&ThisSrvOpen->SrvOpenQLinks);
}
if (FreeSrvOpen ) {
RxFreeFcbObject(ThisSrvOpen);
}
if (!FreeSrvOpen){
ClearFlag(Fcb->FcbState,FCB_STATE_SRVOPEN_USED);
}
RxDereferenceNetFcb(Fcb);
}
NodeActuallyFinalized = TRUE;
} else {
RxDbgTrace(0, Dbg, (" NODE NOT ACTUALLY FINALIZED!!!%C\n", '!'));
}
RxDbgTrace(-1, Dbg, ("RxFinalizeSrvOpen<-> %08lx\n", ThisSrvOpen, NodeActuallyFinalized));
return NodeActuallyFinalized;
}
ULONG RxPreviousFobxSerialNumber = 0;
PMRX_FOBX
RxCreateNetFobx (
OUT PRX_CONTEXT RxContext,
IN PMRX_SRV_OPEN mrxSrvOpen
)
/*++
Routine Description:
This routine allocates, initializes, and inserts a new file object extension instance.
Arguments:
RxContext - an RxContext describing a create............
pSrvOpen - the associated SrvOpen
Return Value:
none
Notes:
On Entry : FCB associated with the FOBX instance have been acquired exclusive.
On Exit : No change in resource ownership
--*/
{
PFCB pFcb;
PFOBX pFobx;
PSRV_OPEN pSrvOpen = (PSRV_OPEN)mrxSrvOpen;
RxCaptureRequestPacket;
RxCaptureParamBlock;
ULONG FobxFlags;
POOL_TYPE PoolType;
PAGED_CODE();
RxDbgTrace(+1, Dbg, ("RxCreateFobx<+>\n", 0));
ASSERT(NodeType(pSrvOpen) == RDBSS_NTC_SRVOPEN);
ASSERT( NodeTypeIsFcb(pSrvOpen->Fcb) );
ASSERT(RxIsFcbAcquiredExclusive(pSrvOpen->Fcb));
pFcb = pSrvOpen->Fcb;
PoolType = (pFcb->FcbState & FCB_STATE_PAGING_FILE) ? NonPagedPool : PagedPool;
if (!(FlagOn(pFcb->FcbState,FCB_STATE_FOBX_USED)) &&
(pSrvOpen == pFcb->InternalSrvOpen)){
// Try and use the FOBX allocated as part of the FCB if it is available
pFobx = pFcb->InternalFobx;
RxAllocateFcbObject(
pFcb->RxDeviceObject,
RDBSS_NTC_FOBX,PoolType,
0,
pFobx);//just initialize
SetFlag(pFcb->FcbState,FCB_STATE_FOBX_USED);
FobxFlags = FOBX_FLAG_ENCLOSED_ALLOCATED;
} else if (!(FlagOn(pSrvOpen->Flags,SRVOPEN_FLAG_FOBX_USED))){
// Try and use the FOBX allocated as part of the SRV_OPEN if it is available
pFobx = pSrvOpen->InternalFobx;
RxAllocateFcbObject(
pFcb->RxDeviceObject,
RDBSS_NTC_FOBX,
PoolType,
0,
pFobx);//just initialize
SetFlag(pSrvOpen->Flags,SRVOPEN_FLAG_FOBX_USED);
FobxFlags = FOBX_FLAG_ENCLOSED_ALLOCATED;
} else {
pFobx = RxAllocateFcbObject(
pFcb->RxDeviceObject,
RDBSS_NTC_FOBX,
PoolType,
0,
NULL);
FobxFlags = 0;
}
if (pFobx != NULL) {
PMRX_NET_ROOT pNetRoot;
pFobx->Flags = FobxFlags;
if ((pNetRoot = RxContext->Create.pNetRoot) != NULL) {
switch (pNetRoot->DeviceType) {
case RxDeviceType(NAMED_PIPE):
RxInitializeThrottlingState(
&pFobx->Specific.NamedPipe.ThrottlingState,
pNetRoot->NamedPipeParameters.PipeReadThrottlingParameters.Increment,
pNetRoot->NamedPipeParameters.PipeReadThrottlingParameters.MaximumDelay
);
break;
case RxDeviceType(DISK):
RxInitializeThrottlingState(
&pFobx->Specific.DiskFile.LockThrottlingState,
pNetRoot->DiskParameters.LockThrottlingParameters.Increment,
pNetRoot->DiskParameters.LockThrottlingParameters.MaximumDelay
);
break;
}
}
if (FlagOn(RxContext->Create.Flags,RX_CONTEXT_CREATE_FLAG_UNC_NAME)){
SetFlag(pFobx->Flags,FOBX_FLAG_UNC_NAME);
//DbgPrint("setting UNC flag in fobx\n");
}
if (FlagOn(RxContext->Create.NtCreateParameters.CreateOptions,FILE_OPEN_FOR_BACKUP_INTENT)) {
SetFlag(pFobx->Flags,FOBX_FLAG_BACKUP_INTENT);
}
pFobx->FobxSerialNumber = 0;
pFobx->SrvOpen = pSrvOpen;
pFobx->NodeReferenceCount = 1;
pFobx->fOpenCountDecremented = FALSE;
RxReferenceSrvOpen(pSrvOpen);
InterlockedIncrement(&pSrvOpen->pVNetRoot->NumberOfFobxs);
InsertTailList(&pSrvOpen->FobxList,&pFobx->FobxQLinks);
InitializeListHead(&pFobx->ClosePendingList);
InitializeListHead(&pFobx->ScavengerFinalizationList);
RxLog(("Fobx %lx %lx %lx\n",pFobx,pFobx->SrvOpen,pFobx->SrvOpen->Fcb));
RxWmiLog(LOG,
RxCreateNetFobx,
LOGPTR(pFobx)
LOGPTR(pFobx->SrvOpen)
LOGPTR(pFobx->SrvOpen->Fcb));
}
RxDbgTrace(-1, Dbg, ("RxCreateNetFobx<-> %08lx\n", pFobx));
return (PMRX_FOBX)pFobx;
}
BOOLEAN
RxFinalizeNetFobx (
OUT PFOBX ThisFobx,
IN BOOLEAN RecursiveFinalize,
IN BOOLEAN ForceFinalize
)
/*++
Routine Description:
The routine finalizes the given Fobx. you need exclusive fcblock.
Arguments:
ThisFobx - the Fobx being dereferenced
Return Value:
BOOLEAN - tells whether finalization actually occured
Notes:
On Entry : FCB associated with the FOBX instance must have been acquired exclusive.
On Exit : No change in resource ownership
--*/
{
BOOLEAN NodeActuallyFinalized = FALSE;
PAGED_CODE();
RxDbgTrace(+1, Dbg, ("RxFinalizeFobx<+> %08lx %wZ RefC=%ld\n",
ThisFobx,&ThisFobx->SrvOpen->Fcb->FcbTableEntry.Path,
ThisFobx->NodeReferenceCount));
ASSERT( NodeType(ThisFobx) == RDBSS_NTC_FOBX );
if( ThisFobx->NodeReferenceCount == 0 || ForceFinalize ){
NTSTATUS Status;
PSRV_OPEN SrvOpen = ThisFobx->SrvOpen;
PFCB Fcb = SrvOpen->Fcb;
BOOLEAN FreeFobx = !FlagOn(ThisFobx->Flags,FOBX_FLAG_ENCLOSED_ALLOCATED);
RxLog(("FinalFobx %lx %lx %lx",
ThisFobx,ForceFinalize,ThisFobx->NodeReferenceCount
));
RxWmiLog(LOG,
RxFinalizeNetFobx_1,
LOGPTR(ThisFobx)
LOGUCHAR(ForceFinalize)
LOGULONG(ThisFobx->NodeReferenceCount));
if (!ThisFobx->UpperFinalizationDone) {
ASSERT(NodeType(ThisFobx->SrvOpen->Fcb) != RDBSS_NTC_OPENTARGETDIR_FCB );
ASSERT( RxIsFcbAcquiredExclusive ( ThisFobx->SrvOpen->Fcb ) );
RemoveEntryList ( &ThisFobx->FobxQLinks);
if (FlagOn(ThisFobx->Flags,FOBX_FLAG_FREE_UNICODE)){
RxFreePool(ThisFobx->UnicodeQueryTemplate.Buffer);
}
if ((Fcb->MRxDispatch != NULL) && (Fcb->MRxDispatch->MRxDeallocateForFobx != NULL)) {
Fcb->MRxDispatch->MRxDeallocateForFobx((PMRX_FOBX)ThisFobx);
}
if (!FlagOn(ThisFobx->Flags,FOBX_FLAG_SRVOPEN_CLOSED)) {
// DbgPrint("@@@@ CloseAssociatedSrvOpen FOBX(%lx) SrvOpen(%lx) %wZ\n",ThisFobx,SrvOpen,&SrvOpen->Fcb->FcbTableEntry.Path);
Status = RxCloseAssociatedSrvOpen(ThisFobx,NULL);
RxLog(("$$ScCl FOBX %lx SrvOp %lx %lx\n",ThisFobx,ThisFobx->SrvOpen,Status));
RxWmiLog(LOG,
RxFinalizeNetFobx_2,
LOGPTR(ThisFobx)
LOGPTR(ThisFobx->SrvOpen)
LOGULONG(Status));
}
ThisFobx->UpperFinalizationDone = TRUE;
}
if (ThisFobx->NodeReferenceCount == 0){
ASSERT(IsListEmpty(&ThisFobx->ClosePendingList));
if (ThisFobx == Fcb->InternalFobx) {
ClearFlag(Fcb->FcbState,FCB_STATE_FOBX_USED);
} else if (ThisFobx == SrvOpen->InternalFobx) {
ClearFlag(SrvOpen->Flags,SRVOPEN_FLAG_FOBX_USED);
}
if (SrvOpen != NULL) {
ThisFobx->SrvOpen = NULL;
InterlockedDecrement(&SrvOpen->pVNetRoot->NumberOfFobxs);
RxDereferenceSrvOpen(SrvOpen,LHS_ExclusiveLockHeld);
}
if (FreeFobx){
RxFreeFcbObject(ThisFobx);
}
NodeActuallyFinalized = TRUE;
}
} else {
RxDbgTrace(0, Dbg, (" NODE NOT ACTUALLY FINALIZED!!!%C\n", '!'));
}
RxDbgTrace(-1, Dbg, ("RxFinalizeFobx<-> %08lx\n", ThisFobx, NodeActuallyFinalized));
return NodeActuallyFinalized;
}
//#define RDBSS_ENABLELOUDFCBOPSBYDEFAULT
#if DBG
#ifdef RDBSS_ENABLELOUDFCBOPSBYDEFAULT
BOOLEAN RxLoudFcbOpsOnExes = TRUE;
#else
BOOLEAN RxLoudFcbOpsOnExes = FALSE;
#endif // RDBSS_ENABLELOUDFCBOPSBYDEFAULT
BOOLEAN
RxLoudFcbMsg(
PUCHAR msg,
PUNICODE_STRING Name
)
{
PWCHAR Buffer;
ULONG Length;
if (!RxLoudFcbOpsOnExes) {
return FALSE;
}
Length = (Name->Length)/sizeof(WCHAR);
Buffer = Name->Buffer + Length;
if (
( Length < 4 )
|| ( (Buffer[-1]&'E') != 'E' )
|| ( (Buffer[-2]&'X') != 'X' )
|| ( (Buffer[-3]&'E') != 'E' )
|| ( (Buffer[-4]&'.') != '.' )
) { return FALSE; }
DbgPrint("--->%s %wZ\n",msg,Name);
return(TRUE);
}
#endif
VOID
RxCheckFcbStructuresForAlignment(void)
{
ULONG StructureId;
PAGED_CODE();
if (FIELD_OFFSET(NET_ROOT,SrvCall) != FIELD_OFFSET(NET_ROOT,pSrvCall)) {
StructureId = 'RN'; goto DO_A_BUGCHECK;
}
if (FIELD_OFFSET(V_NET_ROOT,NetRoot) != FIELD_OFFSET(V_NET_ROOT,pNetRoot)) {
StructureId = 'RNV'; goto DO_A_BUGCHECK;
}
if (FIELD_OFFSET(FCB,VNetRoot) != FIELD_OFFSET(FCB,VNetRoot)) {
StructureId = 'BCF'; goto DO_A_BUGCHECK;
}
if (FIELD_OFFSET(SRV_OPEN,Fcb) != FIELD_OFFSET(SRV_OPEN,pFcb)) {
StructureId = 'NPOS'; goto DO_A_BUGCHECK;
}
if (FIELD_OFFSET(FOBX,SrvOpen) != FIELD_OFFSET(FOBX,pSrvOpen)) {
StructureId = 'XBOF'; goto DO_A_BUGCHECK;
}
return;
DO_A_BUGCHECK:
RxBugCheck( StructureId, 0, 0 );
}
BOOLEAN
RxIsThisACscAgentOpen(
IN PRX_CONTEXT RxContext
)
/*++
Routine Description:
This routine determines if the open was made by the user mode CSC agent.
Arguments:
RxContext - the RDBSS context
Return Value:
TRUE - if it is an agent open, FALSE otherwise
Notes:
The agent opens are always satisfied by going to the server. They are never
satisfied from the cached copies. This enables reintegration using snapshots
even when the files are being currently used.
--*/
{
BOOLEAN AgentOpen = FALSE;
ULONG EaInformationLength;
PDFS_NAME_CONTEXT pDfsNameContext;
if (RxContext->Create.EaLength > 0) {
PFILE_FULL_EA_INFORMATION pEaEntry;
pEaEntry = (PFILE_FULL_EA_INFORMATION)RxContext->Create.EaBuffer;
ASSERT(pEaEntry != NULL);
for(;;) {
if (strcmp(pEaEntry->EaName, EA_NAME_CSCAGENT) == 0) {
AgentOpen = TRUE;
break;
}
if (pEaEntry->NextEntryOffset == 0) {
break;
} else {
pEaEntry = (PFILE_FULL_EA_INFORMATION)
((PCHAR) pEaEntry + pEaEntry->NextEntryOffset);
}
}
}
pDfsNameContext = RxContext->Create.NtCreateParameters.DfsNameContext;
if ((pDfsNameContext != NULL) &&
(pDfsNameContext->NameContextType == DFS_CSCAGENT_NAME_CONTEXT)) {
AgentOpen = TRUE;
}
return AgentOpen;
}
VOID
RxOrphanThisFcb(
PFCB pFcb
)
/*++
Routine Description:
This routine orphans an FCB
Arguments:
pFcb - the fcb to be orphaned
Return Value:
None
Notes:
--*/
{
// force orphan all SrvOpens for this FCB and orphan the FCB itself
RxOrphanSrvOpensForThisFcb(pFcb, NULL, TRUE);
}
VOID
RxOrphanSrvOpensForThisFcb(
PFCB pFcb,
IN PV_NET_ROOT ThisVNetRoot,
BOOLEAN fOrphanAll
)
/*++
Routine Description:
This routine orphans all srvopens for a file belonging to a particular VNetRoot. The
SrvOpen collapsing routine elsewhere makes sure that srvopens for different vnetroots
are not collapsed.
Arguments:
pFcb - the fcb whose srvopens need to be orphaned
ThisVNetRoot - the VNetRoot for which the SrvOpens have to be orphaned
fOrphanAll - Orphan all SrvOpens, ie ignore the ThisVNetRoot parameter
Return Value:
None
Notes:
--*/
{
NTSTATUS Status;
PLIST_ENTRY pListEntry;
BOOLEAN fAllSrvOpensOrphaned = TRUE;
// fOrphanAll = TRUE; // temporarily force the old behaviour
Status = RxAcquireExclusiveFcb(NULL,pFcb);
ASSERT(Status == STATUS_SUCCESS);
RxReferenceNetFcb(pFcb);
pListEntry = pFcb->SrvOpenList.Flink;
while (pListEntry != &pFcb->SrvOpenList) {
PSRV_OPEN pSrvOpen;
pSrvOpen = (PSRV_OPEN)
(CONTAINING_RECORD(
pListEntry,
SRV_OPEN,
SrvOpenQLinks));
pListEntry = pSrvOpen->SrvOpenQLinks.Flink;
if (!FlagOn(pSrvOpen->Flags,SRVOPEN_FLAG_ORPHANED))
{
// NB check fOrphanAll first as if it is TRUE, the ThisVNetRoot
// parameter maybe NULL
if (fOrphanAll || ((PV_NET_ROOT)(pSrvOpen->pVNetRoot) == ThisVNetRoot))
{
PLIST_ENTRY pEntry;
PFOBX pFobx;
SetFlag(pSrvOpen->Flags, SRVOPEN_FLAG_ORPHANED);
RxAcquireScavengerMutex();
pEntry = pSrvOpen->FobxList.Flink;
while (pEntry != &pSrvOpen->FobxList) {
pFobx = (PFOBX)CONTAINING_RECORD(
pEntry,
FOBX,
FobxQLinks);
if (!pFobx->fOpenCountDecremented) {
InterlockedDecrement(&pFcb->OpenCount);
pFobx->fOpenCountDecremented = TRUE;
}
pEntry = pEntry->Flink;
}
RxReleaseScavengerMutex();
if (!FlagOn(pSrvOpen->Flags,SRVOPEN_FLAG_CLOSED) &&
!IsListEmpty(&pSrvOpen->FobxList)) {
PLIST_ENTRY pEntry;
NTSTATUS Status;
PFOBX pFobx;
pEntry = pSrvOpen->FobxList.Flink;
pFobx = (PFOBX)CONTAINING_RECORD(
pEntry,
FOBX,
FobxQLinks);
RxReferenceNetFobx(pFobx);
RxPurgeChangeBufferingStateRequestsForSrvOpen(pSrvOpen);
Status = RxCloseAssociatedSrvOpen(pFobx,NULL);
RxDereferenceNetFobx(pFobx,LHS_ExclusiveLockHeld);
pListEntry = pFcb->SrvOpenList.Flink;
}
}
else
{
// we found atleast one SrvOpen which is a) Not Orphaned and
// b) doesn't belong to this VNetRoot
// hence we cannot orphan this FCB
fAllSrvOpensOrphaned = FALSE;
}
}
}
// if all srvopens for this FCB are in orphaned state, orphan the FCB as well.
if (fAllSrvOpensOrphaned)
{
// remove the FCB from the netname table
// so that any new opens/creates for this file will create a new FCB.
RxRemoveNameNetFcb(pFcb);
SetFlag(pFcb->FcbState,FCB_STATE_ORPHANED);
ClearFlag(pFcb->FcbState,FCB_STATE_WRITECACHEING_ENABLED);
if (!RxDereferenceAndFinalizeNetFcb(pFcb,NULL,FALSE,FALSE)) {
RxReleaseFcb(NULL,pFcb);
}
}
else
{
// some srvopens are still active, just remove the refcount and release the FCB
RxDereferenceNetFcb(pFcb);
RxReleaseFcb(NULL,pFcb);
}
}
VOID
RxForceFinalizeAllVNetRoots(
PNET_ROOT pNetRoot
)
/*++
Routine Description:
The routine foce finalizes all the vnetroots from the given netroot. You must be exclusive on
the NetName tablelock.
Arguments:
pNetRoot - the NetRoot
Return Value:
VOID
--*/
{
PLIST_ENTRY pListEntry;
pListEntry = pNetRoot->VirtualNetRoots.Flink;
while (pListEntry != &pNetRoot->VirtualNetRoots)
{
PV_NET_ROOT pTempVNetRoot;
pTempVNetRoot = (PV_NET_ROOT)
CONTAINING_RECORD(
pListEntry,
V_NET_ROOT,
NetRootListEntry);
if (NodeType(pTempVNetRoot) == RDBSS_NTC_V_NETROOT)
{
RxFinalizeVNetRoot(pTempVNetRoot, TRUE, TRUE);
}
pListEntry = pListEntry->Flink;
}
}
Reference in a new issue View git blame Copy permalink