log.c

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

    }

    GetRegStringCreate( regs, (mad_reg_set_data*)reg_set, PAGE_WIDTH, &reg_create, &num_regs, &num_columns );
    j = 0;
    for( i = 0; i < num_regs; i++ ) {
        logStrPrintf("%*s  ", -reg_create[j].length, reg_create[i].buffer );
        j++;
        if ( j == num_columns ){
            logStrPrintf( "\n" );
            j = 0;
        }
    }

    FreeRegStringCreate( reg_create, num_regs );
    return( WR_CONTINUE );
}
/*
 * logRegisters
 */
static void logRegisters( ExceptDlgInfo *info ) {
    logPrintf( STR_REGISTER_CONTENTS );
    MADRegSetWalk( MTK_ALL, logRegisterSet, info->regs );
}


static void logModules( DWORD pid, WORD indent ) {

    char        **modules;
    char        end[10];
    DWORD       cnt;
    DWORD       i;
    ProcNode    *pnode;
    ModuleNode  *mnode;
    char        *name;

    pnode = FindProcess( pid );
    if( pnode != NULL ) {
        mnode = GetFirstModule( pnode );
        while( mnode != NULL ) {
            if( mnode->size == -1 ) {
                strcpy( end, "????????" );
            } else {
                sprintf( end, "%08lX", mnode->base + mnode->size );
            }
            if( mnode->name == NULL ) {
                name = "???";
            } else {
                name = mnode->name;
            }
            logPrintf( STR_MODULE_WITH_ADDR,
                        indent, "", mnode->base, end, name );
            mnode = GetNextModule( mnode );
        }
    } else {
        modules = GetModuleList( pid, &cnt );
        if( modules == NULL ) {
            logPrintf( STR_MODULE_LST_UNAVAILABLE );
        } else {
            for( i=0; i < cnt; i++ ) {
                logPrintf( STR_MODULE, indent, "", modules[i] );
            }
        }
        FreeModuleList( modules, cnt );
    }
}


/*
 * logProcessList
 */

static void logProcessList( void ) {

    ProcList    info;
    ProcPlace   place;
    BOOL        rc;

    RefreshInfo();
    logPrintf( STR_CURRENT_PROCESSES );
    rc = GetNextProcess( &info, &place, TRUE );
    while( rc ) {
        logStrPrintf( "%*s%08lX %s\n", INDENT, "", info.pid, info.name );
        if( LogData.log_modules ) {
            logModules( info.pid, INDENT + 9 );
        }
        rc = GetNextProcess( &info, &place, FALSE );
    }
}

#ifndef CHICAGO
static void logMemManClass( MemByType *info ) {

    logPrintf( STR_NO_ACCESS,           2 * INDENT, "", info->noaccess / 1024 );
    logPrintf( STR_READ_ONLY,           2 * INDENT, "", info->read / 1024 );
    logPrintf( STR_READ_WRITE,          2 * INDENT, "", info->write / 1024 );
    logPrintf( STR_WRITE_COPY,          2 * INDENT, "", info->copy / 1024 );
    logPrintf( STR_EXECUTE,             2 * INDENT, "", info->exec / 1024 );
    logPrintf( STR_EXECUTE_READ,        2 * INDENT, "", info->execread / 1024 );
    logPrintf( STR_EXECUTE_READ_WRITE,  2 * INDENT, "", info->execwrite / 1024 );
    logPrintf( STR_EXECUTE_WRITE_COPY,  2 * INDENT, "", info->execcopy / 1024 );
    logStrPrintf( "%*s                    ==========\n", 2 * INDENT, "" );
    logPrintf( STR_TOTAL,               2 * INDENT, "", info->tot / 1024 );
}

/*
 * logMemManInfo
 */
