From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from eggs.gnu.org ([2001:4830:134:3::10]:40504) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1XIHgw-0001vs-0D for qemu-devel@nongnu.org; Fri, 15 Aug 2014 09:37:20 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1XIHgg-000676-IP for qemu-devel@nongnu.org; Fri, 15 Aug 2014 09:37:13 -0400 Received: from lputeaux-656-01-25-125.w80-12.abo.wanadoo.fr ([80.12.84.125]:42483 helo=paradis.irqsave.net) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1XIHgf-000657-PB for qemu-devel@nongnu.org; Fri, 15 Aug 2014 09:36:58 -0400 From: =?UTF-8?q?Beno=C3=AEt=20Canet?= Date: Fri, 15 Aug 2014 15:35:45 +0200 Message-Id: <1408109759-1100-14-git-send-email-benoit.canet@nodalink.com> In-Reply-To: <1408109759-1100-1-git-send-email-benoit.canet@nodalink.com> References: <1408109759-1100-1-git-send-email-benoit.canet@nodalink.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: quoted-printable Subject: [Qemu-devel] [PATCH v2 13/26] monitor: Make some monitor functions public before moving them in monitor-system.c List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , To: qemu-devel@nongnu.org Cc: kwolf@redhat.com, pbonzini@redhat.com, =?UTF-8?q?Beno=C3=AEt=20Canet?= , stefanha@redhat.com This will allow monitor.c to access these functions once they are moved i= n monitor-system.c Signed-off-by: Beno=C3=AEt Canet --- include/monitor/monitor-system.h | 37 ++ monitor-system.c | 1164 ++++++++++++++++++++++++++++++++= ++++++ monitor.c | 1163 --------------------------------= ----- 3 files changed, 1201 insertions(+), 1163 deletions(-) diff --git a/include/monitor/monitor-system.h b/include/monitor/monitor-s= ystem.h index a9e6f36..319b30c 100644 --- a/include/monitor/monitor-system.h +++ b/include/monitor/monitor-system.h @@ -104,4 +104,41 @@ void do_trace_event_set_state(Monitor *mon, const QD= ict *qdict); void do_trace_file(Monitor *mon, const QDict *qdict); void do_info_help(Monitor *mon, const QDict *qdict); =20 +void do_info_registers(Monitor *mon, const QDict *qdict); +void do_info_jit(Monitor *mon, const QDict *qdict); +void do_info_history(Monitor *mon, const QDict *qdict); +void tlb_info(Monitor *mon, const QDict *qdict); +void mem_info(Monitor *mon, const QDict *qdict); +void do_info_mtree(Monitor *mon, const QDict *qdict); +void do_info_numa(Monitor *mon, const QDict *qdict); +void do_info_profile(Monitor *mon, const QDict *qdict); +void do_info_capture(Monitor *mon, const QDict *qdict); +void do_info_cpu_stats(Monitor *mon, const QDict *qdict); +void do_trace_print_events(Monitor *mon, const QDict *qdict); +void do_logfile(Monitor *mon, const QDict *qdict); +void do_log(Monitor *mon, const QDict *qdict); +void do_singlestep(Monitor *mon, const QDict *qdict); +void do_gdbserver(Monitor *mon, const QDict *qdict); +void do_memory_dump(Monitor *mon, const QDict *qdict); +void do_physical_memory_dump(Monitor *mon, const QDict *qdict); +void do_print(Monitor *mon, const QDict *qdict); +void do_ioport_read(Monitor *mon, const QDict *qdict); +void do_ioport_write(Monitor *mon, const QDict *qdict); +void do_sum(Monitor *mon, const QDict *qdict); +void do_mouse_move(Monitor *mon, const QDict *qdict); +void do_mouse_button(Monitor *mon, const QDict *qdict); +void do_wav_capture(Monitor *mon, const QDict *qdict); +void do_stop_capture(Monitor *mon, const QDict *qdict); +void do_boot_set(Monitor *mon, const QDict *qdict); +int client_migrate_info(Monitor *mon, const QDict *qdict, + MonitorCompletion cb, void *opaque); +void do_watchdog_action(Monitor *mon, const QDict *qdict); +void do_acl_show(Monitor *mon, const QDict *qdict); +void do_acl_policy(Monitor *mon, const QDict *qdict); +void do_acl_add(Monitor *mon, const QDict *qdict); +void do_acl_remove(Monitor *mon, const QDict *qdict); +void do_acl_reset(Monitor *mon, const QDict *qdict); +void do_inject_mce(Monitor *mon, const QDict *qdict); +CPUArchState *mon_get_cpu(void); + #endif diff --git a/monitor-system.c b/monitor-system.c index 9dc270b..a87203c 100644 --- a/monitor-system.c +++ b/monitor-system.c @@ -26,6 +26,7 @@ =20 #include "net/net.h" #include "exec/address-spaces.h" +#include "exec/cpu_ldst.h" #include "exec/gdbstub.h" #include "hw/usb.h" #include "hw/pcmcia.h" @@ -236,3 +237,1166 @@ void do_info_help(Monitor *mon, const QDict *qdict= ) { help_cmd(mon, "info"); } + +/* set the current CPU defined by the user */ +int monitor_set_cpu(int cpu_index) +{ + CPUState *cpu; + + cpu =3D qemu_get_cpu(cpu_index); + if (cpu =3D=3D NULL) { + return -1; + } + cur_mon->mon_cpu =3D cpu; + return 0; +} + +CPUArchState *mon_get_cpu(void) +{ + if (!cur_mon->mon_cpu) { + monitor_set_cpu(0); + } + cpu_synchronize_state(cur_mon->mon_cpu); + return cur_mon->mon_cpu->env_ptr; +} + +int monitor_get_cpu_index(void) +{ + CPUState *cpu =3D ENV_GET_CPU(mon_get_cpu()); + return cpu->cpu_index; +} + +void do_info_registers(Monitor *mon, const QDict *qdict) +{ + CPUState *cpu; + CPUArchState *env; + env =3D mon_get_cpu(); + cpu =3D ENV_GET_CPU(env); + cpu_dump_state(cpu, (FILE *)mon, monitor_fprintf, CPU_DUMP_FPU); +} + +void do_info_jit(Monitor *mon, const QDict *qdict) +{ + dump_exec_info((FILE *)mon, monitor_fprintf); + dump_drift_info((FILE *)mon, monitor_fprintf); +} + +void do_info_history(Monitor *mon, const QDict *qdict) +{ + int i; + const char *str; + + if (!mon->rs) + return; + i =3D 0; + for(;;) { + str =3D readline_get_history(mon->rs, i); + if (!str) + break; + monitor_printf(mon, "%d: '%s'\n", i, str); + i++; + } +} + +void do_info_cpu_stats(Monitor *mon, const QDict *qdict) +{ + CPUState *cpu; + CPUArchState *env; + + env =3D mon_get_cpu(); + cpu =3D ENV_GET_CPU(env); + cpu_dump_statistics(cpu, (FILE *)mon, &monitor_fprintf, 0); +} + +void do_trace_print_events(Monitor *mon, const QDict *qdict) +{ + trace_print_events((FILE *)mon, &monitor_fprintf); +} + +int client_migrate_info(Monitor *mon, const QDict *qdict, + MonitorCompletion cb, void *opaque) +{ + const char *protocol =3D qdict_get_str(qdict, "protocol"); + const char *hostname =3D qdict_get_str(qdict, "hostname"); + const char *subject =3D qdict_get_try_str(qdict, "cert-subject"); + int port =3D qdict_get_try_int(qdict, "port", -1); + int tls_port =3D qdict_get_try_int(qdict, "tls-port", -1); + int ret; + + if (strcmp(protocol, "spice") =3D=3D 0) { + if (!using_spice) { + qerror_report(QERR_DEVICE_NOT_ACTIVE, "spice"); + return -1; + } + + if (port =3D=3D -1 && tls_port =3D=3D -1) { + qerror_report(QERR_MISSING_PARAMETER, "port/tls-port"); + return -1; + } + + ret =3D qemu_spice_migrate_info(hostname, port, tls_port, subjec= t, + cb, opaque); + if (ret !=3D 0) { + qerror_report(QERR_UNDEFINED_ERROR); + return -1; + } + return 0; + } + + qerror_report(QERR_INVALID_PARAMETER, "protocol"); + return -1; +} + +void do_logfile(Monitor *mon, const QDict *qdict) +{ + qemu_set_log_filename(qdict_get_str(qdict, "filename")); +} + +void do_log(Monitor *mon, const QDict *qdict) +{ + int mask; + const char *items =3D qdict_get_str(qdict, "items"); + + if (!strcmp(items, "none")) { + mask =3D 0; + } else { + mask =3D qemu_str_to_log_mask(items); + if (!mask) { + help_cmd(mon, "log"); + return; + } + } + qemu_set_log(mask); +} + +void do_singlestep(Monitor *mon, const QDict *qdict) +{ + const char *option =3D qdict_get_try_str(qdict, "option"); + if (!option || !strcmp(option, "on")) { + singlestep =3D 1; + } else if (!strcmp(option, "off")) { + singlestep =3D 0; + } else { + monitor_printf(mon, "unexpected option %s\n", option); + } +} + +void do_gdbserver(Monitor *mon, const QDict *qdict) +{ + const char *device =3D qdict_get_try_str(qdict, "device"); + if (!device) + device =3D "tcp::" DEFAULT_GDBSTUB_PORT; + if (gdbserver_start(device) < 0) { + monitor_printf(mon, "Could not open gdbserver on device '%s'\n", + device); + } else if (strcmp(device, "none") =3D=3D 0) { + monitor_printf(mon, "Disabled gdbserver\n"); + } else { + monitor_printf(mon, "Waiting for gdb connection on device '%s'\n= ", + device); + } +} + +void do_watchdog_action(Monitor *mon, const QDict *qdict) +{ + const char *action =3D qdict_get_str(qdict, "action"); + if (select_watchdog_action(action) =3D=3D -1) { + monitor_printf(mon, "Unknown watchdog action '%s'\n", action); + } +} + +static void monitor_printc(Monitor *mon, int c) +{ + monitor_printf(mon, "'"); + switch(c) { + case '\'': + monitor_printf(mon, "\\'"); + break; + case '\\': + monitor_printf(mon, "\\\\"); + break; + case '\n': + monitor_printf(mon, "\\n"); + break; + case '\r': + monitor_printf(mon, "\\r"); + break; + default: + if (c >=3D 32 && c <=3D 126) { + monitor_printf(mon, "%c", c); + } else { + monitor_printf(mon, "\\x%02x", c); + } + break; + } + monitor_printf(mon, "'"); +} + +static void memory_dump(Monitor *mon, int count, int format, int wsize, + hwaddr addr, int is_physical) +{ + CPUArchState *env; + int l, line_size, i, max_digits, len; + uint8_t buf[16]; + uint64_t v; + + if (format =3D=3D 'i') { + int flags; + flags =3D 0; + env =3D mon_get_cpu(); +#ifdef TARGET_I386 + if (wsize =3D=3D 2) { + flags =3D 1; + } else if (wsize =3D=3D 4) { + flags =3D 0; + } else { + /* as default we use the current CS size */ + flags =3D 0; + if (env) { +#ifdef TARGET_X86_64 + if ((env->efer & MSR_EFER_LMA) && + (env->segs[R_CS].flags & DESC_L_MASK)) + flags =3D 2; + else +#endif + if (!(env->segs[R_CS].flags & DESC_B_MASK)) + flags =3D 1; + } + } +#endif +#ifdef TARGET_PPC + flags =3D msr_le << 16; + flags |=3D env->bfd_mach; +#endif + monitor_disas(mon, env, addr, count, is_physical, flags); + return; + } + + len =3D wsize * count; + if (wsize =3D=3D 1) + line_size =3D 8; + else + line_size =3D 16; + max_digits =3D 0; + + switch(format) { + case 'o': + max_digits =3D (wsize * 8 + 2) / 3; + break; + default: + case 'x': + max_digits =3D (wsize * 8) / 4; + break; + case 'u': + case 'd': + max_digits =3D (wsize * 8 * 10 + 32) / 33; + break; + case 'c': + wsize =3D 1; + break; + } + + while (len > 0) { + if (is_physical) + monitor_printf(mon, TARGET_FMT_plx ":", addr); + else + monitor_printf(mon, TARGET_FMT_lx ":", (target_ulong)addr); + l =3D len; + if (l > line_size) + l =3D line_size; + if (is_physical) { + cpu_physical_memory_read(addr, buf, l); + } else { + env =3D mon_get_cpu(); + if (cpu_memory_rw_debug(ENV_GET_CPU(env), addr, buf, l, 0) <= 0) { + monitor_printf(mon, " Cannot access memory\n"); + break; + } + } + i =3D 0; + while (i < l) { + switch(wsize) { + default: + case 1: + v =3D ldub_raw(buf + i); + break; + case 2: + v =3D lduw_raw(buf + i); + break; + case 4: + v =3D (uint32_t)ldl_raw(buf + i); + break; + case 8: + v =3D ldq_raw(buf + i); + break; + } + monitor_printf(mon, " "); + switch(format) { + case 'o': + monitor_printf(mon, "%#*" PRIo64, max_digits, v); + break; + case 'x': + monitor_printf(mon, "0x%0*" PRIx64, max_digits, v); + break; + case 'u': + monitor_printf(mon, "%*" PRIu64, max_digits, v); + break; + case 'd': + monitor_printf(mon, "%*" PRId64, max_digits, v); + break; + case 'c': + monitor_printc(mon, v); + break; + } + i +=3D wsize; + } + monitor_printf(mon, "\n"); + addr +=3D l; + len -=3D l; + } +} + +void do_memory_dump(Monitor *mon, const QDict *qdict) +{ + int count =3D qdict_get_int(qdict, "count"); + int format =3D qdict_get_int(qdict, "format"); + int size =3D qdict_get_int(qdict, "size"); + target_long addr =3D qdict_get_int(qdict, "addr"); + + memory_dump(mon, count, format, size, addr, 0); +} + +void do_physical_memory_dump(Monitor *mon, const QDict *qdict) +{ + int count =3D qdict_get_int(qdict, "count"); + int format =3D qdict_get_int(qdict, "format"); + int size =3D qdict_get_int(qdict, "size"); + hwaddr addr =3D qdict_get_int(qdict, "addr"); + + memory_dump(mon, count, format, size, addr, 1); +} + +void do_print(Monitor *mon, const QDict *qdict) +{ + int format =3D qdict_get_int(qdict, "format"); + hwaddr val =3D qdict_get_int(qdict, "val"); + + switch(format) { + case 'o': + monitor_printf(mon, "%#" HWADDR_PRIo, val); + break; + case 'x': + monitor_printf(mon, "%#" HWADDR_PRIx, val); + break; + case 'u': + monitor_printf(mon, "%" HWADDR_PRIu, val); + break; + default: + case 'd': + monitor_printf(mon, "%" HWADDR_PRId, val); + break; + case 'c': + monitor_printc(mon, val); + break; + } + monitor_printf(mon, "\n"); +} + +void do_sum(Monitor *mon, const QDict *qdict) +{ + uint32_t addr; + uint16_t sum; + uint32_t start =3D qdict_get_int(qdict, "start"); + uint32_t size =3D qdict_get_int(qdict, "size"); + + sum =3D 0; + for(addr =3D start; addr < (start + size); addr++) { + uint8_t val =3D ldub_phys(&address_space_memory, addr); + /* BSD sum algorithm ('sum' Unix command) */ + sum =3D (sum >> 1) | (sum << 15); + sum +=3D val; + } + monitor_printf(mon, "%05d\n", sum); +} + +static int mouse_button_state; + +void do_mouse_move(Monitor *mon, const QDict *qdict) +{ + int dx, dy, dz, button; + const char *dx_str =3D qdict_get_str(qdict, "dx_str"); + const char *dy_str =3D qdict_get_str(qdict, "dy_str"); + const char *dz_str =3D qdict_get_try_str(qdict, "dz_str"); + + dx =3D strtol(dx_str, NULL, 0); + dy =3D strtol(dy_str, NULL, 0); + qemu_input_queue_rel(NULL, INPUT_AXIS_X, dx); + qemu_input_queue_rel(NULL, INPUT_AXIS_Y, dy); + + if (dz_str) { + dz =3D strtol(dz_str, NULL, 0); + if (dz !=3D 0) { + button =3D (dz > 0) ? INPUT_BUTTON_WHEEL_UP : INPUT_BUTTON_W= HEEL_DOWN; + qemu_input_queue_btn(NULL, button, true); + qemu_input_event_sync(); + qemu_input_queue_btn(NULL, button, false); + } + } + qemu_input_event_sync(); +} + +void do_mouse_button(Monitor *mon, const QDict *qdict) +{ + static uint32_t bmap[INPUT_BUTTON_MAX] =3D { + [INPUT_BUTTON_LEFT] =3D MOUSE_EVENT_LBUTTON, + [INPUT_BUTTON_MIDDLE] =3D MOUSE_EVENT_MBUTTON, + [INPUT_BUTTON_RIGHT] =3D MOUSE_EVENT_RBUTTON, + }; + int button_state =3D qdict_get_int(qdict, "button_state"); + + if (mouse_button_state =3D=3D button_state) { + return; + } + qemu_input_update_buttons(NULL, bmap, mouse_button_state, button_sta= te); + qemu_input_event_sync(); + mouse_button_state =3D button_state; +} + +void do_ioport_read(Monitor *mon, const QDict *qdict) +{ + int size =3D qdict_get_int(qdict, "size"); + int addr =3D qdict_get_int(qdict, "addr"); + int has_index =3D qdict_haskey(qdict, "index"); + uint32_t val; + int suffix; + + if (has_index) { + int index =3D qdict_get_int(qdict, "index"); + cpu_outb(addr & IOPORTS_MASK, index & 0xff); + addr++; + } + addr &=3D 0xffff; + + switch(size) { + default: + case 1: + val =3D cpu_inb(addr); + suffix =3D 'b'; + break; + case 2: + val =3D cpu_inw(addr); + suffix =3D 'w'; + break; + case 4: + val =3D cpu_inl(addr); + suffix =3D 'l'; + break; + } + monitor_printf(mon, "port%c[0x%04x] =3D %#0*x\n", + suffix, addr, size * 2, val); +} + +void do_ioport_write(Monitor *mon, const QDict *qdict) +{ + int size =3D qdict_get_int(qdict, "size"); + int addr =3D qdict_get_int(qdict, "addr"); + int val =3D qdict_get_int(qdict, "val"); + + addr &=3D IOPORTS_MASK; + + switch (size) { + default: + case 1: + cpu_outb(addr, val); + break; + case 2: + cpu_outw(addr, val); + break; + case 4: + cpu_outl(addr, val); + break; + } +} + +void do_boot_set(Monitor *mon, const QDict *qdict) +{ + int res; + const char *bootdevice =3D qdict_get_str(qdict, "bootdevice"); + + res =3D qemu_boot_set(bootdevice); + if (res =3D=3D 0) { + monitor_printf(mon, "boot device list now set to %s\n", bootdevi= ce); + } else if (res > 0) { + monitor_printf(mon, "setting boot device list failed\n"); + } else { + monitor_printf(mon, "no function defined to set boot device list= for " + "this architecture\n"); + } +} + +#if defined(TARGET_I386) +static void print_pte(Monitor *mon, hwaddr addr, + hwaddr pte, + hwaddr mask) +{ +#ifdef TARGET_X86_64 + if (addr & (1ULL << 47)) { + addr |=3D -1LL << 48; + } +#endif + monitor_printf(mon, TARGET_FMT_plx ": " TARGET_FMT_plx + " %c%c%c%c%c%c%c%c%c\n", + addr, + pte & mask, + pte & PG_NX_MASK ? 'X' : '-', + pte & PG_GLOBAL_MASK ? 'G' : '-', + pte & PG_PSE_MASK ? 'P' : '-', + pte & PG_DIRTY_MASK ? 'D' : '-', + pte & PG_ACCESSED_MASK ? 'A' : '-', + pte & PG_PCD_MASK ? 'C' : '-', + pte & PG_PWT_MASK ? 'T' : '-', + pte & PG_USER_MASK ? 'U' : '-', + pte & PG_RW_MASK ? 'W' : '-'); +} + +static void tlb_info_32(Monitor *mon, CPUArchState *env) +{ + unsigned int l1, l2; + uint32_t pgd, pde, pte; + + pgd =3D env->cr[3] & ~0xfff; + for(l1 =3D 0; l1 < 1024; l1++) { + cpu_physical_memory_read(pgd + l1 * 4, &pde, 4); + pde =3D le32_to_cpu(pde); + if (pde & PG_PRESENT_MASK) { + if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) { + /* 4M pages */ + print_pte(mon, (l1 << 22), pde, ~((1 << 21) - 1)); + } else { + for(l2 =3D 0; l2 < 1024; l2++) { + cpu_physical_memory_read((pde & ~0xfff) + l2 * 4, &p= te, 4); + pte =3D le32_to_cpu(pte); + if (pte & PG_PRESENT_MASK) { + print_pte(mon, (l1 << 22) + (l2 << 12), + pte & ~PG_PSE_MASK, + ~0xfff); + } + } + } + } + } +} + +static void tlb_info_pae32(Monitor *mon, CPUArchState *env) +{ + unsigned int l1, l2, l3; + uint64_t pdpe, pde, pte; + uint64_t pdp_addr, pd_addr, pt_addr; + + pdp_addr =3D env->cr[3] & ~0x1f; + for (l1 =3D 0; l1 < 4; l1++) { + cpu_physical_memory_read(pdp_addr + l1 * 8, &pdpe, 8); + pdpe =3D le64_to_cpu(pdpe); + if (pdpe & PG_PRESENT_MASK) { + pd_addr =3D pdpe & 0x3fffffffff000ULL; + for (l2 =3D 0; l2 < 512; l2++) { + cpu_physical_memory_read(pd_addr + l2 * 8, &pde, 8); + pde =3D le64_to_cpu(pde); + if (pde & PG_PRESENT_MASK) { + if (pde & PG_PSE_MASK) { + /* 2M pages with PAE, CR4.PSE is ignored */ + print_pte(mon, (l1 << 30 ) + (l2 << 21), pde, + ~((hwaddr)(1 << 20) - 1)); + } else { + pt_addr =3D pde & 0x3fffffffff000ULL; + for (l3 =3D 0; l3 < 512; l3++) { + cpu_physical_memory_read(pt_addr + l3 * 8, &= pte, 8); + pte =3D le64_to_cpu(pte); + if (pte & PG_PRESENT_MASK) { + print_pte(mon, (l1 << 30 ) + (l2 << 21) + + (l3 << 12), + pte & ~PG_PSE_MASK, + ~(hwaddr)0xfff); + } + } + } + } + } + } + } +} + +#ifdef TARGET_X86_64 +static void tlb_info_64(Monitor *mon, CPUArchState *env) +{ + uint64_t l1, l2, l3, l4; + uint64_t pml4e, pdpe, pde, pte; + uint64_t pml4_addr, pdp_addr, pd_addr, pt_addr; + + pml4_addr =3D env->cr[3] & 0x3fffffffff000ULL; + for (l1 =3D 0; l1 < 512; l1++) { + cpu_physical_memory_read(pml4_addr + l1 * 8, &pml4e, 8); + pml4e =3D le64_to_cpu(pml4e); + if (pml4e & PG_PRESENT_MASK) { + pdp_addr =3D pml4e & 0x3fffffffff000ULL; + for (l2 =3D 0; l2 < 512; l2++) { + cpu_physical_memory_read(pdp_addr + l2 * 8, &pdpe, 8); + pdpe =3D le64_to_cpu(pdpe); + if (pdpe & PG_PRESENT_MASK) { + if (pdpe & PG_PSE_MASK) { + /* 1G pages, CR4.PSE is ignored */ + print_pte(mon, (l1 << 39) + (l2 << 30), pdpe, + 0x3ffffc0000000ULL); + } else { + pd_addr =3D pdpe & 0x3fffffffff000ULL; + for (l3 =3D 0; l3 < 512; l3++) { + cpu_physical_memory_read(pd_addr + l3 * 8, &= pde, 8); + pde =3D le64_to_cpu(pde); + if (pde & PG_PRESENT_MASK) { + if (pde & PG_PSE_MASK) { + /* 2M pages, CR4.PSE is ignored */ + print_pte(mon, (l1 << 39) + (l2 << 3= 0) + + (l3 << 21), pde, + 0x3ffffffe00000ULL); + } else { + pt_addr =3D pde & 0x3fffffffff000ULL= ; + for (l4 =3D 0; l4 < 512; l4++) { + cpu_physical_memory_read(pt_addr + + l4 * = 8, + &pte, 8= ); + pte =3D le64_to_cpu(pte); + if (pte & PG_PRESENT_MASK) { + print_pte(mon, (l1 << 39) + + (l2 << 30) + + (l3 << 21) + (l4 <= < 12), + pte & ~PG_PSE_MASK= , + 0x3fffffffff000ULL= ); + } + } + } + } + } + } + } + } + } + } +} +#endif + +void tlb_info(Monitor *mon, const QDict *qdict) +{ + CPUArchState *env; + + env =3D mon_get_cpu(); + + if (!(env->cr[0] & CR0_PG_MASK)) { + monitor_printf(mon, "PG disabled\n"); + return; + } + if (env->cr[4] & CR4_PAE_MASK) { +#ifdef TARGET_X86_64 + if (env->hflags & HF_LMA_MASK) { + tlb_info_64(mon, env); + } else +#endif + { + tlb_info_pae32(mon, env); + } + } else { + tlb_info_32(mon, env); + } +} + +static void mem_print(Monitor *mon, hwaddr *pstart, + int *plast_prot, + hwaddr end, int prot) +{ + int prot1; + prot1 =3D *plast_prot; + if (prot !=3D prot1) { + if (*pstart !=3D -1) { + monitor_printf(mon, TARGET_FMT_plx "-" TARGET_FMT_plx " " + TARGET_FMT_plx " %c%c%c\n", + *pstart, end, end - *pstart, + prot1 & PG_USER_MASK ? 'u' : '-', + 'r', + prot1 & PG_RW_MASK ? 'w' : '-'); + } + if (prot !=3D 0) + *pstart =3D end; + else + *pstart =3D -1; + *plast_prot =3D prot; + } +} + +static void mem_info_32(Monitor *mon, CPUArchState *env) +{ + unsigned int l1, l2; + int prot, last_prot; + uint32_t pgd, pde, pte; + hwaddr start, end; + + pgd =3D env->cr[3] & ~0xfff; + last_prot =3D 0; + start =3D -1; + for(l1 =3D 0; l1 < 1024; l1++) { + cpu_physical_memory_read(pgd + l1 * 4, &pde, 4); + pde =3D le32_to_cpu(pde); + end =3D l1 << 22; + if (pde & PG_PRESENT_MASK) { + if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) { + prot =3D pde & (PG_USER_MASK | PG_RW_MASK | PG_PRESENT_M= ASK); + mem_print(mon, &start, &last_prot, end, prot); + } else { + for(l2 =3D 0; l2 < 1024; l2++) { + cpu_physical_memory_read((pde & ~0xfff) + l2 * 4, &p= te, 4); + pte =3D le32_to_cpu(pte); + end =3D (l1 << 22) + (l2 << 12); + if (pte & PG_PRESENT_MASK) { + prot =3D pte & pde & + (PG_USER_MASK | PG_RW_MASK | PG_PRESENT_MASK= ); + } else { + prot =3D 0; + } + mem_print(mon, &start, &last_prot, end, prot); + } + } + } else { + prot =3D 0; + mem_print(mon, &start, &last_prot, end, prot); + } + } + /* Flush last range */ + mem_print(mon, &start, &last_prot, (hwaddr)1 << 32, 0); +} + +static void mem_info_pae32(Monitor *mon, CPUArchState *env) +{ + unsigned int l1, l2, l3; + int prot, last_prot; + uint64_t pdpe, pde, pte; + uint64_t pdp_addr, pd_addr, pt_addr; + hwaddr start, end; + + pdp_addr =3D env->cr[3] & ~0x1f; + last_prot =3D 0; + start =3D -1; + for (l1 =3D 0; l1 < 4; l1++) { + cpu_physical_memory_read(pdp_addr + l1 * 8, &pdpe, 8); + pdpe =3D le64_to_cpu(pdpe); + end =3D l1 << 30; + if (pdpe & PG_PRESENT_MASK) { + pd_addr =3D pdpe & 0x3fffffffff000ULL; + for (l2 =3D 0; l2 < 512; l2++) { + cpu_physical_memory_read(pd_addr + l2 * 8, &pde, 8); + pde =3D le64_to_cpu(pde); + end =3D (l1 << 30) + (l2 << 21); + if (pde & PG_PRESENT_MASK) { + if (pde & PG_PSE_MASK) { + prot =3D pde & (PG_USER_MASK | PG_RW_MASK | + PG_PRESENT_MASK); + mem_print(mon, &start, &last_prot, end, prot); + } else { + pt_addr =3D pde & 0x3fffffffff000ULL; + for (l3 =3D 0; l3 < 512; l3++) { + cpu_physical_memory_read(pt_addr + l3 * 8, &= pte, 8); + pte =3D le64_to_cpu(pte); + end =3D (l1 << 30) + (l2 << 21) + (l3 << 12)= ; + if (pte & PG_PRESENT_MASK) { + prot =3D pte & pde & (PG_USER_MASK | PG_= RW_MASK | + PG_PRESENT_MASK); + } else { + prot =3D 0; + } + mem_print(mon, &start, &last_prot, end, prot= ); + } + } + } else { + prot =3D 0; + mem_print(mon, &start, &last_prot, end, prot); + } + } + } else { + prot =3D 0; + mem_print(mon, &start, &last_prot, end, prot); + } + } + /* Flush last range */ + mem_print(mon, &start, &last_prot, (hwaddr)1 << 32, 0); +} + + +#ifdef TARGET_X86_64 +static void mem_info_64(Monitor *mon, CPUArchState *env) +{ + int prot, last_prot; + uint64_t l1, l2, l3, l4; + uint64_t pml4e, pdpe, pde, pte; + uint64_t pml4_addr, pdp_addr, pd_addr, pt_addr, start, end; + + pml4_addr =3D env->cr[3] & 0x3fffffffff000ULL; + last_prot =3D 0; + start =3D -1; + for (l1 =3D 0; l1 < 512; l1++) { + cpu_physical_memory_read(pml4_addr + l1 * 8, &pml4e, 8); + pml4e =3D le64_to_cpu(pml4e); + end =3D l1 << 39; + if (pml4e & PG_PRESENT_MASK) { + pdp_addr =3D pml4e & 0x3fffffffff000ULL; + for (l2 =3D 0; l2 < 512; l2++) { + cpu_physical_memory_read(pdp_addr + l2 * 8, &pdpe, 8); + pdpe =3D le64_to_cpu(pdpe); + end =3D (l1 << 39) + (l2 << 30); + if (pdpe & PG_PRESENT_MASK) { + if (pdpe & PG_PSE_MASK) { + prot =3D pdpe & (PG_USER_MASK | PG_RW_MASK | + PG_PRESENT_MASK); + prot &=3D pml4e; + mem_print(mon, &start, &last_prot, end, prot); + } else { + pd_addr =3D pdpe & 0x3fffffffff000ULL; + for (l3 =3D 0; l3 < 512; l3++) { + cpu_physical_memory_read(pd_addr + l3 * 8, &= pde, 8); + pde =3D le64_to_cpu(pde); + end =3D (l1 << 39) + (l2 << 30) + (l3 << 21)= ; + if (pde & PG_PRESENT_MASK) { + if (pde & PG_PSE_MASK) { + prot =3D pde & (PG_USER_MASK | PG_RW= _MASK | + PG_PRESENT_MASK); + prot &=3D pml4e & pdpe; + mem_print(mon, &start, &last_prot, e= nd, prot); + } else { + pt_addr =3D pde & 0x3fffffffff000ULL= ; + for (l4 =3D 0; l4 < 512; l4++) { + cpu_physical_memory_read(pt_addr + + l4 * = 8, + &pte, 8= ); + pte =3D le64_to_cpu(pte); + end =3D (l1 << 39) + (l2 << 30) = + + (l3 << 21) + (l4 << 12); + if (pte & PG_PRESENT_MASK) { + prot =3D pte & (PG_USER_MASK= | PG_RW_MASK | + PG_PRESENT_MAS= K); + prot &=3D pml4e & pdpe & pde= ; + } else { + prot =3D 0; + } + mem_print(mon, &start, &last_pro= t, end, prot); + } + } + } else { + prot =3D 0; + mem_print(mon, &start, &last_prot, end, = prot); + } + } + } + } else { + prot =3D 0; + mem_print(mon, &start, &last_prot, end, prot); + } + } + } else { + prot =3D 0; + mem_print(mon, &start, &last_prot, end, prot); + } + } + /* Flush last range */ + mem_print(mon, &start, &last_prot, (hwaddr)1 << 48, 0); +} +#endif + +void mem_info(Monitor *mon, const QDict *qdict) +{ + CPUArchState *env; + + env =3D mon_get_cpu(); + + if (!(env->cr[0] & CR0_PG_MASK)) { + monitor_printf(mon, "PG disabled\n"); + return; + } + if (env->cr[4] & CR4_PAE_MASK) { +#ifdef TARGET_X86_64 + if (env->hflags & HF_LMA_MASK) { + mem_info_64(mon, env); + } else +#endif + { + mem_info_pae32(mon, env); + } + } else { + mem_info_32(mon, env); + } +} +#endif + +#if defined(TARGET_SH4) + +static void print_tlb(Monitor *mon, int idx, tlb_t *tlb) +{ + monitor_printf(mon, " tlb%i:\t" + "asid=3D%hhu vpn=3D%x\tppn=3D%x\tsz=3D%hhu size=3D%u\= t" + "v=3D%hhu shared=3D%hhu cached=3D%hhu prot=3D%hhu " + "dirty=3D%hhu writethrough=3D%hhu\n", + idx, + tlb->asid, tlb->vpn, tlb->ppn, tlb->sz, tlb->size, + tlb->v, tlb->sh, tlb->c, tlb->pr, + tlb->d, tlb->wt); +} + +void tlb_info(Monitor *mon, const QDict *qdict) +{ + CPUArchState *env =3D mon_get_cpu(); + int i; + + monitor_printf (mon, "ITLB:\n"); + for (i =3D 0 ; i < ITLB_SIZE ; i++) + print_tlb (mon, i, &env->itlb[i]); + monitor_printf (mon, "UTLB:\n"); + for (i =3D 0 ; i < UTLB_SIZE ; i++) + print_tlb (mon, i, &env->utlb[i]); +} + +#endif + +#if defined(TARGET_SPARC) || defined(TARGET_PPC) || defined(TARGET_XTENS= A) +void tlb_info(Monitor *mon, const QDict *qdict) +{ + CPUArchState *env1 =3D mon_get_cpu(); + + dump_mmu((FILE*)mon, (fprintf_function)monitor_printf, env1); +} +#endif + +void do_info_mtree(Monitor *mon, const QDict *qdict) +{ + mtree_info((fprintf_function)monitor_printf, mon); +} + +void do_info_numa(Monitor *mon, const QDict *qdict) +{ + int i; + CPUState *cpu; + + monitor_printf(mon, "%d nodes\n", nb_numa_nodes); + for (i =3D 0; i < nb_numa_nodes; i++) { + monitor_printf(mon, "node %d cpus:", i); + CPU_FOREACH(cpu) { + if (cpu->numa_node =3D=3D i) { + monitor_printf(mon, " %d", cpu->cpu_index); + } + } + monitor_printf(mon, "\n"); + monitor_printf(mon, "node %d size: %" PRId64 " MB\n", i, + numa_info[i].node_mem >> 20); + } +} + +#ifdef CONFIG_PROFILER + +int64_t qemu_time; +int64_t dev_time; + +void do_info_profile(Monitor *mon, const QDict *qdict) +{ + monitor_printf(mon, "async time %" PRId64 " (%0.3f)\n", + dev_time, dev_time / (double)get_ticks_per_sec()); + monitor_printf(mon, "qemu time %" PRId64 " (%0.3f)\n", + qemu_time, qemu_time / (double)get_ticks_per_sec()); + qemu_time =3D 0; + dev_time =3D 0; +} +#else +void do_info_profile(Monitor *mon, const QDict *qdict) +{ + monitor_printf(mon, "Internal profiler not compiled\n"); +} +#endif + +/* Capture support */ +static QLIST_HEAD (capture_list_head, CaptureState) capture_head; + +void do_info_capture(Monitor *mon, const QDict *qdict) +{ + int i; + CaptureState *s; + + for (s =3D capture_head.lh_first, i =3D 0; s; s =3D s->entries.le_ne= xt, ++i) { + monitor_printf(mon, "[%d]: ", i); + s->ops.info (s->opaque); + } +} + +void do_stop_capture(Monitor *mon, const QDict *qdict) +{ + int i; + int n =3D qdict_get_int(qdict, "n"); + CaptureState *s; + + for (s =3D capture_head.lh_first, i =3D 0; s; s =3D s->entries.le_ne= xt, ++i) { + if (i =3D=3D n) { + s->ops.destroy (s->opaque); + QLIST_REMOVE (s, entries); + g_free (s); + return; + } + } +} + +void do_wav_capture(Monitor *mon, const QDict *qdict) +{ + const char *path =3D qdict_get_str(qdict, "path"); + int has_freq =3D qdict_haskey(qdict, "freq"); + int freq =3D qdict_get_try_int(qdict, "freq", -1); + int has_bits =3D qdict_haskey(qdict, "bits"); + int bits =3D qdict_get_try_int(qdict, "bits", -1); + int has_channels =3D qdict_haskey(qdict, "nchannels"); + int nchannels =3D qdict_get_try_int(qdict, "nchannels", -1); + CaptureState *s; + + s =3D g_malloc0 (sizeof (*s)); + + freq =3D has_freq ? freq : 44100; + bits =3D has_bits ? bits : 16; + nchannels =3D has_channels ? nchannels : 2; + + if (wav_start_capture (s, path, freq, bits, nchannels)) { + monitor_printf(mon, "Failed to add wave capture\n"); + g_free (s); + return; + } + QLIST_INSERT_HEAD (&capture_head, s, entries); +} + +static qemu_acl *find_acl(Monitor *mon, const char *name) +{ + qemu_acl *acl =3D qemu_acl_find(name); + + if (!acl) { + monitor_printf(mon, "acl: unknown list '%s'\n", name); + } + return acl; +} + +void do_acl_show(Monitor *mon, const QDict *qdict) +{ + const char *aclname =3D qdict_get_str(qdict, "aclname"); + qemu_acl *acl =3D find_acl(mon, aclname); + qemu_acl_entry *entry; + int i =3D 0; + + if (acl) { + monitor_printf(mon, "policy: %s\n", + acl->defaultDeny ? "deny" : "allow"); + QTAILQ_FOREACH(entry, &acl->entries, next) { + i++; + monitor_printf(mon, "%d: %s %s\n", i, + entry->deny ? "deny" : "allow", entry->match)= ; + } + } +} + +void do_acl_reset(Monitor *mon, const QDict *qdict) +{ + const char *aclname =3D qdict_get_str(qdict, "aclname"); + qemu_acl *acl =3D find_acl(mon, aclname); + + if (acl) { + qemu_acl_reset(acl); + monitor_printf(mon, "acl: removed all rules\n"); + } +} + +void do_acl_policy(Monitor *mon, const QDict *qdict) +{ + const char *aclname =3D qdict_get_str(qdict, "aclname"); + const char *policy =3D qdict_get_str(qdict, "policy"); + qemu_acl *acl =3D find_acl(mon, aclname); + + if (acl) { + if (strcmp(policy, "allow") =3D=3D 0) { + acl->defaultDeny =3D 0; + monitor_printf(mon, "acl: policy set to 'allow'\n"); + } else if (strcmp(policy, "deny") =3D=3D 0) { + acl->defaultDeny =3D 1; + monitor_printf(mon, "acl: policy set to 'deny'\n"); + } else { + monitor_printf(mon, "acl: unknown policy '%s', " + "expected 'deny' or 'allow'\n", policy); + } + } +} + +void do_acl_add(Monitor *mon, const QDict *qdict) +{ + const char *aclname =3D qdict_get_str(qdict, "aclname"); + const char *match =3D qdict_get_str(qdict, "match"); + const char *policy =3D qdict_get_str(qdict, "policy"); + int has_index =3D qdict_haskey(qdict, "index"); + int index =3D qdict_get_try_int(qdict, "index", -1); + qemu_acl *acl =3D find_acl(mon, aclname); + int deny, ret; + + if (acl) { + if (strcmp(policy, "allow") =3D=3D 0) { + deny =3D 0; + } else if (strcmp(policy, "deny") =3D=3D 0) { + deny =3D 1; + } else { + monitor_printf(mon, "acl: unknown policy '%s', " + "expected 'deny' or 'allow'\n", policy); + return; + } + if (has_index) + ret =3D qemu_acl_insert(acl, deny, match, index); + else + ret =3D qemu_acl_append(acl, deny, match); + if (ret < 0) + monitor_printf(mon, "acl: unable to add acl entry\n"); + else + monitor_printf(mon, "acl: added rule at position %d\n", ret)= ; + } +} + +void do_acl_remove(Monitor *mon, const QDict *qdict) +{ + const char *aclname =3D qdict_get_str(qdict, "aclname"); + const char *match =3D qdict_get_str(qdict, "match"); + qemu_acl *acl =3D find_acl(mon, aclname); + int ret; + + if (acl) { + ret =3D qemu_acl_remove(acl, match); + if (ret < 0) + monitor_printf(mon, "acl: no matching acl entry\n"); + else + monitor_printf(mon, "acl: removed rule at position %d\n", re= t); + } +} + +#if defined(TARGET_I386) +void do_inject_mce(Monitor *mon, const QDict *qdict) +{ + X86CPU *cpu; + CPUState *cs; + int cpu_index =3D qdict_get_int(qdict, "cpu_index"); + int bank =3D qdict_get_int(qdict, "bank"); + uint64_t status =3D qdict_get_int(qdict, "status"); + uint64_t mcg_status =3D qdict_get_int(qdict, "mcg_status"); + uint64_t addr =3D qdict_get_int(qdict, "addr"); + uint64_t misc =3D qdict_get_int(qdict, "misc"); + int flags =3D MCE_INJECT_UNCOND_AO; + + if (qdict_get_try_bool(qdict, "broadcast", 0)) { + flags |=3D MCE_INJECT_BROADCAST; + } + cs =3D qemu_get_cpu(cpu_index); + if (cs !=3D NULL) { + cpu =3D X86_CPU(cs); + cpu_x86_inject_mce(mon, cpu, bank, status, mcg_status, addr, mis= c, + flags); + } +} +#endif diff --git a/monitor.c b/monitor.c index 6b19746..29dbb5e 100644 --- a/monitor.c +++ b/monitor.c @@ -773,1169 +773,6 @@ EventInfoList *qmp_query_events(Error **errp) return ev_list; } =20 -/* set the current CPU defined by the user */ -int monitor_set_cpu(int cpu_index) -{ - CPUState *cpu; - - cpu =3D qemu_get_cpu(cpu_index); - if (cpu =3D=3D NULL) { - return -1; - } - cur_mon->mon_cpu =3D cpu; - return 0; -} - -static CPUArchState *mon_get_cpu(void) -{ - if (!cur_mon->mon_cpu) { - monitor_set_cpu(0); - } - cpu_synchronize_state(cur_mon->mon_cpu); - return cur_mon->mon_cpu->env_ptr; -} - -int monitor_get_cpu_index(void) -{ - CPUState *cpu =3D ENV_GET_CPU(mon_get_cpu()); - return cpu->cpu_index; -} - -static void do_info_registers(Monitor *mon, const QDict *qdict) -{ - CPUState *cpu; - CPUArchState *env; - env =3D mon_get_cpu(); - cpu =3D ENV_GET_CPU(env); - cpu_dump_state(cpu, (FILE *)mon, monitor_fprintf, CPU_DUMP_FPU); -} - -static void do_info_jit(Monitor *mon, const QDict *qdict) -{ - dump_exec_info((FILE *)mon, monitor_fprintf); - dump_drift_info((FILE *)mon, monitor_fprintf); -} - -static void do_info_history(Monitor *mon, const QDict *qdict) -{ - int i; - const char *str; - - if (!mon->rs) - return; - i =3D 0; - for(;;) { - str =3D readline_get_history(mon->rs, i); - if (!str) - break; - monitor_printf(mon, "%d: '%s'\n", i, str); - i++; - } -} - -static void do_info_cpu_stats(Monitor *mon, const QDict *qdict) -{ - CPUState *cpu; - CPUArchState *env; - - env =3D mon_get_cpu(); - cpu =3D ENV_GET_CPU(env); - cpu_dump_statistics(cpu, (FILE *)mon, &monitor_fprintf, 0); -} - -static void do_trace_print_events(Monitor *mon, const QDict *qdict) -{ - trace_print_events((FILE *)mon, &monitor_fprintf); -} - -static int client_migrate_info(Monitor *mon, const QDict *qdict, - MonitorCompletion cb, void *opaque) -{ - const char *protocol =3D qdict_get_str(qdict, "protocol"); - const char *hostname =3D qdict_get_str(qdict, "hostname"); - const char *subject =3D qdict_get_try_str(qdict, "cert-subject"); - int port =3D qdict_get_try_int(qdict, "port", -1); - int tls_port =3D qdict_get_try_int(qdict, "tls-port", -1); - int ret; - - if (strcmp(protocol, "spice") =3D=3D 0) { - if (!using_spice) { - qerror_report(QERR_DEVICE_NOT_ACTIVE, "spice"); - return -1; - } - - if (port =3D=3D -1 && tls_port =3D=3D -1) { - qerror_report(QERR_MISSING_PARAMETER, "port/tls-port"); - return -1; - } - - ret =3D qemu_spice_migrate_info(hostname, port, tls_port, subjec= t, - cb, opaque); - if (ret !=3D 0) { - qerror_report(QERR_UNDEFINED_ERROR); - return -1; - } - return 0; - } - - qerror_report(QERR_INVALID_PARAMETER, "protocol"); - return -1; -} - -static void do_logfile(Monitor *mon, const QDict *qdict) -{ - qemu_set_log_filename(qdict_get_str(qdict, "filename")); -} - -static void do_log(Monitor *mon, const QDict *qdict) -{ - int mask; - const char *items =3D qdict_get_str(qdict, "items"); - - if (!strcmp(items, "none")) { - mask =3D 0; - } else { - mask =3D qemu_str_to_log_mask(items); - if (!mask) { - help_cmd(mon, "log"); - return; - } - } - qemu_set_log(mask); -} - -static void do_singlestep(Monitor *mon, const QDict *qdict) -{ - const char *option =3D qdict_get_try_str(qdict, "option"); - if (!option || !strcmp(option, "on")) { - singlestep =3D 1; - } else if (!strcmp(option, "off")) { - singlestep =3D 0; - } else { - monitor_printf(mon, "unexpected option %s\n", option); - } -} - -static void do_gdbserver(Monitor *mon, const QDict *qdict) -{ - const char *device =3D qdict_get_try_str(qdict, "device"); - if (!device) - device =3D "tcp::" DEFAULT_GDBSTUB_PORT; - if (gdbserver_start(device) < 0) { - monitor_printf(mon, "Could not open gdbserver on device '%s'\n", - device); - } else if (strcmp(device, "none") =3D=3D 0) { - monitor_printf(mon, "Disabled gdbserver\n"); - } else { - monitor_printf(mon, "Waiting for gdb connection on device '%s'\n= ", - device); - } -} - -static void do_watchdog_action(Monitor *mon, const QDict *qdict) -{ - const char *action =3D qdict_get_str(qdict, "action"); - if (select_watchdog_action(action) =3D=3D -1) { - monitor_printf(mon, "Unknown watchdog action '%s'\n", action); - } -} - -static void monitor_printc(Monitor *mon, int c) -{ - monitor_printf(mon, "'"); - switch(c) { - case '\'': - monitor_printf(mon, "\\'"); - break; - case '\\': - monitor_printf(mon, "\\\\"); - break; - case '\n': - monitor_printf(mon, "\\n"); - break; - case '\r': - monitor_printf(mon, "\\r"); - break; - default: - if (c >=3D 32 && c <=3D 126) { - monitor_printf(mon, "%c", c); - } else { - monitor_printf(mon, "\\x%02x", c); - } - break; - } - monitor_printf(mon, "'"); -} - -static void memory_dump(Monitor *mon, int count, int format, int wsize, - hwaddr addr, int is_physical) -{ - CPUArchState *env; - int l, line_size, i, max_digits, len; - uint8_t buf[16]; - uint64_t v; - - if (format =3D=3D 'i') { - int flags; - flags =3D 0; - env =3D mon_get_cpu(); -#ifdef TARGET_I386 - if (wsize =3D=3D 2) { - flags =3D 1; - } else if (wsize =3D=3D 4) { - flags =3D 0; - } else { - /* as default we use the current CS size */ - flags =3D 0; - if (env) { -#ifdef TARGET_X86_64 - if ((env->efer & MSR_EFER_LMA) && - (env->segs[R_CS].flags & DESC_L_MASK)) - flags =3D 2; - else -#endif - if (!(env->segs[R_CS].flags & DESC_B_MASK)) - flags =3D 1; - } - } -#endif -#ifdef TARGET_PPC - flags =3D msr_le << 16; - flags |=3D env->bfd_mach; -#endif - monitor_disas(mon, env, addr, count, is_physical, flags); - return; - } - - len =3D wsize * count; - if (wsize =3D=3D 1) - line_size =3D 8; - else - line_size =3D 16; - max_digits =3D 0; - - switch(format) { - case 'o': - max_digits =3D (wsize * 8 + 2) / 3; - break; - default: - case 'x': - max_digits =3D (wsize * 8) / 4; - break; - case 'u': - case 'd': - max_digits =3D (wsize * 8 * 10 + 32) / 33; - break; - case 'c': - wsize =3D 1; - break; - } - - while (len > 0) { - if (is_physical) - monitor_printf(mon, TARGET_FMT_plx ":", addr); - else - monitor_printf(mon, TARGET_FMT_lx ":", (target_ulong)addr); - l =3D len; - if (l > line_size) - l =3D line_size; - if (is_physical) { - cpu_physical_memory_read(addr, buf, l); - } else { - env =3D mon_get_cpu(); - if (cpu_memory_rw_debug(ENV_GET_CPU(env), addr, buf, l, 0) <= 0) { - monitor_printf(mon, " Cannot access memory\n"); - break; - } - } - i =3D 0; - while (i < l) { - switch(wsize) { - default: - case 1: - v =3D ldub_raw(buf + i); - break; - case 2: - v =3D lduw_raw(buf + i); - break; - case 4: - v =3D (uint32_t)ldl_raw(buf + i); - break; - case 8: - v =3D ldq_raw(buf + i); - break; - } - monitor_printf(mon, " "); - switch(format) { - case 'o': - monitor_printf(mon, "%#*" PRIo64, max_digits, v); - break; - case 'x': - monitor_printf(mon, "0x%0*" PRIx64, max_digits, v); - break; - case 'u': - monitor_printf(mon, "%*" PRIu64, max_digits, v); - break; - case 'd': - monitor_printf(mon, "%*" PRId64, max_digits, v); - break; - case 'c': - monitor_printc(mon, v); - break; - } - i +=3D wsize; - } - monitor_printf(mon, "\n"); - addr +=3D l; - len -=3D l; - } -} - -static void do_memory_dump(Monitor *mon, const QDict *qdict) -{ - int count =3D qdict_get_int(qdict, "count"); - int format =3D qdict_get_int(qdict, "format"); - int size =3D qdict_get_int(qdict, "size"); - target_long addr =3D qdict_get_int(qdict, "addr"); - - memory_dump(mon, count, format, size, addr, 0); -} - -static void do_physical_memory_dump(Monitor *mon, const QDict *qdict) -{ - int count =3D qdict_get_int(qdict, "count"); - int format =3D qdict_get_int(qdict, "format"); - int size =3D qdict_get_int(qdict, "size"); - hwaddr addr =3D qdict_get_int(qdict, "addr"); - - memory_dump(mon, count, format, size, addr, 1); -} - -static void do_print(Monitor *mon, const QDict *qdict) -{ - int format =3D qdict_get_int(qdict, "format"); - hwaddr val =3D qdict_get_int(qdict, "val"); - - switch(format) { - case 'o': - monitor_printf(mon, "%#" HWADDR_PRIo, val); - break; - case 'x': - monitor_printf(mon, "%#" HWADDR_PRIx, val); - break; - case 'u': - monitor_printf(mon, "%" HWADDR_PRIu, val); - break; - default: - case 'd': - monitor_printf(mon, "%" HWADDR_PRId, val); - break; - case 'c': - monitor_printc(mon, val); - break; - } - monitor_printf(mon, "\n"); -} - -static void do_sum(Monitor *mon, const QDict *qdict) -{ - uint32_t addr; - uint16_t sum; - uint32_t start =3D qdict_get_int(qdict, "start"); - uint32_t size =3D qdict_get_int(qdict, "size"); - - sum =3D 0; - for(addr =3D start; addr < (start + size); addr++) { - uint8_t val =3D ldub_phys(&address_space_memory, addr); - /* BSD sum algorithm ('sum' Unix command) */ - sum =3D (sum >> 1) | (sum << 15); - sum +=3D val; - } - monitor_printf(mon, "%05d\n", sum); -} - -static int mouse_button_state; - -static void do_mouse_move(Monitor *mon, const QDict *qdict) -{ - int dx, dy, dz, button; - const char *dx_str =3D qdict_get_str(qdict, "dx_str"); - const char *dy_str =3D qdict_get_str(qdict, "dy_str"); - const char *dz_str =3D qdict_get_try_str(qdict, "dz_str"); - - dx =3D strtol(dx_str, NULL, 0); - dy =3D strtol(dy_str, NULL, 0); - qemu_input_queue_rel(NULL, INPUT_AXIS_X, dx); - qemu_input_queue_rel(NULL, INPUT_AXIS_Y, dy); - - if (dz_str) { - dz =3D strtol(dz_str, NULL, 0); - if (dz !=3D 0) { - button =3D (dz > 0) ? INPUT_BUTTON_WHEEL_UP : INPUT_BUTTON_W= HEEL_DOWN; - qemu_input_queue_btn(NULL, button, true); - qemu_input_event_sync(); - qemu_input_queue_btn(NULL, button, false); - } - } - qemu_input_event_sync(); -} - -static void do_mouse_button(Monitor *mon, const QDict *qdict) -{ - static uint32_t bmap[INPUT_BUTTON_MAX] =3D { - [INPUT_BUTTON_LEFT] =3D MOUSE_EVENT_LBUTTON, - [INPUT_BUTTON_MIDDLE] =3D MOUSE_EVENT_MBUTTON, - [INPUT_BUTTON_RIGHT] =3D MOUSE_EVENT_RBUTTON, - }; - int button_state =3D qdict_get_int(qdict, "button_state"); - - if (mouse_button_state =3D=3D button_state) { - return; - } - qemu_input_update_buttons(NULL, bmap, mouse_button_state, button_sta= te); - qemu_input_event_sync(); - mouse_button_state =3D button_state; -} - -static void do_ioport_read(Monitor *mon, const QDict *qdict) -{ - int size =3D qdict_get_int(qdict, "size"); - int addr =3D qdict_get_int(qdict, "addr"); - int has_index =3D qdict_haskey(qdict, "index"); - uint32_t val; - int suffix; - - if (has_index) { - int index =3D qdict_get_int(qdict, "index"); - cpu_outb(addr & IOPORTS_MASK, index & 0xff); - addr++; - } - addr &=3D 0xffff; - - switch(size) { - default: - case 1: - val =3D cpu_inb(addr); - suffix =3D 'b'; - break; - case 2: - val =3D cpu_inw(addr); - suffix =3D 'w'; - break; - case 4: - val =3D cpu_inl(addr); - suffix =3D 'l'; - break; - } - monitor_printf(mon, "port%c[0x%04x] =3D %#0*x\n", - suffix, addr, size * 2, val); -} - -static void do_ioport_write(Monitor *mon, const QDict *qdict) -{ - int size =3D qdict_get_int(qdict, "size"); - int addr =3D qdict_get_int(qdict, "addr"); - int val =3D qdict_get_int(qdict, "val"); - - addr &=3D IOPORTS_MASK; - - switch (size) { - default: - case 1: - cpu_outb(addr, val); - break; - case 2: - cpu_outw(addr, val); - break; - case 4: - cpu_outl(addr, val); - break; - } -} - -static void do_boot_set(Monitor *mon, const QDict *qdict) -{ - int res; - const char *bootdevice =3D qdict_get_str(qdict, "bootdevice"); - - res =3D qemu_boot_set(bootdevice); - if (res =3D=3D 0) { - monitor_printf(mon, "boot device list now set to %s\n", bootdevi= ce); - } else if (res > 0) { - monitor_printf(mon, "setting boot device list failed\n"); - } else { - monitor_printf(mon, "no function defined to set boot device list= for " - "this architecture\n"); - } -} - -#if defined(TARGET_I386) -static void print_pte(Monitor *mon, hwaddr addr, - hwaddr pte, - hwaddr mask) -{ -#ifdef TARGET_X86_64 - if (addr & (1ULL << 47)) { - addr |=3D -1LL << 48; - } -#endif - monitor_printf(mon, TARGET_FMT_plx ": " TARGET_FMT_plx - " %c%c%c%c%c%c%c%c%c\n", - addr, - pte & mask, - pte & PG_NX_MASK ? 'X' : '-', - pte & PG_GLOBAL_MASK ? 'G' : '-', - pte & PG_PSE_MASK ? 'P' : '-', - pte & PG_DIRTY_MASK ? 'D' : '-', - pte & PG_ACCESSED_MASK ? 'A' : '-', - pte & PG_PCD_MASK ? 'C' : '-', - pte & PG_PWT_MASK ? 'T' : '-', - pte & PG_USER_MASK ? 'U' : '-', - pte & PG_RW_MASK ? 'W' : '-'); -} - -static void tlb_info_32(Monitor *mon, CPUArchState *env) -{ - unsigned int l1, l2; - uint32_t pgd, pde, pte; - - pgd =3D env->cr[3] & ~0xfff; - for(l1 =3D 0; l1 < 1024; l1++) { - cpu_physical_memory_read(pgd + l1 * 4, &pde, 4); - pde =3D le32_to_cpu(pde); - if (pde & PG_PRESENT_MASK) { - if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) { - /* 4M pages */ - print_pte(mon, (l1 << 22), pde, ~((1 << 21) - 1)); - } else { - for(l2 =3D 0; l2 < 1024; l2++) { - cpu_physical_memory_read((pde & ~0xfff) + l2 * 4, &p= te, 4); - pte =3D le32_to_cpu(pte); - if (pte & PG_PRESENT_MASK) { - print_pte(mon, (l1 << 22) + (l2 << 12), - pte & ~PG_PSE_MASK, - ~0xfff); - } - } - } - } - } -} - -static void tlb_info_pae32(Monitor *mon, CPUArchState *env) -{ - unsigned int l1, l2, l3; - uint64_t pdpe, pde, pte; - uint64_t pdp_addr, pd_addr, pt_addr; - - pdp_addr =3D env->cr[3] & ~0x1f; - for (l1 =3D 0; l1 < 4; l1++) { - cpu_physical_memory_read(pdp_addr + l1 * 8, &pdpe, 8); - pdpe =3D le64_to_cpu(pdpe); - if (pdpe & PG_PRESENT_MASK) { - pd_addr =3D pdpe & 0x3fffffffff000ULL; - for (l2 =3D 0; l2 < 512; l2++) { - cpu_physical_memory_read(pd_addr + l2 * 8, &pde, 8); - pde =3D le64_to_cpu(pde); - if (pde & PG_PRESENT_MASK) { - if (pde & PG_PSE_MASK) { - /* 2M pages with PAE, CR4.PSE is ignored */ - print_pte(mon, (l1 << 30 ) + (l2 << 21), pde, - ~((hwaddr)(1 << 20) - 1)); - } else { - pt_addr =3D pde & 0x3fffffffff000ULL; - for (l3 =3D 0; l3 < 512; l3++) { - cpu_physical_memory_read(pt_addr + l3 * 8, &= pte, 8); - pte =3D le64_to_cpu(pte); - if (pte & PG_PRESENT_MASK) { - print_pte(mon, (l1 << 30 ) + (l2 << 21) - + (l3 << 12), - pte & ~PG_PSE_MASK, - ~(hwaddr)0xfff); - } - } - } - } - } - } - } -} - -#ifdef TARGET_X86_64 -static void tlb_info_64(Monitor *mon, CPUArchState *env) -{ - uint64_t l1, l2, l3, l4; - uint64_t pml4e, pdpe, pde, pte; - uint64_t pml4_addr, pdp_addr, pd_addr, pt_addr; - - pml4_addr =3D env->cr[3] & 0x3fffffffff000ULL; - for (l1 =3D 0; l1 < 512; l1++) { - cpu_physical_memory_read(pml4_addr + l1 * 8, &pml4e, 8); - pml4e =3D le64_to_cpu(pml4e); - if (pml4e & PG_PRESENT_MASK) { - pdp_addr =3D pml4e & 0x3fffffffff000ULL; - for (l2 =3D 0; l2 < 512; l2++) { - cpu_physical_memory_read(pdp_addr + l2 * 8, &pdpe, 8); - pdpe =3D le64_to_cpu(pdpe); - if (pdpe & PG_PRESENT_MASK) { - if (pdpe & PG_PSE_MASK) { - /* 1G pages, CR4.PSE is ignored */ - print_pte(mon, (l1 << 39) + (l2 << 30), pdpe, - 0x3ffffc0000000ULL); - } else { - pd_addr =3D pdpe & 0x3fffffffff000ULL; - for (l3 =3D 0; l3 < 512; l3++) { - cpu_physical_memory_read(pd_addr + l3 * 8, &= pde, 8); - pde =3D le64_to_cpu(pde); - if (pde & PG_PRESENT_MASK) { - if (pde & PG_PSE_MASK) { - /* 2M pages, CR4.PSE is ignored */ - print_pte(mon, (l1 << 39) + (l2 << 3= 0) + - (l3 << 21), pde, - 0x3ffffffe00000ULL); - } else { - pt_addr =3D pde & 0x3fffffffff000ULL= ; - for (l4 =3D 0; l4 < 512; l4++) { - cpu_physical_memory_read(pt_addr - + l4 * = 8, - &pte, 8= ); - pte =3D le64_to_cpu(pte); - if (pte & PG_PRESENT_MASK) { - print_pte(mon, (l1 << 39) + - (l2 << 30) + - (l3 << 21) + (l4 <= < 12), - pte & ~PG_PSE_MASK= , - 0x3fffffffff000ULL= ); - } - } - } - } - } - } - } - } - } - } -} -#endif - -static void tlb_info(Monitor *mon, const QDict *qdict) -{ - CPUArchState *env; - - env =3D mon_get_cpu(); - - if (!(env->cr[0] & CR0_PG_MASK)) { - monitor_printf(mon, "PG disabled\n"); - return; - } - if (env->cr[4] & CR4_PAE_MASK) { -#ifdef TARGET_X86_64 - if (env->hflags & HF_LMA_MASK) { - tlb_info_64(mon, env); - } else -#endif - { - tlb_info_pae32(mon, env); - } - } else { - tlb_info_32(mon, env); - } -} - -static void mem_print(Monitor *mon, hwaddr *pstart, - int *plast_prot, - hwaddr end, int prot) -{ - int prot1; - prot1 =3D *plast_prot; - if (prot !=3D prot1) { - if (*pstart !=3D -1) { - monitor_printf(mon, TARGET_FMT_plx "-" TARGET_FMT_plx " " - TARGET_FMT_plx " %c%c%c\n", - *pstart, end, end - *pstart, - prot1 & PG_USER_MASK ? 'u' : '-', - 'r', - prot1 & PG_RW_MASK ? 'w' : '-'); - } - if (prot !=3D 0) - *pstart =3D end; - else - *pstart =3D -1; - *plast_prot =3D prot; - } -} - -static void mem_info_32(Monitor *mon, CPUArchState *env) -{ - unsigned int l1, l2; - int prot, last_prot; - uint32_t pgd, pde, pte; - hwaddr start, end; - - pgd =3D env->cr[3] & ~0xfff; - last_prot =3D 0; - start =3D -1; - for(l1 =3D 0; l1 < 1024; l1++) { - cpu_physical_memory_read(pgd + l1 * 4, &pde, 4); - pde =3D le32_to_cpu(pde); - end =3D l1 << 22; - if (pde & PG_PRESENT_MASK) { - if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) { - prot =3D pde & (PG_USER_MASK | PG_RW_MASK | PG_PRESENT_M= ASK); - mem_print(mon, &start, &last_prot, end, prot); - } else { - for(l2 =3D 0; l2 < 1024; l2++) { - cpu_physical_memory_read((pde & ~0xfff) + l2 * 4, &p= te, 4); - pte =3D le32_to_cpu(pte); - end =3D (l1 << 22) + (l2 << 12); - if (pte & PG_PRESENT_MASK) { - prot =3D pte & pde & - (PG_USER_MASK | PG_RW_MASK | PG_PRESENT_MASK= ); - } else { - prot =3D 0; - } - mem_print(mon, &start, &last_prot, end, prot); - } - } - } else { - prot =3D 0; - mem_print(mon, &start, &last_prot, end, prot); - } - } - /* Flush last range */ - mem_print(mon, &start, &last_prot, (hwaddr)1 << 32, 0); -} - -static void mem_info_pae32(Monitor *mon, CPUArchState *env) -{ - unsigned int l1, l2, l3; - int prot, last_prot; - uint64_t pdpe, pde, pte; - uint64_t pdp_addr, pd_addr, pt_addr; - hwaddr start, end; - - pdp_addr =3D env->cr[3] & ~0x1f; - last_prot =3D 0; - start =3D -1; - for (l1 =3D 0; l1 < 4; l1++) { - cpu_physical_memory_read(pdp_addr + l1 * 8, &pdpe, 8); - pdpe =3D le64_to_cpu(pdpe); - end =3D l1 << 30; - if (pdpe & PG_PRESENT_MASK) { - pd_addr =3D pdpe & 0x3fffffffff000ULL; - for (l2 =3D 0; l2 < 512; l2++) { - cpu_physical_memory_read(pd_addr + l2 * 8, &pde, 8); - pde =3D le64_to_cpu(pde); - end =3D (l1 << 30) + (l2 << 21); - if (pde & PG_PRESENT_MASK) { - if (pde & PG_PSE_MASK) { - prot =3D pde & (PG_USER_MASK | PG_RW_MASK | - PG_PRESENT_MASK); - mem_print(mon, &start, &last_prot, end, prot); - } else { - pt_addr =3D pde & 0x3fffffffff000ULL; - for (l3 =3D 0; l3 < 512; l3++) { - cpu_physical_memory_read(pt_addr + l3 * 8, &= pte, 8); - pte =3D le64_to_cpu(pte); - end =3D (l1 << 30) + (l2 << 21) + (l3 << 12)= ; - if (pte & PG_PRESENT_MASK) { - prot =3D pte & pde & (PG_USER_MASK | PG_= RW_MASK | - PG_PRESENT_MASK); - } else { - prot =3D 0; - } - mem_print(mon, &start, &last_prot, end, prot= ); - } - } - } else { - prot =3D 0; - mem_print(mon, &start, &last_prot, end, prot); - } - } - } else { - prot =3D 0; - mem_print(mon, &start, &last_prot, end, prot); - } - } - /* Flush last range */ - mem_print(mon, &start, &last_prot, (hwaddr)1 << 32, 0); -} - - -#ifdef TARGET_X86_64 -static void mem_info_64(Monitor *mon, CPUArchState *env) -{ - int prot, last_prot; - uint64_t l1, l2, l3, l4; - uint64_t pml4e, pdpe, pde, pte; - uint64_t pml4_addr, pdp_addr, pd_addr, pt_addr, start, end; - - pml4_addr =3D env->cr[3] & 0x3fffffffff000ULL; - last_prot =3D 0; - start =3D -1; - for (l1 =3D 0; l1 < 512; l1++) { - cpu_physical_memory_read(pml4_addr + l1 * 8, &pml4e, 8); - pml4e =3D le64_to_cpu(pml4e); - end =3D l1 << 39; - if (pml4e & PG_PRESENT_MASK) { - pdp_addr =3D pml4e & 0x3fffffffff000ULL; - for (l2 =3D 0; l2 < 512; l2++) { - cpu_physical_memory_read(pdp_addr + l2 * 8, &pdpe, 8); - pdpe =3D le64_to_cpu(pdpe); - end =3D (l1 << 39) + (l2 << 30); - if (pdpe & PG_PRESENT_MASK) { - if (pdpe & PG_PSE_MASK) { - prot =3D pdpe & (PG_USER_MASK | PG_RW_MASK | - PG_PRESENT_MASK); - prot &=3D pml4e; - mem_print(mon, &start, &last_prot, end, prot); - } else { - pd_addr =3D pdpe & 0x3fffffffff000ULL; - for (l3 =3D 0; l3 < 512; l3++) { - cpu_physical_memory_read(pd_addr + l3 * 8, &= pde, 8); - pde =3D le64_to_cpu(pde); - end =3D (l1 << 39) + (l2 << 30) + (l3 << 21)= ; - if (pde & PG_PRESENT_MASK) { - if (pde & PG_PSE_MASK) { - prot =3D pde & (PG_USER_MASK | PG_RW= _MASK | - PG_PRESENT_MASK); - prot &=3D pml4e & pdpe; - mem_print(mon, &start, &last_prot, e= nd, prot); - } else { - pt_addr =3D pde & 0x3fffffffff000ULL= ; - for (l4 =3D 0; l4 < 512; l4++) { - cpu_physical_memory_read(pt_addr - + l4 * = 8, - &pte, 8= ); - pte =3D le64_to_cpu(pte); - end =3D (l1 << 39) + (l2 << 30) = + - (l3 << 21) + (l4 << 12); - if (pte & PG_PRESENT_MASK) { - prot =3D pte & (PG_USER_MASK= | PG_RW_MASK | - PG_PRESENT_MAS= K); - prot &=3D pml4e & pdpe & pde= ; - } else { - prot =3D 0; - } - mem_print(mon, &start, &last_pro= t, end, prot); - } - } - } else { - prot =3D 0; - mem_print(mon, &start, &last_prot, end, = prot); - } - } - } - } else { - prot =3D 0; - mem_print(mon, &start, &last_prot, end, prot); - } - } - } else { - prot =3D 0; - mem_print(mon, &start, &last_prot, end, prot); - } - } - /* Flush last range */ - mem_print(mon, &start, &last_prot, (hwaddr)1 << 48, 0); -} -#endif - -static void mem_info(Monitor *mon, const QDict *qdict) -{ - CPUArchState *env; - - env =3D mon_get_cpu(); - - if (!(env->cr[0] & CR0_PG_MASK)) { - monitor_printf(mon, "PG disabled\n"); - return; - } - if (env->cr[4] & CR4_PAE_MASK) { -#ifdef TARGET_X86_64 - if (env->hflags & HF_LMA_MASK) { - mem_info_64(mon, env); - } else -#endif - { - mem_info_pae32(mon, env); - } - } else { - mem_info_32(mon, env); - } -} -#endif - -#if defined(TARGET_SH4) - -static void print_tlb(Monitor *mon, int idx, tlb_t *tlb) -{ - monitor_printf(mon, " tlb%i:\t" - "asid=3D%hhu vpn=3D%x\tppn=3D%x\tsz=3D%hhu size=3D%u\= t" - "v=3D%hhu shared=3D%hhu cached=3D%hhu prot=3D%hhu " - "dirty=3D%hhu writethrough=3D%hhu\n", - idx, - tlb->asid, tlb->vpn, tlb->ppn, tlb->sz, tlb->size, - tlb->v, tlb->sh, tlb->c, tlb->pr, - tlb->d, tlb->wt); -} - -static void tlb_info(Monitor *mon, const QDict *qdict) -{ - CPUArchState *env =3D mon_get_cpu(); - int i; - - monitor_printf (mon, "ITLB:\n"); - for (i =3D 0 ; i < ITLB_SIZE ; i++) - print_tlb (mon, i, &env->itlb[i]); - monitor_printf (mon, "UTLB:\n"); - for (i =3D 0 ; i < UTLB_SIZE ; i++) - print_tlb (mon, i, &env->utlb[i]); -} - -#endif - -#if defined(TARGET_SPARC) || defined(TARGET_PPC) || defined(TARGET_XTENS= A) -static void tlb_info(Monitor *mon, const QDict *qdict) -{ - CPUArchState *env1 =3D mon_get_cpu(); - - dump_mmu((FILE*)mon, (fprintf_function)monitor_printf, env1); -} -#endif - -static void do_info_mtree(Monitor *mon, const QDict *qdict) -{ - mtree_info((fprintf_function)monitor_printf, mon); -} - -static void do_info_numa(Monitor *mon, const QDict *qdict) -{ - int i; - CPUState *cpu; - - monitor_printf(mon, "%d nodes\n", nb_numa_nodes); - for (i =3D 0; i < nb_numa_nodes; i++) { - monitor_printf(mon, "node %d cpus:", i); - CPU_FOREACH(cpu) { - if (cpu->numa_node =3D=3D i) { - monitor_printf(mon, " %d", cpu->cpu_index); - } - } - monitor_printf(mon, "\n"); - monitor_printf(mon, "node %d size: %" PRId64 " MB\n", i, - numa_info[i].node_mem >> 20); - } -} - -#ifdef CONFIG_PROFILER - -int64_t qemu_time; -int64_t dev_time; - -static void do_info_profile(Monitor *mon, const QDict *qdict) -{ - monitor_printf(mon, "async time %" PRId64 " (%0.3f)\n", - dev_time, dev_time / (double)get_ticks_per_sec()); - monitor_printf(mon, "qemu time %" PRId64 " (%0.3f)\n", - qemu_time, qemu_time / (double)get_ticks_per_sec()); - qemu_time =3D 0; - dev_time =3D 0; -} -#else -static void do_info_profile(Monitor *mon, const QDict *qdict) -{ - monitor_printf(mon, "Internal profiler not compiled\n"); -} -#endif - -/* Capture support */ -static QLIST_HEAD (capture_list_head, CaptureState) capture_head; - -static void do_info_capture(Monitor *mon, const QDict *qdict) -{ - int i; - CaptureState *s; - - for (s =3D capture_head.lh_first, i =3D 0; s; s =3D s->entries.le_ne= xt, ++i) { - monitor_printf(mon, "[%d]: ", i); - s->ops.info (s->opaque); - } -} - -static void do_stop_capture(Monitor *mon, const QDict *qdict) -{ - int i; - int n =3D qdict_get_int(qdict, "n"); - CaptureState *s; - - for (s =3D capture_head.lh_first, i =3D 0; s; s =3D s->entries.le_ne= xt, ++i) { - if (i =3D=3D n) { - s->ops.destroy (s->opaque); - QLIST_REMOVE (s, entries); - g_free (s); - return; - } - } -} - -static void do_wav_capture(Monitor *mon, const QDict *qdict) -{ - const char *path =3D qdict_get_str(qdict, "path"); - int has_freq =3D qdict_haskey(qdict, "freq"); - int freq =3D qdict_get_try_int(qdict, "freq", -1); - int has_bits =3D qdict_haskey(qdict, "bits"); - int bits =3D qdict_get_try_int(qdict, "bits", -1); - int has_channels =3D qdict_haskey(qdict, "nchannels"); - int nchannels =3D qdict_get_try_int(qdict, "nchannels", -1); - CaptureState *s; - - s =3D g_malloc0 (sizeof (*s)); - - freq =3D has_freq ? freq : 44100; - bits =3D has_bits ? bits : 16; - nchannels =3D has_channels ? nchannels : 2; - - if (wav_start_capture (s, path, freq, bits, nchannels)) { - monitor_printf(mon, "Failed to add wave capture\n"); - g_free (s); - return; - } - QLIST_INSERT_HEAD (&capture_head, s, entries); -} - -static qemu_acl *find_acl(Monitor *mon, const char *name) -{ - qemu_acl *acl =3D qemu_acl_find(name); - - if (!acl) { - monitor_printf(mon, "acl: unknown list '%s'\n", name); - } - return acl; -} - -static void do_acl_show(Monitor *mon, const QDict *qdict) -{ - const char *aclname =3D qdict_get_str(qdict, "aclname"); - qemu_acl *acl =3D find_acl(mon, aclname); - qemu_acl_entry *entry; - int i =3D 0; - - if (acl) { - monitor_printf(mon, "policy: %s\n", - acl->defaultDeny ? "deny" : "allow"); - QTAILQ_FOREACH(entry, &acl->entries, next) { - i++; - monitor_printf(mon, "%d: %s %s\n", i, - entry->deny ? "deny" : "allow", entry->match)= ; - } - } -} - -static void do_acl_reset(Monitor *mon, const QDict *qdict) -{ - const char *aclname =3D qdict_get_str(qdict, "aclname"); - qemu_acl *acl =3D find_acl(mon, aclname); - - if (acl) { - qemu_acl_reset(acl); - monitor_printf(mon, "acl: removed all rules\n"); - } -} - -static void do_acl_policy(Monitor *mon, const QDict *qdict) -{ - const char *aclname =3D qdict_get_str(qdict, "aclname"); - const char *policy =3D qdict_get_str(qdict, "policy"); - qemu_acl *acl =3D find_acl(mon, aclname); - - if (acl) { - if (strcmp(policy, "allow") =3D=3D 0) { - acl->defaultDeny =3D 0; - monitor_printf(mon, "acl: policy set to 'allow'\n"); - } else if (strcmp(policy, "deny") =3D=3D 0) { - acl->defaultDeny =3D 1; - monitor_printf(mon, "acl: policy set to 'deny'\n"); - } else { - monitor_printf(mon, "acl: unknown policy '%s', " - "expected 'deny' or 'allow'\n", policy); - } - } -} - -static void do_acl_add(Monitor *mon, const QDict *qdict) -{ - const char *aclname =3D qdict_get_str(qdict, "aclname"); - const char *match =3D qdict_get_str(qdict, "match"); - const char *policy =3D qdict_get_str(qdict, "policy"); - int has_index =3D qdict_haskey(qdict, "index"); - int index =3D qdict_get_try_int(qdict, "index", -1); - qemu_acl *acl =3D find_acl(mon, aclname); - int deny, ret; - - if (acl) { - if (strcmp(policy, "allow") =3D=3D 0) { - deny =3D 0; - } else if (strcmp(policy, "deny") =3D=3D 0) { - deny =3D 1; - } else { - monitor_printf(mon, "acl: unknown policy '%s', " - "expected 'deny' or 'allow'\n", policy); - return; - } - if (has_index) - ret =3D qemu_acl_insert(acl, deny, match, index); - else - ret =3D qemu_acl_append(acl, deny, match); - if (ret < 0) - monitor_printf(mon, "acl: unable to add acl entry\n"); - else - monitor_printf(mon, "acl: added rule at position %d\n", ret)= ; - } -} - -static void do_acl_remove(Monitor *mon, const QDict *qdict) -{ - const char *aclname =3D qdict_get_str(qdict, "aclname"); - const char *match =3D qdict_get_str(qdict, "match"); - qemu_acl *acl =3D find_acl(mon, aclname); - int ret; - - if (acl) { - ret =3D qemu_acl_remove(acl, match); - if (ret < 0) - monitor_printf(mon, "acl: no matching acl entry\n"); - else - monitor_printf(mon, "acl: removed rule at position %d\n", re= t); - } -} - -#if defined(TARGET_I386) -static void do_inject_mce(Monitor *mon, const QDict *qdict) -{ - X86CPU *cpu; - CPUState *cs; - int cpu_index =3D qdict_get_int(qdict, "cpu_index"); - int bank =3D qdict_get_int(qdict, "bank"); - uint64_t status =3D qdict_get_int(qdict, "status"); - uint64_t mcg_status =3D qdict_get_int(qdict, "mcg_status"); - uint64_t addr =3D qdict_get_int(qdict, "addr"); - uint64_t misc =3D qdict_get_int(qdict, "misc"); - int flags =3D MCE_INJECT_UNCOND_AO; - - if (qdict_get_try_bool(qdict, "broadcast", 0)) { - flags |=3D MCE_INJECT_BROADCAST; - } - cs =3D qemu_get_cpu(cpu_index); - if (cs !=3D NULL) { - cpu =3D X86_CPU(cs); - cpu_x86_inject_mce(mon, cpu, bank, status, mcg_status, addr, mis= c, - flags); - } -} -#endif - void qmp_getfd(const char *fdname, Error **errp) { mon_fd_t *monfd; --=20 2.1.0.rc1