log.c

开放源码的编译器open watcom 1.6.0版的源代码

    rcLogPrint( STR_WIN_FLAGS_ARE );
    if( WindowsFlags & WF_ENHANCED ) {
        rcLogPrint( STR_ENHANCED_MODE );
    }
    if( WindowsFlags & WF_STANDARD ) {
        rcLogPrint( STR_STANDARD_MODE );
    }
    if( WindowsFlags & WF_CPU286 ) {
        rcLogPrint( STR_PROCESSOR_286 );
    }
    if( WindowsFlags & WF_CPU386 ) {
        rcLogPrint( STR_PROCESSOR_386 );
    }
    if( WindowsFlags & WF_CPU486 ) {
        rcLogPrint( STR_PROCESSOR_486 );
    }
    if( WindowsFlags & WF_80x87 ) {
        rcLogPrint( STR_MATH_COPROC_PRESENT );
    }
    rcLogPrint( STR_N_TASKS_EXECUTING, GetNumTasks() );

} /* logSysInfo */

/*
 * logMyTask - record task info
 */
static void logMyTask( void )
{
    char        str[128];
    syminfo     si;
    ADDRESS     addr;

    logPrint( "\n" );
    rcLogPrint( STR_OFFENDING_TASK_LINE );
    rcLogPrint( STR_OFFENDING_TASK_INFO );
    rcLogPrint( STR_OFFENDING_TASK_LINE );
    rcLogPrint( STR_FAULT_OCCURRED_IN, IntData.InterruptNumber,
                DTTaskEntry.szModule, IntData.CS, (WORD) IntData.EIP );
    GetFaultString( IntData.InterruptNumber, str );
    rcLogPrint( STR_FAULT_TYPE_WAS, str );
    rcLogPrint( STR_EXECUTABLE_IS, DTModuleEntry.szExePath );
    rcLogPrint( STR_REGISTER_CONTENTS );
    if( WindowsFlags & WF_CPU386 || WindowsFlags & WF_CPU486 ) {
        logPrint( "    eax=%08lx  ebx=%08lx  ecx=%08lx  edx=%08lx\n",
                IntData.EAX, IntData.EBX, IntData.ECX,
                IntData.EDX );
        logPrint( "    edi=%08lx  esi=%08lx  ebp=%08lx  esp=%08lx\n",
                IntData.EDI,
                IntData.ESI, IntData.EBP, IntData.ESP );
        logPrint(
        "    AF=%d   CF=%d   DF=%d   IF=%d   OF=%d   PF=%d   SF=%d   ZF=%d\n\n",
                ( IntData.EFlags & FLAG_A_MASK ) ? 1 : 0,
                ( IntData.EFlags & FLAG_C_MASK ) ? 1 : 0,
                ( IntData.EFlags & FLAG_D_MASK ) ? 1 : 0,
                ( IntData.EFlags & FLAG_I_MASK ) ? 1 : 0,
                ( IntData.EFlags & FLAG_O_MASK ) ? 1 : 0,
                ( IntData.EFlags & FLAG_P_MASK ) ? 1 : 0,
                ( IntData.EFlags & FLAG_S_MASK ) ? 1 : 0,
                ( IntData.EFlags & FLAG_Z_MASK ) ? 1 : 0 );
        rcLogPrint( STR_SEGMENT_REGISTERS );
        rcLogPrint( STR_SELECTOR_HEADINGS );
        formatSel( "cs", IntData.CS );
        formatSel( "ds", IntData.DS );
        formatSel( "es", IntData.ES );
        formatSel( "fs", IntData.FS );
        formatSel( "gs", IntData.GS );
        formatSel( "ss", IntData.SS );
    } else {
    }
    addr.seg = IntData.CS;
    addr.offset = IntData.EIP;
    if( FindWatSymbol( &addr, &si, TRUE ) == FOUND ) {
        rcLogPrint( STR_SOURCE_INFO );
        rcLogPrint( STR_FILE_IS, si.filename );
        if( si.linenum > 0 ) {
            rcLogPrint( STR_FAULT_ON_LINE, si.linenum );
        }
    }

    rcLogPrint( STR_DISASSEMBLY );
    logDisasm( IntData.CS, IntData.EIP );

} /* logMyTask */


