qnxpmd.c

来自「开放源码的编译器open watcom 1.6.0版的源代码」· C语言 代码 · 共 904 行 · 第 1/2 页

unsigned ReqWrite_fpu()
{
    return( 0 );
}

unsigned ReqWrite_regs()
{
    return( 0 );
}

static bool LoadPmdHeader( char *name )
{
    struct stat     tmp;
    char            result[256];

    if( TryOnePath( ":/usr/dumps", &tmp, name, result ) == 0 ) return( FALSE );
    PmdInfo.fd = open( result, O_RDONLY );
    if( PmdInfo.fd < 0 ) return( FALSE );
    if( read( PmdInfo.fd, &PmdInfo.hdr, sizeof( PmdInfo.hdr ) )
            != sizeof( PmdInfo.hdr ) ) {
        close( PmdInfo.fd );
        PmdInfo.fd = NO_FILE;
        errno = ENOEXEC;
        return( FALSE );
    }
    if( PmdInfo.hdr.signature != DUMP_SIGNATURE
     || PmdInfo.hdr.version != DUMP_VERSION
     || PmdInfo.hdr.errnum != 0 ) {
        close( PmdInfo.fd );
        PmdInfo.fd = NO_FILE;
        errno = ENOEXEC;
        return( FALSE );
    }
    return( TRUE );
}

static void ReadSegData()
{
    int                 i;
    seg_data            *ptr;
    off_t               offset;
    struct _seginfo     seg_info;

    offset = sizeof( PmdInfo.hdr );
    for( ptr = PmdInfo.segs, i = PmdInfo.hdr.numsegs; i != 0; ++ptr, --i ) {
        if( lseek( PmdInfo.fd, offset, SEEK_SET ) != offset ) return;
        if( read( PmdInfo.fd, &seg_info, sizeof( seg_info ) )
                 != sizeof( seg_info ) ) return;
        ptr->is_32 = ((seg_info.flags & _PMF_DBBIT) != 0);
        ptr->file_off = offset + sizeof( seg_info );
        ptr->seg_len = seg_info.nbytes;
        ptr->mem_off = 0;
        if( PmdInfo.hdr.osdata.sflags & _PSF_PROTECTED ) {
            if( seg_info.selector & 0x8000 ) {
                /* flat model */
                ptr[0] = ptr[-1];
                ptr[-1].mem_off = seg_info.addr;
                ptr[ 0].mem_off = seg_info.addr + seg_info.nbytes;
                seg_info.nbytes = 0;
            }
            ptr->real_seg = seg_info.selector & 0x7fff;
        } else {
            ptr->real_seg = seg_info.addr >> 4;
        }
        seg_info.nbytes = (seg_info.nbytes+0xff) & ~0xffUL;
        offset = ptr->file_off + seg_info.nbytes;
    }
}

unsigned ReqProg_load()
{
    prog_load_req       *acc;
    prog_load_ret       *ret;
    char                *argv;
    struct _osinfo      info;

    PmdInfo.dbg32 = FALSE;
    PmdInfo.mapping_shared = FALSE;
    acc = GetInPtr( 0 );
    ret = GetOutPtr( 0 );
    argv = GetInPtr( sizeof( *acc ) );
    ret->mod_handle = MH_DEBUGGEE;

    if( argv[0] == '\0' ) {
        ret->task_id = 0;
        ret->err = ENOENT;
        return( sizeof( *ret ) );
    }
    errno = 0;
    if( LoadPmdHeader( argv ) ) {
        PmdInfo.segs = malloc( sizeof( seg_data ) * PmdInfo.hdr.numsegs );
        if( PmdInfo.segs == NULL ) {
            errno = ENOMEM;
        } else {
            errno = 0;
            ReadSegData();
        }
    }
    ret->flags = LD_FLAG_IS_STARTED;
    if( PmdInfo.hdr.osdata.sflags & _PSF_PROTECTED ) {
        ret->flags |= LD_FLAG_IS_PROT;
    }
    if( PmdInfo.hdr.psdata.flags & _PPF_32BIT ) {
        ret->flags |= LD_FLAG_IS_32;
        PmdInfo.dbg32 = TRUE;
    }
    if( PmdInfo.hdr.psdata.flags & _PPF_32BIT ) {
        PmdInfo.fpu32 = TRUE;
    } else if( PmdInfo.hdr.osdata.sflags & _PSF_EMU16_INSTALLED ) {
        PmdInfo.fpu32 = FALSE;
    } else if( PmdInfo.hdr.osdata.sflags & _PSF_32BIT ) {
        PmdInfo.fpu32 = TRUE;
    } else {
        PmdInfo.fpu32 = FALSE;
    }
    qnx_osinfo( 0, &info );
    if( info.version == PmdInfo.hdr.osdata.version
     && info.release == PmdInfo.hdr.osdata.release
     && (info.sflags & _PSF_32BIT) == (PmdInfo.hdr.osdata.sflags & _PSF_32BIT) ) {
        PmdInfo.read_gdts = PmdInfo.enable_read_gdts;
    } else if( PmdInfo.force_read_gdts ) {
        PmdInfo.read_gdts = TRUE;
    } else {
        PmdInfo.read_gdts = FALSE;
    }
    ret->task_id = PmdInfo.hdr.psdata.pid;
    ret->err = errno;
    if( errno == 0 ) {
        PmdInfo.loaded = TRUE;
    } else {
        close( PmdInfo.fd );
        PmdInfo.fd = NO_FILE;
    }
    return( sizeof( *ret ) );
}

