able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/com/ole32/dcomss/objex/orsvr.cxx

1008 lines
22 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1995-1996 Microsoft Corporation
Module Name:
OrSvr.cxx
Abstract:
Object resolver server side class implementations. CServerOxid, CServerOid,
CServerSet and CServerSetTable classes are implemented here.
Author:
Mario Goertzel [MarioGo]
Revision History:
MarioGo 04-03-95 Combined many smaller .cxx files
MarioGo 01-12-96 Locally unique IDs
--*/
#include<or.hxx>
//
// ScanForOrphanedPinnedOids
//
// This function is called from CServerOxid::ProcessRelease when
// the soxid is deregistered or the server dies.
//
void
ScanForOrphanedPinnedOids(CServerOxid* pDeadOxid)
{
CListElement* pLE;
CServerOid* pOid;
CServerOid* pNextOid;
ASSERT(gpServerLock->HeldExclusive());
// Walk the list, unpinning oids which were owned by the
// dead soxid.
pLE = gpServerPinnedOidList->First();
pOid = pLE ? CServerOid::ContainingRecord2(pLE) : NULL;
while (pOid)
{
pLE = pLE->Next();
pNextOid = pLE ? CServerOid::ContainingRecord2(pLE) : NULL;
if (pOid->GetOxid() == pDeadOxid)
{
// This will remove it from the pinned list
pOid->SetPinned(FALSE);
}
pOid = pNextOid;
}
ASSERT(gpServerLock->HeldExclusive());
return;
}
//
// CServerOid methods
//
void
CServerOid::Reference()
{
ASSERT(gpServerLock->HeldExclusive());
BOOL fRemove = (this->References() == 0);
// We may remove something from a PList more then once; this won't
// hurt anything. fRemove is used to avoid trying to remove it more
// often then necessary without taking lock.
this->CIdTableElement::Reference();
if (fRemove)
{
CPListElement * t = Remove();
ASSERT(t == &this->_plist || t == 0);
}
}
DWORD
CServerOid::Release()
{
ASSERT(gpServerLock->HeldExclusive());
DWORD c = this->CReferencedObject::Dereference();
if (0 == c)
{
// If another thread is already running this down it
// means we got referenced and released during the rundown
// callback. That thread will figure out what to do.
if (IsRunningDown())
{
KdPrintEx((DPFLTR_DCOMSS_ID,
DPFLTR_WARNING_LEVEL,
"OR: Oid running down in release: %p\n",
this));
}
else if (IsFreed() || this->_pOxid->IsRunning() == FALSE)
{
// Server freed this OID already; no need to run it down
KdPrintEx((DPFLTR_DCOMSS_ID,
DPFLTR_INFO_LEVEL,
"OR: OID %p freed by server so not rundown\n",
this));
SetRundown(TRUE);
delete this;
}
else
{
// All serverset (or pinned) references have been released. Put
// ourselves into the oid plist so we can be rundown.
ASSERT(!IsPinned());
Insert();
}
}
// this pointer maybe invalid.
return(c);
}
CServerOid::~CServerOid()
{
ASSERT(gpServerLock->HeldExclusive());
ASSERT(_pOxid);
ASSERT(_fRunningDown);
ASSERT(!IsPinned());
_pOxid->Release();
gpServerOidTable->Remove(this);
}
void
CServerOid::KeepAlive()
// A client has removed this oid from its set. This keeps
// the oid alive for another timeout period.
{
ASSERT(gpServerLock->HeldExclusive());
if (IsRunningDown() == FALSE && References() == 0)
{
// It's in the rundown list, move it to the end.
CPListElement *pT = Remove();
ASSERT(pT == &this->_plist);
Insert();
}
}
void
CServerOid::SetPinned(BOOL fPinned)
{
ASSERT(gpServerLock->HeldExclusive());
// Assert that this is a state switch.
ASSERT(_fPinned ? !fPinned : fPinned);
// Set new state
_fPinned = fPinned;
// When we are pinned, we take an extra reference to avoid further
// rundown attempts. When unpinned, we remove the reference.
if (_fPinned)
{
this->Reference();
// Now we should not be in any list
ASSERT(_list.NotInList());
ASSERT(_plist.NotInList());
gpServerPinnedOidList->Insert(&_list);
}
else
{
// We should be in the gpServerPinnedOidList list, but not the plist
ASSERT(_list.InList());
ASSERT(_plist.NotInList());
gpServerPinnedOidList->Remove(&_list);
// This Release call may put us in the oidplist
this->Release();
}
ASSERT(gpServerLock->HeldExclusive());
return;
}
//
// CServerOidPList method
//
CServerOid *
CServerOidPList::MaybeRemoveMatchingOxid(
IN CTime &when,
IN CServerOid *pOid
)
{
CPListElement *ple;
CServerOid *poid;
CMutexLock lock(&this->_lock);
ple = (CPListElement *)CPList::First();
while( ple != 0
&& *ple->GetTimeout() < when)
{
poid = CServerOid::ContainingRecord(ple);
if (poid->Match(pOid))
{
Remove(ple);
return(poid);
}
ple = ple->Next();
}
return(0);
}
//
// CServerOxid methods
//
void
CServerOxid::ProcessRelease()
/*++
Routine Desciption
The server process owning this OXID has either died
or deregistered this oxid. Releases the oxid and
nulls the pProcess pointer.
Arguments:
n/a
Return Value:
n/a
--*/
{
ASSERT(gpServerLock->HeldExclusive());
ASSERT(_pProcess);
_fRunning = FALSE;
ScanForOrphanedPinnedOids(this);
Release();
// This pointer may now be invalid, _pProcess pointer maybe invalid.
}
CServerOxid::~CServerOxid(void)
{
ASSERT(gpServerLock->HeldExclusive());
ASSERT(_pProcess);
ASSERT(!IsRunning()); // implies that the oxid has been removed from the table
ASSERT(!_fRundownInProgress);
_pProcess->Release();
}
ORSTATUS
CServerOxid::GetInfo(
OUT OXID_INFO *poxidInfo,
IN BOOL fLocal
)
// Server lock held shared.
{
ORSTATUS status;
DUALSTRINGARRAY *psa;
if (!IsRunning())
{
// Server crashed, info is not needed.
return(OR_NOSERVER);
}
if (fLocal)
{
psa = _pProcess->GetLocalBindings();
}
else
{
psa = _pProcess->GetRemoteBindings();
}
if (!psa)
{
return(OR_NOMEM);
}
// copy the data
memcpy(poxidInfo, &_info, sizeof(_info));
poxidInfo->psa = psa;
return(OR_OK);
}
void
CServerOxid::RundownOids(ULONG cOids,
CServerOid* aOids[])
// Note: Returns without the server lock held.
{
RPC_STATUS status = RPC_S_OK;
ASSERT(cOids > 0);
ASSERT(cOids <= MAX_OID_RUNDOWNS_PER_CALL);
ASSERT(gpServerLock->HeldExclusive());
// We only issue the rundown call if a) we're still running
// and b) there isn't another rundown call to this oxid
// already in progress.
if (IsRunning() && !_fRundownInProgress)
{
// Note: The server lock is released during the callback.
// Since the OID hasn't rundown yet, it will keep a reference
// to this OXID which in turn keeps the process object alive.
// Ask our process object to issue an async call to try
// to rundown the specified oids. If call was sent ok,
// return. Otherwise fall thru and cleanup below.
_fRundownInProgress = TRUE;
status = _pProcess->RundownOids(this,
cOids,
aOids);
ASSERT(!gpServerLock->HeldExclusive());
if (status == RPC_S_OK)
{
return;
}
else
{
// Re-take the lock
gpServerLock->LockExclusive();
// No rundown in progress now
_fRundownInProgress = FALSE;
}
}
BYTE aRundownStatus[MAX_OID_RUNDOWNS_PER_CALL];
// If server died or apartment was unregistered, okay to run all
// oids down. Otherwise don't run any down (this is also the
// case for when we are still running but another rundown is already
// in progress).
for (ULONG i = 0; i < cOids; i++)
{
aRundownStatus[i] = IsRunning() ? ORS_DONTRUNDOWN : ORS_OK_TO_RUNDOWN;
}
// Call the notify function whih will do appropriate
// cleanup on the oids
ProcessRundownResultsInternal(FALSE, cOids, aOids, aRundownStatus);
gpServerLock->UnlockExclusive();
}
void
CServerOxid::ProcessRundownResults(ULONG cOids,
CServerOid* aOids[],
BYTE aRundownStatus[])
/*++
Routine Desciption
Takes the appropriate action based on the result of trying
to rundown one or more oids.
Arguments:
cOids -- # of oids in aOids
aOids -- array of CServerOid*'s that we tried to rundown
aRundownStatus -- array of status values from the
OID_RUNDOWN_STATUS enumeration.
Return Value:
void
--*/
{
ProcessRundownResultsInternal(TRUE,
cOids,
aOids,
aRundownStatus);
return;
}
void
CServerOxid::ProcessRundownResultsInternal(BOOL fAsyncReturn,
ULONG cOids,
CServerOid* aOids[],
BYTE aRundownStatus[])
/*++
Routine Desciption
Takes the appropriate action based on the result of trying
to rundown one or more oids.
Arguments:
fAsyncReturn -- TRUE if we are processing these results in response
to a async rundown call returning, FALSE otherwise.
cOids -- # of oids in aOids
aOids -- array of CServerOid*'s that we tried to rundown
aRundownStatus -- array of status values from the
OID_RUNDOWN_STATUS enumeration.
Return Value:
void
--*/
{
ULONG i;
ASSERT(gpServerLock->HeldExclusive());
// Flip the "rundown in progress" flag as necessary.
if (fAsyncReturn)
{
ASSERT(_fRundownInProgress);
_fRundownInProgress = FALSE;
}
for(i = 0; i < cOids; i++)
{
CServerOid* pOid;
pOid = aOids[i];
ASSERT(pOid);
ASSERT(this == pOid->GetOxid());
if (aRundownStatus[i] == ORS_OID_PINNED)
{
KdPrintEx((DPFLTR_DCOMSS_ID,
DPFLTR_INFO_LEVEL,
"OR: Randown OID %p but the client says it's pinned\n",
pOid));
// Server says that particular oid is "pinned", ie cannot
// be rundown until we are told otherwise. Note that we
// check for this before we check # of references -- the
// ORS_OID_PINNED status takes precedence.
pOid->SetPinned(TRUE);
pOid->SetRundown(FALSE);
}
else if (pOid->References() != 0)
{
// Added to a set while running down and still referenced.
pOid->SetRundown(FALSE);
}
else if (aRundownStatus[i] == ORS_OK_TO_RUNDOWN)
{
delete pOid;
}
else
{
ASSERT(aRundownStatus[i] == ORS_DONTRUNDOWN);
KdPrintEx((DPFLTR_DCOMSS_ID,
DPFLTR_INFO_LEVEL,
"OR: Randown OID %p but the client kept it alive\n",
pOid));
// Client want us to keep it alive and is still running.
pOid->SetRundown(FALSE);
pOid->Insert();
}
}
}
ORSTATUS
CServerOxid::GetRemoteInfo(
OUT OXID_INFO *pInfo,
IN USHORT cClientProtseqs,
IN USHORT aClientProtseqs[]
)
// Server lock held shared.
{
ORSTATUS status;
USHORT protseq;
status = GetInfo(pInfo, FALSE);
if (OR_OK == status)
{
protseq = FindMatchingProtseq(cClientProtseqs,
aClientProtseqs,
pInfo->psa->aStringArray
);
if (0 == protseq)
{
MIDL_user_free(pInfo->psa);
pInfo->psa = 0;
status = OR_I_NOPROTSEQ;
}
}
return(status);
}
ORSTATUS
CServerOxid::LazyUseProtseq(
IN USHORT cClientProtseqs,
IN USHORT *aClientProtseqs
)
// Server lock held shared, returns with the server lock exclusive.
// Note: It is possible, that after this call the OXID has been deleted.
{
ORSTATUS status;
if (IsRunning())
{
// Keep this OXID process alive while making the callback. If the process
// crashes and this OXID has no OIDs it could be released by everybody
// else. This keeps the OXID and process alive until we finish.
this->Reference();
gpServerLock->UnlockShared();
status = _pProcess->UseProtseqIfNeeded(cClientProtseqs, aClientProtseqs);
gpServerLock->LockExclusive();
this->Release();
}
else
{
gpServerLock->ConvertToExclusive();
status = OR_NOSERVER;
}
// Note: The this poiner maybe BAD now.
return(status);
}
//
// CServerSet methods.
//
ORSTATUS
CServerSet::AddObject(OID &oid)
{
ORSTATUS status = OR_OK;
CServerOid *pOid;
ASSERT(gpServerLock->HeldExclusive());
CIdKey key(oid);
pOid = (CServerOid *)gpServerOidTable->Lookup(key);
if (pOid)
{
ASSERT(_blistOids.Member(pOid) == FALSE);
// Don't add duplicate IDs to the set
if (_blistOids.Member(pOid) == FALSE)
{
status = _blistOids.Insert(pOid);
if (status == OR_OK)
{
pOid->Reference();
}
}
}
else
status = OR_BADOID;
VALIDATE((status, OR_BADOID, OR_NOMEM, 0));
return(status);
}
void
CServerSet::RemoveObject(OID &oid)
{
CServerOid *pOid;
ASSERT(gpServerLock->HeldExclusive());
CIdKey key(oid);
pOid = (CServerOid *)gpServerOidTable->Lookup(key);
if (pOid)
{
CServerOid *pOidTmp = (CServerOid *)_blistOids.Remove(pOid);
if (pOid == pOidTmp)
{
pOid->Release();
}
else
{
// Set doesn't contain the specified oid, treat this as an
// add and delete by keeping the oid alive for another timeout
// period.
ASSERT(pOidTmp == 0);
pOid->KeepAlive();
}
}
}
BOOL
CServerSet::ValidateObjects(BOOL fShared)
// fShared - Indicates if the server lock is held
// shared (TRUE) or exclusive (FALSE).
//
// Return - TRUE the lock is still shared, false
// the lock is held exclusive.
{
CServerOid *pOid;
CBListIterator oids(&_blistOids);
// Since we own a reference on all the Oids they must still exist.
// No need to lock exclusive until we find something to delete.
while(pOid = (CServerOid *)oids.Next())
{
if (!pOid->IsRunning())
{
if (fShared)
{
KdPrintEx((DPFLTR_DCOMSS_ID,
DPFLTR_WARNING_LEVEL,
"OR: Cleanup in set (%p), removing dead oids.\n",
this,
pOid));
gpServerLock->ConvertToExclusive();
fShared = FALSE;
oids.Reset(&_blistOids);
continue;
}
CServerOid *pOidTmp = (CServerOid *)_blistOids.Remove(pOid);
ASSERT(pOidTmp == pOid);
ASSERT(pOid->IsRunning() == FALSE);
pOid->Release();
}
}
return(fShared);
}
BOOL
CServerSet::Rundown()
// Rundown the whole set.
{
CServerOid *poid;
CTime now;
ASSERT(gpServerLock->HeldExclusive());
if (_timeout > now)
{
// Don't rundown if we've recieved a late ping.
return(FALSE);
}
if (_fLocal && _blistOids.Size() != 0)
{
KdPrintEx((DPFLTR_DCOMSS_ID,
DPFLTR_WARNING_LEVEL,
"OR: Premature rundown of local set ignored.\n"));
return(FALSE);
}
KdPrintEx((DPFLTR_DCOMSS_ID,
DPFLTR_WARNING_LEVEL,
"OR: Set %p's client appears to have died\n",
this));
CBListIterator oids(&_blistOids);
while(poid = (CServerOid *)oids.Next())
{
poid->Release();
}
return(TRUE);
}
//
// CServerSetTable implementation
//
CServerSet *
CServerSetTable::Allocate(
IN USHORT sequence,
IN PSID psid,
IN BOOL fLocal,
OUT ID &setid
)
/*++
Routine Description:
Allocates a new CServerSet and returns the setid for the new set.
Arguments:
sequence - initial sequence number for the new set.
psid - pointer to an NT SID structure for the new set.
fLocal - TRUE : set is for the local client,
FALSE : set is for a remote client
setid - the setid of the set returned. Unchanged if return value 0.
Return Value:
0 - Unable to allocate a resource
non-zero - A pointer to the newly created set.
--*/
{
ASSERT(gpServerLock->HeldExclusive());
UINT i;
LARGE_INTEGER li;
ASSERT(_cAllocated <= _cMax);
if (_cAllocated == _cMax)
{
// Table is full, realloc
// Do this first, if it succeeds great even if
// a later allocation fails. If not, fail now.
IndexElement *pNew = new IndexElement[_cMax * 2];
if (!pNew)
{
return(0);
}
for (i = 0; i < _cMax; i++)
{
pNew[i] = _pElements[i];
}
for(i = _cMax; i < _cMax*2; i++)
{
pNew[i]._sequence = GetTickCount();
pNew[i]._pSet = 0;
}
delete _pElements;
_pElements = pNew;
_cMax *= 2;
}
CServerSet *pSet = new CServerSet(sequence, psid, fLocal);
if (0 == pSet)
{
return(0);
}
ASSERT(_pElements);
ASSERT(_cMax > _cAllocated);
for(i = _iFirstFree; i < _cMax; i++)
{
if (0 == _pElements[i]._pSet)
{
_pElements[i]._sequence++;
_pElements[i]._pSet = pSet;
li.HighPart = i + 1;
li.LowPart = _pElements[i]._sequence;
setid = li.QuadPart;
_iFirstFree = i + 1;
_cAllocated++;
return pSet;
}
}
ASSERT(0);
return(0);
}
CServerSet *
CServerSetTable::Lookup(
IN ID setid
)
/*++
Routine Description:
Looks up an a set given the sets ID.
Server lock held shared.
Arguments:
setid - the ID of the set to lookup
Return Value:
0 - set doesn't exist
non-zero - the set.
--*/
{
LARGE_INTEGER li;
li.QuadPart = setid;
LONG i = li.HighPart - 1;
DWORD sequence = (DWORD)(setid & ~((ID)0));
if (i >= 0 && (DWORD) i < _cMax)
{
if (_pElements[i]._sequence == sequence)
{
// May still be null if it is free and has not yet be reused.
return(_pElements[i]._pSet);
}
}
return(0);
}
ID
CServerSetTable::CheckForRundowns(
)
/*++
Routine Description:
Used by ping and worker threads to monitor for sets that should
be rundown. It is called with the server lock held shared.
Arguments:
None
Return Value:
0 - Didn't find a set to rundown
non-zero - ID of a set which may need to be rundown.
--*/
{
UINT i, end;
LARGE_INTEGER id;
id.QuadPart = 0;
ASSERT(_iRundown < _cMax);
if (_cAllocated == 0)
{
return(0);
}
i = _iRundown;
do
{
ASSERT(_cAllocated); // loop assumes one or more allocated elements.
i = (i + 1) % _cMax;
}
while(0 == _pElements[i]._pSet);
ASSERT(_pElements[i]._pSet);
if (_pElements[i]._pSet->ShouldRundown())
{
id.HighPart = i + 1;
id.LowPart = _pElements[i]._sequence;
}
_iRundown = i;
return(id.QuadPart);
}
BOOL
CServerSetTable::RundownSetIfNeeded(
IN ID setid
)
/*++
Routine Description:
Rundowns down a set (or sets) if needed. Called by
ping and worker threads. Server lock held exclusive.
Arguments:
setid - An ID previously returned from CheckForRundowns.
Return Value:
TRUE - A set was actually rundown
FALSE - No sets actually rundown
--*/
{
ASSERT(gpServerLock->HeldExclusive());
CServerSet *pSet = Lookup(setid);
if (0 == pSet || FALSE == pSet->ShouldRundown())
{
// Set already randown or has been pinged in the meantime.
return(FALSE);
}
// PERF REVIEW this function has the option of running multiple sets,
// saving the worker thread from taking and leaving the lock many times
// when a bunch of sets all rundown. This feature is not used.
LARGE_INTEGER li;
li.QuadPart = setid;
UINT i = li.HighPart - 1;
if (pSet->Rundown())
{
delete pSet;
_cAllocated--;
if (i < _iFirstFree) _iFirstFree = i;
_pElements[i]._pSet = 0;
return(TRUE);
}
return(FALSE);
}
void
CServerSetTable::PingAllSets()
/*++
Routine Description:
Performs a ping of all sets currently in the table.
Arguments:
none
Return Value:
void
--*/
{
ASSERT(gpServerLock->HeldExclusive());
ULONG i;
for(i = 0; i < _cMax; i++)
{
if (_pElements[i]._pSet)
{
_pElements[i]._pSet->Ping(FALSE);
}
}
}
Reference in a new issue Copy permalink