/*++
Copyright (c) 2000 Microsoft Corporation
Module Name:
SvrUtil.cxx
Abstract:
Utility functions for querying RPC Server debug data
Author:
Kamen Moutafov (kamenm) Dec 99 - Feb 2000
Revision History:
--*/
#include <precomp.hxx>
#include <DbgLib.hxx>
typedef struct tagServerEnumerationState
{
int CurrentPosition;
int NumberOfProcesses;
// the actual size is NumberOfProcesses
ULONG ProcessUniqueId[1];
} ServerEnumerationState;
RPC_STATUS StartServerEnumeration(ServerEnumerationHandle *pHandle)
{
ServerEnumerationState *pNewState;
void *pProcessDataBuffer = NULL;
NTSTATUS NtStatus;
int CurrentAllocatedSize = 0x6000;
SYSTEM_PROCESS_INFORMATION *pCurrentProcessInfo;
unsigned char *pCurrentPos;
int NumberOfProcesses;
int i;
BOOL fResult;
do
{
if (pProcessDataBuffer)
{
fResult = VirtualFree(pProcessDataBuffer, 0, MEM_RELEASE);
ASSERT(fResult);
}
CurrentAllocatedSize += 4096 * 2;
pProcessDataBuffer = VirtualAlloc(NULL, CurrentAllocatedSize, MEM_COMMIT, PAGE_READWRITE);
if (pProcessDataBuffer == NULL)
return RPC_S_OUT_OF_MEMORY;
NtStatus = NtQuerySystemInformation(SystemProcessInformation, pProcessDataBuffer,
CurrentAllocatedSize, NULL);
}
while (NtStatus == STATUS_INFO_LENGTH_MISMATCH);
if (!NT_SUCCESS(NtStatus))
return RPC_S_OUT_OF_MEMORY;
// walk the buffer - on first pass, we just count the entries
pCurrentPos = (unsigned char *)pProcessDataBuffer;
pCurrentProcessInfo = (SYSTEM_PROCESS_INFORMATION *)pCurrentPos;
NumberOfProcesses = 0;
while (TRUE)
{
// we skip idle process and zombie processes
if (pCurrentProcessInfo->UniqueProcessId != NULL)
{
NumberOfProcesses ++;
}
// is there a place to advance to?
if (pCurrentProcessInfo->NextEntryOffset == 0)
break;
pCurrentPos += pCurrentProcessInfo->NextEntryOffset;
pCurrentProcessInfo = (SYSTEM_PROCESS_INFORMATION *)pCurrentPos;
}
pNewState = (ServerEnumerationState *) new char [
sizeof(ServerEnumerationState) + (NumberOfProcesses - 1) * sizeof(ULONG)];
// implicit placement
// pNewState = new ((NumberOfProcesses - 1) * sizeof(ULONG)) ServerEnumerationState;
if (pNewState == NULL)
{
fResult = VirtualFree(pProcessDataBuffer, 0, MEM_RELEASE);
ASSERT(fResult);
return RPC_S_OUT_OF_MEMORY;
}
new (pNewState) ServerEnumerationState;
// make the second pass - actual copying of data
pCurrentPos = (unsigned char *)pProcessDataBuffer;
pCurrentProcessInfo = (SYSTEM_PROCESS_INFORMATION *)pCurrentPos;
i = 0;
while (TRUE)
{
// we skip idle process and zombie processes
if (pCurrentProcessInfo->UniqueProcessId != NULL)
{
pNewState->ProcessUniqueId[i] = PtrToUlong(pCurrentProcessInfo->UniqueProcessId);
i ++;
}
// is there a place to advance to?
if (pCurrentProcessInfo->NextEntryOffset == 0)
break;
pCurrentPos += pCurrentProcessInfo->NextEntryOffset;
pCurrentProcessInfo = (SYSTEM_PROCESS_INFORMATION *)pCurrentPos;
}
ASSERT(i == NumberOfProcesses);
fResult = VirtualFree(pProcessDataBuffer, 0, MEM_RELEASE);
ASSERT(fResult);
// make the data available to the user
pNewState->CurrentPosition = 0;
pNewState->NumberOfProcesses = NumberOfProcesses;
*pHandle = pNewState;
return RPC_S_OK;
}
RPC_STATUS OpenNextRPCServer(IN ServerEnumerationHandle Handle, OUT CellEnumerationHandle *pHandle)
{
ServerEnumerationState *ServerState = (ServerEnumerationState *)Handle;
int CurrentPosition;
RPC_STATUS RpcStatus;
ASSERT(ServerState != NULL);
ASSERT(pHandle != NULL);
do
{
CurrentPosition = ServerState->CurrentPosition;
if (CurrentPosition >= ServerState->NumberOfProcesses)
return RPC_S_INVALID_BOUND;
ServerState->CurrentPosition ++;
RpcStatus = OpenRPCServerDebugInfo(ServerState->ProcessUniqueId[CurrentPosition], pHandle);
}
while(RpcStatus == ERROR_FILE_NOT_FOUND);
return RpcStatus;
}
void ResetServerEnumeration(IN ServerEnumerationHandle Handle)
{
ServerEnumerationState *ServerState = (ServerEnumerationState *)Handle;
ASSERT(ServerState != NULL);
ServerState->CurrentPosition = 0;
}
void FinishServerEnumeration(ServerEnumerationHandle *pHandle)
{
ServerEnumerationState *ServerState;
ASSERT (pHandle != NULL);
ServerState = *(ServerEnumerationState **)pHandle;
ASSERT(ServerState != NULL);
delete ServerState;
*pHandle = NULL;
}
DWORD GetCurrentServerPID(IN ServerEnumerationHandle Handle)
{
ServerEnumerationState *ServerState = (ServerEnumerationState *)Handle;
ASSERT(ServerState != NULL);
// -1, because the CurrentPosition points to the next server
return (DWORD)ServerState->ProcessUniqueId[ServerState->CurrentPosition - 1];
}
// a helper function
// whenever we detect an inconsistency in one of the lists,
// we can call this function, which will determine what to do
// with the current section, and will transfer sections between
// the OpenedSections list and the InconsistentSections list
void InconsistencyDetected(IN LIST_ENTRY *OpenedSections, IN LIST_ENTRY *InconsistentSections,
IN LIST_ENTRY *CurrentListEntry, IN OpenedDbgSection *pCurrentSection,
BOOL fExceptionOccurred)
{
LIST_ENTRY *NextEntry;
LIST_ENTRY *LastEntry;
// if an exception occurred, throw away this section altogether
if (fExceptionOccurred)
{
// save the next entry before we delete this one
NextEntry = CurrentListEntry->Flink;
RemoveEntryList(CurrentListEntry);
CloseDbgSection(pCurrentSection->SectionHandle, pCurrentSection->SectionPointer);
delete pCurrentSection;
CurrentListEntry = NextEntry;
pCurrentSection = CONTAINING_RECORD(CurrentListEntry, OpenedDbgSection, SectionsList);
// if the bad section was the last on the list,
// there is nothing to add to the grab bag - just
// return
if (CurrentListEntry == OpenedSections)
{
return;
}
}
// the chain is broken - we need to throw the rest of the list in
// the grab bag
// unchain this segment from the opened sections list
LastEntry = OpenedSections->Blink;
OpenedSections->Blink = CurrentListEntry->Blink;
CurrentListEntry->Blink->Flink = OpenedSections;
// chain the segment to the inconsistent sections list
CurrentListEntry->Blink = InconsistentSections->Blink;
InconsistentSections->Blink->Flink = CurrentListEntry;
InconsistentSections->Blink = LastEntry;
LastEntry->Flink = InconsistentSections;
}
RPC_STATUS OpenRPCServerDebugInfo(IN DWORD ProcessID, OUT CellEnumerationHandle *pHandle)
{
RPC_STATUS RpcStatus;
HANDLE SecHandle;
PVOID SecPointer;
int Retries = 10;
BOOL fConsistentSnapshotObtained = FALSE;
BOOL fNeedToRetry;
CellSection *CurrentSection;
DWORD SectionNumbers[2];
OpenedDbgSection *pCurrentSection;
// each section as it is opened, is linked on one of those lists
// if the view of the sections is consistent, we link it to opened
// sections. Otherwise, we link it to InconsistentSections
LIST_ENTRY OpenedSections;
LIST_ENTRY InconsistentSections;
LIST_ENTRY *CurrentListEntry;
DWORD *pActualSectionNumbers;
BOOL fExceptionOccurred;
LIST_ENTRY *LastEntry;
BOOL fFound;
int NumberOfCommittedPages;
BOOL fConsistencyPass = FALSE;
DWORD LocalPageSize;
SectionsSnapshot *LocalSectionsSnapshot;
BOOL fResult;
RpcStatus = InitializeDbgLib();
if (RpcStatus != RPC_S_OK)
return RpcStatus;
LocalPageSize = GetPageSize();
// loop until we obtain a consistent snapshot or we are out of
// retry attempts. We declare a snapshot to be consistent
// if we manage to:
// - open all sections
// - copy their contents to a private memory location
// - verify that the section chain is still consistent after the copying
// For this purpose, when we copy all the sections, we make one more
// pass at the section chain to verify it is consistent using the special
// flag fConsistencyPass.
InconsistentSections.Blink = InconsistentSections.Flink = &InconsistentSections;
OpenedSections.Blink = OpenedSections.Flink = &OpenedSections;
while (Retries > 0)
{
// on entry to the loop, the state will be this - OpenSections will
// contain a consistent view of the sections. Inconsistent sections
// will be a grab bag of sections we could not bring into
// consistent view. It's used as a cache to facilitate quick
// recovery
// we are just starting, or we are recovering from an inconsistency
// found somewhere. As soon as somebody detects an inconsistency,
// they will jump here. First thing is to try to establish what
// part of the chain is consistent. Walk the open sections for
// this purpose. We walk as far as we can, and then we declare
// the rest of the sections inconsistent, and we throw them in
// the grab bag
SectionNumbers[0] = SectionNumbers[1] = 0;
CurrentListEntry = OpenedSections.Flink;
fNeedToRetry = FALSE;
while (CurrentListEntry != &OpenedSections)
{
pCurrentSection = CONTAINING_RECORD(CurrentListEntry, OpenedDbgSection, SectionsList);
if ((SectionNumbers[0] != pCurrentSection->SectionNumbers[0])
|| (SectionNumbers[1] != pCurrentSection->SectionNumbers[1]))
{
fNeedToRetry = TRUE;
}
else
{
__try
{
// attempt to read the numbers of the next section
// we do this within try/except since server may free this
// memory and we will get toast
SectionNumbers[0] = pCurrentSection->SectionPointer->NextSectionId[0];
SectionNumbers[1] = pCurrentSection->SectionPointer->NextSectionId[1];
fExceptionOccurred = FALSE;
// note that the SectionNumbers array will be used after the end of
// the loop - make sure we don't whack them
}
__except (EXCEPTION_EXECUTE_HANDLER)
{
fExceptionOccurred = TRUE;
fNeedToRetry = TRUE;
}
}
if (fNeedToRetry)
{
// if this is the first section, the server went down. There is no
// legal way for the server to have inconsistent first section
if (CurrentListEntry == OpenedSections.Flink)
{
RpcStatus = ERROR_FILE_NOT_FOUND;
goto CleanupAndExit;
}
InconsistencyDetected(&OpenedSections, &InconsistentSections, CurrentListEntry,
pCurrentSection, fExceptionOccurred);
fNeedToRetry = TRUE;
break;
}
CurrentListEntry = CurrentListEntry->Flink;
}
// walking is complete. Did we detect inconsistency?
if (fNeedToRetry)
{
Retries --;
fConsistencyPass = FALSE;
continue;
}
else if (fConsistencyPass)
{
// this is the only place we break out of the loop -
// the consistency pass has passed
break;
}
// whatever we have in the opened sections list is consistent
// if there was something in the list keep reading,
// otherwise, start reading
if (IsListEmpty(&OpenedSections))
{
pActualSectionNumbers = NULL;
}
else
{
pCurrentSection = CONTAINING_RECORD(OpenedSections.Blink, OpenedDbgSection, SectionsList);
// we re-use the section numbers from the loop above. They can be 0 at
// this point if the last section got dropped
pActualSectionNumbers = SectionNumbers;
}
// make a pass over the sections, opening each one, but only if
// case we're missing parts of the chain or this is the first time.
// Otherwise, skip this step
while ((SectionNumbers[0] != 0) || (SectionNumbers[1] != 0) || (pActualSectionNumbers == NULL))
{
// we know which section we're looking for
// first, search the grab bag. We can only do this for a non-first
// section. The first section never goes to the grab bag
// pActualSectionNumbers will contain the section we're looking for
fFound = FALSE;
if (pActualSectionNumbers)
{
CurrentListEntry = InconsistentSections.Flink;
while (CurrentListEntry != &InconsistentSections)
{
pCurrentSection = CONTAINING_RECORD(CurrentListEntry, OpenedDbgSection, SectionsList);
// it is impossible that a well behaving server will have
// opened a different section with the same numbers, because we
// keep the section object opened.
if ((pActualSectionNumbers[0] == pCurrentSection->SectionNumbers[0])
&& (pActualSectionNumbers[1] == pCurrentSection->SectionNumbers[1]))
{
// found something
RemoveEntryList(CurrentListEntry);
// if we had already made a copy of this one, free it, as it is
// probably inconsistent
if (pCurrentSection->SectionCopy)
{
fResult = VirtualFree(pCurrentSection->SectionCopy, 0, MEM_RELEASE);
ASSERT(fResult);
pCurrentSection->SectionCopy = NULL;
}
fFound = TRUE;
break;
}
CurrentListEntry = CurrentListEntry->Flink;
}
}
if (fFound == FALSE)
{
// nothing in the grab bag - try to open it the normal way
RpcStatus = OpenDbgSection(&SecHandle, &SecPointer, ProcessID, pActualSectionNumbers);
if (RpcStatus == ERROR_FILE_NOT_FOUND)
{
// if this is the first time, this is not a server - bail out
if (pActualSectionNumbers == NULL)
{
goto CleanupAndExit;
}
// not the first time - we have an inconsistent view - need to retry
fNeedToRetry = TRUE;
break;
}
else if (RpcStatus != RPC_S_OK)
{
goto CleanupAndExit;
}
pCurrentSection = new OpenedDbgSection;
if (pCurrentSection == NULL)
{
RpcStatus = RPC_S_OUT_OF_MEMORY;
CloseDbgSection(SecHandle, SecPointer);
goto CleanupAndExit;
}
pCurrentSection->SectionHandle = SecHandle;
if (pActualSectionNumbers)
{
pCurrentSection->SectionNumbers[0] = pActualSectionNumbers[0];
pCurrentSection->SectionNumbers[1] = pActualSectionNumbers[1];
}
else
{
pCurrentSection->SectionNumbers[0] = pCurrentSection->SectionNumbers[1] = 0;
}
pCurrentSection->SectionPointer = (CellSection *) SecPointer;
pCurrentSection->SectionCopy = NULL;
}
// either we have found this in the grab bag, or we have just opened it
// both ways, try to get the section numbers we expect for the next section
__try
{
// load the section numbers that we expect for the next iteration of the
// loop
SectionNumbers[0] = pCurrentSection->SectionPointer->NextSectionId[0];
SectionNumbers[1] = pCurrentSection->SectionPointer->NextSectionId[1];
pActualSectionNumbers = SectionNumbers;
fExceptionOccurred = FALSE;
}
__except (EXCEPTION_EXECUTE_HANDLER)
{
fExceptionOccurred = TRUE;
}
if (fExceptionOccurred)
{
delete pCurrentSection;
CloseDbgSection(SecHandle, SecPointer);
fNeedToRetry = TRUE;
break;
}
InsertTailList(&OpenedSections, &pCurrentSection->SectionsList);
}
if (fNeedToRetry)
{
Retries --;
fConsistencyPass = FALSE;
continue;
}
// at this point, we have opened all the sections
// now we need to allocate memory for the snapshots and to do the copying
CurrentListEntry = OpenedSections.Flink;
while (CurrentListEntry != &OpenedSections)
{
pCurrentSection = CONTAINING_RECORD(CurrentListEntry, OpenedDbgSection, SectionsList);
__try
{
// do all the allocation and copying only if it hasn't been done yet
if (pCurrentSection->SectionCopy == NULL)
{
NumberOfCommittedPages = pCurrentSection->SectionPointer->LastCommittedPage;
pCurrentSection->SectionCopy = (CellSection *)VirtualAlloc(NULL,
NumberOfCommittedPages * LocalPageSize, MEM_COMMIT, PAGE_READWRITE);
if (pCurrentSection->SectionCopy == NULL)
{
RpcStatus = RPC_S_OUT_OF_MEMORY;
goto CleanupAndExit;
}
memcpy(pCurrentSection->SectionCopy, pCurrentSection->SectionPointer,
NumberOfCommittedPages * LocalPageSize);
pCurrentSection->SectionID = pCurrentSection->SectionPointer->SectionID;
pCurrentSection->CommittedPagesInSection = NumberOfCommittedPages;
}
fExceptionOccurred = FALSE;
}
__except (EXCEPTION_EXECUTE_HANDLER)
{
fExceptionOccurred = TRUE;
}
if (fExceptionOccurred)
{
if (pCurrentSection->SectionCopy)
{
fResult = VirtualFree(pCurrentSection->SectionCopy, 0, MEM_RELEASE);
ASSERT(fResult);
pCurrentSection->SectionCopy = NULL;
}
// the section got out of sync
InconsistencyDetected(&OpenedSections, &InconsistentSections, CurrentListEntry,
pCurrentSection, fExceptionOccurred);
fNeedToRetry = TRUE;
break;
}
CurrentListEntry = CurrentListEntry->Flink;
}
if (fNeedToRetry)
{
Retries --;
fConsistencyPass = FALSE;
continue;
}
else
{
fConsistencyPass = TRUE;
}
}
// if we managed to get a consistent view, unmap the shared sections and
// save the opened section list
if (Retries != 0)
{
ASSERT(fConsistencyPass == TRUE);
ASSERT(fNeedToRetry == FALSE);
ASSERT(!IsListEmpty(&OpenedSections));
CurrentListEntry = OpenedSections.Flink;
while (CurrentListEntry != &OpenedSections)
{
pCurrentSection = CONTAINING_RECORD(CurrentListEntry, OpenedDbgSection, SectionsList);
CloseDbgSection(pCurrentSection->SectionHandle, pCurrentSection->SectionPointer);
pCurrentSection->SectionHandle = NULL;
pCurrentSection->SectionPointer = NULL;
pCurrentSection->SectionNumbers[0] = pCurrentSection->SectionNumbers[1] = 0;
CurrentListEntry = CurrentListEntry->Flink;
}
// save the opened section list
CurrentListEntry = OpenedSections.Flink;
pCurrentSection = CONTAINING_RECORD(CurrentListEntry, OpenedDbgSection, SectionsList);
LocalSectionsSnapshot = new SectionsSnapshot;
if (LocalSectionsSnapshot != NULL)
{
LocalSectionsSnapshot->CellIndex = 0;
LocalSectionsSnapshot->FirstOpenedSection = pCurrentSection;
LocalSectionsSnapshot->CurrentOpenedSection = pCurrentSection;
// unchain the opened sections
// terminate the chain with NULL
OpenedSections.Blink->Flink = NULL;
OpenedSections.Blink = OpenedSections.Flink = &OpenedSections;
// that's the only place where we return success
*pHandle = (CellEnumerationHandle)LocalSectionsSnapshot;
RpcStatus = RPC_S_OK;
}
else
{
// let the CleanupAndExit code destroy the lists
RpcStatus = RPC_S_OUT_OF_MEMORY;
}
}
else
{
// we couldn't get a consistent snapshot of the server and
// we ran out of retries
RpcStatus = RPC_S_CANNOT_SUPPORT;
}
CleanupAndExit:
// walk the two lists, and free all sections on them
CurrentListEntry = OpenedSections.Flink;
while (CurrentListEntry != &OpenedSections)
{
pCurrentSection = CONTAINING_RECORD(CurrentListEntry, OpenedDbgSection, SectionsList);
// advance the pointer while we haven't freed the stuff
CurrentListEntry = CurrentListEntry->Flink;
if (pCurrentSection->SectionCopy)
{
fResult = VirtualFree(pCurrentSection->SectionCopy, 0, MEM_RELEASE);
ASSERT(fResult);
}
if (pCurrentSection->SectionHandle)
{
ASSERT(pCurrentSection->SectionPointer);
CloseDbgSection(pCurrentSection->SectionHandle, pCurrentSection->SectionPointer);
}
delete pCurrentSection;
}
CurrentListEntry = InconsistentSections.Flink;
while (CurrentListEntry != &InconsistentSections)
{
pCurrentSection = CONTAINING_RECORD(CurrentListEntry, OpenedDbgSection, SectionsList);
// advance the pointer while we haven't freed the stuff
CurrentListEntry = CurrentListEntry->Flink;
if (pCurrentSection->SectionCopy)
{
fResult = VirtualFree(pCurrentSection->SectionCopy, 0, MEM_RELEASE);
ASSERT(fResult);
}
if (pCurrentSection->SectionHandle)
{
ASSERT(pCurrentSection->SectionPointer);
CloseDbgSection(pCurrentSection->SectionHandle, pCurrentSection->SectionPointer);
}
delete pCurrentSection;
}
return RpcStatus;
}
DebugCellUnion *GetNextDebugCellInfo(IN CellEnumerationHandle Handle, OUT DebugCellID *CellID)
{
SectionsSnapshot *Snapshot = (SectionsSnapshot *)Handle;
OpenedDbgSection *CurrentSection, *NextSection;
DebugCellGeneric *CurrentCell;
int CurrentCellIndex;
DebugCellGeneric *LastCellForCurrentSection;
DWORD LocalPageSize = GetPageSize();
ASSERT(Handle != NULL);
CurrentSection = Snapshot->CurrentOpenedSection;
LastCellForCurrentSection = GetLastCellForSection(CurrentSection, LocalPageSize);
if (Snapshot->CellIndex == 0)
{
#ifdef _WIN64
Snapshot->CellIndex = 2;
#else
Snapshot->CellIndex = 1;
#endif
}
CurrentCell = GetCellForSection(CurrentSection, Snapshot->CellIndex);
while (TRUE)
{
// did we exhaust the current section?
if (CurrentCell > LastCellForCurrentSection)
{
// try to advance to the next one
if (CurrentSection->SectionsList.Flink)
{
CurrentSection = CONTAINING_RECORD(CurrentSection->SectionsList.Flink,
OpenedDbgSection, SectionsList);
Snapshot->CurrentOpenedSection = CurrentSection;
#ifdef _WIN64
Snapshot->CellIndex = 2;
#else
Snapshot->CellIndex = 1;
#endif
LastCellForCurrentSection = GetLastCellForSection(CurrentSection, LocalPageSize);
CurrentCell = GetCellForSection(CurrentSection, Snapshot->CellIndex);
continue;
}
return NULL;
}
CellID->CellID = (USHORT) Snapshot->CellIndex;
Snapshot->CellIndex ++;
if ((CurrentCell->Type == dctCallInfo) || (CurrentCell->Type == dctThreadInfo)
|| (CurrentCell->Type == dctEndpointInfo) || (CurrentCell->Type == dctClientCallInfo))
{
CellID->SectionID = (USHORT)CurrentSection->SectionID;
return (DebugCellUnion *)CurrentCell;
}
CurrentCell = (DebugCellGeneric *)((unsigned char *)CurrentCell + sizeof(DebugFreeCell));
}
return NULL;
}
void ResetRPCServerDebugInfo(IN CellEnumerationHandle Handle)
{
SectionsSnapshot *LocalSnapshot = (SectionsSnapshot *)Handle;
ASSERT(Handle != NULL);
LocalSnapshot->CellIndex = 0;
LocalSnapshot->CurrentOpenedSection = LocalSnapshot->FirstOpenedSection;
}
void CloseRPCServerDebugInfo(IN CellEnumerationHandle *pHandle)
{
SectionsSnapshot *LocalSnapshot;
OpenedDbgSection *DbgSection;
LIST_ENTRY *CurrentListEntry;
ASSERT(pHandle != NULL);
LocalSnapshot = (SectionsSnapshot *)*pHandle;
ASSERT(LocalSnapshot != NULL);
ASSERT(LocalSnapshot->FirstOpenedSection != NULL);
DbgSection = LocalSnapshot->FirstOpenedSection;
do
{
// advance while we can
CurrentListEntry = DbgSection->SectionsList.Flink;
// free the section
ASSERT(DbgSection->SectionCopy);
VirtualFree(DbgSection->SectionCopy, 0, MEM_RELEASE);
delete DbgSection;
// calculate next record. Note that this will not AV even if
// CurrentListEntry is NULL - this is just offset calculation
DbgSection = CONTAINING_RECORD(CurrentListEntry, OpenedDbgSection, SectionsList);
}
while (CurrentListEntry != NULL);
delete LocalSnapshot;
*pHandle = NULL;
}
typedef struct tagRPCSystemWideCellEnumeration
{
ServerEnumerationHandle serverHandle;
CellEnumerationHandle cellHandle;
} RPCSystemWideCellEnumeration;
RPC_STATUS OpenRPCSystemWideCellEnumeration(OUT RPCSystemWideCellEnumerationHandle *pHandle)
{
RPCSystemWideCellEnumeration *cellEnum;
RPC_STATUS Status;
DebugCellUnion *NextCell;
ASSERT(pHandle != NULL);
*pHandle = NULL;
cellEnum = new RPCSystemWideCellEnumeration;
if (cellEnum == NULL)
return RPC_S_OUT_OF_MEMORY;
cellEnum->cellHandle = NULL;
cellEnum->serverHandle = NULL;
Status = StartServerEnumeration(&cellEnum->serverHandle);
if (Status != RPC_S_OK)
{
delete cellEnum;
return Status;
}
Status = OpenNextRPCServer(cellEnum->serverHandle, &cellEnum->cellHandle);
// if we're done, we will get RPC_S_SERVER_INVALID_BOUND - ok to
// just return to caller
if (Status != RPC_S_OK)
{
FinishServerEnumeration(&cellEnum->serverHandle);
delete cellEnum;
return Status;
}
*pHandle = (RPCSystemWideCellEnumerationHandle) cellEnum;
return RPC_S_OK;
}
RPC_STATUS GetNextRPCSystemWideCell(IN RPCSystemWideCellEnumerationHandle handle, OUT DebugCellUnion **NextCell,
OUT DebugCellID *CellID, OUT DWORD *ServerPID OPTIONAL)
{
RPCSystemWideCellEnumeration *cellEnum = (RPCSystemWideCellEnumeration *)handle;
RPC_STATUS Status;
ASSERT(cellEnum != NULL);
// loop skipping empty servers
do
{
*NextCell = GetNextDebugCellInfo(cellEnum->cellHandle, CellID);
// this server is done - move on to the next
if (*NextCell == NULL)
{
CloseRPCServerDebugInfo(&cellEnum->cellHandle);
Status = OpenNextRPCServer(cellEnum->serverHandle, &cellEnum->cellHandle);
// if we're done with all servers, we will get RPC_S_SERVER_INVALID_BOUND - ok to
// just return to caller. Caller needs to call us back to finish enumeration
if (Status != RPC_S_OK)
{
// remember that this failed so that we don't try to clean it up
// when finishing the enumeration
cellEnum->cellHandle = NULL;
return Status;
}
}
}
while(*NextCell == NULL);
if (ServerPID && (*NextCell != NULL))
{
*ServerPID = GetCurrentServerPID(cellEnum->serverHandle);
}
return RPC_S_OK;
}
DebugCellUnion *GetRPCSystemWideCellFromCellID(IN RPCSystemWideCellEnumerationHandle handle,
IN DebugCellID CellID)
{
RPCSystemWideCellEnumeration *cellEnum = (RPCSystemWideCellEnumeration *)handle;
return GetCellByDebugCellID(cellEnum->cellHandle, CellID);
}
void FinishRPCSystemWideCellEnumeration(IN OUT RPCSystemWideCellEnumerationHandle *pHandle)
{
RPCSystemWideCellEnumeration *cellEnum;
ASSERT(pHandle != NULL);
cellEnum = (RPCSystemWideCellEnumeration *)*pHandle;
ASSERT(cellEnum != NULL);
if (cellEnum->cellHandle)
{
CloseRPCServerDebugInfo(&cellEnum->cellHandle);
}
FinishServerEnumeration(&cellEnum->serverHandle);
delete cellEnum;
*pHandle = NULL;
}
RPC_STATUS ResetRPCSystemWideCellEnumeration(IN RPCSystemWideCellEnumerationHandle handle)
{
RPCSystemWideCellEnumeration *cellEnum = (RPCSystemWideCellEnumeration *)handle;
RPC_STATUS Status;
ASSERT(cellEnum != NULL);
if (cellEnum->cellHandle)
{
CloseRPCServerDebugInfo(&cellEnum->cellHandle);
cellEnum->cellHandle = NULL;
}
ResetServerEnumeration(cellEnum->serverHandle);
Status = OpenNextRPCServer(cellEnum->serverHandle, &cellEnum->cellHandle);
if (Status != RPC_S_OK)
{
// remember that this failed so that we don't try to clean it up
// when finishing the enumeration
cellEnum->cellHandle = NULL;
}
return Status;
}