/*
 * LogSSBP - log memory at SS:BP
 */
#define BYTES   16
static void LogSSBP( WORD ss, WORD bp )
{
    WORD        start,end;
    WORD        i,num,j;
    char        buff[BYTES];

    start = (bp/(BYTES)*BYTES);
    if( start < BYTES ) {
        start = 0;
    } else {
        start -= BYTES;
    }
    end = start+BYTES*3;
    for( i=start;i<end; i+= BYTES ) {
        logPrint( "SS:%04x = ", i );
        num = ReadMem( ss, i, buff, BYTES );
        for( j=0;j<BYTES;j++ ) {
            if( j >= num ) {
                rcLogPrint( STR_QUEST_MARKS );
            } else {
                logPrint( "%02x ", (WORD) buff[j] );
            }
        }
        logPrint( "\n" );
    }

} /* LogSSBP */

/*
 * logStackTrace - record stack trace info
 */
static void logStackTrace( void )
{
    STACKTRACEENTRY     ste;
    MODULEENTRY         me;
    int                 frame=0;
    syminfo             si;
    ADDRESS             addr;

    if( LogInfo.flags[LOGFL_STACK_TRACE] == '0' ) {
        return;
    }
    ste.hTask = DeadTask;
    if( !MyStackTraceCSIPFirst( &ste, IntData.SS, IntData.CS,
                        (WORD) IntData.EIP, (WORD) IntData.EBP ) ) return;
    logPrint( "\n" );
    rcLogPrint( STR_STACK_TRACE_ULINE );
    rcLogPrint( STR_STACK_TRACE_HEADING );
    rcLogPrint( STR_STACK_TRACE_ULINE );
    while( 1 ) {
        MyModuleFindHandle( &me, ste.hModule );
        rcLogPrint( STR_STACK_FRAME, frame, me.szModule, ste.hModule );
        logPrint( "CS:IP=%04x:%04x, SS:BP=%04x:%04x\n", ste.wCS, ste.wIP,
                ste.wSS, ste.wBP );
        rcLogPrint( STR_CS_MAPS_TO_SEG_NUM, ste.wSegment );
        LogSSBP( ste.wSS, ste.wBP );

        addr.seg = ste.wCS;
        addr.offset = ste.wIP;
        if( FindWatSymbol( &addr, &si, TRUE ) == FOUND ) {
            rcLogPrint( STR_SOURCE_INFO );
            rcLogPrint( STR_FILE_IS, si.filename );
            if( si.linenum > 0 ) {
                rcLogPrint( STR_CSIP_REFERS_TO_LINE, si.linenum );
            }
        }
        rcLogPrint( STR_DISASSEMBLY );
        logDisasm( ste.wCS, ste.wIP );
        if( !MyStackTraceNext( &ste ) ) {
            break;
        }
        if( !IsValidSelector( ste.wCS )) {
            break;
        }
        logPrint( "\n" );
        frame++;
    }

} /* logStackTrace */

/*
 * logCurrentTasks - record current tasks in system
 */
static void logCurrentTasks( void )
{
    MODULEENTRY         me;
    TASKENTRY           te;
    struct stat         st;

    if( LogInfo.flags[LOGFL_TASKS] == '0' ) {
        return;
    }

    if( !MyTaskFirst( &te ) ) {
        return;
    }

    logPrint( "\n" );
    rcLogPrint( STR_SYS_TASKS_ULINE );
    rcLogPrint( STR_SYSTEM_TASKS );
    rcLogPrint( STR_SYS_TASKS_ULINE );

    do {
        MyModuleFindHandle( &me, te.hModule );
        rcLogPrint( STR_TASK, te.szModule );
        rcLogPrint( STR_ID_PARENT_ID, te.hTask, te.hTaskParent );
        rcLogPrint( STR_MOD_HDL_USAGE_CNT, te.hModule, me.wcUsage );
        rcLogPrint( STR_SSSP_STACKTOP_BOTTOM,
                    te.wSS, te.wSP, te.wStackTop, te.wStackBottom );
        stat( me.szExePath, &st );
        rcLogPrint( STR_EXECUTABLE_EQ, me.szExePath );
        rcLogPrint( STR_SIZE_TIME, st.st_size, ctime( &st.st_atime ) );
    } while( MyTaskNext( &te ) );

} /* logCurrentTasks */

