static g_val_t multi_cpu_sintr_func (int cpu_index)
{
char *p;
cpu_util *cpu = &(cpu_sintr[cpu_index]);
if (num_cpustates == NUM_CPUSTATES_24X) {
cpu->val.f = 0.;
return cpu->val;
}
p = update_file(&proc_stat);
if((proc_stat.last_read.tv_sec != cpu->stamp.tv_sec) &&
(proc_stat.last_read.tv_usec != cpu->stamp.tv_usec)) {
cpu->stamp = proc_stat.last_read;
p = find_cpu (p, cpu_index, &cpu->curr_total_jiffies);
p = skip_token(p);
p = skip_token(p);
p = skip_token(p);
p = skip_token(p);
p = skip_token(p);
p = skip_token(p);
p = skip_whitespace(p);
calculate_utilization (p, cpu);
}
return cpu->val;
}
/* Show info about potential timer drift */
static int cmd_show_timer_drift(hypervisor_conn_t *conn,
int argc,char *argv[])
{
vm_instance_t *vm;
cpu_gen_t *cpu;
if (!(vm = hypervisor_find_object(conn,argv[0],OBJ_TYPE_VM)))
return(-1);
if (!(cpu = find_cpu(conn,vm,atoi(argv[1]))))
return(-1);
switch(cpu->type) {
case CPU_TYPE_MIPS64:
hypervisor_send_reply(conn,HSC_INFO_MSG,0,"Timer Drift: %u",
CPU_MIPS64(cpu)->timer_drift);
hypervisor_send_reply(conn,HSC_INFO_MSG,0,"Pending Timer IRQ: %u",
CPU_MIPS64(cpu)->timer_irq_pending);
break;
case CPU_TYPE_PPC32:
hypervisor_send_reply(conn,HSC_INFO_MSG,0,"Timer Drift: %u",
CPU_PPC32(cpu)->timer_drift);
hypervisor_send_reply(conn,HSC_INFO_MSG,0,"Pending Timer IRQ: %u",
CPU_PPC32(cpu)->timer_irq_pending);
break;
}
vm_release(vm);
hypervisor_send_reply(conn,HSC_INFO_OK,1,"OK");
return(0);
}
/*
* Callback to the ptree walk function during remove_cpus.
* As a part of the args receives a picl nodeh, searches
* the device tree for a cpu whose cpuid matches the picl cpu node.
* Sets arg struct's result to 1 if it failed to match and terminates
* the walk.
*/
static int
remove_cpu_candidate(picl_nodehdl_t nodeh, void *c_args)
{
di_node_t di_node;
cpu_lookup_t *cpu_arg;
int err;
int pcpuid;
int reg_prop[SUN4V_CPU_REGSIZE];
if (c_args == NULL)
return (PICL_INVALIDARG);
cpu_arg = c_args;
di_node = cpu_arg->di_node;
err = ptree_get_propval_by_name(nodeh, OBP_REG, reg_prop,
sizeof (reg_prop));
if (err != PICL_SUCCESS) {
return (PICL_WALK_CONTINUE);
}
pcpuid = CFGHDL_TO_CPUID(reg_prop[0]);
if (!find_cpu(di_node, pcpuid)) {
cpu_arg->result = 1;
cpu_arg->nodeh = nodeh;
return (PICL_WALK_TERMINATE);
}
cpu_arg->result = 0;
return (PICL_WALK_CONTINUE);
}
static g_val_t multi_cpu_user_func (int cpu_index)
{
char *p;
cpu_util *cpu = &(cpu_user[cpu_index]);
p = update_file(&proc_stat);
if((proc_stat.last_read.tv_sec != cpu->stamp.tv_sec) &&
(proc_stat.last_read.tv_usec != cpu->stamp.tv_usec)) {
cpu->stamp = proc_stat.last_read;
p = find_cpu (p, cpu_index, &cpu->curr_total_jiffies);
calculate_utilization (p, cpu);
}
return cpu->val;
}
/* Set CPU idle max value */
static int cmd_set_idle_max(hypervisor_conn_t *conn,int argc,char *argv[])
{
vm_instance_t *vm;
cpu_gen_t *cpu;
if (!(vm = hypervisor_find_object(conn,argv[0],OBJ_TYPE_VM)))
return(-1);
if (!(cpu = find_cpu(conn,vm,atoi(argv[1]))))
return(-1);
cpu->idle_max = atoi(argv[2]);
vm_release(vm);
hypervisor_send_reply(conn,HSC_INFO_OK,1,"OK");
return(0);
}
static g_val_t multi_cpu_nice_func (int cpu_index)
{
char *p;
cpu_util *cpu = &(cpu_nice[cpu_index]);
p = update_file(&proc_stat);
if((proc_stat.last_read.tv_sec != cpu->stamp.tv_sec) &&
(proc_stat.last_read.tv_usec != cpu->stamp.tv_usec)) {
cpu->stamp = proc_stat.last_read;
p = find_cpu (p, cpu_index);
p = skip_token(p);
p = skip_whitespace(p);
calculate_utilization (p, cpu);
}
return cpu->val;
}
static g_val_t multi_cpu_system_func (int cpu_index)
{
char *p;
cpu_util *cpu = &(cpu_system[cpu_index]);
p = update_file(&proc_stat);
if((proc_stat.last_read.tv_sec != cpu->stamp.tv_sec) &&
(proc_stat.last_read.tv_usec != cpu->stamp.tv_usec)) {
cpu->stamp = proc_stat.last_read;
p = find_cpu (p, cpu_index);
p = skip_token(p);
p = skip_token(p);
p = skip_whitespace(p);
cpu->curr_jiffies = strtod(p , (char **)NULL);
if (num_cpustates > NUM_CPUSTATES_24X) {
p = skip_token(p);
p = skip_token(p);
p = skip_token(p);
p = skip_whitespace(p);
cpu->curr_jiffies += strtod(p , (char **)NULL); /* "intr" counted in system */
p = skip_token(p);
cpu->curr_jiffies += strtod(p , (char **)NULL); /* "sintr" counted in system */
}
cpu->curr_total_jiffies = total_jiffies_func();
cpu->diff = cpu->curr_jiffies - cpu->last_jiffies;
if (cpu->diff)
cpu->val.f = (cpu->diff/(cpu->curr_total_jiffies - cpu->last_total_jiffies))*100;
else
cpu->val.f = 0.0;
cpu->last_jiffies = cpu->curr_jiffies;
cpu->last_total_jiffies = cpu->curr_total_jiffies;
}
return cpu->val;
}
/* Dump the idle PC proposals */
static int cmd_show_idle_pc_prop(hypervisor_conn_t *conn,int argc,char *argv[])
{
vm_instance_t *vm;
cpu_gen_t *cpu;
int i;
if (!(vm = hypervisor_find_object(conn,argv[0],OBJ_TYPE_VM)))
return(-1);
if (!(cpu = find_cpu(conn,vm,atoi(argv[1]))))
return(-1);
for(i=0;i<cpu->idle_pc_prop_count;i++) {
hypervisor_send_reply(conn,HSC_INFO_MSG,0,"0x%llx [%d]",
cpu->idle_pc_prop[i].pc,
cpu->idle_pc_prop[i].count);
}
vm_release(vm);
hypervisor_send_reply(conn,HSC_INFO_OK,1,"OK");
return(0);
}
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;
}
