AssertTracer.cpp

/*==============================================================================
Copyright(c) 2017 Intel Corporation

Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files(the "Software"),
to deal in the Software without restriction, including without limitation
the rights to use, copy, modify, merge, publish, distribute, sublicense,
and / or sell copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
OTHER DEALINGS IN THE SOFTWARE.
============================================================================*/
/*

File Name:  AssertTracer.cpp

Abstract:
    These functions enables reporting asserts to system log in the debug
    driver build.

Notes:

\*****************************************************************************/

#if defined( _WIN32 ) && (defined( _DEBUG ) || defined( _RELEASE_INTERNAL ))
#include "AssertTracer.h"
#ifndef NOMINMAX
#define NOMINMAX
#endif
#include <windows.h>

// Windows.h defines MemoryFence as _mm_mfence, but this conflicts with llvm::sys::MemoryFence
#undef MemoryFence
#include <stdio.h>
#include <stdlib.h>

#if defined( __GMM_KMD__ ) || defined( STATIC_DRIVER_MODEL )
#include"BufferedDbg.h"
#include "igdKrnlEtwMacros.h"
#endif //__GMM_KMD__ || STATIC_DRIVER_MODEL

#if _DEBUG
/*****************************************************************************\

Function:
    ReportAsserts

Description:
    Sends message to the system log.

Input:
    const char *expr -
        The expression passed to function.
    const char *file -
        The name of the file that is the origin of the expression.
    const char *func -
        The function from which call to this function was made.
    const unsigned long line -
        The line number from file, which caused this function call.
    const char *msg -
        Message passed to the system log.
Output:
    void - None.

\*****************************************************************************/
void __stdcall ReportAssert(
    const char              *expr,
    const char              *file,
    const char              *func,
    const unsigned long      line,
    const char              *msg )
{
#if !defined( __GMM_KMD__ ) && !defined( STATIC_DRIVER_MODEL )//We are in UMD, use the UMD implementation

#if 0

    HANDLE hEventLog = RegisterEventSourceA( NULL, "GFX Driver AssertTracer" );
    char *wideMessage;
    if ( hEventLog != NULL )
    {
        // Calculate length with hard coded max unsigned long length plus some safe space.
        size_t length = strlen( expr ) + strlen( file ) + strlen( func ) + strlen( msg ) + 15;

        // Checks against maximum string size for ReportEvent lpStrings parameter.
        // Cuts string to the limit size.
        uint32_t maxSizeReached = 0;
        if ( length > 31839 )
        {
            length = 31839;
            maxSizeReached = 1;
        }

        wideMessage = ( char * ) malloc( sizeof( char ) * length );
        if( wideMessage != NULL )
        {
            // snprintf spec: "The resulting character string will be terminated with a null character"
            _snprintf_s( wideMessage, length, length / sizeof( char ), "%s:%lu\n%s\n%s\n%s", file, line, expr, func, msg);

            ReportEventA( hEventLog, EVENTLOG_INFORMATION_TYPE, 0, 0, NULL, 1, 0, ( LPCSTR* ) &wideMessage, NULL );
            free( wideMessage );
        }

        DeregisterEventSource( hEventLog );
    }

#endif //!define( WINDOWS_MOBILE )

    // Windows Mobile has no implementation. Reference the parameters to remove the unreference param warnings.
    (void)expr;
    (void)file;
    (void)func;
    (void)line;
    (void)msg;

#else //We are in KMD, use the KMD implementation
    BufDbgPrint("ASSERT_TRACE: %s::%s:%i : %s : %s\n", file, func, line, expr, msg);
#endif //!defined( __GMM_KMD__ ) && !defined( STATIC_DRIVER_MODEL )
}
#endif

