HyperLogCallback.h File Reference

Header for VMM callback interface routines. More...

Go to the source code of this file.

Functions
BOOLEAN	LogCallbackPrepareAndSendMessageToQueue (UINT32 OperationCode, BOOLEAN IsImmediateMessage, BOOLEAN ShowCurrentSystemTime, BOOLEAN Priority, const CHAR *Fmt,...)
	Prepare a printf-style message mapping and send string messages and tracing for logging and monitoring.
BOOLEAN	LogCallbackSendMessageToQueue (UINT32 OperationCode, BOOLEAN IsImmediateMessage, CHAR *LogMessage, UINT32 BufferLen, BOOLEAN Priority)
	Send string messages and tracing for logging and monitoring.
BOOLEAN	LogCallbackCheckIfBufferIsFull (BOOLEAN Priority)
	Checks whether the priority or regular buffer is full or not.
BOOLEAN	LogCallbackSendBuffer (_In_ UINT32 OperationCode, _In_reads_bytes_(BufferLength) PVOID Buffer, _In_ UINT32 BufferLength, _In_ BOOLEAN Priority)
	routines callback for sending buffer

Detailed Description

Header for VMM callback interface routines.

Author

Sina Karvandi (sina@.nosp@m.hype.nosp@m.rdbg..nosp@m.org)

Version

0.2

Date

2023-01-29

Copyright

This project is released under the GNU Public License v3.

Function Documentation

LogCallbackCheckIfBufferIsFull()

BOOLEAN LogCallbackCheckIfBufferIsFull

(

BOOLEAN

Priority

)

Checks whether the priority or regular buffer is full or not.

Parameters

Priority

Whether the buffer has priority

Returns

BOOLEAN Returns true if the buffer is full, otherwise, return false

{
    UINT32  Index;
    BOOLEAN IsVmxRoot;
    UINT32  CurrentIndexToWrite         = NULL_ZERO;
    UINT32  CurrentIndexToWritePriority = NULL_ZERO;
 
    //
    // Check that if we're in vmx root-mode
    //
    IsVmxRoot = LogCheckVmxOperation();
 
    if (IsVmxRoot)
    {
        //
        // Set the index
        //
        Index = 1;
    }
    else
    {
        //
        // Set the index
        //
        Index = 0;
    }
 
    //
    // check if the buffer is filled to it's maximum index or not
    //
    if (Priority)
    {
        CurrentIndexToWritePriority = g_MessageBufferInformation[Index].CurrentIndexToWritePriority;
 
        if (g_MessageBufferInformation[Index].CurrentIndexToWritePriority > MaximumPacketsCapacityPriority - 1)
        {
            //
            // start from the beginning
            //
            CurrentIndexToWritePriority = 0;
        }
    }
    else
    {
        CurrentIndexToWrite = g_MessageBufferInformation[Index].CurrentIndexToWrite;
 
        if (g_MessageBufferInformation[Index].CurrentIndexToWrite > MaximumPacketsCapacity - 1)
        {
            //
            // start from the beginning
            //
            CurrentIndexToWrite = 0;
        }
    }
 
    //
    // Compute the start of the buffer header
    //
    BUFFER_HEADER * Header;
 
    if (Priority)
    {
        Header = (BUFFER_HEADER *)((UINT64)g_MessageBufferInformation[Index].BufferStartAddressPriority + (CurrentIndexToWritePriority * (PacketChunkSize + sizeof(BUFFER_HEADER))));
    }
    else
    {
        Header = (BUFFER_HEADER *)((UINT64)g_MessageBufferInformation[Index].BufferStartAddress + (CurrentIndexToWrite * (PacketChunkSize + sizeof(BUFFER_HEADER))));
    }
 
    //
    // If the next item is valid, then it means the buffer is full and the next
    // item will replace the previous (not served items)
    //
    return Header->Valid;
}

LogCallbackPrepareAndSendMessageToQueue()

BOOLEAN LogCallbackPrepareAndSendMessageToQueue	(	UINT32	OperationCode,
		BOOLEAN	IsImmediateMessage,
		BOOLEAN	ShowCurrentSystemTime,
		BOOLEAN	Priority,
		const CHAR *	Fmt,
			... )

Prepare a printf-style message mapping and send string messages and tracing for logging and monitoring.

Parameters

OperationCode	Optional operation code
IsImmediateMessage	Should be sent immediately
ShowCurrentSystemTime	Show system-time
Priority	Whether the message has priority
Fmt	Message format-string
...

Returns

BOOLEAN if it was successful then return TRUE, otherwise returns FALSE

{
    va_list ArgList;
    BOOLEAN Result;
 
    va_start(ArgList, Fmt);
 
    Result = LogCallbackPrepareAndSendMessageToQueueWrapper(OperationCode,
                                                            IsImmediateMessage,
                                                            ShowCurrentSystemTime,
                                                            Priority,
                                                            Fmt,
                                                            ArgList);
 
    va_end(ArgList);
 
    return Result;
}

LogCallbackSendBuffer()

BOOLEAN LogCallbackSendBuffer	(	_In_ UINT32	OperationCode,
		_In_reads_bytes_(BufferLength) PVOID	Buffer,
		_In_ UINT32	BufferLength,
		_In_ BOOLEAN	Priority )

routines callback for sending buffer

Parameters

OperationCode
Buffer
BufferLength
Priority

Returns

BOOLEAN

