#include "json-streamer.h"
#include "json-parser.h"
#include "osdep.h"
-#include "exec-all.h"
-#ifdef CONFIG_SIMPLE_TRACE
+#include "cpu.h"
#include "trace.h"
+#include "trace/control.h"
+#ifdef CONFIG_TRACE_SIMPLE
+#include "trace/simple.h"
#endif
#include "ui/qemu-spice.h"
+#include "memory.h"
//#define DEBUG
//#define DEBUG_COMPLETION
void monitor_flush(Monitor *mon)
{
if (mon && mon->outbuf_index != 0 && !mon->mux_out) {
- qemu_chr_write(mon->chr, mon->outbuf, mon->outbuf_index);
+ qemu_chr_fe_write(mon->chr, mon->outbuf, mon->outbuf_index);
mon->outbuf_index = 0;
}
}
{
QDict *qmp;
+ trace_monitor_protocol_emitter(mon);
+
qmp = qdict_new();
if (!monitor_has_error(mon)) {
help_cmd(mon, qdict_get_try_str(qdict, "name"));
}
-#ifdef CONFIG_SIMPLE_TRACE
-static void do_change_trace_event_state(Monitor *mon, const QDict *qdict)
+static void do_trace_event_set_state(Monitor *mon, const QDict *qdict)
{
const char *tp_name = qdict_get_str(qdict, "name");
bool new_state = qdict_get_bool(qdict, "option");
- int ret = st_change_trace_event_state(tp_name, new_state);
+ int ret = trace_event_set_state(tp_name, new_state);
if (!ret) {
monitor_printf(mon, "unknown event name \"%s\"\n", tp_name);
}
}
+#ifdef CONFIG_TRACE_SIMPLE
static void do_trace_file(Monitor *mon, const QDict *qdict)
{
const char *op = qdict_get_try_str(qdict, "op");
data->user_print(data->mon, ret_data);
}
monitor_resume(data->mon);
- qemu_free(data);
+ g_free(data);
}
static void qmp_monitor_complete(void *opaque, QObject *ret_data)
{
int ret;
- MonitorCompletionData *cb_data = qemu_malloc(sizeof(*cb_data));
+ MonitorCompletionData *cb_data = g_malloc(sizeof(*cb_data));
cb_data->mon = mon;
cb_data->user_print = cmd->user_print;
monitor_suspend(mon);
user_monitor_complete, cb_data);
if (ret < 0) {
monitor_resume(mon);
- qemu_free(cb_data);
+ g_free(cb_data);
}
}
{
int ret;
- MonitorCompletionData *cb_data = qemu_malloc(sizeof(*cb_data));
+ MonitorCompletionData *cb_data = g_malloc(sizeof(*cb_data));
cb_data->mon = mon;
cb_data->user_print = cmd->user_print;
monitor_suspend(mon);
ret = cmd->mhandler.info_async(mon, user_monitor_complete, cb_data);
if (ret < 0) {
monitor_resume(mon);
- qemu_free(cb_data);
+ g_free(cb_data);
}
}
monitor_printf(mon, "nip=0x" TARGET_FMT_lx,
(target_long) qdict_get_int(cpu, "nip"));
#elif defined(TARGET_SPARC)
- monitor_printf(mon, "pc=0x " TARGET_FMT_lx,
+ monitor_printf(mon, "pc=0x" TARGET_FMT_lx,
(target_long) qdict_get_int(cpu, "pc"));
monitor_printf(mon, "npc=0x" TARGET_FMT_lx,
(target_long) qdict_get_int(cpu, "npc"));
}
#endif
-#if defined(CONFIG_SIMPLE_TRACE)
+#if defined(CONFIG_TRACE_SIMPLE)
static void do_info_trace(Monitor *mon)
{
st_print_trace((FILE *)mon, &monitor_fprintf);
}
+#endif
-static void do_info_trace_events(Monitor *mon)
+static void do_trace_print_events(Monitor *mon)
{
- st_print_trace_events((FILE *)mon, &monitor_fprintf);
+ trace_print_events((FILE *)mon, &monitor_fprintf);
}
-#endif
/**
* do_quit(): Quit QEMU execution
return -1;
}
+static int add_graphics_client(Monitor *mon, const QDict *qdict, QObject **ret_data)
+{
+ const char *protocol = qdict_get_str(qdict, "protocol");
+ const char *fdname = qdict_get_str(qdict, "fdname");
+ CharDriverState *s;
+
+ if (strcmp(protocol, "spice") == 0) {
+ if (!using_spice) {
+ /* correct one? spice isn't a device ,,, */
+ qerror_report(QERR_DEVICE_NOT_ACTIVE, "spice");
+ return -1;
+ }
+ qerror_report(QERR_ADD_CLIENT_FAILED);
+ return -1;
+#ifdef CONFIG_VNC
+ } else if (strcmp(protocol, "vnc") == 0) {
+ int fd = monitor_get_fd(mon, fdname);
+ int skipauth = qdict_get_try_bool(qdict, "skipauth", 0);
+ vnc_display_add_client(NULL, fd, skipauth);
+ return 0;
+#endif
+ } else if ((s = qemu_chr_find(protocol)) != NULL) {
+ int fd = monitor_get_fd(mon, fdname);
+ if (qemu_chr_add_client(s, fd) < 0) {
+ qerror_report(QERR_ADD_CLIENT_FAILED);
+ return -1;
+ }
+ return 0;
+ }
+
+ qerror_report(QERR_INVALID_PARAMETER, "protocol");
+ return -1;
+}
+
static int client_migrate_info(Monitor *mon, const QDict *qdict, QObject **ret_data)
{
const char *protocol = qdict_get_str(qdict, "protocol");
*/
static int do_stop(Monitor *mon, const QDict *qdict, QObject **ret_data)
{
- vm_stop(VMSTOP_USER);
+ vm_stop(RSTATE_PAUSED);
return 0;
}
{
struct bdrv_iterate_context context = { mon, 0 };
- if (incoming_expected) {
+ if (runstate_check(RSTATE_IN_MIGRATE)) {
qerror_report(QERR_MIGRATION_EXPECTED);
return -1;
+ } else if (runstate_check(RSTATE_PANICKED) ||
+ runstate_check(RSTATE_SHUTDOWN)) {
+ qerror_report(QERR_RESET_REQUIRED);
+ return -1;
}
+
bdrv_iterate(encrypted_bdrv_it, &context);
/* only resume the vm if all keys are set and valid */
if (!context.err) {
static void tlb_info_32(Monitor *mon, CPUState *env)
{
- int l1, l2;
+ unsigned int l1, l2;
uint32_t pgd, pde, pte;
pgd = env->cr[3] & ~0xfff;
static void tlb_info_pae32(Monitor *mon, CPUState *env)
{
- int l1, l2, l3;
+ unsigned int l1, l2, l3;
uint64_t pdpe, pde, pte;
uint64_t pdp_addr, pd_addr, pt_addr;
static void mem_info_32(Monitor *mon, CPUState *env)
{
- int l1, l2, prot, last_prot;
+ unsigned int l1, l2;
+ int prot, last_prot;
uint32_t pgd, pde, pte;
target_phys_addr_t start, end;
pte = le32_to_cpu(pte);
end = (l1 << 22) + (l2 << 12);
if (pte & PG_PRESENT_MASK) {
- prot = pte & (PG_USER_MASK | PG_RW_MASK | PG_PRESENT_MASK);
+ prot = pte & pde &
+ (PG_USER_MASK | PG_RW_MASK | PG_PRESENT_MASK);
} else {
prot = 0;
}
mem_print(mon, &start, &last_prot, end, prot);
}
}
+ /* Flush last range */
+ mem_print(mon, &start, &last_prot, (target_phys_addr_t)1 << 32, 0);
}
static void mem_info_pae32(Monitor *mon, CPUState *env)
{
- int l1, l2, l3, prot, last_prot;
+ unsigned int l1, l2, l3;
+ int prot, last_prot;
uint64_t pdpe, pde, pte;
uint64_t pdp_addr, pd_addr, pt_addr;
target_phys_addr_t start, end;
pte = le64_to_cpu(pte);
end = (l1 << 30) + (l2 << 21) + (l3 << 12);
if (pte & PG_PRESENT_MASK) {
- prot = pte & (PG_USER_MASK | PG_RW_MASK |
- PG_PRESENT_MASK);
+ prot = pte & pde & (PG_USER_MASK | PG_RW_MASK |
+ PG_PRESENT_MASK);
} else {
prot = 0;
}
mem_print(mon, &start, &last_prot, end, prot);
}
}
+ /* Flush last range */
+ mem_print(mon, &start, &last_prot, (target_phys_addr_t)1 << 32, 0);
}
if (pdpe & PG_PSE_MASK) {
prot = pdpe & (PG_USER_MASK | PG_RW_MASK |
PG_PRESENT_MASK);
+ prot &= pml4e;
mem_print(mon, &start, &last_prot, end, prot);
} else {
pd_addr = pdpe & 0x3fffffffff000ULL;
if (pde & PG_PSE_MASK) {
prot = pde & (PG_USER_MASK | PG_RW_MASK |
PG_PRESENT_MASK);
+ prot &= pml4e & pdpe;
mem_print(mon, &start, &last_prot, end, prot);
} else {
pt_addr = pde & 0x3fffffffff000ULL;
if (pte & PG_PRESENT_MASK) {
prot = pte & (PG_USER_MASK | PG_RW_MASK |
PG_PRESENT_MASK);
+ prot &= pml4e & pdpe & pde;
} else {
prot = 0;
}
mem_print(mon, &start, &last_prot, end, prot);
}
}
+ /* Flush last range */
+ mem_print(mon, &start, &last_prot, (target_phys_addr_t)1 << 48, 0);
}
#endif
#endif
-#if defined(TARGET_SPARC)
+#if defined(TARGET_SPARC) || defined(TARGET_PPC)
static void tlb_info(Monitor *mon)
{
CPUState *env1 = mon_get_cpu();
}
#endif
+static void do_info_mtree(Monitor *mon)
+{
+ mtree_info((fprintf_function)monitor_printf, mon);
+}
+
static void do_info_kvm_print(Monitor *mon, const QObject *data)
{
QDict *qdict;
if (i == n) {
s->ops.destroy (s->opaque);
QLIST_REMOVE (s, entries);
- qemu_free (s);
+ g_free (s);
return;
}
}
int nchannels = qdict_get_try_int(qdict, "nchannels", -1);
CaptureState *s;
- s = qemu_mallocz (sizeof (*s));
+ s = g_malloc0 (sizeof (*s));
freq = has_freq ? freq : 44100;
bits = has_bits ? bits : 16;
if (wav_start_capture (s, path, freq, bits, nchannels)) {
monitor_printf(mon, "Failed to add wave capture\n");
- qemu_free (s);
+ g_free (s);
return;
}
QLIST_INSERT_HEAD (&capture_head, s, entries);
static void do_info_status_print(Monitor *mon, const QObject *data)
{
QDict *qdict;
+ const char *status;
qdict = qobject_to_qdict(data);
monitor_printf(mon, "paused");
}
+ status = qdict_get_str(qdict, "status");
+ if (strcmp(status, "paused") && strcmp(status, "running")) {
+ monitor_printf(mon, " (%s)", status);
+ }
+
monitor_printf(mon, "\n");
}
static void do_info_status(Monitor *mon, QObject **ret_data)
{
- *ret_data = qobject_from_jsonf("{ 'running': %i, 'singlestep': %i }",
- vm_running, singlestep);
+ *ret_data = qobject_from_jsonf("{ 'running': %i, 'singlestep': %i, 'status': %s }", runstate_is_running(), singlestep, runstate_as_string());
}
static qemu_acl *find_acl(Monitor *mon, const char *name)
mon_fd_t *monfd;
int fd;
- fd = qemu_chr_get_msgfd(mon->chr);
+ fd = qemu_chr_fe_get_msgfd(mon->chr);
if (fd == -1) {
qerror_report(QERR_FD_NOT_SUPPLIED);
return -1;
return 0;
}
- monfd = qemu_mallocz(sizeof(mon_fd_t));
- monfd->name = qemu_strdup(fdname);
+ monfd = g_malloc0(sizeof(mon_fd_t));
+ monfd->name = g_strdup(fdname);
monfd->fd = fd;
QLIST_INSERT_HEAD(&mon->fds, monfd, next);
QLIST_REMOVE(monfd, next);
close(monfd->fd);
- qemu_free(monfd->name);
- qemu_free(monfd);
+ g_free(monfd->name);
+ g_free(monfd);
return 0;
}
static void do_loadvm(Monitor *mon, const QDict *qdict)
{
- int saved_vm_running = vm_running;
+ int saved_vm_running = runstate_is_running();
const char *name = qdict_get_str(qdict, "name");
- vm_stop(VMSTOP_LOADVM);
+ vm_stop(RSTATE_RESTORE);
if (load_vmstate(name) == 0 && saved_vm_running) {
vm_start();
/* caller takes ownership of fd */
QLIST_REMOVE(monfd, next);
- qemu_free(monfd->name);
- qemu_free(monfd);
+ g_free(monfd->name);
+ g_free(monfd);
return fd;
}
.user_print = do_pci_info_print,
.mhandler.info_new = do_pci_info,
},
-#if defined(TARGET_I386) || defined(TARGET_SH4) || defined(TARGET_SPARC)
+#if defined(TARGET_I386) || defined(TARGET_SH4) || defined(TARGET_SPARC) || \
+ defined(TARGET_PPC)
{
.name = "tlb",
.args_type = "",
.mhandler.info = mem_info,
},
#endif
+ {
+ .name = "mtree",
+ .args_type = "",
+ .params = "",
+ .help = "show memory tree",
+ .mhandler.info = do_info_mtree,
+ },
{
.name = "jit",
.args_type = "",
.help = "show roms",
.mhandler.info = do_info_roms,
},
-#if defined(CONFIG_SIMPLE_TRACE)
+#if defined(CONFIG_TRACE_SIMPLE)
{
.name = "trace",
.args_type = "",
.help = "show current contents of trace buffer",
.mhandler.info = do_info_trace,
},
+#endif
{
.name = "trace-events",
.args_type = "",
.params = "",
.help = "show available trace-events & their state",
- .mhandler.info = do_info_trace_events,
+ .mhandler.info = do_trace_print_events,
},
-#endif
{
.name = NULL,
},
}
len = p - type;
- str = qemu_malloc(len + 1);
+ str = g_malloc(len + 1);
memcpy(str, type, len);
str[len] = '\0';
monitor_printf(mon, "%s: unknown type '%c'\n", cmdname, c);
goto fail;
}
- qemu_free(key);
+ g_free(key);
key = NULL;
}
/* check that all arguments were parsed */
return cmd;
fail:
- qemu_free(key);
+ g_free(key);
return NULL;
}
if (nb_args >= MAX_ARGS)
break;
ret = get_str(buf, sizeof(buf), &p);
- args[nb_args] = qemu_strdup(buf);
+ args[nb_args] = g_strdup(buf);
nb_args++;
if (ret < 0)
break;
if (nb_args >= MAX_ARGS) {
goto cleanup;
}
- args[nb_args++] = qemu_strdup("");
+ args[nb_args++] = g_strdup("");
}
if (nb_args <= 1) {
/* command completion */
cleanup:
for (i = 0; i < nb_args; i++) {
- qemu_free(args[i]);
+ g_free(args[i]);
}
}
qobject_incref(mon->mc->id);
cmd_name = qdict_get_str(input, "execute");
+ trace_handle_qmp_command(mon, cmd_name);
if (invalid_qmp_mode(mon, cmd_name)) {
qerror_report(QERR_COMMAND_NOT_FOUND, cmd_name);
goto err_out;
is_first_init = 0;
}
- mon = qemu_mallocz(sizeof(*mon));
+ mon = g_malloc0(sizeof(*mon));
mon->chr = chr;
mon->flags = flags;
}
if (monitor_ctrl_mode(mon)) {
- mon->mc = qemu_mallocz(sizeof(MonitorControl));
+ mon->mc = g_malloc0(sizeof(MonitorControl));
/* Control mode requires special handlers */
qemu_chr_add_handlers(chr, monitor_can_read, monitor_control_read,
monitor_control_event, mon);
- qemu_chr_set_echo(chr, true);
+ qemu_chr_fe_set_echo(chr, true);
} else {
qemu_chr_add_handlers(chr, monitor_can_read, monitor_read,
monitor_event, mon);
projects / mirror_qemu.git / blobdiff