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); }