public override bool QueryActiveEntry(UIntPtr sourceHandle,
int index,
ref QueryBuffer entryBuffer)
{
unsafe {
UInt32 offset;
UIntPtr type;
fixed(byte *ptr = &(entryBuffer.GetBuffer()[0]))
{
bool success = DiagnosisService.ReadActiveSourceItem(sourceHandle,
index,
&type,
ptr,
entryBuffer.GetBufferSize());
entryBuffer.Type = type;
// the active entries do not have any header
entryBuffer.UserOffset = 0;
return(success);
}
}
}
static internal bool ActiveEntryDelegate(UIntPtr sourceHandle,
int index,
EventDescriptor descriptor,
QueryBuffer entryBuffer,
ref EnumerationContext context)
{
Console.Write("{0:d5}", index);
descriptor.EnumerateFields(new QueryFieldDelegate(ActiveFieldDelegate), entryBuffer, ref context);
Console.WriteLine("");
return(true);
}
public object GetProperty(QueryBuffer buffer, string propertyName)
{
FieldDescriptor fieldDescriptor = LookupTable[propertyName] as FieldDescriptor;
if (fieldDescriptor == null)
{
return(null);
}
return(fieldDescriptor.GetObject(buffer));
}
static internal bool EntryDelegate(EventDescriptor currentEntry,
QueryBuffer buffer,
ref EnumerationContext context)
{
if ((currentEntry != null) && (buffer != null))
{
currentEntry.EnumerateFields(new QueryFieldDelegate(fieldDelegate), buffer, ref context);
}
return(true);
}
public object GetObject(QueryBuffer buffer)
{
unsafe {
switch (Type)
{
case DataType.__int8:
case DataType.__uint8:
fixed(byte *ptrInt = &(buffer.GetBuffer()[buffer.UserOffset + Offset]))
{
return(*(byte *)ptrInt);
}
case DataType.__int16:
case DataType.__uint16:
fixed(byte *ptrInt = &(buffer.GetBuffer()[buffer.UserOffset + Offset]))
{
return(*(ushort *)ptrInt);
}
case DataType.__int32:
case DataType.__uint32:
fixed(byte *ptrInt = &(buffer.GetBuffer()[buffer.UserOffset + Offset]))
{
return(*(Int32 *)ptrInt);
}
case DataType.__UIntPtr:
fixed(byte *ptrInt = &(buffer.GetBuffer()[buffer.UserOffset + Offset]))
{
return(*(UIntPtr *)ptrInt);
}
case DataType.__IntPtr:
fixed(byte *ptrInt = &(buffer.GetBuffer()[buffer.UserOffset + Offset]))
{
return(*(IntPtr *)ptrInt);
}
default:
DebugStub.WriteLine("Unknown field type");
break;
}
}
return(null);
}
public bool Initialize(EventingStorage storage,
bool forward)
{
if (EntryBuffer == null)
{
EntryBuffer = new QueryBuffer(256);
if ((EntryBuffer == null) || (EntryBuffer.GetBuffer() == null))
{
return(false);
}
}
// Cleanup for the previous states.
if (QueryHandle != 0)
{
QueryStorage.DeleteQueryView(QueryHandle);
QueryHandle = 0;
QueryStorage = null;
}
// Initialize the new query states
QueryStorage = storage;
if (QueryStorage == null)
{
return(false);
}
QueryHandle = QueryStorage.CreateQueryView(forward);
if (QueryHandle == 0)
{
QueryStorage = null;
return(false);
}
return(true);
}
public override UIntPtr GetNextEntry(UIntPtr queryHandle,
ref QueryBuffer entryBuffer)
{
unsafe {
UInt32 offset;
UIntPtr type;
fixed(byte *ptr = &(entryBuffer.GetBuffer()[0]))
{
entryBuffer.EntryHandle = DiagnosisService.GetNextEntry(queryHandle,
&type,
&offset,
ptr,
entryBuffer.GetBufferSize());
entryBuffer.Type = type;
entryBuffer.UserOffset = offset;
return(entryBuffer.EntryHandle);
}
}
}
public void EnumerateFields(QueryFieldDelegate fieldDelegate,
QueryBuffer buffer,
ref EnumerationContext context)
{
for (int i = 0; i < Fields.Count; i++)
{
FieldDescriptor fieldDescriptor = Fields[i] as FieldDescriptor;
if (buffer != null)
{
if (!fieldDelegate(fieldDescriptor, fieldDescriptor.GetObject(buffer), ref context))
{
break;
}
}
else
{
if (!fieldDelegate(fieldDescriptor, null, ref context))
{
break;
}
}
}
}
public abstract UIntPtr GetNextEntry(UIntPtr queryHandle,
ref QueryBuffer entryBuffer);
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);
}
}
}
}
}
}
}
public virtual bool QueryActiveEntry(UIntPtr sourceHandle,
int index,
ref QueryBuffer entryBuffer)
{
return(false);
}