417 lines
11 KiB
C
417 lines
11 KiB
C
////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Microsoft Research Singularity
|
|
//
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//
|
|
// File: eventing.h
|
|
//
|
|
// Note:
|
|
//
|
|
|
|
// Misc. general purpose declarations
|
|
|
|
#define ROUND_UP_TO_POWER2( x, n ) (((uintptr)(x) + (uintptr)((n)-1)) & ~((uintptr)(n)-1))
|
|
extern "C" void * __cdecl memcpy(void *, const void *, size_t);
|
|
|
|
#define C_ASSERT(e) typedef char __C_ASSERT__[(e)?1:-1]
|
|
|
|
#define BUFFER_VALIDATION 1
|
|
|
|
#ifdef BUFFER_VALIDATION
|
|
|
|
#define EV_ASSERT(x) if (!(x)) __debugbreak();
|
|
|
|
#else // !BUFFER_VALIDATION
|
|
|
|
#define EV_ASSERT(x)
|
|
|
|
#endif // BUFFER_VALIDATION
|
|
|
|
|
|
#ifndef PCHAR
|
|
#define PCHAR char*
|
|
#endif
|
|
|
|
inline
|
|
uint32
|
|
strlen(char * str)
|
|
{
|
|
uint32 length = 0;
|
|
while (*str++) length += 1;
|
|
return length;
|
|
}
|
|
|
|
|
|
extern "C"
|
|
PVOID
|
|
_ReturnAddress(
|
|
void
|
|
);
|
|
|
|
char * ConvertToChars(char * dst, bartok_char *src, int32 length);
|
|
|
|
// Memory zone management
|
|
|
|
#define EV_MAXIMUM_ZONE_SIZE ((uint16)0xff80)
|
|
#define EV_DEFAULT_ZONE_BUFFER_RATIO 10
|
|
#define EV_ZONE_ALIGNMENT 0x10
|
|
|
|
typedef struct _ZONE_READY_LIST {
|
|
|
|
union {
|
|
|
|
struct {
|
|
|
|
uint16 ReadyList;
|
|
uint16 Count;
|
|
};
|
|
|
|
volatile INT32 AtomicValue32;
|
|
};
|
|
|
|
} ZONE_READY_LIST, *PZONE_READY_LIST;
|
|
|
|
typedef struct _ZONE_ALLOCATION_POINTER {
|
|
|
|
union {
|
|
|
|
struct {
|
|
|
|
uint16 FreeOffset;
|
|
uint16 Count : 13;
|
|
uint16 Recycling : 1; // the entire zone is filled with blocks.
|
|
uint16 Filled : 1; // the entire zone is filled with blocks.
|
|
uint16 Committed : 1; // The last entry allocated has been committed
|
|
};
|
|
|
|
volatile INT32 AtomicValue32;
|
|
};
|
|
|
|
} ZONE_ALLOCATION_POINTER, *PZONE_ALLOCATION_POINTER;
|
|
|
|
// Declare the system event structures by including the common definition
|
|
|
|
// Type definitions for the structure generation macros
|
|
//
|
|
|
|
#define TYPE_UIntPtr UIntPtr
|
|
#define TYPE_uint8 uint8
|
|
#define TYPE_uint16 uint16
|
|
#define TYPE_uint32 uint32
|
|
#define TYPE_uint64 uint64
|
|
#define TYPE_PCHAR PCHAR
|
|
#define TYPE_BOOL bool
|
|
|
|
#define DECLARE_STRUCTURE_BEGIN(x,d) typedef struct _##x {
|
|
#define DECLARE_STRUCTURE_END(x) } ##x, *P##x;
|
|
#define DECLARE_FIELD(c,t,n) t n;
|
|
#define DECLARE_GENERIC_FIELD(s,t,sz,t1,n) t n;
|
|
#define DECLARE_SPECIAL_FIELD DECLARE_FIELD
|
|
#define DECLARE_EXTENDED_ARRAY_FIELD(s,t,n) uint16 n;
|
|
#define _CONSTANT_DEFINITIONS 1
|
|
#include "SystemEvents.inl"
|
|
#undef _CONSTANT_DEFINITIONS
|
|
|
|
// Declare the external types that are required by the kernel repository
|
|
|
|
#define _LOGGING_TO_REPOSITORY
|
|
|
|
#define DECLARE_STRUCTURE_BEGIN(x,d) extern UIntPtr Handle_##x;
|
|
|
|
#include "SystemEvents.inl"
|
|
|
|
#undef _LOGGING_TO_REPOSITORY
|
|
|
|
|
|
#ifdef BUFFER_VALIDATION
|
|
|
|
void SetEndOfBuffer(PMEMORY_ZONE Zone);
|
|
|
|
void CheckEndOfBuffer(PMEMORY_ZONE Zone);
|
|
|
|
#else
|
|
|
|
#define SetEndOfBuffer(x)
|
|
|
|
#define CheckEndOfBuffer(x)
|
|
|
|
#endif // BUFFER_VALIDATION
|
|
|
|
#define GetMemoryHeader(p,o) (PMEMORY_HEADER)((ULONG_PTR)(p) + (o))
|
|
#define GetEntryOffset(p,o) (uint32)((ULONG_PTR)(o) - (ULONG_PTR)(p))
|
|
PSOURCE_DESCRIPTOR GetSourceFromHandle(UIntPtr sourceHandle);
|
|
|
|
void DebugPrintEvent(UIntPtr eventHandle);
|
|
|
|
//
|
|
// Record layout (optional extensions)
|
|
//
|
|
|
|
#define RECORD_STACK_TRACES Class_Microsoft_Singularity_Eventing_EventSource_CAPTURE_STACK_TRACE
|
|
|
|
#define RECORD_LAYOUT_FLAGS (RECORD_STACK_TRACES)
|
|
|
|
// Stack TrackTraces
|
|
// Variable size array, first pointer represents the number of pointers in the array
|
|
|
|
#define RECORD_MAXSTACKSIZE 32
|
|
|
|
uint32
|
|
inline
|
|
GetRecordHeaderSize (
|
|
uint16 Flags,
|
|
uint16 StackSize
|
|
)
|
|
|
|
{
|
|
uint16 HeaderSize = sizeof(MEMORY_HEADER);
|
|
|
|
if (Flags & RECORD_STACK_TRACES) {
|
|
|
|
HeaderSize += StackSize;
|
|
}
|
|
|
|
return HeaderSize;
|
|
}
|
|
|
|
|
|
inline
|
|
void *
|
|
GetRecordInternalStructure (
|
|
PMEMORY_HEADER Record,
|
|
uint16 RecordFlag
|
|
)
|
|
{
|
|
if (Record->Flags & RecordFlag) {
|
|
|
|
uint16 HeaderSize;
|
|
|
|
if (RecordFlag & (RecordFlag - 1)) {
|
|
|
|
// A single bit at the time can be set to query the internal layout info.
|
|
// Return failure otherwise.
|
|
|
|
return NULL;
|
|
}
|
|
|
|
// The structures are allocated in order, as the flags bits decrease
|
|
// We can clear the flags
|
|
|
|
HeaderSize = GetRecordHeaderSize(Record->Flags & (~((RecordFlag << 1) - 1)), 0);
|
|
|
|
return (PVOID)((ULONG_PTR)Record + HeaderSize);
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
inline
|
|
void *
|
|
GetUserRecordStructure (
|
|
PMEMORY_HEADER Record
|
|
)
|
|
{
|
|
if (Record->Flags & RECORD_STACK_TRACES) {
|
|
|
|
ULONG_PTR * StackSize = (ULONG_PTR *)GetRecordInternalStructure(Record, RECORD_STACK_TRACES);
|
|
return (PVOID)((ULONG_PTR)Record + GetRecordHeaderSize(Record->Flags, (uint16)(*StackSize + 1) * sizeof(UIntPtr)));
|
|
|
|
} else {
|
|
|
|
return (PVOID)((ULONG_PTR)Record + GetRecordHeaderSize(Record->Flags, 0));
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
PMEMORY_ZONE
|
|
InitializeMemoryZone(void * Buffer, uint16 Size, UIntPtr storageHandle);
|
|
|
|
PMEMORY_HEADER
|
|
AllocateEventEntry(PMEMORY_ZONE Zone, uint16 size);
|
|
|
|
void
|
|
CommitEventEntry(PMEMORY_HEADER Entry);
|
|
|
|
bool
|
|
IsZoneCompleted(PMEMORY_ZONE Zone);
|
|
|
|
bool
|
|
RecycleZone(PMEMORY_ZONE Zone);
|
|
|
|
|
|
#define MEMORY_STORAGE_FLAGS_RECYCLE_MEMORY Struct_Microsoft_Singularity_Eventing_QualityOfService_RecyclableEvents
|
|
#define MEMORY_STORAGE_FLAGS_BREAK_ON_RECYCLE Struct_Microsoft_Singularity_Eventing_QualityOfService_OOM_BreakOnRecycle
|
|
#define MEMORY_STORAGE_FLAGS_ACTIVE_STORAGE Struct_Microsoft_Singularity_Eventing_QualityOfService_ActiveEvents
|
|
#define MEMORY_STORAGE_FLAGS_PERMANENT Struct_Microsoft_Singularity_Eventing_QualityOfService_PermanentEvents
|
|
|
|
// Just use the pointers for now in translation.
|
|
// More type checking and safety would have to be added
|
|
//
|
|
|
|
#define HANDLE_TO_STORAGE(x) ((PMEMORY_STORAGE)(x))
|
|
#define HANDLE_TO_HEADER(x) ((PMEMORY_HEADER)(x))
|
|
|
|
#define HANDLE_TO_TYPE(x) ((PEVENT_DESCRIPTOR) (HANDLE_TO_HEADER(x) + 1))
|
|
#define HANDLE_TO_SOURCE(x) ((PSOURCE_DESCRIPTOR)( HANDLE_TO_HEADER(x) + 1))
|
|
|
|
UIntPtr
|
|
RegisterNativeSource(char * sourceName, UIntPtr storageHandle, uint32 controlFlags);
|
|
|
|
char * GetExtendedString(UIntPtr EntryHandle, int index);
|
|
|
|
PMEMORY_HEADER
|
|
InternalLogRecord(UIntPtr StorageHandle,
|
|
uint32 Flags,
|
|
UIntPtr eventType,
|
|
PVOID Buffer,
|
|
uint32 size,
|
|
PVOID * ExtendedBuffer,
|
|
uint32 ExtendedSize );
|
|
|
|
PMEMORY_HEADER
|
|
InternalLogFixedRecord(UIntPtr StorageHandle,
|
|
uint32 Flags,
|
|
UIntPtr eventType,
|
|
PVOID Buffer,
|
|
uint32 size);
|
|
|
|
PMEMORY_HEADER
|
|
InternalLogVariableRecord(bool doCommit,
|
|
UIntPtr StorageHandle,
|
|
uint32 Flags,
|
|
UIntPtr eventType,
|
|
PVOID Buffer,
|
|
uint32 size,
|
|
int32 stringCount,
|
|
Struct_Microsoft_Singularity_Eventing_ArrayType * strings);
|
|
|
|
//
|
|
// Event fields type
|
|
//
|
|
|
|
|
|
#define EVENT_FIELD_TYPE_uint8 Class_Microsoft_Singularity_Eventing_DataType___uint8
|
|
#define EVENT_FIELD_TYPE_uint16 Class_Microsoft_Singularity_Eventing_DataType___uint16
|
|
#define EVENT_FIELD_TYPE_uint32 Class_Microsoft_Singularity_Eventing_DataType___uint32
|
|
#define EVENT_FIELD_TYPE_uint64 Class_Microsoft_Singularity_Eventing_DataType___uint64
|
|
#define EVENT_FIELD_TYPE_int8 Class_Microsoft_Singularity_Eventing_DataType___int8
|
|
#define EVENT_FIELD_TYPE_int16 Class_Microsoft_Singularity_Eventing_DataType___int16
|
|
#define EVENT_FIELD_TYPE_int32 Class_Microsoft_Singularity_Eventing_DataType___int32
|
|
#define EVENT_FIELD_TYPE_int64 Class_Microsoft_Singularity_Eventing_DataType___int64
|
|
|
|
#define EVENT_FIELD_TYPE_IntPtr Class_Microsoft_Singularity_Eventing_DataType___IntPtr
|
|
#define EVENT_FIELD_TYPE_UIntPtr Class_Microsoft_Singularity_Eventing_DataType___UIntPtr
|
|
|
|
#define EVENT_FIELD_TYPE_arrayType Class_Microsoft_Singularity_Eventing_DataType___arrayType
|
|
#define EVENT_FIELD_TYPE_string Class_Microsoft_Singularity_Eventing_DataType___string
|
|
#define EVENT_FIELD_TYPE_szChar Class_Microsoft_Singularity_Eventing_DataType___szChar
|
|
|
|
PMEMORY_HEADER
|
|
RegisterEventDescriptorImplementation(int stringType,
|
|
PVOID name,
|
|
uint16 nameLength,
|
|
PVOID description,
|
|
uint16 descriptionLength);
|
|
PMEMORY_HEADER
|
|
RegisterFieldDescriptorImplementation(int stringType,
|
|
PMEMORY_HEADER Descriptor,
|
|
PVOID name,
|
|
uint32 nameLength,
|
|
uint16 offset,
|
|
uint16 type );
|
|
|
|
PMEMORY_HEADER
|
|
RegisterGenericFieldDescriptorImplementation( int stringType,
|
|
PMEMORY_HEADER event,
|
|
PVOID name,
|
|
uint32 nameLength,
|
|
uint16 offset,
|
|
uint16 size,
|
|
UIntPtr typeFieldDescriptor);
|
|
|
|
PMEMORY_HEADER
|
|
RegisterEnumDescriptorImplementation(int stringType,
|
|
PVOID name,
|
|
uint16 nameLength,
|
|
uint16 type);
|
|
|
|
PMEMORY_HEADER
|
|
RegisterValueDescriptorImplementation(int stringType,
|
|
PMEMORY_HEADER descriptor,
|
|
PVOID name,
|
|
uint32 nameLength,
|
|
uint64 value,
|
|
uint8 flagLetter);
|
|
|
|
void
|
|
InitializeRegistrationSystem(void * buffer, size_t size);
|
|
|
|
void
|
|
RegisterNativeTypes();
|
|
|
|
extern SOURCE_CONTROLLER SourceController;
|
|
|
|
void
|
|
RegisterExternalController(PEXTERNAL_CONTROLLER_DESCRIPTOR controller);
|
|
|
|
void
|
|
UnRegisterExternalController(PEXTERNAL_CONTROLLER_DESCRIPTOR controller);
|
|
|
|
PMEMORY_STORAGE
|
|
inline
|
|
GetLocalRepository()
|
|
{
|
|
return SourceController.SourceRepository;
|
|
}
|
|
|
|
UIntPtr
|
|
inline
|
|
GetLocalRepositoryHandle()
|
|
{
|
|
return (UIntPtr)GetLocalRepository();
|
|
}
|
|
|
|
void
|
|
RegisterRepositoryStorage(PMEMORY_STORAGE storage);
|
|
|
|
bool
|
|
RegisterStorage(PMEMORY_STORAGE storage);
|
|
|
|
void
|
|
UnRegisterStorage(PMEMORY_STORAGE storage);
|
|
|
|
uint32
|
|
MemoryStorageGetNextGeneration(PMEMORY_STORAGE Storage);
|
|
|
|
PQUERY_VIEW AllocateQueryView( );
|
|
|
|
PMEMORY_HEADER
|
|
GetFirstEntry(PMEMORY_ZONE Zone, bool forward);
|
|
|
|
PMEMORY_HEADER
|
|
GetNextEntry(PQUERY_VIEW view);
|
|
|
|
void
|
|
EnumerateStorageEntries(UIntPtr storageHandle, bool forward);
|
|
|
|
void
|
|
UnRegisterQueryView(PQUERY_VIEW queryView);
|
|
|
|
//
|
|
// Specific logging prototypes for usage in the native size
|
|
//
|
|
|
|
extern UIntPtr TracingStorageHandle;
|
|
|
|
void LogExceptionInfo(UIntPtr throwFrom, UIntPtr handler, Class_System_String * exceptionName);
|
|
|
|
|
|
UIntPtr
|
|
OpenLoggingStorage(UIntPtr sourceHandle, uint32 * flags);
|
|
|
|
//
|
|
///////////////////////////////////////////////////////////////// End of File.
|