unsigned ReqProg_kill()
{
    prog_kill_ret       *ret;

    if( PmdInfo.loaded ) {
        PmdInfo.loaded = FALSE;
        free( PmdInfo.segs );
        close( PmdInfo.fd );
        PmdInfo.fd = NO_FILE;
    }
    PmdInfo.mapping_shared = FALSE;
    ret = GetOutPtr( 0 );
    ret->err = 0;
    return( sizeof( *ret ) );
}

unsigned ReqSet_break()
{
    set_break_ret       *ret;

    ret = GetOutPtr( 0 );
    ret->old = 0;
    return( sizeof( *ret ) );
}

unsigned ReqClear_break()
{
    return( 0 );
}

unsigned ReqSet_watch()
{
    set_watch_ret       *ret;

    ret = GetOutPtr( 0 );
    ret->err = 0;
    ret->multiplier = USING_DEBUG_REG | 1;
    return( sizeof( *ret ) );
}

unsigned ReqClear_watch()
{
    return( 0 );
}


unsigned ReqProg_go()
{
    prog_go_ret *ret;

    ret = GetOutPtr( 0 );
    ret->conditions = COND_TERMINATE;
    return( sizeof( *ret ) );
}

unsigned ReqProg_step()
{
    return( ReqProg_go() );
}


unsigned ReqGet_message_text()
{
    get_message_text_ret        *ret;
    char                        *err_txt;

    ret = GetOutPtr( 0 );
    err_txt = GetOutPtr( sizeof(*ret) );
    err_txt[0] = '\0';
    ret->flags = MSG_NEWLINE | MSG_ERROR;
    return( sizeof( *ret ) + 1 );
}

unsigned ReqRedirect_stdin()
{
    redirect_stdin_ret  *ret;

    ret = GetOutPtr( 0 );
    ret->err = 0;
    return( sizeof( *ret ) );
}

unsigned ReqRedirect_stdout()
{
    return( ReqRedirect_stdin() );
}

unsigned ReqFile_string_to_fullpath()
{
    struct  stat                chk;
    unsigned_16                 len;
    char                        *name;
    char                        *fullname;
    unsigned                    save_handle;
    file_string_to_fullpath_req *acc;
    file_string_to_fullpath_ret *ret;

    acc = GetInPtr( 0 );
    name = GetInPtr( sizeof( *acc ) );
    ret = GetOutPtr( 0 );
    fullname = GetOutPtr( sizeof( *ret ) );
    fullname[0] = '\0';
    len = 0;
    if( acc->file_type != TF_TYPE_EXE ) {
        len = FindFilePath( FALSE, name, fullname );
    } else if( PmdInfo.mapping_shared ) {
        len = FindFilePath( TRUE, name, fullname );
    } else {
        save_handle = PmdInfo.fd;
        if( LoadPmdHeader( name ) ) {
            name = PmdInfo.hdr.psdata.un.proc.name;
            if( stat( name, &chk ) != 0 ) {
                /* try it without the node number */
                name += 2;
                while( *name != '/' ) ++name;
                if( stat( name, &chk ) != 0 ) {
                    chk.st_mtime = 0;
                }
            }
            if( PmdInfo.ignore_timestamp || chk.st_mtime==PmdInfo.hdr.cmdtime ) {
                len = StrCopy( name, fullname ) - fullname;
            }
            close( PmdInfo.fd );
        }
        PmdInfo.fd = save_handle;
    }
    if( len == 0 ) {
        ret->err = ENOENT;      /* File not found */
    } else {
        ret->err = 0;
    }
    return( sizeof( *ret ) + len + 1 );
}

