qnxacc.c

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

            for( i = amount; i != 0; --i ) {
                sum += UtilBuff[ i - 1 ];
            }
            offv += amount;
            length -= amount;
            if( amount != size ) break;
        }
    }
    ret->result = sum;
    return( sizeof( *ret ) );
}


unsigned ReqRead_mem()
{
    read_mem_req        *acc;
    unsigned            len;

    acc = GetInPtr(0);

    len = ReadBuffer(GetOutPtr(0),acc->mem_addr.segment,acc->mem_addr.offset,acc->len);
    return( len );
}


unsigned ReqWrite_mem()
{
    write_mem_req       *acc;
    write_mem_ret       *ret;
    unsigned            len;

    acc = GetInPtr(0);
    ret = GetOutPtr(0);

    len = GetTotalSize() - sizeof(*acc);

    ret->len = WriteBuffer( GetInPtr(sizeof(*acc)),
                            acc->mem_addr.segment, acc->mem_addr.offset, len );
    return( sizeof( *ret ) );
}


unsigned ReqRead_io()
{
    union _port_struct  port;
    read_io_req         *acc;
    void                *ret;
    unsigned            len;

    acc = GetInPtr(0);
    ret = GetOutPtr(0);
    if( __qnx_debug_xfer( ProcInfo.proc, ProcInfo.pid, _DEBUG_IO_RD, &port, acc->len,
            acc->IO_offset, 0 ) == 0 ) {
        len = acc->len;
        switch( len ) {
        case 1:
            *( (unsigned_8 *)ret ) = port.byte;
            break;
        case 2:
            *( (unsigned_16 *)ret ) = port.word;
            break;
        case 4:
            *( (unsigned_32 *)ret ) = port.dword;
            break;
        }
    } else {
        len = 0;
    }
    return( len );
}


unsigned ReqWrite_io()
{
    union _port_struct  port;
    write_io_req        *acc;
    write_io_ret        *ret;
    void                *data;
    unsigned            len;

    acc = GetInPtr(0);
    data = GetInPtr( sizeof( *acc ) );
    len = GetTotalSize() - sizeof( *acc );
    ret = GetOutPtr(0);
    switch( len ) {
    case 1:
        port.byte = *( (unsigned_8 *)data );
        break;
    case 2:
        port.word = *( (unsigned_16 *)data );
        break;
    case 4:
        port.dword = *( (unsigned_32 *)data );
        break;
    }
    if( __qnx_debug_xfer( ProcInfo.proc, ProcInfo.pid, _DEBUG_IO_WR, &port, len,
            acc->IO_offset, 0 ) != 0 ) {
        ret->len = 0;
    } else {
        ret->len = len;
    }
    return( sizeof( *ret ) );
}

static void ReadCPU( struct x86_cpu *r )
{
    struct _reg_struct  qnx_regs;

    memset( r, 0, sizeof( *r ) );
    ProcInfo.last_eax = 0;
    if( ProcInfo.pid != 0 && __qnx_debug_xfer( ProcInfo.proc, ProcInfo.pid, _DEBUG_REG_RD, &qnx_regs,
                        sizeof( qnx_regs ), 0, 0 ) == 0 ) {
        ProcInfo.last_eax = qnx_regs.ax;
        r->eax = qnx_regs.ax;
        r->ebx = qnx_regs.bx;
        r->ecx = qnx_regs.cx;
        r->edx = qnx_regs.dx;
        r->esi = qnx_regs.si;
        r->edi = qnx_regs.di;
        r->ebp = qnx_regs.bp;
        r->esp = qnx_regs.sp;
        r->eip = qnx_regs.ip;
        r->efl = qnx_regs.fl;
        r->cs = qnx_regs.cs;
        r->ds = qnx_regs.ds;
        r->ss = qnx_regs.ss;
        r->es = qnx_regs.es;
        r->fs = qnx_regs.fs;
        r->gs = qnx_regs.gs;
    }
}

static void ReadFPU( struct x86_fpu *r )
{
    unsigned    state_size;

    memset( r, 0, sizeof( *r ) );
    if( ProcInfo.fpu32 ) {
        state_size = 108;
    } else {
        state_size = 94;
    }
    if( ProcInfo.pid != 0 && __qnx_debug_xfer( ProcInfo.proc, ProcInfo.pid, _DEBUG_80X87_RD, r,
                        state_size, 0, 0 ) == 0 ) {
        if( !ProcInfo.fpu32 ) FPUExpand( r );
    }
}

unsigned ReqRead_cpu()
{
    ReadCPU( GetOutPtr( 0 ) );
    return( sizeof( struct x86_cpu ) );
}

unsigned ReqRead_fpu()
{
    ReadFPU( GetOutPtr( 0 ) );
    return( sizeof( struct x86_fpu ) );
}

