qnxacc.c

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

    }
    slib = GetSLibTable( FALSE );
    if( slib.offset == 0 && slib.segment == 0 ) {
        return( sizeof( *ret ) );
    }
    if( __qnx_debug_xfer( ProcInfo.proc, ProcInfo.pid, _DEBUG_REG_RD,
                          &save, sizeof( save ), 0, 0 ) != 0 ) {
        return( sizeof( *ret ) );
    }
    new = save;
    if( input ) {
        new.ax = 0;
        save_hdl = &ProcInfo.save_in;
    } else {
        new.ax = 1;
        save_hdl = &ProcInfo.save_out;
    }
    ret->err = 0;
    if( *save_hdl != -1 ) {
        __qnx_debug_xfer( ProcInfo.proc, ProcInfo.pid, _DEBUG_MEM_RD, &func,
            sizeof( func ), slib.offset+4*70, slib.segment );
        new.cs = func.segment & ~PRIV_MASK;
        new.cs |= save.cs & PRIV_MASK;
        new.ip = func.offset;
        new.dx = *save_hdl;
        __qnx_debug_xfer( ProcInfo.proc, ProcInfo.pid, _DEBUG_REG_WR, &new,
            sizeof( new ), 0, 0 );
        __qnx_debug_cont( ProcInfo.proc, ProcInfo.pid, 0 );
        Receive( 0, 0, 0 );
        *save_hdl = -1;
    }
    if( file_name[0] != '\0' ) {
        __qnx_debug_xfer( ProcInfo.proc, ProcInfo.pid, _DEBUG_MEM_RD, &func,
            sizeof( func ), slib.offset+4*69, slib.segment );
        new.cs = func.segment & ~PRIV_MASK;
        new.cs |= save.cs & PRIV_MASK;
        new.ip = func.offset;
        len = strlen( file_name ) + 1;
        new.sp -= STK_ALIGN( len, word );
        new.bx = new.sp;
        new.cx = new.ss;
        __qnx_debug_xfer( ProcInfo.proc, ProcInfo.pid, _DEBUG_MEM_WR, file_name,
            len, new.sp, new.ss );
        __qnx_debug_xfer( ProcInfo.proc, ProcInfo.pid, _DEBUG_REG_WR, &new,
            sizeof( new ), 0, 0 );
        __qnx_debug_cont( ProcInfo.proc, ProcInfo.pid, 0 );
        Receive( 0, 0, 0 );
        __qnx_debug_xfer( ProcInfo.proc, ProcInfo.pid, _DEBUG_REG_RD, &new,
            sizeof( new ), 0, 0 );
        if( (unsigned)new.ax == -1 ) ret->err = 1;
        *save_hdl = new.ax;
    }
    __qnx_debug_xfer( ProcInfo.proc, ProcInfo.pid, _DEBUG_REG_WR, &save,
            sizeof( save ), 0, 0 );
    return( sizeof( *ret ) );
}

unsigned ReqRedirect_stdin()
{
    if( ProcInfo.dbg32 ) {
        return( Redir32( TRUE ) );
    } else {
        return( Redir16( TRUE ) );
    }
}

unsigned ReqRedirect_stdout()
{
    if( ProcInfo.dbg32 ) {
        return( Redir32( FALSE ) );
    } else {
        return( Redir16( FALSE ) );
    }
}

unsigned ReqFile_string_to_fullpath()
{
    struct _psinfo     proc;
    pid_t              pid;
    nid_t              nid;
    bool               exe;
    int                len;
    char               *name;
    char               *fullname;
    file_string_to_fullpath_req *acc;
    file_string_to_fullpath_ret *ret;

/*     -- convert string in acc->name to full path (searchpath style)
 *        in acc->info (MAXIMUM len acc->info_len).
 */
    pid = 0;
    acc = GetInPtr( 0 );
    name = GetInPtr( sizeof( *acc ) );
    ret = GetOutPtr( 0 );
    fullname = GetOutPtr( sizeof( *ret ) );
    exe = ( acc->file_type == TF_TYPE_EXE ) ? TRUE : FALSE;
    if( exe ) {
        pid = RunningProc( &nid, name, &proc, &name );
    }
    if( pid != 0 ) {
        len = StrCopy( proc.un.proc.name, fullname ) - fullname;
    } else {
        len = FindFilePath( exe, name, fullname );
    }
    if( len == 0 ) {
        ret->err = ENOENT;      /* File not found */
    } else {
        ret->err = 0;
    }
    return( sizeof( *ret ) + len + 1 );
}