static bool AddrIs32( addr_seg seg )
{
    unsigned            index;
    bool                is_32;
    struct _seginfo     info;

    is_32 = FALSE;
    index = seg >> 3;
    if( (seg & 0x04) == 0 ) {
        if( PmdInfo.read_gdts
         && qnx_segment_info(PROC_PID,PROC_PID,seg,&info)!=-1 ) {
            if( info.flags & _PMF_DBBIT ) {
                is_32 = TRUE;
            }
         }
    } else if( PmdInfo.loaded && index < PmdInfo.hdr.numsegs ) {
        is_32 = PmdInfo.segs[ index ].is_32;
    }
    return( is_32 );
}

unsigned ReqAddr_info()
{
    addr_info_req       *acc;
    addr_info_ret       *ret;

    acc = GetInPtr( 0 );
    ret = GetOutPtr( 0 );
    ret->is_32 = AddrIs32( acc->in_addr.segment );
    return( sizeof( *ret ) );
}

unsigned ReqMachine_data()
{
    machine_data_req    *acc;
    machine_data_ret    *ret;
    unsigned_8          *data;

    acc = GetInPtr( 0 );
    ret = GetOutPtr( 0 );
    data = GetOutPtr( sizeof( *ret ) );
    ret->cache_start = 0;
    ret->cache_end = ~(addr_off)0;
    *data = 0;
    if( AddrIs32( acc->addr.segment ) ) {
        *data |= X86AC_BIG;
    }
    return( sizeof( *ret ) + sizeof( *data ) );
}

unsigned ReqGet_lib_name()
{
    get_lib_name_req    *acc;
    get_lib_name_ret    *ret;
    char                *name;

    acc = GetInPtr(0);
    ret = GetOutPtr( 0 );
    name = GetOutPtr( sizeof( *ret ) );
    switch( acc->handle ) {
    case MH_NONE:
    case MH_DEBUGGEE:
        ret->handle = MH_SLIB;
        if( PmdInfo.dbg32 ) {
            strcpy( name, "/boot/sys/Slib32" );
        } else {
            strcpy( name, "/boot/sys/Slib16" );
        }
        break;
    case MH_SLIB:
        ret->handle = MH_PROC;
        if( PmdInfo.hdr.osdata.sflags & _PSF_32BIT ) {
            strcpy( name, "/boot/sys/Proc32" );
        } else {
            strcpy( name, "/boot/sys/Proc16" );
        }
        break;
    default:
        ret->handle = MH_NONE;
        name[0] = '\0';
        break;
    }
    if( PmdInfo.read_gdts ) {
        PmdInfo.mapping_shared = TRUE;
    } else {
        name[0] = '\0';
        ret->handle = MH_NONE;
    }
    return( sizeof( *ret ) + 1 + strlen( name ) );
}

unsigned ReqThread_get_next()
{
    thread_get_next_req *req;
    thread_get_next_ret *ret;

    req = GetInPtr( 0 );
    ret = GetOutPtr( 0 );
    if( req->thread == 0 ) {
        ret->thread = PmdInfo.hdr.psdata.pid;
        ret->state = THREAD_THAWED;
    } else {
        ret->thread = 0;
    }
    return( sizeof( *ret ) );
}

unsigned ReqThread_set()
{
    thread_set_ret      *ret;

    ret = GetOutPtr( 0 );
    ret->err = 0;
    ret->old_thread = PmdInfo.hdr.psdata.pid;
    return( sizeof( *ret ) );
}

unsigned ReqThread_freeze()
{
    thread_freeze_ret   *ret;

    ret = GetOutPtr( 0 );
    ret->err = 0;
    return( sizeof( *ret ) );
}

unsigned ReqThread_thaw()
{
    thread_thaw_ret     *ret;

    ret = GetOutPtr( 0 );
    ret->err = 0;
    return( sizeof( *ret ) );
}

unsigned ReqThread_get_extra()
{
    char                    *ret;

    ret = GetOutPtr( 0 );
    ret[0] = '\0';
    return( strlen( ret ) + 1 );
}

trap_version TRAPENTRY TrapInit( char *parm, char *err, bool remote )
{
    trap_version ver;

    remote = remote;
    PmdInfo.fd = NO_FILE;
    PmdInfo.enable_read_gdts = TRUE;
    PmdInfo.force_read_gdts  = FALSE;
    if( parm != NULL ) {
        while( *parm != '\0' ) {
            switch( *parm ) {
            case 'I':
            case 'i':
                PmdInfo.ignore_timestamp = TRUE;
                break;
            case 'G':
            case 'g':
                PmdInfo.force_read_gdts = TRUE;
                break;
            case 'd':
            case 'D':
                PmdInfo.enable_read_gdts = FALSE;
                break;
            }
            ++parm;
        }
    }
    err[0] = '\0'; /* all ok */
    ver.major = TRAP_MAJOR_VERSION;
    ver.minor = TRAP_MINOR_VERSION;
    ver.remote = FALSE;
    return( ver );
}

void TRAPENTRY TrapFini()
{
}