static void logMemManInfo( DWORD procid ) {

    MemByType   imageinfo;
    MemInfo     meminfo;
    SYSTEM_INFO sysinfo;
    DWORD       i;

    logPrintf( STR_VIRTUAL_MEM_INFO );
    GetSystemInfo( &sysinfo );
    logPrintf( STR_VIRTUAL_PAGE_SIZE,
               INDENT, "", sysinfo.dwPageSize, sysinfo.dwPageSize / 1024 );
    if( GetMemInfo( procid, &meminfo ) ) {
        logPrintf( STR_RESERVED_MEM, INDENT, "" );
        logMemManClass( &meminfo.res );
        logPrintf( STR_COMMITTED_MEM, INDENT, "" );
        logMemManClass( &meminfo.mapped );
        logPrintf( STR_IMAGE_ADDR_SPACE_FOR, INDENT, "", TOTAL_MEM_STR );
        logMemManClass( &meminfo.image );
        for( i=0; i < meminfo.modcnt; i++ ) {
            logPrintf( STR_IMAGE_ADDR_SPACE_FOR, INDENT, "",
                        meminfo.modlist[i] );
            if( GetImageMemInfo( procid, meminfo.modlist[i], &imageinfo ) ) {
                logMemManClass( &imageinfo );
            } else {
                logPrintf( STR_NOT_AVAILABLE, 2 * INDENT, "" );
            }
        }
        FreeModuleList( meminfo.modlist, meminfo.modcnt );
    } else {
        logPrintf( STR_NOT_AVAILABLE, INDENT, "" );
    }
}
#endif

#define MEM_DMP_WIDTH   16

/*
 * logMemLine
 * NB data must be at least width+1 bytes long
 */
static void logMemLine( char *data, DWORD offset, DWORD width ) {

    DWORD       i;

    logStrPrintf( "%08lX  ", offset );
    for( i=0; i < width; i++ ) {
        logStrPrintf( "%02X ", (int)data[i] );
        if( !isalnum( data[i] ) && !ispunct( data[i] ) ) {
            data[i] = '.';
        }
    }
    data[width] = '\0';
    logStrPrintf( " %s\n", data );
}

/*
 * logDumpMemItem
 */
static void logDumpMemItem( HANDLE prochdl, MEMORY_BASIC_INFORMATION *mbi ) {

    char        data[MEM_DMP_WIDTH + 1];
    DWORD       offset;
    DWORD       limit;
    DWORD       bytesleft;
    BOOL        ret;

    offset = (DWORD)mbi->BaseAddress;
    limit = offset + mbi->RegionSize;
    data[ MEM_DMP_WIDTH ] = '\0';
    ret = ReadProcessMemory( prochdl, (void *)offset, data,
                             MEM_DMP_WIDTH, NULL );
    if( !ret ) {
        logPrintf( STR_CANT_READ_MEM );
        return;
    }
    for( ;; ) {
        logMemLine( data, offset, MEM_DMP_WIDTH );
        offset += MEM_DMP_WIDTH;
        if( offset + MEM_DMP_WIDTH > limit ) break;
        ReadProcessMemory( prochdl, (void *)offset, data,
                           MEM_DMP_WIDTH, NULL );
    }
    if( offset < limit ) {
        bytesleft = limit - offset;
        ReadProcessMemory( prochdl, (void *)offset, data, bytesleft, NULL );
        logMemLine( data, offset, bytesleft );
    }
}