unsigned ReqGet_message_text()
{
    static const char *const ExceptionMsgs[] = {
        "",
        TRP_QNX_hangup,
        TRP_QNX_user_interrupt,
        TRP_QNX_quit,
        TRP_EXC_illegal_instruction,
        TRP_QNX_trap,
        //"I/O trap",
        TRP_QNX_abort,
        TRP_QNX_emt,
        TRP_QNX_floating_point_error,
        TRP_QNX_process_killed,
        TRP_QNX_bus_error,
        TRP_EXC_access_violation,
        TRP_QNX_sys,
        TRP_QNX_broken_pipe,
        TRP_QNX_alarm,
        TRP_QNX_process_termination,
        TRP_QNX_user_signal_1,
        TRP_QNX_user_signal_2,
        TRP_QNX_child_stopped,
        TRP_QNX_power_fail,
        TRP_QNX_winch,
        TRP_QNX_urgent,
        TRP_QNX_poll,
        TRP_QNX_process_stopped,
        "",
        TRP_QNX_process_continued,
        TRP_QNX_device_ready,
        "",
        ""
    };
    get_message_text_ret        *ret;
    char                        *err_txt;

    ret = GetOutPtr( 0 );
    err_txt = GetOutPtr( sizeof(*ret) );
    if( ProcInfo.fork ) {
        ProcInfo.fork = FALSE;
        strcpy( err_txt, TRP_QNX_PROC_FORK );
        ret->flags = MSG_NEWLINE | MSG_WARNING;
    } else {
        if( ProcInfo.sig == -1 ) {
            err_txt[0] = '\0';
        } else if( ProcInfo.sig > ( (sizeof(ExceptionMsgs) / sizeof(char *) - 1) ) ) {
            strcpy( err_txt, TRP_EXC_unknown );
        } else {
            strcpy( err_txt, ExceptionMsgs[ ProcInfo.sig ] );
        }
        ProcInfo.sig = -1;
        ret->flags = MSG_NEWLINE | MSG_ERROR;
    }
    return( sizeof( *ret ) + strlen( err_txt ) + 1 );
}

unsigned ReqAddr_info()
{
    addr_info_req       *acc;
    addr_info_ret       *ret;
    struct _seginfo     info;
    bool                is_32;

    acc = GetInPtr( 0 );
    is_32 = FALSE;
    if( ProcInfo.proc32 ) {
        qnx_segment_info( ProcInfo.proc, ProcInfo.pid, acc->in_addr.segment,
                        &info );
        if( info.flags & _PMF_DBBIT ) {
            is_32 = TRUE;
        }
    }
    ret = GetOutPtr( 0 );
    ret->is_32 = is_32;
    return( sizeof( *ret ) );
}

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

    acc = GetInPtr( 0 );
    ret = GetOutPtr( 0 );
    data = GetOutPtr( sizeof( *ret ) );
    ret->cache_start = 0;
    ret->cache_end = ~(addr_off)0;
    *data = 0;
    if( ProcInfo.proc32 ) {
        qnx_segment_info( ProcInfo.proc, ProcInfo.pid, acc->addr.segment,
                        &info );
        if( info.flags & _PMF_DBBIT ) {
            *data |= X86AC_BIG;
        }
    }
    return( sizeof( *ret ) + sizeof( *data ) );
}

unsigned ReqGet_lib_name()
{
#if 0
    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( ProcInfo.dbg32 ) {
            strcpy( name, "/boot/sys/Slib32" );
        } else {
            strcpy( name, "/boot/sys/Slib16" );
        }
        break;
    case MH_SLIB:
        ret->handle = MH_PROC;
        if( ProcInfo.proc32 ) {
            strcpy( name, "/boot/sys/Proc32" );
        } else {
            strcpy( name, "/boot/sys/Proc16" );
        }
        break;
    default:
        ret->handle = MH_NONE;
        name[0] = '\0';
        break;
    }
#else
    get_lib_name_req    *acc;
    get_lib_name_ret    *ret;
    char                *name;
    char                *p;
    pid_t               pid, vid, proc;
    struct _psinfo      info;

    acc = GetInPtr(0);
    ret = GetOutPtr( 0 );
    name = GetOutPtr( sizeof( *ret ) );
    p = NULL;
    switch( acc->handle ) {
    case MH_NONE:
    case MH_DEBUGGEE:
        ret->handle = MH_SLIB;
        if( ProcInfo.dbg32 ) {
            if( ( pid = vid = qnx_name_locate(ProcInfo.nid, _SLIB_NAME, 0, 0 ) ) != -1 ) {
                qnx_psinfo( proc = PROC_PID, pid, &info, 0, 0 );
                if( info.flags & _PPF_VID ) {
                    pid = info.un.vproc.remote_pid;
                    proc = qnx_vc_attach( ProcInfo.nid, PROC_PID, 0, 0 );
                }
                if( proc != -1 ) {
                    if( qnx_psinfo( proc, pid, &info, 0, 0 ) == pid ) {;
                        p = info.un.proc.name;
                        qnx_vc_detach( proc );
                    }
                }
                qnx_vc_detach( vid );
            }
            if( p == NULL ) p = "sys/Slib32";
        } else {
            p = "sys/Slib16";
        }
        break;
    case MH_SLIB:
        ret->handle = MH_PROC;
        if( ( proc = qnx_vc_attach(ProcInfo.nid, PROC_PID, 0, 0 ) ) != -1 ) {
            qnx_psinfo( proc, PROC_PID, &info, 0, 0 );
            p = info.un.proc.name;
            qnx_vc_detach( proc );
        } else if( ProcInfo.proc32 ) {
            p = "sys/Proc32";
        } else {
            p = "sys/Proc16";
        }
    default:
        ret->handle = MH_NONE;
        break;
    }
    if( p == NULL ) {
        name[0] = '\0';
    } else if( p[0] == '/' ) {
        if( p[1] == '/' ) {
            for( p += 2; *p >= '0' && *p <= '9'; p++ );
        }
        strcpy( name, p );
    } else {
        strcpy( name, "/boot/" );
        strcat( name, p );
    }