static BOOL     hasTitle;

/*
 * formatModuleSeg - format a segment for a module entry
 */
void formatModuleSeg( int index, WORD sel )
{
    if( !hasTitle ) {
        hasTitle = TRUE;
        rcLogPrint( STR_SEGMENTS_TITLE );
    }
    logPrint( "              %3d  ", index );
    formatSel( NULL, sel );

} /* formatModuleSeg */


/*
 * logModuleSegments - record all segments allocated to a module
 */
static void logModuleSegments( MODULEENTRY *me )
{
    int         i;
    GLOBALENTRY ge;

    hasTitle = FALSE;
    if( CheckIsModuleWin32App( me->hModule, &Win32DS, &Win32CS, &Win32InitialEIP ) ) {
        formatModuleSeg( 1, Win32CS );
        formatModuleSeg( 2, Win32DS );
    } else {
        for( i=0;i<512;i++ ) {
            if( MyGlobalEntryModule( &ge, me->hModule, i ) ) {
                formatModuleSeg( i, (WORD)ge.hBlock );
            }
        }
    }

} /* logModuleSegments */

/*
 * logModules - record current modules in system
 */
static void logModules( void )
{
    MODULEENTRY         me;
    struct stat         st;

    if( LogInfo.flags[LOGFL_MODULES] == '0' ) {
        return;
    }
    logPrint( "\n" );
    rcLogPrint( STR_SYS_MODULES_ULINE );
    rcLogPrint( STR_SYSTEM_MODULES );
    rcLogPrint( STR_SYS_MODULES_ULINE );

    me.dwSize = sizeof( MODULEENTRY );
    if( !ModuleFirst( &me ) ) {
        return;
    }
    do {
        rcLogPrint( STR_MODULE, me.szModule );
        rcLogPrint( STR_MOD_HDL_USAGE_CNT, me.hModule, me.wcUsage );
        stat( me.szExePath, &st );
        rcLogPrint( STR_EXECUTABLE_EQ, me.szExePath );
        rcLogPrint( STR_SIZE_TIME, st.st_size, ctime( &st.st_atime ) );
        me.dwSize = sizeof( MODULEENTRY );
        if( LogInfo.flags[LOGFL_MOD_SEGMENTS] == '1' ) {
            logModuleSegments( &me );
        }
    } while( ModuleNext( &me ) );

} /* logModules */

/*
 * logMemory - record current memory state
 */
static void logMemory( void )
{
    MEMMANINFO  mmi;

    if( LogInfo.flags[LOGFL_MEM] == '0' ) {
        return;
    }
    logPrint( "\n" );
    rcLogPrint( STR_MEM_MAN_ULINE );
    rcLogPrint( STR_MEM_MAN_INFO );
    rcLogPrint( STR_MEM_MAN_ULINE );

    mmi.dwSize = sizeof( MEMMANINFO );
    MemManInfo( &mmi );
    rcLogPrint( STR_TOT_LIN_SPACE, mmi.dwTotalLinearSpace*mmi.wPageSize,
                mmi.dwTotalLinearSpace*mmi.wPageSize/1024L );
    rcLogPrint( STR_TOTAL_PAGES, mmi.dwTotalPages );
    rcLogPrint( STR_SWAP_FILE_PAGES, mmi.dwSwapFilePages );
    rcLogPrint( STR_PAGE_SIZE, mmi.wPageSize, mmi.wPageSize/1024 );
    rcLogPrint( STR_FREE_LIN_SPACE, mmi.dwFreeLinearSpace*mmi.wPageSize,
        mmi.dwFreeLinearSpace*mmi.wPageSize/1024L );
    rcLogPrint( STR_LARGEST_FREE_BLOCK, mmi.dwLargestFreeBlock,
        mmi.dwLargestFreeBlock/1024L );
    rcLogPrint( STR_FREE_PAGES, mmi.dwFreePages );
    rcLogPrint( STR_MAX_PAGES_AVAILABLE, mmi.dwMaxPagesAvailable );
    rcLogPrint( STR_MAX_PAGES_LOCKABLE, mmi.dwMaxPagesLockable );
    rcLogPrint( STR_TOT_UNLOCKED_PAGES, mmi.dwTotalUnlockedPages );

} /* logMemory */

