int
erts_set_mtrace_break(Eterm mfa[3], int specified, Binary *match_spec,
Eterm tracer_pid) {
ERTS_SMP_LC_ASSERT(erts_smp_thr_progress_is_blocking());
return set_break(mfa, specified, match_spec,
(BeamInstr) BeamOp(op_i_mtrace_breakpoint), 0, tracer_pid);
}
int
erts_set_mtrace_break(Eterm mfa[3], int specified, Binary *match_spec,
Eterm tracer_pid) {
ERTS_SMP_LC_ASSERT(erts_smp_is_system_blocked(0));
return set_break(mfa, specified, match_spec,
(Uint) BeamOp(op_i_mtrace_breakpoint), 0, tracer_pid);
}
serial_raw::serial_raw(const char *devname)
{
#ifdef WIN32
char portstr[MAX_PATH];
#ifdef WIN32_RECEIVE_RAW
DWORD threadID;
#endif
#endif
put ("SERR");
settype (SERRLOG);
#ifdef WIN32
memset(&dcb, 0, sizeof(DCB));
dcb.DCBlength = sizeof(DCB);
dcb.fBinary = 1;
dcb.fDtrControl = DTR_CONTROL_ENABLE;
dcb.fRtsControl = RTS_CONTROL_ENABLE;
dcb.Parity = NOPARITY;
dcb.ByteSize = 8;
dcb.StopBits = ONESTOPBIT;
dcb.BaudRate = CBR_115200;
DCBchanged = FALSE;
if (lstrlen(devname) > 0) {
wsprintf(portstr, "\\\\.\\%s", devname);
hCOM = CreateFile(portstr, GENERIC_READ|GENERIC_WRITE, 0, NULL,
OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);
if (hCOM != INVALID_HANDLE_VALUE) {
present = 1;
GetCommModemStatus(hCOM, &MSR_value);
SetupComm(hCOM, 8192, 2048);
PurgeComm(hCOM, PURGE_TXABORT | PURGE_RXABORT |
PURGE_TXCLEAR | PURGE_RXCLEAR);
#ifdef WIN32_RECEIVE_RAW
SetCommMask(hCOM, EV_BREAK | EV_CTS | EV_DSR | EV_ERR | EV_RING | EV_RLSD | EV_RXCHAR);
memset(&rx_ovl, 0, sizeof(OVERLAPPED));
rx_ovl.hEvent = CreateEvent(NULL,TRUE,FALSE,"receive");
hRawSerialThread = CreateThread(NULL, 0, RawSerialThread, this, 0, &threadID);
#endif
} else {
present = 0;
BX_ERROR(("Raw device '%s' not present", devname));
}
} else {
present = 0;
}
#else
present = 0;
#endif
set_modem_control(0x00);
set_break(0);
rxdata_count = 0;
}
void LoadMEM(SAVESTATE_t* save, memc* mem) {
int i;
CHUNK_t* chunk = FindChunk(save, MEM_tag);
chunk->pnt = 0;
mem->flash_size = ReadInt(chunk);
mem->flash_pages= ReadInt(chunk);
mem->ram_size = ReadInt(chunk);
mem->ram_pages = ReadInt(chunk);
mem->step = ReadInt(chunk);
mem->cmd = ReadChar(chunk);
mem->boot_mapped= ReadInt(chunk);
mem->flash_locked= ReadInt(chunk);
mem->flash_version = ReadInt(chunk);
for(i = 0; i < 5; i++) {
mem->normal_banks[i].page = ReadInt(chunk);
mem->normal_banks[i].read_only = ReadInt(chunk);
mem->normal_banks[i].ram = ReadInt(chunk);
mem->normal_banks[i].no_exec = ReadInt(chunk);
if (mem->normal_banks[i].ram) {
mem->normal_banks[i].addr = mem->ram+(mem->normal_banks[i].page*PAGE_SIZE);
} else {
mem->normal_banks[i].addr = mem->flash+(mem->normal_banks[i].page*PAGE_SIZE);
}
}
if (mem->boot_mapped) {
update_bootmap_pages(mem);
mem->banks = mem->bootmap_banks;
} else
mem->banks = mem->normal_banks;
mem->read_OP_flash_tstates = ReadInt(chunk);
mem->read_NOP_flash_tstates = ReadInt(chunk);
mem->write_flash_tstates = ReadInt(chunk);
mem->read_OP_ram_tstates = ReadInt(chunk);
mem->read_NOP_ram_tstates = ReadInt(chunk);
mem->write_ram_tstates = ReadInt(chunk);
mem->flash_upper = ReadInt(chunk);
mem->flash_lower = ReadInt(chunk);
chunk = FindChunk(save, ROM_tag);
chunk->pnt = 0;
ReadBlock(chunk, (unsigned char *)mem->flash, mem->flash_size);
chunk = FindChunk(save, RAM_tag);
chunk->pnt = 0;
ReadBlock(chunk, (unsigned char *)mem->ram, mem->ram_size);
chunk = FindChunk(save, REMAP_tag);
if (chunk) {
chunk->pnt = 0;
mem->port27_remap_count = ReadInt(chunk);
mem->port28_remap_count = ReadInt(chunk);
}
chunk = FindChunk(save, RAM_LIMIT_tag);
if (chunk) {
chunk->pnt = 0;
mem->ram_upper = ReadInt(chunk);
mem->ram_lower = ReadInt(chunk);
}
chunk = FindChunk(save, NUM_FLASH_BREAKS_tag);
if (chunk) {
int num_flash_breaks = ReadInt(chunk);
chunk = FindChunk(save, FLASH_BREAKS_tag);
if (chunk) {
for (int i = 0; i < num_flash_breaks; i++)
{
int addr = ReadInt(chunk);
waddr_t waddr;
waddr.addr = addr % PAGE_SIZE;
waddr.page = addr / PAGE_SIZE;
waddr.is_ram = false;
BREAK_TYPE type = (BREAK_TYPE) ReadInt(chunk);
switch (type) {
case MEM_READ_BREAK:
set_mem_read_break(mem, waddr);
break;
case MEM_WRITE_BREAK:
set_mem_read_break(mem, waddr);
break;
default:
set_break(mem, waddr);
break;
}
}
}
}
chunk = FindChunk(save, NUM_RAM_BREAKS_tag);
if (chunk) {
int num_ram_breaks = ReadInt(chunk);
chunk = FindChunk(save, FLASH_BREAKS_tag);
if (chunk) {
for (int i = 0; i < num_ram_breaks; i++)
{
bool valOk;
int addr = ReadInt(chunk, &valOk);
if (valOk) {
waddr_t waddr;
waddr.addr = addr % PAGE_SIZE;
waddr.page = addr / PAGE_SIZE;
waddr.is_ram = true;
BREAK_TYPE type = (BREAK_TYPE) ReadInt(chunk);
switch (type) {
case MEM_READ_BREAK:
set_mem_read_break(mem, waddr);
break;
case MEM_WRITE_BREAK:
set_mem_read_break(mem, waddr);
break;
default:
set_break(mem, waddr);
break;
}
}
}
}
}
}
/*
* ptrace_slave()
* Called by slave process when it detects a need to call the master
*
* Actually, it's called when it *appears* that a need exists; this
* routine does locking and handles the case where it really wasn't
* needed.
*
* XXX use "event" (pack into longs?), and allow them to clear it
* unless it's the unblockable kill message.
*/
void
ptrace_slave(char *event, uint why)
{
struct thread *t = curthread;
struct proc *p = t->t_proc;
struct portref *pr;
port_t port;
long args[3];
uint x;
extern struct portref *find_portref();
retry:
p_sema(&p->p_sema, PRIHI);
/*
* If we've raced with another thread doing the setup, just
* continue. This would be a pretty chaotic situation anyway.
*/
if (p->p_dbg.pd_flags & PD_CONNECTING) {
v_sema(&p->p_sema);
return;
}
/*
* If it appears we're the first to have seen this ptrace
* request, do the initial connect and setup. Then start
* over.
*/
if (p->p_dbg.pd_name && (p->p_dbg.pd_port == -1)) {
ptrace_attach();
goto retry;
}
/*
* Try to get our portref to the debug port. If it has
* gone away, clear our debug environment and continue.
*
* After this block of code, we hold a semaphore for clients
* on the named portref, and we have released our proc
* semaphore. We are thus in a pretty good position to
* interact at length with our debugger.
*/
port = p->p_dbg.pd_port;
v_sema(&p->p_sema);
pr = find_portref(p, port);
if (pr == 0) {
p_sema(&p->p_sema, PRIHI);
/*
* This could actually blow away a usable, new debug
* session. C'est la vie. To get here you had to
* hunt down your port and msg_disconnect() it yourself,
* which is pretty hosed in itself.
*/
if (p->p_dbg.pd_port == port) {
bzero(&p->p_dbg, sizeof(struct pdbg));
}
v_sema(&p->p_sema);
return;
}
/*
* kernmsg_send() does this for itself. We hold the
* semaphore, so we won't race with other I/O clients.
* Since we have the lock, take this opportunity to
* flag that this connection should never be dup'ed.
*/
pr->p_flags |= PF_NODUP;
v_lock(&pr->p_lock, SPL0);
/*
* Return value is initially the bits which matched and
* caused us to drop into ptrace_slave().
*/
args[0] = why;
args[1] = 0;
for (;;) {
/*
* Build a message and send it
*/
if (kernmsg_send(pr, PD_SLAVE, args) < 0) {
v_sema(&pr->p_sema);
p_sema(&p->p_sema, PRIHI);
(void)msg_disconnect(p->p_dbg.pd_port);
bzero(&p->p_dbg, sizeof(struct pdbg));
v_sema(&p->p_sema);
return;
}
/*
* Act on his answer
*/
switch (args[2]) {
case PD_RUN: /* Continue running */
v_sema(&pr->p_sema);
return;
case PD_STEP: /* Run for one step */
single_step(args[0]);
break;
case PD_BREAK: /* Set/clear breakpoint */
args[0] = set_break(args[1], args[0]);
break;
case PD_RDREG: /* Read register */
args[0] = getreg(args[0]);
break;
case PD_WRREG: /* Write register */
args[0] = setreg(args[0], args[1]);
break;
case PD_MASK: /* Set debug event mask */
p->p_dbg.pd_flags = args[0];
break;
case PD_RDMEM: /* Read memory */
{ ulong l;
if (copyin((void *)args[0], &l, sizeof(l)) < 0) {
args[1] = 1;
} else {
args[0] = l;
args[1] = 0;
}
}
break;
case PD_WRMEM: /* Write memory */
if (copyout((void *)args[0], &args[1],
sizeof(args[1]))) {
args[1] = 1;
} else {
args[1] = 0;
}
args[0] = 0;
break;
case PD_MEVENT: /* Read/write event string */
x = args[0] & 0xFF;
if (x > ERRLEN) {
args[0] = -1;
break;
}
if (args[0] & 0xFF00) {
if (event) {
event[x] = args[1];
}
} else {
if (event) {
args[1] = event[x];
} else {
args[1] = 0;
}
}
break;
case PD_PID: /* Tell him our PID/TID */
args[0] = p->p_pid;
args[1] = t->t_pid;
break;
default: /* Bogus--drop him */
v_sema(&pr->p_sema);
(void)msg_disconnect(port);
p_sema(&p->p_sema, PRIHI);
if (p->p_dbg.pd_port == port) {
bzero(&p->p_dbg, sizeof(struct pdbg));
}
v_sema(&p->p_sema);
return;
}
}
}
void
erts_set_time_break(BpFunctions* f, enum erts_break_op count_op)
{
set_break(f, 0, ERTS_BPF_TIME_TRACE|ERTS_BPF_TIME_TRACE_ACTIVE,
count_op, erts_tracer_nil);
}
void
erts_set_count_break(BpFunctions* f, enum erts_break_op count_op)
{
set_break(f, 0, ERTS_BPF_COUNT|ERTS_BPF_COUNT_ACTIVE,
count_op, erts_tracer_nil);
}
void
erts_set_debug_break(BpFunctions* f) {
set_break(f, NULL, ERTS_BPF_DEBUG, 0, erts_tracer_nil);
}
void
erts_set_mtrace_break(BpFunctions* f, Binary *match_spec, ErtsTracer tracer)
{
set_break(f, match_spec, ERTS_BPF_META_TRACE, 0, tracer);
}
void
erts_set_trace_break(BpFunctions* f, Binary *match_spec)
{
set_break(f, match_spec, ERTS_BPF_LOCAL_TRACE, 0, erts_tracer_true);
}
void xbee_term( xbee_serial_t *port)
{
int ch, retval;
char buffer[40];
// set up the console for nonblocking
xbee_term_console_init();
puts( "Simple XBee Terminal");
puts( "CTRL-X to EXIT, CTRL-K toggles break, CTRL-R toggles RTS, "
"TAB changes bps.");
print_baudrate( port);
set_rts( port, RTS_ASSERT);
check_cts( port);
puts( "");
for (;;)
{
check_cts( port);
ch = xbee_term_getchar();
if (ch == CTRL('X'))
{
break; // exit terminal
}
else if (ch == CTRL('R'))
{
set_rts( port, RTS_TOGGLE);
}
else if (ch == CTRL('K'))
{
set_break( port, BREAK_TOGGLE);
}
else if (ch == CTRL('I')) // tab
{
next_baudrate( port);
}
else if (ch > 0)
{
// Pass all characters out serial port, converting LF to CR
// since XBee expects CR for line endings.
xbee_ser_putchar( port, ch == '\n' ? '\r' : ch);
// Only print printable characters or CR, LF or backspace to stdout.
if (isprint( ch) || ch == '\r' || ch == '\n' || ch == '\b')
{
set_color( SOURCE_KEYBOARD);
// stdout expects LF for line endings
putchar( ch == '\r' ? '\n' : ch);
fflush( stdout);
}
}
retval = xbee_ser_read( port, buffer, sizeof buffer);
if (retval > 0)
{
dump_serial_data( buffer, retval);
}
}
xbee_term_console_restore();
puts( "");
}
int
erts_set_time_break(Eterm mfa[3], int specified, enum erts_break_op count_op) {
ERTS_SMP_LC_ASSERT(erts_smp_thr_progress_is_blocking());
return set_break(mfa, specified, NULL,
(BeamInstr) BeamOp(op_i_time_breakpoint), count_op, NIL);
}
int
erts_set_debug_break(Eterm mfa[3], int specified) {
ERTS_SMP_LC_ASSERT(erts_smp_thr_progress_is_blocking());
return set_break(mfa, specified, NULL,
(BeamInstr) BeamOp(op_i_debug_breakpoint), 0, NIL);
}
void
erts_set_debug_break(BpFunctions* f) {
set_break(f, NULL, ERTS_BPF_DEBUG, 0, NIL);
}
int
erts_set_count_break(Eterm mfa[3], int specified, enum erts_break_op count_op) {
ERTS_SMP_LC_ASSERT(erts_smp_is_system_blocked(0));
return set_break(mfa, specified, NULL,
(Uint) BeamOp(op_i_count_breakpoint), count_op, NIL);
}
int
erts_set_debug_break(Eterm mfa[3], int specified) {
ERTS_SMP_LC_ASSERT(erts_smp_is_system_blocked(0));
return set_break(mfa, specified, NULL,
(Uint) BeamOp(op_i_debug_breakpoint), 0, NIL);
}