BOOL CALLBACK MemDmpDlgProc( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam )
{
    char                        buf[150];
    SelMemDlgInfo               *info;
    LRESULT                     selcnt;
    int                         *selitems;
    DWORD                       i;
    LRESULT                     index;
    HWND                        lb;
    MEMORY_BASIC_INFORMATION    *mbi;

    info = (SelMemDlgInfo *)GetWindowLong( hwnd, DWL_USER );
    switch( msg ) {
    case WM_INITDIALOG:
        info = (SelMemDlgInfo *)lparam;
        SetWindowLong( hwnd, DWL_USER, lparam );
        lb = GetDlgItem( hwnd, DMP_BOX );
        SetDlgMonoFont( hwnd, DMP_BOX );
        SetDlgMonoFont( hwnd, DMP_LABEL );
        SetDlgItemText( hwnd, DMP_LABEL, MEM_WALKER_HEADER );
        for( i=0; i < info->list.used; i++ ) {
            if( info->list.data[i]->mbi.State == MEM_COMMIT ) {
                FormatMemListEntry( buf, info->list.data[i] );
                index = SendMessage( lb, LB_ADDSTRING, 0, (DWORD)buf );
                SendMessage( lb, LB_SETITEMDATA, index, i );
            }
        }
        break;
    case WM_COMMAND:
        switch( LOWORD( wparam ) ) {
        case IDOK:
            lb = GetDlgItem( hwnd, DMP_BOX );
            selcnt = SendMessage( lb, LB_GETSELCOUNT, 0, 0 );
            if( selcnt > 0 ) {
                logStrPrintf( "\n" );
                selitems = MemAlloc( selcnt * sizeof( int ) );
                SendMessage( lb, LB_GETSELITEMS, selcnt, (DWORD)selitems );
                for( i=0; i < selcnt; i++ ) {
                    index = SendMessage( lb, LB_GETITEMDATA, selitems[i], 0 );
                    mbi = &info->list.data[ index ]->mbi;
                    logPrintf( STR_MEM_DMP_X_TO_Y,
                           mbi->BaseAddress,
                           (DWORD)mbi->BaseAddress + mbi->RegionSize );
                    logDumpMemItem( info->prochdl, mbi );
                }
                MemFree( selitems );
            }
            SendMessage( hwnd, WM_CLOSE, 0, 0L );
            break;
        case IDCANCEL:
            SendMessage( hwnd, WM_CLOSE, 0, 0L );
            break;
        case DMP_SEL_ALL:
            SendDlgItemMessage( hwnd, DMP_BOX, LB_SELITEMRANGE, TRUE,
                                MAKELPARAM( 0, info->list.used - 1 ) );
            break;
        case DMP_CLEAR_ALL:
            SendDlgItemMessage( hwnd, DMP_BOX, LB_SELITEMRANGE, FALSE,
                                MAKELPARAM( 0, info->list.used - 1 ) );
            break;
        }
        break;
    case WM_CLOSE:
        EndDialog( hwnd, 0 );
        break;
    default:
        return( FALSE );
        break;
    }
    return( TRUE );
}

/*
 * logMemDump
 */
static void logMemDmp( ExceptDlgInfo *info ) {

    SelMemDlgInfo       selinfo;
    DWORD               i;
    char                buf[150];

    logPrintf( STR_PROCESS_MEM_DMP );
    selinfo.list.allocated = 0;
    selinfo.list.used = 0;
    selinfo.list.data = NULL;
    selinfo.prochdl = info->procinfo->prochdl;
    RefreshMemList( info->procinfo->procid, info->procinfo->prochdl,
                    &selinfo.list );
    logStrPrintf( "%s\n\n", MEM_WALKER_HEADER );
    for( i=0; i < selinfo.list.used; i++ ) {
        FormatMemListEntry( buf, selinfo.list.data[i] );
        logStrPrintf( "%s\n", buf );
    }
    JDialogBoxParam( Instance, "SEL_MEM_TO_DMP", NULL, MemDmpDlgProc,
                    (DWORD)&selinfo );
    FreeMemList( &selinfo.list );
}

#define FNAME_BUFLEN    50
/*
 * logFaultInfo
 */
static void logFaultInfo( ExceptDlgInfo *info ) {

    char        *str;
    char        buf[150];
    char        addr_buf[64];
    char        fname[ FNAME_BUFLEN ];
    DWORD       type;
    DWORD       line;
    DWORD       gptype;
    ProcStats   stats;

    logStrPrintf( "\n" );
    logPrintf( STR_OFFENDING_PROC_ULINE );
    logPrintf( STR_OFFENDING_PROC_INFO );
    logPrintf( STR_OFFENDING_PROC_ULINE );

    while( !GetProcessInfo( info->procinfo->procid, &stats ) ) {
        Sleep( 100 );
        RefreshInfo();
    }
    logPrintf( STR_OFFENDING_PROC_X, stats.name, info->procinfo->procid );
    type = info->dbinfo->u.Exception.ExceptionRecord.ExceptionCode;
    FormatException( buf, type );
    MADCliAddrToString( info->init_ip,
        MADTypeDefault( MTK_ADDRESS, MAF_FULL, NULL, &( info->init_ip ) ),
        MLK_CODE, 63, addr_buf );