unsigned ReqRead_regs( void )
{
    mad_registers       *mr;

    mr = GetOutPtr( 0 );

    ReadCPU( &mr->x86.cpu );
    ReadFPU( &mr->x86.fpu );
    return( sizeof( mr->x86 ) );
}

static void WriteCPU( struct x86_cpu *r )
{
    struct _reg_struct  qnx_regs;
    unsigned            suppress;

    qnx_regs.ax = r->eax;
    qnx_regs.bx = r->ebx;
    qnx_regs.cx = r->ecx;
    qnx_regs.dx = r->edx;
    qnx_regs.si = r->esi;
    qnx_regs.di = r->edi;
    qnx_regs.bp = r->ebp;
    qnx_regs.sp = r->esp;
    qnx_regs.ip = r->eip;
    qnx_regs.fl = r->efl;
    qnx_regs.cs = r->cs;
    qnx_regs.ds = r->ds;
    qnx_regs.ss = r->ss;
    qnx_regs.es = r->es;
    qnx_regs.fs = r->fs;
    qnx_regs.gs = r->gs;
    suppress = 0;
    if( qnx_regs.ax == ProcInfo.last_eax ) {
        suppress |= 1 << 11;
    }
    __qnx_debug_xfer( ProcInfo.proc, ProcInfo.pid, _DEBUG_REG_WR, &qnx_regs,
                sizeof( qnx_regs ), 0, suppress );
}

static void WriteFPU( struct x86_fpu *r )
{
    unsigned            state_size;

    if( ProcInfo.pid != 0 ) {
        if( !ProcInfo.fpu32 ) FPUContract( r );
        if( ProcInfo.fpu32 ) {
            state_size = 108;
        } else {
            state_size = 94;
        }
        __qnx_debug_xfer( ProcInfo.proc, ProcInfo.pid, _DEBUG_80X87_WR, r, state_size, 0, 0);
    }
}

unsigned ReqWrite_cpu()
{
    WriteCPU( GetInPtr( sizeof( write_cpu_req ) ) );
    return( 0 );
}

unsigned ReqWrite_fpu()
{
    WriteFPU( GetInPtr( sizeof( write_fpu_req ) ) );
    return( 0 );
}

unsigned ReqWrite_regs( void )
{
    mad_registers       *mr;

    mr = GetInPtr( sizeof( write_regs_req ) );
    WriteCPU( &mr->x86.cpu );
    WriteFPU( &mr->x86.fpu );
    return( 0 );
}

static int SplitParms( char *p, char *args[], unsigned len )
{
    int     i;
    char    endc;

    i = 0;
    if( len == 1 ) goto done;
    for( ;; ) {
        for( ;; ) {
            if( len == 0 ) goto done;
            if( *p != ' ' && *p != '\t' ) break;
            ++p;
            --len;
        }
        if( len == 0 ) goto done;
        if( *p == '"' ) {
            --len;
            ++p;
            endc = '"';
        } else {
            endc = ' ';
        }
        if( args != NULL ) args[i] = p;
        ++i;
        for( ;; ) {
            if( len == 0 ) goto done;
            if( *p == endc
                || *p == '\0'
                || (endc == ' ' && *p == '\t' ) ) {
                if( args != NULL ) {
                    *p = '\0';  //NYI: not a good idea, should make a copy
                }
                ++p;
                --len;
                if( len == 0 ) goto done;
                break;
            }
            ++p;
            --len;
        }
    }
done:
    return( i );
}

static pid_t RunningProc( nid_t *nid, char *name, struct _psinfo *info,
                            char **name_ret )
{
    pid_t       pid;
    pid_t       proc;
    char        ch;
    char        *start;

    start = name;
    name = CollectNid( name, strlen( name ), nid );

    for( ;; ) {
        ch = *name;
        if( ch != ' ' && ch != '\t' ) break;
        ++name;
    }
    if( name_ret != NULL ) *name_ret = name;
    pid = 0;
    for( ;; ) {
        if( *name < '0' || *name > '9' ) break;
        pid = (pid*10) + (*name - '0');
        ++name;
    }
    if( *name != '\0') return( 0 );
    for( ;; ) {
        proc = qnx_vc_attach( *nid, PROC_PID,
                     sizeof( struct _proc_psinfo_reply ), 0 );
        info->pid = 0;
        qnx_psinfo( proc, pid, info, 0, 0 );
        qnx_vc_detach( proc );
        if( info->pid != pid ) return( 0 );
        if( info->flags & ( _PPF_MID | _PPF_VMID ) ) return( 0 );
        if( !(info->flags & _PPF_VID) ) break;
        *nid = info->un.vproc.remote_nid;
        pid = info->un.vproc.remote_pid;
    }
    return( pid );
}

