projects / OpenSPARC-T2-SAM / blob
? search:
summary | tags | clone url | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Initial commit of OpenSPARC T2 architecture model.
[OpenSPARC-T2-SAM] / sam-t2 / sam / devices / remote / remote.cc
// ========== Copyright Header Begin ==========================================
//
// OpenSPARC T2 Processor File: remote.cc
// Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved.
// DO NOT ALTER OR REMOVE COPYRIGHT NOTICES.
//
// The above named program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public
// License version 2 as published by the Free Software Foundation.
//
// The above named program is distributed in the hope that it will be
// useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// General Public License for more details.
//
// You should have received a copy of the GNU General Public
// License along with this work; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
//
// ========== Copyright Header End ============================================
/////////////////////////////////////////////////////////////////////
//
// FIle: remote.cc
//
// Copyright (C) 2005 Sun Microsystems, Inc.
// All rights reserved.
//
//
// Frontend socket interface for the debugger
//
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/conf.h>
#include <stropts.h>
#include <signal.h>
#include <netinet/in.h>
#include <sys/un.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h> /* for memset in FD_ZERO */
#include <errno.h>
#include <thread.h>
#include <stdlib.h>
#include <assert.h>
#include "types.h"
#include "cpu_interface.h"
#include "remote.h"
// output debug log messages
int g_debug_on = 1;
#define DEBUG(s) if(g_debug_on){s}
#define SWAP_BIT_5_0(I) ((( (I) & 0x01e ) | ( ((I) & 0x020) >> 5 )) & 0x1f)
const int FOREVER = 1;
// command delimiters
const char START_CHR = '$';
const char END_CHR = '#';
typedef enum INSTATE
{
UNATTACHED,
STOPPED,
RUNNING
} state_t;
const int MAX_BUF_SIZE = 8192;
// external routines called from this module
extern int cpu_set_breakpoint ( int cpu_id, VCPU_BpType type, uint64_t addr );
extern int cpu_remove_breakpoint ( int cpu_id, VCPU_BpType type, uint64_t addr );
extern void UI_exec_cmd ( char *cmd );
// Convert number NIB to a hex digit.
static int tohex (int nib)
{
if (nib < 10)
return '0' + nib;
else
return 'a' + nib - 10;
}
// Convert hex digit A to a number.
static int fromhex (uint8_t a)
{
int value = 0;
if (a >= '0' && a <= '9')
value = a - '0';
else if (a >= 'a' && a <= 'f')
value = a - 'a' + 10;
else if (a >= 'A' && a <= 'F')
value = a - 'A' + 10;
else
printf ("Reply contains invalid hex digit %d", a);
return value & 0xf;
}
// read next parameter from the command string;
// return param value;
// set string pointer to the next param
static uint64_t read_next_param ( uint8_t **p )
{
uint64_t value = 0;
if (p != NULL)
{
// remove all spaces
while((*p)[0] == ' ')
(*p)++;
for (int i=0; i<100; i++)
{
uint8_t c = (*p)[i];
if (c == '#' || c == '\0')
{
// last character
*p = NULL;
break;
}
else if (c == ',' || c == ':' || c == ' ')
{
// end of parameter
(*p)+=i+1;
break;
}
else
{
// convert from hex
value = (value<<4) | fromhex(c);
}
}
}
return value;
}
static uint64_t get_value
(
uint8_t **buf, // buffer to get value from
int size // size of the value
)
{
assert( size <= 8 );
int i = 0;
uint64_t value = 0;
for (int offset = size * 8 - 4; offset>=0; offset -= 4)
value = value | fromhex ( (*buf)[i++] ) << offset;
*buf += i; // update buffer pointer
return value;
}
static void put_value
(
uint8_t **buf, // buffer to put a hex string value
uint64_t val, // value
int size // number of bytes ( should less or equal 8 )
)
{
assert( size <= 8 );
int i = 0;
for (int offset = size * 8 - 4; offset>=0; offset -= 4)
{
(*buf)[i++] = uint8_t( tohex (int(val >> offset)&0xf ));
}
*buf += i; // update the buffer pointer
}
class SocketInterface
{
public:
int id; // connection id
SocketInterface *next;
int socket;
state_t state;
thread_t thread_id;
int cpu_id; // current cpu id
uint64_t symtab_base;
char * symtab_fname;
// communication buffers
uint8_t send_buffer[MAX_BUF_SIZE];
uint8_t recv_buffer[MAX_BUF_SIZE];
public:
SocketInterface ()
{
id = 0;
next = NULL;
state = UNATTACHED;
thread_id = 0;
cpu_id = 0;
}
~SocketInterface () { close(socket); }
// send an ack - command was recieved
void reply_ack ()
{
uint8_t ack[4] = {'+',0};
DEBUG( printf("send an ack : + ; "); );
write( socket, ack, 1);
}
void reply_nack ()
{
uint8_t nack[4] = {'-',0};
DEBUG( printf("send a nack : -\n"); );
write( socket, nack, 1);
}
void reply_ok ()
{
send_buffer[1] = 'O';
send_buffer[2] = 'K';
this->send(3);
}
void reply_not_implemented ()
{
this->send(0);
}
// send error number in hex
void reply_error ( uint32_t error_number )
{
send_buffer[1] = 'E';
send_buffer[2] = tohex ((error_number >> 4) & 0xf);
send_buffer[3] = tohex (error_number & 0xf);
this->send (4);
}
// send target stop reason in hex
void reply_target_stopped (uint32_t reason)
{
send_buffer[1] = 'S';
send_buffer[2] = tohex ((reason >> 4) & 0xf);
send_buffer[3] = tohex (reason & 0xf);
this->send (4);
}
// send a data from the send_buffer;
// add first, last control symbols and a checksum
int send ( int size )
{
int n = 0;
// first control char
send_buffer[n++] = START_CHR;
uint8_t check_sum = 0;
while (n<size)
{
if ( n > MAX_BUF_SIZE-3 )
return -1;
uint8_t c = send_buffer[n];
// check null terminated
if ( c == '\0')
break;
check_sum += c;
n++;
}
// insert end control char
send_buffer[n++] = END_CHR;
// insert a check sum
send_buffer[n++] = tohex ((check_sum >> 4) & 0xf);
send_buffer[n++] = tohex (check_sum & 0xf);
send_buffer[n] = 0; // null terminate
DEBUG( printf("\n intf %d send a reply :%s \n", id, send_buffer); );
uint64_t res = write( socket, send_buffer, n);
return (res != n) ? -1 : 0;
}
// read a command into recieve buffer;
// overwrite a previous command if it was there;
// return the number of bytes read,-1 if error
int recv ()
{
uint8_t c;
int n = 0;
int packet_started = 0;
while ( n < MAX_BUF_SIZE )
{
// read one character
if ( read (socket, &c, 1) == 1 )
{
// one character recieved
if ( c == START_CHR)
{
// begin a new command
n = 0;
packet_started = 1;
continue;
}
if ( c == END_CHR)
{
// last character in the command
recv_buffer[n] = 0; // null terminated
return n;
}
// accumulate the characters
if (packet_started)
{
recv_buffer[n] = c;
}
n++;
}
}
return (-1); // data is incomplete
}
// read one register value from the recieve buffer
int read_reg ()
{
uint8_t *args = recv_buffer+1;
int reg_idx = (int)read_next_param ( &args );
uint8_t *sbuf = send_buffer+1; // skip first control char
uint64_t value = 0;
int size = 8;
// read 8 byte gpr value
if (reg_idx < 32)
{
g_vcpu[cpu_id]->get_reg(VCPU_IRF_0 + reg_idx, &value);
put_value( &sbuf, value, 8);
}
else if (reg_idx < 64) // read 4 byte fpr value
{
g_vcpu[cpu_id]->get_reg(VCPU_FRF_0 + reg_idx - 32, &value);
put_value( &sbuf, value, 4);
}
else if (reg_idx < 80) // read 8 byte fpr value
{
g_vcpu[cpu_id]->get_reg(VCPU_DRF_0 + reg_idx - 64 + 16, &value);
put_value( &sbuf, value, 8);
}
else if (reg_idx < 90) // read control reg value
{
switch(reg_idx)
{
case 80: g_vcpu[cpu_id]->get_reg(VCPU_ASR_PC, &value); break;
case 81: g_vcpu[cpu_id]->get_reg(VCPU_ASR_NPC, &value); break;
case 82: g_vcpu[cpu_id]->get_reg(VCPU_PR_PSTATE, &value); break;
case 83: g_vcpu[cpu_id]->get_reg(VCPU_ASR_FSR, &value); break;
case 84: g_vcpu[cpu_id]->get_reg(VCPU_ASR_FPRS, &value); break;
case 85: g_vcpu[cpu_id]->get_reg(VCPU_ASR_Y, &value); break;
case 86: g_vcpu[cpu_id]->get_reg(VCPU_PR_CWP, &value); break;
case 87: g_vcpu[cpu_id]->get_reg(VCPU_PR_PSTATE, &value); break;
case 88: g_vcpu[cpu_id]->get_reg(VCPU_ASR_ASI, &value); break;
case 89: g_vcpu[cpu_id]->get_reg(VCPU_ASR_CCR, &value); break;
}
put_value( &sbuf, value, 8);
}
else if (reg_idx < 122) // read 8 byte fpr value
{
g_vcpu[cpu_id]->get_reg(VCPU_DRF_0 + reg_idx - 90, &value);
put_value( &sbuf, value, 8);
}
else if (reg_idx < 138) // read 16 byte fpr value
{
int regnum = (reg_idx - 122) * 2;
g_vcpu[cpu_id]->get_reg(VCPU_DRF_0 + regnum, &value);
put_value( &sbuf, value, 8);
g_vcpu[cpu_id]->get_reg(VCPU_DRF_0 + regnum + 1, &value);
put_value( &sbuf, value, 8);
}
else
{
reply_error (0);
return 1;
}
int msg_size = int(sbuf - send_buffer);
send(msg_size);
return 0;
}
int read_all_regs ()
{
uint8_t *sbuf = send_buffer+1; // skip first control char
// read all GPRs
for (int i=0; i<32; i++)
{
uint64_t gpr;
g_vcpu[cpu_id]->get_reg(VCPU_IRF_0 + i, &gpr);
put_value( &sbuf, gpr, 8);
}
// read all 32 bit fp regs
for (int i=0; i<32; i++)
{
uint64_t fpr = 0;
g_vcpu[cpu_id]->get_reg(VCPU_FRF_0 + i, &fpr);
put_value( &sbuf, fpr, 4);
}
// read all 64 bit fp regs
for (int i=32; i<64; i+=2)
{
// swap bit 5 and 0
uint64_t dfpr = 0;
g_vcpu[cpu_id]->get_reg(VCPU_DRF_0 + (i / 2), &dfpr);
put_value( &sbuf, dfpr, 8);
}
// read control registers
uint64_t reg;
g_vcpu[cpu_id]->get_reg(VCPU_ASR_PC, &reg);
put_value( &sbuf, reg, 8);
g_vcpu[cpu_id]->get_reg(VCPU_ASR_NPC, &reg);
put_value( &sbuf, reg, 8);
g_vcpu[cpu_id]->get_reg(VCPU_PR_PSTATE, &reg);
put_value( &sbuf, reg, 8);
g_vcpu[cpu_id]->get_reg(VCPU_ASR_FSR, &reg);
put_value( &sbuf, reg, 8);
g_vcpu[cpu_id]->get_reg(VCPU_ASR_FPRS, &reg);
put_value( &sbuf, reg, 8);
g_vcpu[cpu_id]->get_reg(VCPU_ASR_Y, &reg);
put_value( &sbuf, reg, 8);
int msg_size = int(sbuf - send_buffer);
send(msg_size);
return 0;
}
int write_all_regs ()
{
uint64_t reg;
uint8_t *buf = recv_buffer;
// write all GPRs
for (int i=0; i<32; i++)
{
reg = get_value( &buf, 8);
g_vcpu[cpu_id]->set_reg(VCPU_IRF_0 + i, reg);
}
// write all 32 bit fp regs
for (int i=0; i<32; i++)
{
reg = get_value( &buf, 4);
g_vcpu[cpu_id]->set_reg(VCPU_FRF_0 + i, reg);
}
// write all 64 bit fp regs
for (int i=32; i<64; i+=2)
{
reg = get_value( &buf, 8);
g_vcpu[cpu_id]->set_reg(VCPU_DRF_0 + (i / 2), reg);
}
// write control registers
reg = get_value( &buf, 8);
g_vcpu[cpu_id]->set_reg(VCPU_ASR_PC, reg);
reg = get_value( &buf, 8);
g_vcpu[cpu_id]->set_reg(VCPU_ASR_NPC, reg);
reg = get_value( &buf, 8);
g_vcpu[cpu_id]->set_reg(VCPU_PR_PSTATE, reg);
reg = get_value( &buf, 8);
g_vcpu[cpu_id]->set_reg(VCPU_ASR_FSR, reg);
reg = get_value( &buf, 8);
g_vcpu[cpu_id]->set_reg(VCPU_ASR_FPRS, reg);
reg = get_value( &buf, 8);
g_vcpu[cpu_id]->set_reg(VCPU_ASR_Y, reg);
return 0;
}
int read_mem ()
{
uint8_t *args = recv_buffer+1;
uint64_t addr = read_next_param ( &args );
int size = (int)read_next_param ( &args );
if (size <= 0)
{
reply_error (0);
return 1;
}
if (size > MAX_BUF_SIZE-3)
{
size = MAX_BUF_SIZE-3;
}
uint8_t *sbuf = send_buffer+1;
// read from the double word aligned address
uint64_t addr8 = addr & ~uint64_t(7);
uint64_t value = 0;
if ( g_vcpu[cpu_id]->read_mem(addr8, &value, 8) != 0 )
{
reply_error (1);
return 1;
}
DEBUG( printf(" read dword %llx from address %llx \n", value, addr8); );
// alignement for the very first byte
int start_byte_idx = int(addr & 0x7);
int end_byte_idx = start_byte_idx + size-1;
if (end_byte_idx>7)
end_byte_idx = 7;
int chunck_size = end_byte_idx - start_byte_idx + 1;
if (end_byte_idx<7)
value >>= ((7-end_byte_idx)*8);
if (chunck_size<8)
value &= ((uint64_t(1)<<(chunck_size*8))-1);
put_value( &sbuf, value, chunck_size);
int msg_size = int(sbuf - send_buffer);
send( msg_size );
return 0;
}
int write_mem()
{
uint8_t *args = recv_buffer+1;
uint64_t addr = read_next_param ( &args );
int size = (int)read_next_param ( &args );
// allow only double word aligned addresses
if ((size <= 0) || ( addr & 0x7 ) )
{
reply_error (0);
return 1;
}
for (int i=0; i<size/8; i++)
{
// double word aligned address
addr = ( addr + i*8 ) & ~uint64_t(7);
uint64_t value = get_value ( &args ,size );
if (g_vcpu[cpu_id]->write_mem(addr, value, 8) != 0)
{
reply_error (1);
return 1;
}
}
reply_ok ();
return 0;
}
int set_break ()
{
uint8_t *args = recv_buffer+1;
int type = (int)read_next_param ( &args );
uint64_t addr = read_next_param ( &args );
int size = (int)read_next_param ( &args );
switch (type)
{
case 0: // sw breakpoint
case 1: // hw breakpoint
if (cpu_set_breakpoint(cpu_id, VCPU_BP_INSTR_ADDR, addr) != 0)
{
reply_error(1);
return 1;
}
break;
case 2: // write watchpoint
if (cpu_set_breakpoint(cpu_id, VCPU_BP_DATA_WRITE_ADDR, addr) != 0)
{
reply_error(1);
return 1;
}
break;
case 3: // read watchpoint
if (cpu_set_breakpoint(cpu_id, VCPU_BP_DATA_READ_ADDR, addr) != 0)
{
reply_error(1);
return 1;
}
break;
default:
reply_error (0);
return 1;
}
reply_ok ();
return 0;
}
int remove_break ()
{
uint8_t *args = recv_buffer+1;
int type = (int)read_next_param ( &args );
uint64_t addr = read_next_param ( &args );
int size = (int)read_next_param ( &args );
switch (type)
{
case 0: // sw breakpoint
case 1: // hw breakpoint
if (cpu_remove_breakpoint(cpu_id, VCPU_BP_INSTR_ADDR, addr) != 0)
{
//reply_error(1);
return 1;
}
break;
case 2: // write watchpoint
if (cpu_remove_breakpoint(cpu_id, VCPU_BP_DATA_WRITE_ADDR, addr) != 0)
{
//reply_error(1);
return 1;
}
break;
case 3: // read watchpoint
if (cpu_remove_breakpoint(cpu_id, VCPU_BP_DATA_READ_ADDR, addr) != 0)
{
//reply_error(1);
return 1;
}
break;
default:
reply_error (0);
return 1;
}
reply_ok ();
return 0;
}
};
// head of linked list of interface objects
SocketInterface * gpIntf;
// This routine is called when target is stoped.
// Inform the debugger about the reason of stopping.
int target_stopped ( int reason )
{
SocketInterface *in = gpIntf;
// for all attached remote interfaces
while ( in )
{
if(in->state == RUNNING)
{
in->reply_target_stopped (reason);
in->state = STOPPED;
}
in = in->next;
}
return 0;
}
// This new thread is invoked once contact with a debugger is
// been established. This thread exits once that debugger
// connection vanishes.
// Any one debugger can stop the simulation, all are required
// to be active to continue simulation.
extern "C"
void * in_worker_thread (void * argp)
{
SocketInterface *in = (SocketInterface *)argp;
// run the command interface until we get the
// command to termnate this session
while (FOREVER)
{
// get the command packet
int csize = in->recv();
if ( csize <= 0)
{
printf ("failed in communication");
in->reply_nack(); // send a nack
continue;
}
// send an ack
in->reply_ack();
DEBUG( printf(" remote interface %d got a command %s: ", in->id, in->recv_buffer); );
char command = in->recv_buffer[0];
switch ( command )
{
case '?': // why stopped
DEBUG( printf("get the the reason why stoped \n"); );
in->reply_target_stopped (0);
break;
case 'p': // read register
DEBUG( printf("read register :%s \n", in->recv_buffer+1); );
in->read_reg ();
//in->reply_not_implemented(); // not implemented
break;
case 'g': // read all registers
{
DEBUG( printf("read all register \n" ); );
in->read_all_regs ();
break;
}
case 'G': // write registers
{
DEBUG( printf("write registers: %s\n", in->recv_buffer+1); );
in->write_all_regs();
in->reply_ok();
break;
}
case 'm': // read memory
{
DEBUG( printf("read memory : %s \n", in->recv_buffer+1); );
in->read_mem();
break;
}
case 'M': // write memory
{
DEBUG( printf("write memory :%s \n", in->recv_buffer+1); );
in->write_mem();
break;
}
case 'c': // continue from address
DEBUG( printf("continue %s \n", in->recv_buffer+1); );
in->state = RUNNING;
UI_exec_cmd("run\n");
break;
case 's': // step from address
DEBUG( printf("step :%s \n", in->recv_buffer+1); );
in->state = RUNNING;
UI_exec_cmd("stepi 1\n");
break;
case 'z': // remove a breakpoint
DEBUG( printf("remove a breakpoint :%s \n", in->recv_buffer+1); );
in->remove_break();
break;
case 'Z': // set a breakpoint
DEBUG( printf("set a breakpoint :%s \n", in->recv_buffer+1); );
in->set_break();
break;
case 'k': // killed
goto quit;
case 'D': // detach the session
goto quit;
default:
DEBUG( printf("\n unimplemented command %s \n", in->recv_buffer); );
in->reply_not_implemented(); // not implemented
}
}
quit:
// remove interface structure from the list
SocketInterface *prev=NULL;
for ( SocketInterface *p = gpIntf;
p != NULL;
prev = p, p = p->next )
{
if (p == in)
{
if (prev)
prev->next = in->next;
else
gpIntf = in->next;
close (in->socket);
delete in;
break;
}
}
thr_exit(NULL);
return NULL;
}
// main program thread
// to wait for user interface connections.
extern "C"
void *wait_connection (void *param)
{
static fd_set comm_channels;
int tcp_attach_socket, res;
struct sockaddr_in tcp_server;
struct sockaddr_in from;
int fromlen;
int skt;
int fh, length, on=1;
int max_channel;
sigset_t sigs;
struct hostent * hp;
char * froms;
int retry_cnt=0;
sigfillset(&sigs);
thr_sigsetmask(SIG_BLOCK, &sigs, NULL);
skt = socket(AF_INET, SOCK_STREAM, 0);
if (skt < 0)
{
printf ("ERROR: cannot opening stream socket\n");
return NULL;
}
// enable the reuse of this socket if this process dies
if (setsockopt(skt,SOL_SOCKET,SO_REUSEADDR,(char*)&on,int(sizeof(on)))<0)
{
printf ("ERROR: turning on REUSEADDR \n");
return NULL;
}
RemoteConfig *config = (RemoteConfig *)param;
g_debug_on = config->debug_on;
retry: // bind the connection
tcp_server.sin_family = AF_INET;
tcp_server.sin_addr.s_addr = INADDR_ANY;
tcp_server.sin_port = config->port;
retry_cnt++;
printf("- trying port:%d", config->port);
if (bind(skt, (struct sockaddr *)&tcp_server, int(sizeof(tcp_server))) < 0)
{
switch (errno)
{
case EAGAIN:
goto retry;
case EADDRINUSE:
printf("\nPort %d already in use ", config->port);
default:
printf("ERROR: binding tcp stream socket");
return NULL;
}
}
length = int(sizeof(tcp_server));
if (getsockname(skt, (struct sockaddr *) &tcp_server, &length)==-1)
{
printf("ERROR:getting socket name");
return NULL;
}
// start waiting for the connection
printf("\nWaiting for connection on port # %d\n",ntohs(tcp_server.sin_port));
listen(skt, config->max_connections);
tcp_attach_socket = skt;
max_channel = tcp_attach_socket;
FD_ZERO(&comm_channels);
FD_SET(tcp_attach_socket, &comm_channels);
// Wait for a control connection
int next_connection = 0;
while(FOREVER)
{
if (next_connection > config->max_connections - 1)
{
sleep (2);
continue;
}
res = select(max_channel+1, &comm_channels, (fd_set*)0, (fd_set*)0, (struct timeval*)0 /* stall */);
if (res<0)
{
printf("ERROR: select");
break;
}
// accept the connection
fromlen = int(sizeof(from));
fh = accept(tcp_attach_socket,(struct sockaddr *)&from, (int*)&fromlen);
hp = gethostbyaddr((char *)&from.sin_addr, 4, AF_INET);
if (hp == (struct hostent *)0)
{
froms = inet_ntoa(from.sin_addr);
fprintf(stderr,"cant resolve hostname for %s\n", froms);;
}
else
{
froms = hp->h_name;
}
printf("got remote connection from %s : port %d\n", froms, from.sin_port);
// Create the thread to handle this debugger
// connection. It cleans up after itself
// if anything goes wrong
SocketInterface *in = new SocketInterface ();
if (gpIntf == NULL)
{
gpIntf = in;
}
else
{
in->next = gpIntf;
gpIntf = in;
}
in->id = next_connection;
next_connection++;
in->socket = fh;
DEBUG( printf("connection %d on socket_id=%d\n", in->id, in->socket); );
thr_create(NULL, NULL, in_worker_thread, (void*)in, THR_BOUND, &in->thread_id);
}; // while forever
return NULL;
}
int start_connection ( RemoteConfig *config )
{
thread_t thread_id;
// start thread waiting for a remote connection
thr_create(NULL, NULL, wait_connection, (void *)config, THR_BOUND, &thread_id);
printf ( "remote debug server started...\n");
return 0;
}
int destroy_connection ()
{
SocketInterface *in = gpIntf;
// for all attached remote interfaces
while ( in )
{
in->reply_target_stopped (SIGNAL_HUP);
SocketInterface *p = in;
in = in->next;
delete in;
}
return 0;
}
////////////////////////////////////////////////////////
//
// Get exported interface from the Remote shared library.
//
// Assign function pointers in the interface structure.
//
//
// return: 0 - success; 1 - fail;
int get_ex_remote_interface
(
RemoteExInterface *intf // pointer to the interface structure
)
{
intf->create = start_connection;
intf->destroy = destroy_connection;
intf->update_status = target_stopped;
return 0;
}
Full OpenSPARC architecture tarball including simulator, hypervisor, and OBP.