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] / legion / src / simcore / dbgrif.c
/*
* ========== Copyright Header Begin ==========================================
*
* OpenSPARC T2 Processor File: dbgrif.c
* 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 ============================================
*/
/*
* Copyright 2006 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "@(#)dbgrif.c 1.15 06/03/06 SMI"
/* FIXME: Currently this debugger interface is designed solely
* for supporting GDB. I have tried to make it as general
* as possible, but no doubt interface differences will remain
* for other debuggers.
* Ultimately, this interface will split into 2. A set of
* general interaction stubs will exist, and they
* will support loadable modules which inturn can be customised
* for each available debugger required.
*/
#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 <pthread.h>
#include <stdlib.h>
#include <assert.h>
#include "basics.h"
#include "hostcpu.h"
#include "allocate.h"
#include "strutil.h"
#include "fatal.h"
#include "createthr.h"
#include "options.h"
#include "simcore.h"
#include "config.h"
#include "regmap.h"
#include "callback.h"
#define MAX_PORT_STEP 10 /* DEFAULT_PORT to DEFAULT_PORT+9 */
/* allow upto 5 pending connections will never get that many */
#define MAX_CONNECTIONS 5
int port_offset_number; /* for more than one debugger */
bool_t flag_remdeb_if = false;
typedef enum DBGRSTATE {
DS_unattached, DS_stopped, DS_running
#if 0
/*
* available for the sim to tell the debugger about a
* new symtab to load ...
* ... something else to do eventually
*/
, DS_symtab_load
#endif
} dbgr_state_t;
typedef struct DEBUGGER {
int socket;
dbgr_state_t state;
pthread_t pthread_id;
/* ID who we are attached to - if anything */
domain_t* domainp; /* so we can read memory etc. */
/* NOTE: have to go via CPU anyway if caches modeled*/
config_proc_t* config_procp; /* config proc */
void * pspecp; /* within that proc */
/* communication buffers */
uint8_t * send_buffer_p;
uint8_t * recv_buffer_p;
uint8_t * send_ptr;
uint8_t * recv_ptr;
pthread_mutex_t stop_lock;
pthread_cond_t stop_cv;
} debugger_t;
static debugger_t dbgr;
typedef enum {
Receive_error = -1,
Dbgr_Command_Str = 0,
Sim_Command_Str_OK,
Dbgr_Attach,
Sim_Attach_OK,
Sim_Attach_Failed,
Dbgr_Read_Reg,
Sim_Reg_Value_Rtnd,
Dbgr_Write_Reg,
Sim_Reg_Written,
Sim_Reg_Write_Failed,
Dbgr_Set_Breakpoint,
Sim_Breakpoint_Set,
Dbgr_Clear_Breakpoint,
Sim_Breakpoint_Cleared,
Dbgr_Run,
Sim_Executing,
Dbgr_ReqStop,
Dbgr_Wait,
Sim_Stopped,
Sim_SimTab_Load,
Dbgr_Read_Mem,
Sim_Mem_Returned,
Sim_Mem_Read_Failed_No_Mem,
Dbgr_Write_Mem,
Sim_Mem_Write_OK,
Sim_Mem_Write_Failed_No_Mem,
Dbgr_Clear_Mem,
Sim_Mem_Clear_OK,
Sim_Mem_Clear_Failed_No_Mem,
Dbgr_Protocol_Count
} protocol_t;
#ifndef NDEBUG /* { */
#define PD(s) { s, #s },
struct {
int cmd;
char * name;
} protodebug[]= {
PD(Dbgr_Command_Str)
PD(Sim_Command_Str_OK)
PD(Dbgr_Attach)
PD(Sim_Attach_OK)
PD(Sim_Attach_Failed)
PD(Dbgr_Read_Reg)
PD(Sim_Reg_Value_Rtnd)
PD(Dbgr_Write_Reg)
PD(Sim_Reg_Written)
PD(Sim_Reg_Write_Failed)
PD(Dbgr_Set_Breakpoint)
PD(Sim_Breakpoint_Set)
PD(Dbgr_Clear_Breakpoint)
PD(Sim_Breakpoint_Cleared)
PD(Dbgr_Run)
PD(Sim_Executing)
PD(Dbgr_ReqStop)
PD(Dbgr_Wait)
PD(Sim_Stopped)
PD(Sim_SimTab_Load)
PD(Dbgr_Read_Mem)
PD(Sim_Mem_Returned)
PD(Sim_Mem_Read_Failed_No_Mem)
PD(Dbgr_Write_Mem)
PD(Sim_Mem_Write_OK)
PD(Sim_Mem_Write_Failed_No_Mem)
PD(Dbgr_Clear_Mem)
PD(Sim_Mem_Clear_OK)
PD(Sim_Mem_Clear_Failed_No_Mem)
{ -1, NULL },
};
#endif /* } */
#define MAX_BUF_SIZE 8192
static int do_recv(int skt, uint8_t * ptr, int expect);
static protocol_t recv_buffer(debugger_t * dbgp, int * nrecvdp);
static int send_buffer(debugger_t * dbgrp, protocol_t cmd, int num);
static uint16_t get_uint16(uint8_t * bp);
static void put_uint16(uint8_t * bp, uint16_t val);
static uint32_t get_uint32(uint8_t * bp);
static void put_uint32(uint8_t * bp, uint32_t val);
static uint64_t get_uint64(uint8_t * bp);
static void put_uint64(uint8_t * bp, uint64_t val);
/*
*--------------------------------------------
* Register re-map name table
* Get from the GDB numbering to the simulator
* register value ...
* ... for the moment this is for SPARC only
* but will eventually fix this ...
*--------------------------------------------
*/
static char * gdb_reg_name[] = {
#define SPARC_REG_G0 0
"g0", "g1", "g2", "g3", "g4", "g5", "g6", "g7", /*values 0-31*/
"o0", "o1", "o2", "o3", "o4", "o5", "sp", "o7",
"l0", "l1", "l2", "l3", "l4", "l5", "l6", "l7",
"i0", "i1", "i2", "i3", "i4", "i5", "fp", "i7",
#define SPARC_REG_F0 32
"f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7", /* 32-63 */
"f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
"f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
"f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
#define SPARC_REG_F32 64
"f32", "f34", "f36", "f38", "f40", "f42", "f44", "f46", /* 64-79 */
"f48", "f50", "f52", "f54", "f56", "f58", "f60", "f62",
#define SPARC_REG_PC 80
"pc", /* 80 */
#define SPARC_REG_NPC 81
"npc", /* 81 */
"ccr", /* 82 */
"fsr", /* 83 */
"fprs", /* 84 */
"y", /* 85 */
"asi", /* 86 */
"ver", /* 87 */
"tick", /* 88 */
"pil", /* 89 */
"pstate", /* 90 */
"tstate", /* 91 */
"tba", /* 92 */
"tl", /* 93 */
"tt", /* 94 */
"tpc", /* 95 */
"tnpc", /* 96 */
"wstate", /* 97 */
"cwp", /* 98 */
"cansave", /* 99 */
"canrestore", /* 100 */
"cleanwin", /* 101 */
"otherwin", /* 102 */
"asr16", /* 103 */
"asr17", /* 104 */
"asr18", /* 105 */
"asr19", /* 106 */
"asr20", /* 107 */
"asr21", /* 108 */
"asr22", /* 109 */
"asr23", /* 110 */
"asr24", /* 111 */
"asr25", /* 112 */
"asr26", /* 113 */
"asr27", /* 114 */
"asr28", /* 115 */
"asr29", /* 116 */
"asr30", /* 117 */
"asr31", /* 118 */
"icc", /* 119 */
"xcc", /* 120 */
"fcc0", /* 121 */
"fcc1", /* 122 */
"fcc2", /* 123 */
"fcc3", /* 124 */
(char*)0
};
/* Mapping for the GDB register numbering to the CPU models numbering */
int * gdb_reg_map;
static void if_exec_start(debugger_t * dbgrp);
static void if_exec_wait(debugger_t * dbgrp);
static uint64_t symtab_base;
static char * symtab_fname;
static void if_write_register(debugger_t * dbgrp);
static void if_read_register(debugger_t * dbgrp);
static void if_clear_breakpoint(debugger_t * dbgrp);
static void if_set_breakpoint(debugger_t * dbgrp);
static void if_read_memory(debugger_t * dbgrp);
static void if_write_memory(debugger_t * dbgrp);
static void if_clear_memory(debugger_t * dbgrp);
#ifndef NDEBUG
#define DBGRD(s) do { s } while (0)
#else
#define DBGRD(s) do { } while (0)
#endif
/*
* Gah this builds a map from the GDB register numbers to
* those of the sparc processor being simulated ..
* .. based on the map exported for the given
* processor type. This should be done a better way,
* but this works for now : FIXME
*/
void init_gdb_reg_map(reg_map_t * reg_mapp)
{
int count, idx;
/* for each GDB name, find and map the number the
* cpu core model expects to see
*/
for (count=0; gdb_reg_name[count]!=(char*)0; count++) ;
gdb_reg_map = Xcalloc(count, int);
for (idx=0; idx<count; idx++) {
int j;
char * matchp;
matchp = gdb_reg_name[idx];
/* brute force search for name */
for (j=0; reg_mapp[j].namep != (char*)0; j++) {
if (streq(reg_mapp[j].namep, matchp)) break;
}
/* shouldnt have gdb names we dont know ! */
assert(reg_mapp[j].namep != (char*)0);
gdb_reg_map[idx] = reg_mapp[j].idx;
}
}
static void dbgrif_stop_cb(void *arg)
{
debugger_t *dbgrp = (debugger_t *)arg;
DBGRD(printf("dbgrif_stop_cb()\n"););
dbgrp->state = DS_stopped;
pthread_mutex_lock(&dbgrp->stop_lock);
pthread_cond_broadcast(&dbgrp->stop_cv);
pthread_mutex_unlock(&dbgrp->stop_lock);
}
/*
* 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.
*/
void * dbgrif(void * argp)
{
debugger_t * dbgrp = (debugger_t *)argp;
int res, length;
/*
* We have a potential contact, however we must
* setup the structures used for communication
*/
dbgrp->recv_buffer_p = (uint8_t*)valloc(MAX_BUF_SIZE);
if (dbgrp->recv_buffer_p == (uint8_t*)0) fatal("allocating recv buffer");
dbgrp->send_buffer_p = (uint8_t*)valloc(MAX_BUF_SIZE);
if (dbgrp->send_buffer_p == (uint8_t*)0) fatal("allocating send buffer");
dbgrp->recv_ptr = dbgrp->recv_buffer_p + 3;
dbgrp->send_ptr = dbgrp->send_buffer_p + 3;
/*
* Veryify the protocols match ...
* .... by exchanging the max protocol value
*
* Really should use some version checksum ... FIXME
*/
res = recv_buffer( dbgrp, &length );
send_buffer( dbgrp, Dbgr_Protocol_Count, 0 ); /* send regardless - will make other side fail too */
if (res!=Dbgr_Protocol_Count || length!=0) {
printf("Connection failed : received %d %d - debugger protocols do not match\n", res, length);
goto suicide;
}
/*
* OK we've established contact with a legitimate debugger
* run the command interface until we get the
* command to termnate this session
*/
while (1) {
int recv_len;
protocol_t cmd = (protocol_t)recv_buffer(dbgrp, &recv_len);
if (cmd == Receive_error) {
perror("failed in communication");
continue;
}
DBGRD( for (res = 0; protodebug[res].cmd!=-1 && protodebug[res].cmd!=cmd; res++) ;
printf("command [%d] : %s\n",(int)cmd,
protodebug[res].cmd != -1 ? protodebug[res].name : "illegal value"); );
switch ( cmd ) {
case Dbgr_Command_Str:
dbgrp->recv_ptr[recv_len] = '\0';
DBGRD( printf("recvd: %s\n", dbgrp->recv_ptr); );
#if 0
exec_cmds ( (char*)dbgrp->recv_ptr, cmd_ptr );
#endif
send_buffer(dbgrp, Sim_Command_Str_OK, 0);
break;
case Dbgr_Attach:
/* FIXME: for now the simulator must be in virgin state */
assert( dbgrp->state == DS_unattached);
/* Make sure simulator is stopped and ready for attach */
/* FIXME: for now this is not compatible with the auto start mode */
assert( !options.flag_auto_start );
#if 0
stop_cmd((char*)0, dbgrp->cmd_ptr); /* FIXME: prob. wrong too */
wait_for_simulation_stop(dbgrp->cmd_ptr);
if (cpu[0] == (void*)0) {
printf( "Looks like you forgot to init the architecture (file blazerc) before\n"
"you did the sttach - try again\n");
send_buffer(dbgrp->socket, Sim_Attach_Failed, 0);
dbgrp->exec_state = Exec_unattached; /* sanity */
} else {
send_buffer(dbgrp->socket, Sim_Attach_OK, 0);
dbgrp->cpup = cpu[0];
dbgrp->exec_state = Exec_stopped;
}
#endif
/* Kludge an attach just to get something
* running .... FIXME
*/
{ system_t * sysp;
sysp = LIST_ENTRY( target_config.systems, 0 );
dbgrp->domainp = LIST_ENTRY(sysp->domains, 0 );
}
dbgrp->config_procp = LIST_ENTRY(dbgrp->domainp->procs, 0);
dbgrp->pspecp = dbgrp->config_procp->proc_typep->dbgr_attach(dbgrp->domainp, dbgrp->config_procp, "0:0");
ASSERT(dbgrp->config_procp->proc_typep->proc_magic == CPU_MAGIC);
init_gdb_reg_map(dbgrp->config_procp->proc_typep->reg_mapp); /* FIXME */
if (dbgrp->pspecp == NULL) {
send_buffer(dbgrp, Sim_Attach_Failed, 0);
break;
}
dbgrp->state = DS_stopped;
send_buffer(dbgrp, Sim_Attach_OK, 0);
break;
case Dbgr_Read_Reg:
if_read_register(dbgrp);
break;
case Dbgr_Write_Reg:
if_write_register(dbgrp);
break;
case Dbgr_Set_Breakpoint:
if_set_breakpoint(dbgrp);
break;
case Dbgr_Clear_Breakpoint:
if_clear_breakpoint(dbgrp);
break;
case Dbgr_Run:
if_exec_start(dbgrp);
break;
case Dbgr_ReqStop:
/* Cannot get here ... */
fatal("Dbgr_ReqStop unexpectedly received");
case Dbgr_Wait:
if_exec_wait(dbgrp);
break;
case Dbgr_Read_Mem:
if_read_memory(dbgrp);
break;
case Dbgr_Write_Mem:
if_write_memory(dbgrp);
break;
case Dbgr_Clear_Mem:
if_clear_memory(dbgrp);
break;
default:
#ifndef NDEBUG /* { */
for (res = 0; protodebug[res].cmd != -1 && protodebug[res].cmd != cmd; res++) ;
warning("unexpected command [%d] : %s\n",(int)cmd,
protodebug[res].cmd != -1 ? protodebug[res].name : "illegal value");
#else /* } { */
warning("unexpected command %d\n",(int)cmd);
#endif /* } */
goto suicide;
}
}
suicide:;
close(dbgrp->socket);
Xfree( dbgrp->recv_buffer_p );
Xfree( dbgrp->send_buffer_p );
Xfree( dbgrp );
/*
* Clean up this debuggers session ...
* ... remove any assigned breakpoints etc ...
*/
/* FIXME */
/*
* Clean up debugger session count ?
*/
pthread_exit((void*)0);
return (void*)0; /* compiler joy */
}
#if 0 /* { */
/*
* If a symtab message is pending build the response packet
* and send it back to the debugger
*
* The buffer format is quite simple:
* uint16 offset_to_filename { from buffer start }
* uint16 number_of_sections
* Then for each section:
* uint16 offset_to_section_name { from buffer start }
* uint64 section_load_vaddr
* Then the string table:
* .. until the end of the buffer.
* (each string is null terminated)
*
*/
static void if_send_symtab_info(debugger_t * dbgrp)
{
int stridx, secidx, len;
sym_file_t * sfp;
int i;
#define SEC_SIZE (2+8)
/* grab the file info */
sfp = (sym_file_t *)dbgrp->sym_filep;
/* First size the initial sections block */
secidx = 4;
stridx = secidx + SEC_SIZE*(sfp->num_pos);
/* copy in the map name */
/* and the number of sections */
put_uint16( dbgrp->send_ptr, stridx );
put_uint16( dbgrp->send_ptr+2, sfp->num_pos );
len = strlen( sfp->mapnamep );
strcpy( (char*)dbgrp->send_ptr + stridx, sfp->mapnamep );
stridx += len+1;
for (i=0; i<sfp->num_pos; i++) {
put_uint16( dbgrp->send_ptr + secidx, stridx );
put_uint64( dbgrp->send_ptr + secidx + 2, sfp->pos[i].address );
len = strlen( sfp->pos[i].namep );
strcpy( (char*)dbgrp->send_ptr + stridx, sfp->pos[i].namep );
stridx += len + 1;
secidx += SEC_SIZE;
}
DBGRD( printf("\tif_exec_wait: returning Sim_SimTab_Load (%s)...\n", sfp->mapnamep););
send_buffer(dbgrp->socket, Sim_SimTab_Load, stridx);
symfile_cleanup(&dbgrp->sym_filep);
}
#endif /* } */
/*
* Start execution again ...
* ... this is non-blocking (use if_exec_wait to wait until stopped)
*/
static void if_exec_start(debugger_t * dbgrp)
{
DBGRD( printf("run!\n"););
dbgrp->state = DS_running;
simcore_start();
send_buffer(dbgrp, Sim_Executing, 0);
}
/*
* Wait for execution to stop, and give the appropriate response
* to the debugger ...
* ... if execution stopepd to load a symbol table signal that back
* ... after which the debugger should initiate a new run request.
*/
static void if_exec_wait(debugger_t * dbgrp)
{
DBGRD( printf("wait until stopped...\n"););
pthread_mutex_lock(&dbgrp->stop_lock);
while (dbgrp->state != DS_stopped) {
pthread_cond_wait(&dbgrp->stop_cv, &dbgrp->stop_lock);
}
pthread_mutex_unlock(&dbgrp->stop_lock);
DBGRD( printf("\tif_exec_wait: returning Sim_Stopped ...\n"););
send_buffer(dbgrp, Sim_Stopped, 0);
}
static void if_read_register(debugger_t * dbgrp)
{
int regno;
uint64_t val;
regno = (dbgrp->recv_ptr[0]<<8) | dbgrp->recv_ptr[1];
if (!dbgrp->config_procp->proc_typep->regread(dbgrp->pspecp, gdb_reg_map[regno], &val)) {
warning("Register %d [%s] fetch failed", regno, gdb_reg_name[regno]);
send_buffer( dbgrp, Sim_Reg_Value_Rtnd, 0);
return;
}
DBGRD( printf("read register %d : %s = 0x%llx\n",regno,gdb_reg_name[regno],val););
put_uint64(dbgrp->send_ptr, val);
send_buffer( dbgrp, Sim_Reg_Value_Rtnd, 8);
}
static void if_write_register(debugger_t * dbgrp)
{
int regno;
uint64_t val;
regno = (dbgrp->recv_ptr[0]<<8) | dbgrp->recv_ptr[1];
val = get_uint64(dbgrp->recv_ptr + 2);
DBGRD( printf("write register %d : %s = 0x%llx\n",regno,gdb_reg_name[regno],val););
if (!dbgrp->config_procp->proc_typep->regwrite(dbgrp->pspecp, gdb_reg_map[regno], val)) {
warning("Register %d [%s] write failed", regno, gdb_reg_name[regno]);
}
send_buffer( dbgrp, Sim_Reg_Written, 0);
}
static void if_set_breakpoint(debugger_t * dbgrp)
{
uint64_t val;
val = get_uint64(dbgrp->recv_ptr);
DBGRD( printf("set breakpoint @ 0x%llx\n",val););
dbgrp->config_procp->proc_typep->dbgr_set_break(dbgrp->pspecp, val);
send_buffer( dbgrp, Sim_Breakpoint_Set, 0);
}
static void if_clear_breakpoint(debugger_t * dbgrp)
{
uint64_t val;
val = get_uint64(dbgrp->recv_ptr);
DBGRD( printf("clear breakpoint @ 0x%llx\n",val););
dbgrp->config_procp->proc_typep->dbgr_clear_break(dbgrp->pspecp, val);
send_buffer( dbgrp, Sim_Breakpoint_Cleared, 0);
}
static void if_read_memory(debugger_t * dbgrp)
{
tvaddr_t vaddr;
uint32_t len, res;
uint64_t slen;
int offset;
int num;
bool_t is_physical_addr;
proc_type_t * ptp;
ptp = dbgrp->config_procp->proc_typep;
vaddr = get_uint64(dbgrp->recv_ptr);
len = get_uint32(dbgrp->recv_ptr + 8);
res = get_uint32(dbgrp->recv_ptr + 12);
is_physical_addr = (res == 1);
DBGRD( printf("read %s memory @ 0x%llx [ 0x%x bytes]\n",
is_physical_addr ? "physical" : "virtual",
vaddr, len););
len = ptp->dbgr_mem_read(dbgrp->pspecp, vaddr, !is_physical_addr,
dbgrp->send_ptr, len);
if (len == 0) {
DBGRD( fprintf(stdout, "Failed reading memory"); );
send_buffer( dbgrp, Sim_Mem_Read_Failed_No_Mem, 0);
return;
}
send_buffer( dbgrp, Sim_Mem_Returned, len);
}
static void if_write_memory(debugger_t * dbgrp)
{
tvaddr_t vaddr;
uint32_t len, res;
int offset;
int num;
uint64_t slen;
bool_t is_physical_addr;
proc_type_t * ptp;
ptp = dbgrp->config_procp->proc_typep;
vaddr = get_uint64(dbgrp->recv_ptr);
len = get_uint32(dbgrp->recv_ptr + 8);
res = get_uint32(dbgrp->recv_ptr + 12);
is_physical_addr = (res == 1);
DBGRD( printf("write %s memory @ 0x%llx [ 0x%x bytes]\n",
is_physical_addr ? "physical" : "virtual",
vaddr, len););
len = ptp->dbgr_mem_write(dbgrp->pspecp, vaddr, !is_physical_addr,
dbgrp->recv_ptr+16, len);
if (len == 0) {
DBGRD( fprintf(stdout, "Failed reading memory"); );
send_buffer( dbgrp, Sim_Mem_Write_Failed_No_Mem, 0);
return;
}
send_buffer( dbgrp, Sim_Mem_Write_OK, 0);
}
static void if_clear_memory(debugger_t * dbgrp)
{
tvaddr_t vaddr;
uint32_t len, res;
int offset;
int num;
uint64_t slen;
bool_t is_physical_addr;
proc_type_t * ptp;
ptp = dbgrp->config_procp->proc_typep;
vaddr = get_uint64(dbgrp->recv_ptr);
len = get_uint32(dbgrp->recv_ptr + 8);
res = get_uint32(dbgrp->recv_ptr + 12);
is_physical_addr = (res == 1);
DBGRD( printf("clear %s memory @ 0x%llx [ 0x%x bytes]\n",
is_physical_addr ? "physical" : "virtual",
vaddr, len););
len = ptp->dbgr_mem_clear(dbgrp->pspecp, vaddr, !is_physical_addr, len);
if (len == 0) {
DBGRD( fprintf(stdout, "Failed clearing memory"); );
send_buffer( dbgrp, Sim_Mem_Clear_Failed_No_Mem, 0);
return;
}
send_buffer( dbgrp, Sim_Mem_Clear_OK, 0);
}
/*
* We enter here with the main program thread
* to wait for user interface connections.
* we never leave this function.
*
* The simulator closes ungracefully using exit()
* to kill its threads ...
*/
void interface_wait()
{
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);
pthread_sigmask(SIG_BLOCK, &sigs, NULL);
skt = socket(AF_INET, SOCK_STREAM, 0);
if (skt < 0) fatal("opening stream socket");
/* enable the reuse of this socket if this process dies */
if (setsockopt(skt,SOL_SOCKET,SO_REUSEADDR,(char*)&on,sizeof(on))<0)
fatal("turning on REUSEADDR");
/* bind it */
retry:;
tcp_server.sin_family = AF_INET;
tcp_server.sin_addr.s_addr = INADDR_ANY;
tcp_server.sin_port = options.accept_port;
if (bind(skt, (struct sockaddr *)&tcp_server, sizeof(tcp_server)) < 0) {
switch (errno) {
case EAGAIN:
goto retry;
case EADDRINUSE:
printf("\nPort %d already in use ", options.accept_port);
/* user specific a port and it's not available, fatal */
if (options.specific_port) {
printf("\n");
fatal("Port %d already in use, try another",
options.accept_port);
}
/* check if we should retry another port */
if (retry_cnt >= options.port_retry_max) {
printf("\n");
fatal("Max no of retries (%d) reached, use -P -or -p ",
options.port_retry_max);
}
/* try the next port */
options.accept_port++;
retry_cnt++;
printf("- trying %d", options.accept_port);
goto retry;
default:
fatal("binding tcp stream socket");
}
}
/* this not necessary */
length = sizeof(tcp_server);
if (getsockname(skt, (struct sockaddr *) &tcp_server, &length)==-1)
fatal("getting socket name");
PRINTF(("\nWaiting for connection on port # %d\n",
ntohs(tcp_server.sin_port)));
listen(skt, 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
*/
do {
debugger_t * dbgrp;
res = select(max_channel+1, &comm_channels, (fd_set*)0, (fd_set*)0, (struct timeval*)0 /* stall */);
if (res<0) fatal("select");
/*
* accept the connection
*/
fromlen = 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;
}
fprintf(stderr,"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.
*/
dbgrp = Xcalloc(1, debugger_t);
dbgrp->socket = fh;
dbgrp->state = DS_unattached;
pthread_mutex_init(&dbgrp->stop_lock, NULL);
pthread_cond_init(&dbgrp->stop_cv, NULL);
callback_register(CB_Breakpoint, dbgrif_stop_cb, (void *)dbgrp);
create_thread(dbgrif, (void*)dbgrp, &dbgrp->pthread_id);
} while (1);
}
#if 0 /* { */
/*
* These functions are called, not from the debugger IF thread,
* but from the simulation execution thread. It is a callback
* notification to the debugger - during simulation to load
* a new symbol table file.
*/
void remdeb_symtab_add_callback(sym_file_t * sym_filep)
{
if (flag_remdeb_if) {
DBGRD( printf("load symtab %s\n",sym_filep->namep););
dbgr.exec_state = Exec_symtab_load;
assert( dbgr.sym_filep == (sym_file_t *)0);
dbgr.sym_filep = sym_filep;
stop_cmd((char*)0, dbgr.cmd_ptr);
}
}
#endif /* } */
#if 0
/* Delete a block of symbols (object file)
*/
void remdeb_symtab_delete_callback(uint64_t symtab_id)
{
if (flag_remdeb_if) {
DBGRD( printf("delete symtab 0x%llx\n",symtab_id););
}
}
/* Change the offset on a block of symbols ...
*/
void remdeb_symtab_offset_callback(uint64_t symtab_id, uint64_t offset, char * sectp)
{
if (flag_remdeb_if) {
DBGRD( printf("change symtab 0x%llx : section [%s] offset 0x%llx\n",symtab_id, sectp ? sectp : "(NULL)", offset););
}
}
#endif
/*
* basic IO routines to help
*/
static int send_buffer(debugger_t * dbgrp, protocol_t cmd, int num)
{
int res;
dbgrp->send_buffer_p[0] = num >> 8;
dbgrp->send_buffer_p[1] = num & 0xff;
dbgrp->send_buffer_p[2] = (unsigned char) cmd;
res = write(dbgrp->socket, dbgrp->send_buffer_p, 3+num);
return (res != 3+num) ? -1 : 0;
}
static protocol_t recv_buffer(debugger_t * dbgrp, int * nrecvdp)
{
int len, num;
len = do_recv(dbgrp->socket, dbgrp->recv_buffer_p, 3);
if (len != 3) return Receive_error;
len = dbgrp->recv_buffer_p[1] + (dbgrp->recv_buffer_p[0]<<8); /* big endian network order */
num = do_recv(dbgrp->socket, dbgrp->recv_ptr, len);
if (num != len) return Receive_error;
if (nrecvdp != (void*)0) *nrecvdp = num;
return (protocol_t)dbgrp->recv_buffer_p[2];
}
static int do_recv(int skt, unsigned char * ptr, int expect)
{
int idx, num;
for (idx=0; idx<expect; idx+=num) {
num = read(skt, ptr + idx, expect-idx);
if (num<0) return -1;
}
return idx;
}
static uint16_t get_uint16(uint8_t * bp)
{
uint16_t val;
val = (uint16_t)bp[0];
val = (val<<8) | (uint16_t)bp[1];
return val;
}
static uint32_t get_uint32(uint8_t * bp)
{
uint32_t val;
val = (uint32_t)bp[0];
val = (val<<8) | (uint32_t)bp[1];
val = (val<<8) | (uint32_t)bp[2];
val = (val<<8) | (uint32_t)bp[3];
return val;
}
static uint64_t get_uint64(uint8_t * bp)
{
uint64_t val;
val = (uint64_t)bp[0];
val = (val<<8) | (uint64_t)bp[1];
val = (val<<8) | (uint64_t)bp[2];
val = (val<<8) | (uint64_t)bp[3];
val = (val<<8) | (uint64_t)bp[4];
val = (val<<8) | (uint64_t)bp[5];
val = (val<<8) | (uint64_t)bp[6];
val = (val<<8) | (uint64_t)bp[7];
return val;
}
static void put_uint16(uint8_t * bp, uint16_t val)
{
bp[0] = (uint8_t)(val >> 8);
bp[1] = (uint8_t)(val);
}
static void put_uint32(uint8_t * bp, uint32_t val)
{
bp[0] = (uint8_t)(val >> 24);
bp[1] = (uint8_t)(val >> 16);
bp[2] = (uint8_t)(val >> 8);
bp[3] = (uint8_t)(val);
}
static void put_uint64(uint8_t * bp, uint64_t val)
{
bp[0] = (uint8_t)(val >> 56);
bp[1] = (uint8_t)(val >> 48);
bp[2] = (uint8_t)(val >> 40);
bp[3] = (uint8_t)(val >> 32);
bp[4] = (uint8_t)(val >> 24);
bp[5] = (uint8_t)(val >> 16);
bp[6] = (uint8_t)(val >> 8);
bp[7] = (uint8_t)(val);
}
Full OpenSPARC architecture tarball including simulator, hypervisor, and OBP.