/*****************************************************************************\

Function:
    ReportAssertsETW

Description:
    Sends message to the system log.

Input:
    const unsigned long ComponentMask
        Contains the component id for which raised assert (KMD, MINIPORT..)
    const char *expr -
        The expression passed to function.
    const char *file -
        The name of the file that is the origin of the expression.
    const char *func -
        The function from which call to this function was made.
    const unsigned long line -
        The line number from file, which caused this function call.
    const char *msg -
        Message passed to the system log.
Output:
    void - None.

\*****************************************************************************/

void __stdcall ReportAssertETW( const unsigned short     compId,
                                const unsigned long      compMsk,
                                const char              *expr,
                                const char              *file,
                                const char              *func,
                                const unsigned long     line,
                                const char              *msg)
{
#if !defined( __GMM_KMD__ ) && !defined( STATIC_DRIVER_MODEL ) //We are in UMD, use the UMD implementation
    // TODO: Add UMD code for ETW here.
    // Reference the parameters to remove the unreference param warnings.
    (void)compId;
    (void)compMsk;
    (void)expr;
    (void)file;
    (void)func;
    (void)line;
    (void)msg;
#else //We are in KMD, use the KMD implementation
    // Log event if ETW session is active
    if (g_ulHDGraphics_SessionActive)
    {
        EtwAssertPrint(compId, compMsk, expr, file, func, line, msg);
    }
#endif
}