/*
 * logGDI - record current GDI state
 */
static void logGDI( void )
{
    SYSHEAPINFO hi;
    GLOBALENTRY ge;

    if( LogInfo.flags[LOGFL_GDI] == '0' ) {
        return;
    }
    hi.dwSize = sizeof( SYSHEAPINFO );
    logPrint( "\n" );
    rcLogPrint( STR_GDI_HEAP_ULINE );
    rcLogPrint( STR_GDI_HEAP_INFO );
    rcLogPrint( STR_GDI_HEAP_ULINE );
    if( SystemHeapInfo( &hi ) ) {
        MyGlobalEntryHandle( &ge, hi.hGDISegment );
        rcLogPrint( STR_HEAP_SEGMENT, hi.hGDISegment );
        rcLogPrint( STR_HEAP_SIZE, ge.dwBlockSize );
        rcLogPrint( STR_PERCENT_FREE, hi.wGDIFreePercent );
    }

} /* logGDI */

/*
 * logUSER - record current USER state
 */
static void logUSER( void )
{
    SYSHEAPINFO hi;
    GLOBALENTRY ge;

    if( LogInfo.flags[LOGFL_USER] == '0' ) {
        return;
    }
    hi.dwSize = sizeof( SYSHEAPINFO );
    logPrint( "\n" );
    rcLogPrint( STR_USER_HEAP_ULINE );
    rcLogPrint( STR_USER_HEAP_INFO );
    rcLogPrint( STR_USER_HEAP_ULINE );
    if( SystemHeapInfo( &hi ) ) {
        MyGlobalEntryHandle( &ge, hi.hUserSegment );
        rcLogPrint( STR_HEAP_SEGMENT, hi.hUserSegment );
        rcLogPrint( STR_HEAP_SIZE, ge.dwBlockSize );
        rcLogPrint( STR_PERCENT_FREE, hi.wUserFreePercent );
    }

} /* logUSER */

/*
 * EraseLog
 */
void EraseLog( void ) {

    char        buf[500];
    int         ret;

    RCsprintf( buf, STR_ERASE_LOG, LogInfo.filename );
    ret = MessageBox( NULL, buf, AppName, MB_YESNO | MB_ICONQUESTION );
    if( ret == IDYES ) {
        remove( LogInfo.filename );
    }
}

char underLine[] = "===========================================================================";

/*
 * MakeLog - make the log file
 */
void MakeLog( BOOL wasfault )
{
    char        *str;

    if( !startLogFile() ) {
        str = GetRCString( STR_LOG_OPEN_FAILED );
        MessageBox( NULL, LogInfo.filename, str, MB_OK | MB_SYSTEMMODAL );
        return;
    }
    MinAddrSpaces = 20;
    logPrint( "%s\n", underLine );
    logSysInfo( wasfault );
    if( LogInfo.flags[LOGFL_NOTE] == '1' ) {
        notesAdded = FALSE;
        AnotateLog( NULL, Instance, logComment );
    }
    if( wasfault ) {
        logMyTask();
        logStackTrace();
    }
    logCurrentTasks();
    logModules();
    logGDI();
    logUSER();
    logMemory();
    logPrint( "%s\n", underLine );
    finishLogFile();

} /* MakeLog */