static int net_kill( pid_t proc, pid_t pid, int signum )
{
    union {
        struct _proc_signal         s;
        struct _proc_signal_reply   r;
    } msg;

    msg.s.type = _PROC_SIGNAL;
    msg.s.subtype = _SIGRAISE;
    msg.s.pid = pid;
    msg.s.signum = signum;

    if( Send( proc, &msg.s, &msg.r, sizeof(msg.s), sizeof(msg.r) ) == -1 ) {
        return( -1 );
    }

    if( msg.r.status != EOK ) {
        errno = msg.r.status;
        return( -1 );
    }
    return( 0 );
}

unsigned ReqProg_load()
{
    char                        **args;
    char                        *parms;
    char                        *parm_start;
    int                         i;
    char                        exe_name[255];
    struct _osinfo              info;
    struct _psinfo              proc;
    struct _debug_psinfo        off_info;
    nid_t                       nid;
    char                        *name;
    pid_t                       save_pgrp;
    prog_load_req               *acc;
    prog_load_ret               *ret;
    bool                        has_flat;
    unsigned                    len;

    lseek( 0, StdPos.in , SEEK_SET );
    lseek( 1, StdPos.out, SEEK_SET );
    lseek( 2, StdPos.err, SEEK_SET );

    acc = GetInPtr( 0 );
    ret = GetOutPtr( 0 );

    ProcInfo.sig  = -1;
    ProcInfo.proc = PROC_PID;
    ProcInfo.sflags = 0;
    ProcInfo.at_end = FALSE;
    ProcInfo.dbg32  = FALSE;
    ProcInfo.proc32 = FALSE;
    ProcInfo.flat   = FALSE;
    ProcInfo.fpu32  = FALSE;
    ProcInfo.fork   = FALSE;
    memset( ProcInfo.thread, 0, sizeof( ProcInfo.thread[0] ) * ProcInfo.max_threads );
    parms = (char *)GetInPtr( sizeof( *acc ) );
    parm_start = parms;
    len = GetTotalSize() - sizeof( *acc );
    if( acc->true_argv ) {
        i = 1;
        for( ;; ) {
            if( len == 0 ) break;
            if( *parms == '\0' ) {
                i++;
            }
            ++parms;
            --len;
        }
        args = __alloca( i * sizeof( *args ) );
        parms = parm_start;
        len = GetTotalSize() - sizeof( *acc );
        i = 1;
        for( ;; ) {
            if( len == 0 ) break;
            if( *parms == '\0' ) {
                args[ i++ ] = parms + 1;
            }
            ++parms;
            --len;
        }
        args[ i-1 ] = NULL;
    } else {
        while( *parms != '\0' ) {
            ++parms;
            --len;
        }
        ++parms;
        --len;
        i = SplitParms( parms, NULL, len );
        args = __alloca( (i+2) * sizeof( *args ) );
        args[ SplitParms( parms, &args[1], len ) + 1 ] = NULL;
    }
    args[0] = parm_start;
    ProcInfo.pid = RunningProc( &nid, args[0], &proc, &name );
    if( ProcInfo.pid != 0 ) {
        ProcInfo.loaded_proc = FALSE;
    } else {
        args[0] = name;
        if( FindFilePath( TRUE, args[0], exe_name ) == 0 ) {
            exe_name[0] = '\0';
        }
        save_pgrp = getpgrp();
        setpgid( 0, OrigPGrp );
        ProcInfo.pid = qnx_spawn(0, 0, nid, -1, SCHED_OTHER,
                            _SPAWN_HOLD, //NYI: | _SPAWN_NOZOMBIE,
                            exe_name, args, dbg_environ, 0, -1);
        setpgid( 0, save_pgrp );
        if( ProcInfo.pid != -1 ) {
            qnx_psinfo( PROC_PID, ProcInfo.pid, &proc, 0, 0 );
        }
        ProcInfo.loaded_proc = TRUE;
    }
    ret->flags = 0;
    if( ProcInfo.pid != -1 ) {
        //NYI: what if the attaches fail?
        ProcInfo.proc = qnx_vc_attach( nid, PROC_PID, 1000, 0 );
        ProcInfo.mid = qnx_proxy_rem_attach( nid, MID );
        //NYI: temp kludge
        if( ProcInfo.mid == PROC_PID ) ProcInfo.mid = MID;
        ProcInfo.nid = nid;
        if( proc.flags & _PPF_VID ) {
            ProcInfo.pid = proc.un.vproc.remote_pid;
            qnx_psinfo( ProcInfo.proc, ProcInfo.pid, &proc, 0, 0 );
        }
        if( proc.flags & _PPF_32BIT ) {
            ProcInfo.dbg32 = TRUE;
            ret->flags |= LD_FLAG_IS_32;
        }
        ProcInfo.priv_level = proc.ss_reg & PRIV_MASK;
        ProcInfo.magic.offset = proc.magic_off;
        ProcInfo.magic.segment = proc.magic_sel;
        if( __qnx_debug_attach( ProcInfo.proc, ProcInfo.pid, ProcInfo.mid ) != 0 ) {