{
    if (g_Callbacks.LogCallbackSendBuffer == NULL)
    {
        //
        // Ignore sending buffer
        //
        return FALSE;
    }
 
    return g_Callbacks.LogCallbackSendBuffer(OperationCode,
                                             Buffer,
                                             BufferLength,
                                             Priority);
}

LogCallbackSendMessageToQueue()

BOOLEAN LogCallbackSendMessageToQueue	(	UINT32	OperationCode,
		BOOLEAN	IsImmediateMessage,
		CHAR *	LogMessage,
		UINT32	BufferLen,
		BOOLEAN	Priority )

Send string messages and tracing for logging and monitoring.

Parameters

OperationCode	Optional operation code
IsImmediateMessage	Should be sent immediately
LogMessage	Link of message buffer
BufferLen	Length of buffer
Priority	Whether the buffer has priority

Returns

BOOLEAN if it was successful then return TRUE, otherwise returns FALSE

{
    BOOLEAN Result;
    UINT32  Index;
    BOOLEAN IsVmxRootMode;
    KIRQL   OldIRQL = NULL_ZERO;
 
    //
    // Set Vmx State
    //
    IsVmxRootMode = LogCheckVmxOperation();
 
#if UseWPPTracing
 
    if (OperationCode == OPERATION_LOG_INFO_MESSAGE)
    {
        HypervisorTraceLevelMessage(
            TRACE_LEVEL_INFORMATION, // ETW Level defined in evntrace.h
            HVFS_LOG_INFO,
            "%s", // Flag defined in WPP_CONTROL_GUIDS
            LogMessage);
    }
    else if (OperationCode == OPERATION_LOG_WARNING_MESSAGE)
    {
        HypervisorTraceLevelMessage(
            TRACE_LEVEL_WARNING, // ETW Level defined in evntrace.h
            HVFS_LOG_WARNING,
            "%s", // Flag defined in WPP_CONTROL_GUIDS
            LogMessage);
    }
    else if (OperationCode == OPERATION_LOG_ERROR_MESSAGE)
    {
        HypervisorTraceLevelMessage(
            TRACE_LEVEL_ERROR, // ETW Level defined in evntrace.h
            HVFS_LOG_ERROR,
            "%s", // Flag defined in WPP_CONTROL_GUIDS
            LogMessage);
    }
    else
    {
        HypervisorTraceLevelMessage(
            TRACE_LEVEL_NONE, // ETW Level defined in evntrace.h
            HVFS_LOG,
            "%s", // Flag defined in WPP_CONTROL_GUIDS
            LogMessage);
    }
 
#else
    if (IsImmediateMessage)
    {
        return LogCallbackSendBuffer(OperationCode, LogMessage, BufferLen, Priority);
    }
    else
    {
        //
        // Check if we're in Vmx-root, if it is then we use our customized HIGH_IRQL Spinlock,
        // if not we use the windows spinlock
        //
        if (IsVmxRootMode)
        {
            //
            // Set the index
            //
            Index = 1;
            SpinlockLock(&g_VmxRootLoggingLockForNonImmBuffers);
        }
        else
        {
            //
            // Set the index
            //
            Index = 0;
 
            //
            // Acquire the lock
            //
            PlatformSpinlockAcquire(&g_MessageBufferInformation[Index].BufferLockForNonImmMessage, &OldIRQL);
        }
        //
        // Set the result to True
        //
        Result = TRUE;
 
        //
        // If log message WrittenSize is above the buffer then we have to send the previous buffer
        //
        if ((g_MessageBufferInformation[Index].CurrentLengthOfNonImmBuffer + BufferLen) > PacketChunkSize - 1 && g_MessageBufferInformation[Index].CurrentLengthOfNonImmBuffer != 0)
        {
            //
            // Send the previous buffer (non-immediate message),
            // accumulated messages don't have priority
            //
            Result = LogCallbackSendBuffer(OPERATION_LOG_NON_IMMEDIATE_MESSAGE,
                                           (PVOID)g_MessageBufferInformation[Index].BufferForMultipleNonImmediateMessage,
                                           g_MessageBufferInformation[Index].CurrentLengthOfNonImmBuffer,
                                           FALSE);
 
            //
            // Free the immediate buffer
            //
            g_MessageBufferInformation[Index].CurrentLengthOfNonImmBuffer = 0;
            PlatformZeroMemory((PVOID)g_MessageBufferInformation[Index].BufferForMultipleNonImmediateMessage, PacketChunkSize);
        }
 
        //
        // We have to save the message
        //
        PlatformWriteMemory((PVOID)(g_MessageBufferInformation[Index].BufferForMultipleNonImmediateMessage +
                                    g_MessageBufferInformation[Index].CurrentLengthOfNonImmBuffer),
                            LogMessage,
                            BufferLen);
 
        //
        // add the length
        //
        g_MessageBufferInformation[Index].CurrentLengthOfNonImmBuffer += BufferLen;
 
        // Check if we're in Vmx-root, if it is then we use our customized HIGH_IRQL Spinlock,
        // if not we use the windows spinlock
        //
        if (IsVmxRootMode)
        {
            SpinlockUnlock(&g_VmxRootLoggingLockForNonImmBuffers);
        }
        else
        {
            //
            // Release the lock
            //
            PlatformSpinlockRelease(&g_MessageBufferInformation[Index].BufferLockForNonImmMessage, OldIRQL);
        }
 
        return Result;
    }
#endif
}