#elif defined( _RELEASE_INTERNAL ) && !defined( _WIN32 ) && !defined( __ANDROID__ )
#include <algorithm>
#include <syslog.h>
#include <execinfo.h>
#include <string>
#include <cxxabi.h>
#include <cstdlib>
#include <cstring>
#include <sstream>
#include <fstream>
#define CALL_STACK_REPORT_SIZE 50  // maximal limit of call stack to be reported in case of assertion
#define MAX_FUNCTION_NAME_LENGTH 100 // no worries it can be extended (relocated by driver if needed)
#define MAX_SYSLOG_ENTRY_LENGTH 1000 // Syslog protocol recommends minimum entry length 1KB (ubuntu rsyslog message limit is about 2K)
void LogAssertion( const char *function_name, const char *file_name, unsigned int line_number, const char *expr )
{
    std::string  stack;
    std::string  part1;
    std::string  part2;
    std::size_t  pos;
    void         *buffer[CALL_STACK_REPORT_SIZE];
    char         *function_name_buffer = NULL;
    int          nframes;        // numer of frames to be returned
    char         **strings;
    int          i;
    int          status;
    size_t       length;
    const size_t stringLength = 4096;
    std::string  oclAppCmdLine;

    nframes = backtrace( buffer, CALL_STACK_REPORT_SIZE );

    strings = backtrace_symbols( buffer, nframes );
    if( strings == NULL )
    {
        perror( "Getting backtrace symbols error:" );
        nframes = 0;
    }
    else
    {
        // Get Commandline of process (in that case OCL app)
        // from process info itself eg. /proc/self/cmdline

        oclAppCmdLine.reserve( stringLength );
        std::ifstream fileCmdline( "/proc/self/cmdline", std::ifstream::binary );
        if( fileCmdline.is_open() )
        {
            oclAppCmdLine = std::string( std::istreambuf_iterator< char >( fileCmdline ), std::istreambuf_iterator< char >() );
            if( oclAppCmdLine.size() > 0 )
            {
                // Trim last \0 character
                oclAppCmdLine.resize( oclAppCmdLine.size() - 1 );
                // Format of /proc/self/cmdline is that args are separated with '\0'
                // so for nicer printing we replace zeros with spaces (without terminating 0)
                std::replace( oclAppCmdLine.begin(), oclAppCmdLine.end(), '\0', ' ' );
            }
            else
            {
                fprintf( stderr, "Getting Commandline of OCL app error: Error reading /proc/self/cmdline\n" );
            }
        }
        else
        {
            fprintf( stderr, "Getting Commandline of OCL app error:" );
        }
    }

    // allocation by malloc is suggessted by documentation as abi function may do some relocation
    function_name_buffer = ( char * )malloc( MAX_FUNCTION_NAME_LENGTH );
    if( function_name_buffer == NULL )
    {
        // Not enough memory to get small allocation then do not print stack
        nframes = 0;
    }
    else
    {
        length = MAX_FUNCTION_NAME_LENGTH;
        memset( function_name_buffer, 0, length );
    }

    for( i = 0; i < nframes; ++i )
    {
        // Generate signature of given stack frame eg. #0 #1 etc...
        std::stringstream framePromptBuilder;
        framePromptBuilder << "#" << i << " ";
        const std::string &framePrompt = framePromptBuilder.str();
        // demangle name eg. split stack frame into two pieces
        part1 = strings[i];
        pos   = part1.find( "(" );
        if( pos != std::string::npos )
        {
            // For final level instead of binary print whole commandline
            // if were able to get one
            if( ( i == nframes - 1 ) && ( !oclAppCmdLine.empty() ) )
            {
                //..call stack's part1 contains "(" so we add it here manualy
                stack.append( ( oclAppCmdLine.insert( 0, "COMMANDLINE(" ) ).c_str() );
            }
            else
            {
                // part1 contains everything before section to be demangled
                part1 = part1.substr( 0, pos + 1 );
                stack.append(framePrompt);
                stack.append( part1 );
            }
            // part2 contains string to be demangled
            part2 = strings[i];
            part2 = part2.substr( pos + 1 );
            pos   = part2.find( "+" );
            // Final level may not have any function (static functions are not exposed)
            if( pos != std::string::npos )
            {
                part2                = part2.substr( 0, pos );
                function_name_buffer = abi::__cxa_demangle( part2.c_str(), function_name_buffer, &length, &status );
                // in case of error during demangling attach mangled name
                if( status != 0 )
                {
                    stack.append( part2 );
                }
                else
                {
                    stack.append( function_name_buffer );
                }
                stack.append( "())" );
                free( function_name_buffer );
                function_name_buffer = NULL;

            }
            else
            {
                // if there was no function then attach ")"
                stack.append( ")" );
            }
        }
        else
        {
            if( ( i == nframes - 1 ) && ( !oclAppCmdLine.empty() ) )
            {
                stack.append( ( oclAppCmdLine.insert( 0, "COMMANDLINE(" ) ).c_str() );
                stack.append( ")" );
            }
            else
            {
                stack.append(framePrompt);
                stack.append( strings[i] );
            }
        }
        stack.append( " " );
    }
    //Compose full message..
    std::string fullMsg = "File: ";
    std::string syslogEntry;
    fullMsg += file_name;
    fullMsg += " line: ";
    std::stringstream lineStr;
    lineStr << line_number;
    fullMsg += lineStr.str();
    fullMsg += " function: ";
    fullMsg += function_name;
    fullMsg += " expr: ";
    fullMsg += expr;
    fullMsg += " ";
    fullMsg += stack.c_str();

    // split it into chunks we can send
    openlog( "OpenCL", LOG_PID, LOG_USER );
    pos = 0;
    int numberOfChunks = ( fullMsg.length() / MAX_SYSLOG_ENTRY_LENGTH ) + 1;
    while( pos < fullMsg.length() )
    {
        syslogEntry = fullMsg.substr( pos, MAX_SYSLOG_ENTRY_LENGTH );
        // Add chunk ID / part number and send to syslog
        syslog( LOG_MAKEPRI( LOG_USER,
                             LOG_ERR ), "[%zd/%d]%s", ( pos / MAX_SYSLOG_ENTRY_LENGTH + 1 ), numberOfChunks,
                syslogEntry.c_str() );
        pos += MAX_SYSLOG_ENTRY_LENGTH;
    }
    closelog();

    // backtrace_symbols allocates memory in a malloc like way sop it should be freed
    free( strings );
    strings = NULL;
}
#endif //defined( _WIN32 ) && defined( _DEBUG )