#endif
    return( sizeof( *ret ) + 1 + strlen( name ) );
}

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

    req = GetInPtr( 0 );
    ret = GetOutPtr( 0 );
    if( pid = next_thread( req->thread, THREAD_ALL ) ) {
        ret->thread = pid;
        ret->state = find_thread( pid )->frozen ? THREAD_FROZEN : THREAD_THAWED;
    } else {
        ret->thread = 0;
    }
    return( sizeof( *ret ) );
}

unsigned ReqThread_set()
{
    thread_set_req      *req;
    thread_set_ret      *ret;
    pid_t               pid;
    thread_info         *thread;

    req = GetInPtr( 0 );
    ret = GetOutPtr( 0 );
    if( pid = req->thread ) {
        if( ( thread = find_thread( pid ) ) && !thread->fork ) {
            ret->err = 0;
            ret->old_thread = ProcInfo.pid;
            ProcInfo.pid = pid;
        } else {
            ret->err = EINVAL;
            ret->old_thread = ProcInfo.pid;
        }
    } else {
        ret->err = 0;
        ret->old_thread = ProcInfo.pid;
    }
    return( sizeof( *ret ) );
}

unsigned ReqThread_freeze()
{
    thread_freeze_req   *req;
    thread_freeze_ret   *ret;
    thread_info         *thread;

    req = GetInPtr( 0 );
    ret = GetOutPtr( 0 );
    if( thread = find_thread( req->thread ) ) {
        thread->frozen = TRUE;
        ret->err = 0;
    } else {
        ret->err = EINVAL;
    }
    return( sizeof( *ret ) );
}

unsigned ReqThread_thaw()
{
    thread_thaw_req     *req;
    thread_thaw_ret     *ret;
    thread_info         *thread;

    req = GetInPtr( 0 );
    ret = GetOutPtr( 0 );
    if( thread = find_thread( req->thread ) ) {
        thread->frozen = FALSE;
        ret->err = 0;
    } else {
        ret->err = EINVAL;
    }
    return( sizeof( *ret ) );
}

unsigned ReqThread_get_extra()
{
    thread_get_extra_req    *req;
    char                    *ret;
    struct _psinfo          info;
    thread_info             *thread;

    req = GetInPtr( 0 );
    ret = GetOutPtr( 0 );
    ret[0] = '\0';
    if( req->thread ) {
        if( thread = find_thread( req->thread ) ) {
            if( thread->fork ) {
                strcpy( ret, "Forked Process" );
            } else {
                if( qnx_psinfo( ProcInfo.proc, req->thread, &info, 0, 0 ) == req->thread ) {
                    strcpy( ret, info.un.proc.name );
                }
            }
        }
    } else {
        strcpy( ret, "Thread Name" );
    }
    return( strlen( ret ) + 1 );
}

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

    parm=parm;
    ForceFpu32 = 0;
    if( parm != NULL ) {
        switch( *parm ) {
        case 'f':
            ForceFpu32 = -1;
            break;
        case 'F':
            ForceFpu32 = 1;
            break;
        }
    }
    remote = remote;
    ProcInfo.save_in = -1;
    ProcInfo.save_out = -1;
    ProcInfo.thread = NULL;
    ProcInfo.max_threads = 0;
    find_thread( 0 );   /* allocate initial thread array */
    err[0] = '\0'; /* all ok */
    StdPos.in  = lseek( 0, 0, SEEK_CUR );
    StdPos.out = lseek( 1, 0, SEEK_CUR );
    StdPos.err = lseek( 2, 0, SEEK_CUR );
    ver.major = TRAP_MAJOR_VERSION;
    ver.minor = TRAP_MINOR_VERSION;
    ver.remote = FALSE;
    //ver.is_32 = FALSE;
    OrigPGrp = getpgrp();
    MID = qnx_proxy_attach( 0, 0, 0, 0 );
    if( MID == 0 ) {
        strcpy( err, TRP_QNX_no_proxy );
    }
    return( ver );
}

void TRAPENTRY TrapFini()
{
}