// Public methods
static public void InitializeSystem()
{
// Create the system controller if needed. The SIPs will
// get a proxy controller object that will handle operations
// as syscalls.
// TODO: Further optimizations may allow writing a more
// efficient proxy that may use shared memory.
#if SINGULARITY_KERNEL
KernelController controller = new KernelController();
if (controller != null)
{
LocalControllerObject = controller;
SystemControllerObject = LocalControllerObject;
controller.Initialize();
}
#else
LocalController controller = new LocalController();
if (controller != null)
{
LocalControllerObject = controller;
// For SIPs we need a proxy object that will handle the calls
// to the system controller
SystemControllerObject = new SystemControllerProxy();
controller.Initialize();
}
#endif
if (SystemControllerObject != null)
{
SystemControllerObject.Initialize();
SystemControllerObject.RegisterController();
QuerySession.InitializeQuerySystem();
}
}
public virtual void EnumerateActiveSources(QuerySourceDelegate sourceDelegate,
ActiveSourceEntryDelegate activeEntryDelegate,
QueryEntryDelegate entryDelegate,
ushort maxEntrySize,
ref EnumerationContext context)
{
if (maxEntrySize == 0)
{
maxEntrySize = DefaultEntrySize;
}
// Create a temporary buffer to store the temporary query information
QueryBuffer entryBuffer = new QueryBuffer(maxEntrySize);
if ((entryBuffer == null) || (sourceDelegate == null))
{
return;
}
// Prepare to query the controller for the source list. We just pick up an number
// that would represent the limit for most common cases as the initial guess.
int currentSize = 100;
UIntPtr [] sourceArray = new UIntPtr[currentSize];
if (sourceArray != null)
{
// Query the controller for the actual source list
int sourceCount = QuerySourcesList(sourceArray, currentSize);
//
// The array was not large enough, attempt again with the new size
while (sourceCount > currentSize)
{
sourceArray = new UIntPtr[sourceCount];
sourceCount = QuerySourcesList(sourceArray, currentSize);
}
//
// We sucessfully received an array of entries. We walk them and build the
// required information
//
for (int i = 0; i < sourceCount; i++)
{
UIntPtr sourceHandle = sourceArray[i];
UIntPtr storageHandle = 0;
UIntPtr eventType = 0;
UInt16 count = 0;
string bufferName = "";
if (GetSourceInformation(sourceHandle,
ref storageHandle,
ref eventType,
ref count,
ref bufferName))
{
if (storageHandle == 0)
{
//
// This is an active source. The eventing has no information
// about the storage, it has instead information about the
// types of events handled by this source
//
EventDescriptor descriptor = QuerySession.GetEventDescriptor(this,
eventType);
if (descriptor != null)
{
// The source is valid, call the delegate with the appropriate
// arguments filled in
// TODO: Also retrieve the control flags status
if (!sourceDelegate(sourceHandle,
storageHandle,
eventType,
count,
bufferName,
descriptor,
ref context))
{
break;
}
if (entryDelegate != null)
{
// The caller also provided an entry delegate. We need in that
// case to also enumerate all entries from the active source
for (int index = 0; index < count; index++)
{
if (!QueryActiveEntry(sourceHandle,
index,
ref entryBuffer))
{
break;
}
activeEntryDelegate(sourceHandle,
index,
descriptor,
entryBuffer,
ref context);
}
}
}
}
else
{
// This source has an associated storage. Enumerate the entries from
// the storage
// TODO: we might also want to filter the sources inside the storage
// since multiple sources can share the same storage
if (!sourceDelegate(sourceHandle,
storageHandle,
eventType,
count,
bufferName,
null,
ref context))
{
break;
}
EventingStorage storage = OpenStorage(storageHandle);
if (storage != null)
{
// Instantiate a query session for the storage and
// enumerate the entries passing the provided delegate
QuerySession query = new QuerySession();
if ((query != null) && (context != null) &&
query.Initialize(storage, false))
{
query.EnumerateEntries(entryDelegate, ref context);
}
}
}
}
}
}
}