static void
openpic_send_ipi(cpuid_t target, uint32_t mesg)
{
struct cpu_info * const ci = curcpu();
uint32_t cpumask = 0;
switch (target) {
case IPI_DST_ALL:
case IPI_DST_NOTME:
for (u_int i = 0; i < ncpu; i++) {
struct cpu_info * const dst_ci = cpu_lookup(i);
if (target == IPI_DST_ALL || dst_ci != ci) {
cpumask |= 1 << cpu_index(dst_ci);
atomic_or_32(&dst_ci->ci_pending_ipis,
mesg);
}
}
break;
default: {
struct cpu_info * const dst_ci = cpu_lookup(target);
cpumask = 1 << cpu_index(dst_ci);
atomic_or_32(&dst_ci->ci_pending_ipis, mesg);
break;
}
}
openpic_write(OPENPIC_IPI(cpu_index(ci), 1), cpumask);
}
/*
* db_panic: Called by panic(). May print a stack trace; may enter the
* kernel debugger; may just return so that panic() will continue to
* halt or reboot the system.
*/
void db_panic(void)
{
if (db_onpanic == 1)
Debugger();
else if (db_onpanic >= 0) {
static int intrace = 0;
if (intrace == 0) {
intrace = 1;
printf("cpu%u: Begin traceback...\n",
cpu_index(curcpu()));
db_stack_trace_print(
(db_expr_t)(intptr_t)__builtin_frame_address(0),
true, 65535, "", printf);
printf("cpu%u: End traceback...\n",
cpu_index(curcpu()));
intrace = 0;
} else
printf("Faulted in mid-traceback; aborting...");
if (db_onpanic == 2)
Debugger();
}
return;
}
static struct workqueue_queue *
workqueue_queue_lookup(struct workqueue *wq, struct cpu_info *ci)
{
u_int idx = 0;
if (wq->wq_flags & WQ_PERCPU) {
idx = ci ? cpu_index(ci) : cpu_index(curcpu());
}
return (void *)((uintptr_t)(wq) + WQ_SIZE + (idx * WQ_QUEUE_SIZE));
}
static void
ingenic_cpu_init(struct cpu_info *ci)
{
uint32_t reg;
/* enable IPIs for this core */
reg = MFC0(12, 4); /* reset entry and interrupts */
if (cpu_index(ci) == 1) {
reg |= REIM_MIRQ1_M;
} else
reg |= REIM_MIRQ0_M;
MTC0(reg, 12, 4);
printf("%s %d %08x\n", __func__, cpu_index(ci), reg);
}
void
rump_cpu_attach(struct cpu_info *ci)
{
if (cpu_info_list == NULL)
ci->ci_flags |= CPUF_PRIMARY;
/* XXX: wrong order, but ... */
ci->ci_next = cpu_info_list;
cpu_info_list = ci;
kcpuset_set(kcpuset_attached, cpu_index(ci));
kcpuset_set(kcpuset_running, cpu_index(ci));
}
/*
* Pause this cpu
*/
void
cpu_pause(struct reg *regsp)
{
int s = splhigh();
cpuid_t cii = cpu_index(curcpu());
if (__predict_false(cold))
return;
do {
kcpuset_atomic_set(cpus_paused, cii);
do {
;
} while (kcpuset_isset(cpus_paused, cii));
kcpuset_atomic_set(cpus_resumed, cii);
#if defined(DDB)
if (ddb_running_on_this_cpu_p())
cpu_Debugger();
if (ddb_running_on_any_cpu_p())
continue;
#endif
} while (false);
splx(s);
}
static inline void
pmap_tlbstat_count(struct pmap *pm, vaddr_t va, tlbwhy_t why)
{
#ifdef TLBSTATS
const cpuid_t cid = cpu_index(curcpu());
bool local = false, remote = false;
if (va != (vaddr_t)-1LL) {
atomic_inc_64(&tlbstat_single_req.ev_count);
}
if (pm == pmap_kernel()) {
atomic_inc_64(&tlbstat_kernel[why].ev_count);
return;
}
if (va >= VM_MAXUSER_ADDRESS) {
remote = kcpuset_isotherset(pm->pm_kernel_cpus, cid);
local = kcpuset_isset(pm->pm_kernel_cpus, cid);
}
remote |= kcpuset_isotherset(pm->pm_cpus, cid);
local |= kcpuset_isset(pm->pm_cpus, cid);
if (local) {
atomic_inc_64(&tlbstat_local[why].ev_count);
}
if (remote) {
atomic_inc_64(&tlbstat_remote[why].ev_count);
}
#endif
}
void
cpu_multicast_ipi(__cpuset_t cpuset, int tag)
{
CPU_INFO_ITERATOR cii;
struct cpu_info *ci;
CPUSET_DEL(cpuset, cpu_index(curcpu()));
if (CPUSET_EMPTY_P(cpuset))
return;
for (CPU_INFO_FOREACH(cii, ci)) {
if (CPUSET_HAS_P(cpuset, cpu_index(ci))) {
CPUSET_DEL(cpuset, cpu_index(ci));
(void)cpu_send_ipi(ci, tag);
}
}
}
/*
* pserialize_switchpoint:
*
* Monitor system context switch activity. Called from machine
* independent code after mi_switch() returns.
*/
void
pserialize_switchpoint(void)
{
pserialize_t psz, next;
cpuid_t cid;
/*
* If no updates pending, bail out. No need to lock in order to
* test psz_work_todo; the only ill effect of missing an update
* would be to delay LWPs waiting in pserialize_perform(). That
* will not happen because updates are on the queue before an
* xcall is generated (serialization) to tickle every CPU.
*/
if (__predict_true(psz_work_todo == 0)) {
return;
}
mutex_spin_enter(&psz_lock);
cid = cpu_index(curcpu());
/*
* At first, scan through the second queue and update each request,
* if passed all processors, then transfer to the third queue.
*/
for (psz = TAILQ_FIRST(&psz_queue1); psz != NULL; psz = next) {
next = TAILQ_NEXT(psz, psz_chain);
kcpuset_set(psz->psz_pass, cid);
if (!kcpuset_match(psz->psz_pass, psz->psz_target)) {
continue;
}
kcpuset_zero(psz->psz_pass);
TAILQ_REMOVE(&psz_queue1, psz, psz_chain);
TAILQ_INSERT_TAIL(&psz_queue2, psz, psz_chain);
}
/*
* Scan through the first queue and update each request,
* if passed all processors, then move to the second queue.
*/
for (psz = TAILQ_FIRST(&psz_queue0); psz != NULL; psz = next) {
next = TAILQ_NEXT(psz, psz_chain);
kcpuset_set(psz->psz_pass, cid);
if (!kcpuset_match(psz->psz_pass, psz->psz_target)) {
continue;
}
kcpuset_zero(psz->psz_pass);
TAILQ_REMOVE(&psz_queue0, psz, psz_chain);
TAILQ_INSERT_TAIL(&psz_queue1, psz, psz_chain);
}
/*
* Process the third queue: entries have been seen twice on every
* processor, remove from the queue and notify the updating thread.
*/
while ((psz = TAILQ_FIRST(&psz_queue2)) != NULL) {
TAILQ_REMOVE(&psz_queue2, psz, psz_chain);
kcpuset_zero(psz->psz_target);
psz_work_todo--;
}
mutex_spin_exit(&psz_lock);
}
static int
ingenic_send_ipi(struct cpu_info *ci, int tag)
{
uint32_t msg;
msg = 1 << tag;
mutex_enter(&ingenic_ipi_lock);
if (kcpuset_isset(cpus_running, cpu_index(ci))) {
if (cpu_index(ci) == 0) {
MTC0(msg, CP0_CORE_MBOX, 0);
} else {
MTC0(msg, CP0_CORE_MBOX, 1);
}
}
mutex_exit(&ingenic_ipi_lock);
return 0;
}
static void
tprof_amdpmi_stop_cpu(void *arg1, void *arg2)
{
struct cpu_info * const ci = curcpu();
wrmsr(PERFEVTSEL(ctrno), 0);
i82489_writereg(LAPIC_PCINT, tprof_amdpmi_lapic_saved[cpu_index(ci)]);
}
void
cpu_boot_secondary_processors(void)
{
for (struct cpu_info *ci = cpu_info_store.ci_next;
ci != NULL;
ci = ci->ci_next) {
KASSERT(!CPU_IS_PRIMARY(ci));
KASSERT(ci->ci_data.cpu_idlelwp);
/*
* Skip this CPU if it didn't sucessfully hatch.
*/
if (! CPUSET_HAS_P(cpus_hatched, cpu_index(ci)))
continue;
ci->ci_data.cpu_cc_skew = mips3_cp0_count_read();
atomic_or_ulong(&ci->ci_flags, CPUF_RUNNING);
CPUSET_ADD(cpus_running, cpu_index(ci));
}
}
static CPUState *find_cpu(uint32_t thread_id)
{
CPUState *cpu;
CPU_FOREACH(cpu) {
if (cpu_index(cpu) == thread_id) {
return cpu;
}
}
return NULL;
}
/*
* Halt this cpu
*/
void
cpu_halt(void)
{
int index = cpu_index(curcpu());
printf("cpu%d: shutting down\n", index);
CPUSET_ADD(cpus_halted, index);
spl0(); /* allow interrupts e.g. further ipi ? */
for (;;) ; /* spin */
/* NOTREACHED */
}
static CPUState *find_cpu(uint32_t thread_id)
{
CPUState *cpu;
for (cpu = first_cpu; cpu != NULL; cpu = cpu->next_cpu) {
if (cpu_index(cpu) == thread_id) {
return cpu;
}
}
return NULL;
}
/*
* Halt this cpu
*/
void
cpu_halt(void)
{
cpuid_t cii = cpu_index(curcpu());
printf("cpu%lu: shutting down\n", cii);
kcpuset_atomic_set(cpus_halted, cii);
spl0(); /* allow interrupts e.g. further ipi ? */
for (;;) ; /* spin */
/* NOTREACHED */
}
/*
* callout_init_cpu:
*
* Per-CPU initialization.
*/
void
callout_init_cpu(struct cpu_info *ci)
{
struct callout_cpu *cc;
int b;
CTASSERT(sizeof(callout_impl_t) <= sizeof(callout_t));
if ((cc = ci->ci_data.cpu_callout) == NULL) {
cc = kmem_zalloc(sizeof(*cc), KM_SLEEP);
if (cc == NULL)
panic("callout_init_cpu (1)");
cc->cc_lock = mutex_obj_alloc(MUTEX_DEFAULT, IPL_SCHED);
CIRCQ_INIT(&cc->cc_todo);
for (b = 0; b < BUCKETS; b++)
CIRCQ_INIT(&cc->cc_wheel[b]);
} else {
/* Boot CPU, one time only. */
callout_sih = softint_establish(SOFTINT_CLOCK | SOFTINT_MPSAFE,
callout_softclock, NULL);
if (callout_sih == NULL)
panic("callout_init_cpu (2)");
}
sleepq_init(&cc->cc_sleepq);
snprintf(cc->cc_name1, sizeof(cc->cc_name1), "late/%u",
cpu_index(ci));
evcnt_attach_dynamic(&cc->cc_ev_late, EVCNT_TYPE_MISC,
NULL, "callout", cc->cc_name1);
snprintf(cc->cc_name2, sizeof(cc->cc_name2), "wait/%u",
cpu_index(ci));
evcnt_attach_dynamic(&cc->cc_ev_block, EVCNT_TYPE_MISC,
NULL, "callout", cc->cc_name2);
ci->ci_data.cpu_callout = cc;
}
/*
* pcu_lwp_op: perform PCU state save, release or both operations on LWP.
*/
static void
pcu_lwp_op(const pcu_ops_t *pcu, lwp_t *l, const int flags)
{
const u_int id = pcu->pcu_id;
struct cpu_info *ci;
uint64_t where;
int s;
/*
* Caller should have re-checked if there is any state to manage.
* Block the interrupts and inspect again, since cross-call sent
* by remote CPU could have changed the state.
*/
s = splsoftclock();
ci = l->l_pcu_cpu[id];
if (ci == curcpu()) {
/*
* State is on the current CPU - just perform the operations.
*/
KASSERT((flags & PCU_CLAIM) == 0);
KASSERTMSG(ci->ci_pcu_curlwp[id] == l,
"%s: cpu%u: pcu_curlwp[%u] (%p) != l (%p)",
__func__, cpu_index(ci), id, ci->ci_pcu_curlwp[id], l);
pcu_do_op(pcu, l, flags);
splx(s);
return;
}
if (__predict_false(ci == NULL)) {
if (flags & PCU_CLAIM) {
pcu_do_op(pcu, l, flags);
}
/* Cross-call has won the race - no state to manage. */
splx(s);
return;
}
splx(s);
/*
* State is on the remote CPU - perform the operations there.
* Note: there is a race condition; see description in the top.
*/
where = xc_unicast(XC_HIGHPRI, (xcfunc_t)pcu_cpu_op,
__UNCONST(pcu), (void *)(uintptr_t)flags, ci);
xc_wait(where);
KASSERT((flags & PCU_RELEASE) == 0 || l->l_pcu_cpu[id] == NULL);
}
/*
* Pause all running cpus, excluding current cpu.
*/
void
cpu_pause_others(void)
{
__cpuset_t cpuset;
CPUSET_ASSIGN(cpuset, cpus_running);
CPUSET_DEL(cpuset, cpu_index(curcpu()));
if (CPUSET_EMPTY_P(cpuset))
return;
cpu_multicast_ipi(cpuset, IPI_SUSPEND);
if (cpu_ipi_wait(&cpus_paused, cpuset))
cpu_ipi_error("pause", cpus_paused, cpuset);
}
void
interrupt_get_available(kcpuset_t *cpuset)
{
CPU_INFO_ITERATOR cii;
struct cpu_info *ci;
kcpuset_zero(cpuset);
mutex_enter(&cpu_lock);
for (CPU_INFO_FOREACH(cii, ci)) {
if ((ci->ci_schedstate.spc_flags & SPCF_NOINTR) == 0)
kcpuset_set(cpuset, cpu_index(ci));
}
mutex_exit(&cpu_lock);
}
/*
* The real-time timer, interrupting hz times per second.
*/
void
hardclock(struct clockframe *frame)
{
struct lwp *l;
struct cpu_info *ci;
ci = curcpu();
l = ci->ci_data.cpu_onproc;
timer_tick(l, CLKF_USERMODE(frame));
/*
* If no separate statistics clock is available, run it from here.
*/
if (stathz == 0)
statclock(frame);
/*
* If no separate schedclock is provided, call it here
* at about 16 Hz.
*/
if (schedhz == 0) {
if ((int)(--ci->ci_schedstate.spc_schedticks) <= 0) {
schedclock(l);
ci->ci_schedstate.spc_schedticks = hardscheddiv;
}
}
if ((--ci->ci_schedstate.spc_ticks) <= 0)
sched_tick(ci);
if (CPU_IS_PRIMARY(ci)) {
hardclock_ticks++;
tc_ticktock();
}
/*
* Update real-time timeout queue.
*/
callout_hardclock();
#ifdef KDTRACE_HOOKS
cyclic_clock_func_t func = cyclic_clock_func[cpu_index(ci)];
if (func) {
(*func)((struct clockframe *)frame);
}
#endif
}
/*
* Fetch a per-CPU CPRNG, or create and save one if necessary.
*/
static struct cprng_strong *
rnd_percpu_cprng(void)
{
struct cprng_strong **cprngp, *cprng, *tmp = NULL;
/* Fast path: if there already is a CPRNG for this CPU, use it. */
cprngp = percpu_getref(percpu_urandom_cprng);
cprng = *cprngp;
if (__predict_true(cprng != NULL))
goto out;
percpu_putref(percpu_urandom_cprng);
/*
* Slow path: create a CPRNG named by this CPU.
*
* XXX The CPU of the name may be different from the CPU to
* which it is assigned, because we need to choose a name and
* allocate a cprng while preemption is enabled. This could be
* fixed by changing the cprng_strong API (e.g., by adding a
* cprng_strong_setname or by separating allocation from
* initialization), but it's not clear that's worth the
* trouble.
*/
char name[32];
(void)snprintf(name, sizeof(name), "urandom%u", cpu_index(curcpu()));
tmp = cprng_strong_create(name, IPL_NONE,
(CPRNG_INIT_ANY | CPRNG_REKEY_ANY));
/* Try again, but we may have been preempted and lost a race. */
cprngp = percpu_getref(percpu_urandom_cprng);
cprng = *cprngp;
if (__predict_false(cprng != NULL))
goto out;
/* Commit the CPRNG we just created. */
cprng = tmp;
tmp = NULL;
*cprngp = cprng;
out: percpu_putref(percpu_urandom_cprng);
if (tmp != NULL)
cprng_strong_destroy(tmp);
KASSERT(cprng != NULL);
return cprng;
}
static inline void
pmap_tlb_processpacket(pmap_tlb_packet_t *tp, kcpuset_t *target)
{
int err = 0;
if (!kcpuset_match(target, kcpuset_attached)) {
const struct cpu_info * const self = curcpu();
CPU_INFO_ITERATOR cii;
struct cpu_info *lci;
for (CPU_INFO_FOREACH(cii, lci)) {
const cpuid_t lcid = cpu_index(lci);
if (__predict_false(lci == self) ||
!kcpuset_isset(target, lcid)) {
continue;
}
err |= x86_ipi(LAPIC_TLB_VECTOR,
lci->ci_cpuid, LAPIC_DLMODE_FIXED);
}
} else {
/*
* Halt all running cpus, excluding current cpu.
*/
void
cpu_halt_others(void)
{
__cpuset_t cpumask, cpuset;
CPUSET_ASSIGN(cpuset, cpus_running);
CPUSET_DEL(cpuset, cpu_index(curcpu()));
CPUSET_ASSIGN(cpumask, cpuset);
CPUSET_SUB(cpuset, cpus_halted);
if (CPUSET_EMPTY_P(cpuset))
return;
cpu_multicast_ipi(cpuset, IPI_HALT);
if (cpu_ipi_wait(&cpus_halted, cpumask))
cpu_ipi_error("halt", cpumask, cpus_halted);
/*
* TBD
* Depending on available firmware methods, other cpus will
* either shut down themselfs, or spin and wait for us to
* stop them.
*/
}
/*
* Pause this cpu
*/
void
cpu_pause(struct reg *regsp)
{
int s = splhigh();
int index = cpu_index(curcpu());
for (;;) {
CPUSET_ADD(cpus_paused, index);
do {
;
} while (CPUSET_HAS_P(cpus_paused, index));
CPUSET_ADD(cpus_resumed, index);
#if defined(DDB)
if (ddb_running_on_this_cpu_p())
cpu_Debugger();
if (ddb_running_on_any_cpu_p())
continue;
#endif
break;
}
splx(s);
}
static void
tprof_amdpmi_start_cpu(void *arg1, void *arg2)
{
struct cpu_info * const ci = curcpu();
uint64_t pesr;
uint64_t event_lo;
uint64_t event_hi;
event_hi = event >> 8;
event_lo = event & 0xff;
pesr = PESR_USR | PESR_OS | PESR_INT |
__SHIFTIN(event_lo, PESR_EVENT_MASK_LO) |
__SHIFTIN(event_hi, PESR_EVENT_MASK_HI) |
__SHIFTIN(0, PESR_COUNTER_MASK) |
__SHIFTIN(unit, PESR_UNIT_MASK);
wrmsr(PERFCTR(ctrno), counter_reset_val);
wrmsr(PERFEVTSEL(ctrno), pesr);
tprof_amdpmi_lapic_saved[cpu_index(ci)] = i82489_readreg(LAPIC_PCINT);
i82489_writereg(LAPIC_PCINT, LAPIC_DLMODE_NMI);
wrmsr(PERFEVTSEL(ctrno), pesr | PESR_EN);
}
int
ipi_intr(void *v)
{
struct cpu_info * const ci = curcpu();
int cpu_id = cpu_index(ci);
int msr;
uint32_t ipi;
ci->ci_ev_ipi.ev_count++;
ipi = atomic_swap_32(&ci->ci_pending_ipis, 0);
if (ipi == IPI_NOMESG)
return 1;
if (ipi & IPI_XCALL)
xc_ipi_handler();
if (ipi & IPI_GENERIC)
ipi_cpu_handler();
if (ipi & IPI_SUSPEND)
cpu_pause(NULL);
if (ipi & IPI_HALT) {
struct cpuset_info * const csi = &cpuset_info;
aprint_normal("halting CPU %d\n", cpu_id);
kcpuset_set(csi->cpus_halted, cpu_id);
msr = (mfmsr() & ~PSL_EE) | PSL_POW;
for (;;) {
__asm volatile ("sync; isync");
mtmsr(msr);
}
}
return 1;
}
void
cpu_debug_dump(void)
{
CPU_INFO_ITERATOR cii;
struct cpu_info *ci;
char running, hatched, paused, resumed, halted;
db_printf("CPU CPUID STATE CPUINFO CPL INT MTX IPIS\n");
for (CPU_INFO_FOREACH(cii, ci)) {
hatched = (kcpuset_isset(cpus_hatched, cpu_index(ci)) ? 'H' : '-');
running = (kcpuset_isset(cpus_running, cpu_index(ci)) ? 'R' : '-');
paused = (kcpuset_isset(cpus_paused, cpu_index(ci)) ? 'P' : '-');
resumed = (kcpuset_isset(cpus_resumed, cpu_index(ci)) ? 'r' : '-');
halted = (kcpuset_isset(cpus_halted, cpu_index(ci)) ? 'h' : '-');
db_printf("%3d 0x%03lx %c%c%c%c%c %p "
"%3d %3d %3d "
"0x%02" PRIx64 "/0x%02" PRIx64 "\n",
cpu_index(ci), ci->ci_cpuid,
running, hatched, paused, resumed, halted,
ci, ci->ci_cpl, ci->ci_idepth, ci->ci_mtx_count,
ci->ci_active_ipis, ci->ci_request_ipis);
}
}
static int gdb_handle_packet(GDBState *s, const char *line_buf)
{
CPUState *cpu;
CPUClass *cc;
const char *p;
uint32_t thread;
int ch, reg_size, type, res;
char buf[MAX_PACKET_LENGTH];
uint8_t mem_buf[MAX_PACKET_LENGTH];
uint8_t *registers;
target_ulong addr, len;
#ifdef DEBUG_GDB
printf("command='%s'\n", line_buf);
#endif
p = line_buf;
ch = *p++;
switch(ch) {
case '?':
/* TODO: Make this return the correct value for user-mode. */
snprintf(buf, sizeof(buf), "T%02xthread:%02x;", GDB_SIGNAL_TRAP,
cpu_index(s->c_cpu));
put_packet(s, buf);
/* Remove all the breakpoints when this query is issued,
* because gdb is doing and initial connect and the state
* should be cleaned up.
*/
gdb_breakpoint_remove_all();
break;
case 'c':
if (*p != '\0') {
addr = strtoull(p, (char **)&p, 16);
gdb_set_cpu_pc(s, addr);
}
s->signal = 0;
gdb_continue(s);
return RS_IDLE;
case 'C':
s->signal = gdb_signal_to_target (strtoul(p, (char **)&p, 16));
if (s->signal == -1)
s->signal = 0;
gdb_continue(s);
return RS_IDLE;
case 'v':
if (strncmp(p, "Cont", 4) == 0) {
int res_signal, res_thread;
p += 4;
if (*p == '?') {
put_packet(s, "vCont;c;C;s;S");
break;
}
res = 0;
res_signal = 0;
res_thread = 0;
while (*p) {
int action, signal;
if (*p++ != ';') {
res = 0;
break;
}
action = *p++;
signal = 0;
if (action == 'C' || action == 'S') {
signal = gdb_signal_to_target(strtoul(p, (char **)&p, 16));
if (signal == -1) {
signal = 0;
}
} else if (action != 'c' && action != 's') {
res = 0;
break;
}
thread = 0;
if (*p == ':') {
thread = strtoull(p+1, (char **)&p, 16);
}
action = tolower(action);
if (res == 0 || (res == 'c' && action == 's')) {
res = action;
res_signal = signal;
res_thread = thread;
}
}
if (res) {
if (res_thread != -1 && res_thread != 0) {
cpu = find_cpu(res_thread);
if (cpu == NULL) {
put_packet(s, "E22");
break;
}
s->c_cpu = cpu;
}
if (res == 's') {
cpu_single_step(s->c_cpu, sstep_flags);
}
s->signal = res_signal;
gdb_continue(s);
return RS_IDLE;
}
break;
} else {
goto unknown_command;
}
case 'k':
/* Kill the target */
fprintf(stderr, "\nQEMU: Terminated via GDBstub\n");
exit(0);
case 'D':
/* Detach packet */
gdb_breakpoint_remove_all();
gdb_syscall_mode = GDB_SYS_DISABLED;
gdb_continue(s);
put_packet(s, "OK");
break;
case 's':
if (*p != '\0') {
addr = strtoull(p, (char **)&p, 16);
gdb_set_cpu_pc(s, addr);
}
cpu_single_step(s->c_cpu, sstep_flags);
gdb_continue(s);
return RS_IDLE;
case 'F':
{
target_ulong ret;
target_ulong err;
ret = strtoull(p, (char **)&p, 16);
if (*p == ',') {
p++;
err = strtoull(p, (char **)&p, 16);
} else {
err = 0;
}
if (*p == ',')
p++;
type = *p;
if (s->current_syscall_cb) {
s->current_syscall_cb(s->c_cpu, ret, err);
s->current_syscall_cb = NULL;
}
if (type == 'C') {
put_packet(s, "T02");
} else {
gdb_continue(s);
}
}
break;
case 'g':
cpu_synchronize_state(s->g_cpu);
len = 0;
for (addr = 0; addr < s->g_cpu->gdb_num_g_regs; addr++) {
reg_size = gdb_read_register(s->g_cpu, mem_buf + len, addr);
len += reg_size;
}
memtohex(buf, mem_buf, len);
put_packet(s, buf);
break;
case 'G':
cpu_synchronize_state(s->g_cpu);
registers = mem_buf;
len = strlen(p) / 2;
hextomem((uint8_t *)registers, p, len);
for (addr = 0; addr < s->g_cpu->gdb_num_g_regs && len > 0; addr++) {
reg_size = gdb_write_register(s->g_cpu, registers, addr);
len -= reg_size;
registers += reg_size;
}
put_packet(s, "OK");
break;
case 'm':
addr = strtoull(p, (char **)&p, 16);
if (*p == ',')
p++;
len = strtoull(p, NULL, 16);
/* memtohex() doubles the required space */
if (len > MAX_PACKET_LENGTH / 2) {
put_packet (s, "E22");
break;
}
if (target_memory_rw_debug(s->g_cpu, addr, mem_buf, len, false) != 0) {
put_packet (s, "E14");
} else {
memtohex(buf, mem_buf, len);
put_packet(s, buf);
}
break;
case 'M':
addr = strtoull(p, (char **)&p, 16);
if (*p == ',')
p++;
len = strtoull(p, (char **)&p, 16);
if (*p == ':')
p++;
/* hextomem() reads 2*len bytes */
if (len > strlen(p) / 2) {
put_packet (s, "E22");
break;
}
hextomem(mem_buf, p, len);
if (target_memory_rw_debug(s->g_cpu, addr, mem_buf, len,
true) != 0) {
put_packet(s, "E14");
} else {
put_packet(s, "OK");
}
break;
case 'p':
/* Older gdb are really dumb, and don't use 'g' if 'p' is avaialable.
This works, but can be very slow. Anything new enough to
understand XML also knows how to use this properly. */
if (!gdb_has_xml)
goto unknown_command;
addr = strtoull(p, (char **)&p, 16);
reg_size = gdb_read_register(s->g_cpu, mem_buf, addr);
if (reg_size) {
memtohex(buf, mem_buf, reg_size);
put_packet(s, buf);
} else {
put_packet(s, "E14");
}
break;
case 'P':
if (!gdb_has_xml)
goto unknown_command;
addr = strtoull(p, (char **)&p, 16);
if (*p == '=')
p++;
reg_size = strlen(p) / 2;
hextomem(mem_buf, p, reg_size);
gdb_write_register(s->g_cpu, mem_buf, addr);
put_packet(s, "OK");
break;
case 'Z':
case 'z':
type = strtoul(p, (char **)&p, 16);
if (*p == ',')
p++;
addr = strtoull(p, (char **)&p, 16);
if (*p == ',')
p++;
len = strtoull(p, (char **)&p, 16);
if (ch == 'Z')
res = gdb_breakpoint_insert(addr, len, type);
else
res = gdb_breakpoint_remove(addr, len, type);
if (res >= 0)
put_packet(s, "OK");
else if (res == -ENOSYS)
put_packet(s, "");
else
put_packet(s, "E22");
break;
case 'H':
type = *p++;
thread = strtoull(p, (char **)&p, 16);
if (thread == -1 || thread == 0) {
put_packet(s, "OK");
break;
}
cpu = find_cpu(thread);
if (cpu == NULL) {
put_packet(s, "E22");
break;
}
switch (type) {
case 'c':
s->c_cpu = cpu;
put_packet(s, "OK");
break;
case 'g':
s->g_cpu = cpu;
put_packet(s, "OK");
break;
default:
put_packet(s, "E22");
break;
}
break;
case 'T':
thread = strtoull(p, (char **)&p, 16);
cpu = find_cpu(thread);
if (cpu != NULL) {
put_packet(s, "OK");
} else {
put_packet(s, "E22");
}
break;
case 'q':
case 'Q':
/* parse any 'q' packets here */
if (!strcmp(p,"qemu.sstepbits")) {
/* Query Breakpoint bit definitions */
snprintf(buf, sizeof(buf), "ENABLE=%x,NOIRQ=%x,NOTIMER=%x",
SSTEP_ENABLE,
SSTEP_NOIRQ,
SSTEP_NOTIMER);
put_packet(s, buf);
break;
} else if (is_query_packet(p, "qemu.sstep", '=')) {
/* Display or change the sstep_flags */
p += 10;
if (*p != '=') {
/* Display current setting */
snprintf(buf, sizeof(buf), "0x%x", sstep_flags);
put_packet(s, buf);
break;
}
p++;
type = strtoul(p, (char **)&p, 16);
sstep_flags = type;
put_packet(s, "OK");
break;
} else if (strcmp(p,"C") == 0) {
/* "Current thread" remains vague in the spec, so always return
* the first CPU (gdb returns the first thread). */
put_packet(s, "QC1");
break;
} else if (strcmp(p,"fThreadInfo") == 0) {
s->query_cpu = first_cpu;
goto report_cpuinfo;
} else if (strcmp(p,"sThreadInfo") == 0) {
report_cpuinfo:
if (s->query_cpu) {
snprintf(buf, sizeof(buf), "m%x", cpu_index(s->query_cpu));
put_packet(s, buf);
s->query_cpu = CPU_NEXT(s->query_cpu);
} else
put_packet(s, "l");
break;
} else if (strncmp(p,"ThreadExtraInfo,", 16) == 0) {
thread = strtoull(p+16, (char **)&p, 16);
cpu = find_cpu(thread);
if (cpu != NULL) {
cpu_synchronize_state(cpu);
/* memtohex() doubles the required space */
len = snprintf((char *)mem_buf, sizeof(buf) / 2,
"CPU#%d [%s]", cpu->cpu_index,
cpu->halted ? "halted " : "running");
memtohex(buf, mem_buf, len);
put_packet(s, buf);
}
break;
}
#ifdef CONFIG_USER_ONLY
else if (strcmp(p, "Offsets") == 0) {
TaskState *ts = s->c_cpu->opaque;
snprintf(buf, sizeof(buf),
"Text=" TARGET_ABI_FMT_lx ";Data=" TARGET_ABI_FMT_lx
";Bss=" TARGET_ABI_FMT_lx,
ts->info->code_offset,
ts->info->data_offset,
ts->info->data_offset);
put_packet(s, buf);
break;
}
#else /* !CONFIG_USER_ONLY */
else if (strncmp(p, "Rcmd,", 5) == 0) {
int len = strlen(p + 5);
if ((len % 2) != 0) {
put_packet(s, "E01");
break;
}
len = len / 2;
hextomem(mem_buf, p + 5, len);
mem_buf[len++] = 0;
qemu_chr_be_write(s->mon_chr, mem_buf, len);
put_packet(s, "OK");
break;
}
#endif /* !CONFIG_USER_ONLY */
if (is_query_packet(p, "Supported", ':')) {
snprintf(buf, sizeof(buf), "PacketSize=%x", MAX_PACKET_LENGTH);
cc = CPU_GET_CLASS(first_cpu);
if (cc->gdb_core_xml_file != NULL) {
pstrcat(buf, sizeof(buf), ";qXfer:features:read+");
}
put_packet(s, buf);
break;
}
if (strncmp(p, "Xfer:features:read:", 19) == 0) {
const char *xml;
target_ulong total_len;
cc = CPU_GET_CLASS(first_cpu);
if (cc->gdb_core_xml_file == NULL) {
goto unknown_command;
}
gdb_has_xml = true;
p += 19;
xml = get_feature_xml(p, &p, cc);
if (!xml) {
snprintf(buf, sizeof(buf), "E00");
put_packet(s, buf);
break;
}
if (*p == ':')
p++;
addr = strtoul(p, (char **)&p, 16);
if (*p == ',')
p++;
len = strtoul(p, (char **)&p, 16);
total_len = strlen(xml);
if (addr > total_len) {
snprintf(buf, sizeof(buf), "E00");
put_packet(s, buf);
break;
}
if (len > (MAX_PACKET_LENGTH - 5) / 2)
len = (MAX_PACKET_LENGTH - 5) / 2;
if (len < total_len - addr) {
buf[0] = 'm';
len = memtox(buf + 1, xml + addr, len);
} else {
buf[0] = 'l';
len = memtox(buf + 1, xml + addr, total_len - addr);
}
put_packet_binary(s, buf, len + 1);
break;
}
if (is_query_packet(p, "Attached", ':')) {
put_packet(s, GDB_ATTACHED);
break;
}
/* Unrecognised 'q' command. */
goto unknown_command;
default:
unknown_command:
/* put empty packet */
buf[0] = '\0';
put_packet(s, buf);
break;
}
return RS_IDLE;
}
static void gdb_vm_state_change(void *opaque, int running, RunState state)
{
GDBState *s = gdbserver_state;
CPUState *cpu = s->c_cpu;
char buf[256];
const char *type;
int ret;
if (running || s->state == RS_INACTIVE) {
return;
}
/* Is there a GDB syscall waiting to be sent? */
if (s->current_syscall_cb) {
put_packet(s, s->syscall_buf);
return;
}
switch (state) {
case RUN_STATE_DEBUG:
if (cpu->watchpoint_hit) {
switch (cpu->watchpoint_hit->flags & BP_MEM_ACCESS) {
case BP_MEM_READ:
type = "r";
break;
case BP_MEM_ACCESS:
type = "a";
break;
default:
type = "";
break;
}
snprintf(buf, sizeof(buf),
"T%02xthread:%02x;%swatch:" TARGET_FMT_lx ";",
GDB_SIGNAL_TRAP, cpu_index(cpu), type,
(target_ulong)cpu->watchpoint_hit->vaddr);
cpu->watchpoint_hit = NULL;
goto send_packet;
}
tb_flush(cpu);
ret = GDB_SIGNAL_TRAP;
break;
case RUN_STATE_PAUSED:
ret = GDB_SIGNAL_INT;
break;
case RUN_STATE_SHUTDOWN:
ret = GDB_SIGNAL_QUIT;
break;
case RUN_STATE_IO_ERROR:
ret = GDB_SIGNAL_IO;
break;
case RUN_STATE_WATCHDOG:
ret = GDB_SIGNAL_ALRM;
break;
case RUN_STATE_INTERNAL_ERROR:
ret = GDB_SIGNAL_ABRT;
break;
case RUN_STATE_SAVE_VM:
case RUN_STATE_RESTORE_VM:
return;
case RUN_STATE_FINISH_MIGRATE:
ret = GDB_SIGNAL_XCPU;
break;
default:
ret = GDB_SIGNAL_UNKNOWN;
break;
}
gdb_set_stop_cpu(cpu);
snprintf(buf, sizeof(buf), "T%02xthread:%02x;", ret, cpu_index(cpu));
send_packet:
put_packet(s, buf);
/* disable single step if it was enabled */
cpu_single_step(cpu, 0);
}
