#include "hw/hw.h"
#include "monitor/qdev.h"
#include "hw/usb.h"
-#include "hw/i386/pc.h"
#include "hw/pci/pci.h"
#include "sysemu/watchdog.h"
#include "hw/loader.h"
#if defined(TARGET_S390X)
#include "hw/s390x/storage-keys.h"
+#include "hw/s390x/storage-attributes.h"
#endif
/*
ReadLineState *rs;
MonitorQMP qmp;
- CPUState *mon_cpu;
+ gchar *mon_cpu_path;
BlockCompletionFunc *password_completion_cb;
void *password_opaque;
mon_cmd_t *cmd_table;
static void monitor_data_destroy(Monitor *mon)
{
+ g_free(mon->mon_cpu_path);
qemu_chr_fe_deinit(&mon->chr, false);
if (monitor_is_qmp(mon)) {
json_message_parser_destroy(&mon->qmp.parser);
}
- g_free(mon->rs);
+ readline_free(mon->rs);
QDECREF(mon->outbuf);
qemu_mutex_destroy(&mon->out_lock);
}
QAPIEvent e;
for (e = 0 ; e < QAPI_EVENT__MAX ; e++) {
- const char *event_name = QAPIEvent_lookup[e];
+ const char *event_name = QAPIEvent_str(e);
assert(event_name != NULL);
info = g_malloc0(sizeof(*info));
info->value = g_malloc0(sizeof(*info->value));
if (cpu == NULL) {
return -1;
}
- cur_mon->mon_cpu = cpu;
+ g_free(cur_mon->mon_cpu_path);
+ cur_mon->mon_cpu_path = object_get_canonical_path(OBJECT(cpu));
return 0;
}
CPUState *mon_get_cpu(void)
{
- if (!cur_mon->mon_cpu) {
+ CPUState *cpu;
+
+ if (cur_mon->mon_cpu_path) {
+ cpu = (CPUState *) object_resolve_path_type(cur_mon->mon_cpu_path,
+ TYPE_CPU, NULL);
+ if (!cpu) {
+ g_free(cur_mon->mon_cpu_path);
+ cur_mon->mon_cpu_path = NULL;
+ }
+ }
+ if (!cur_mon->mon_cpu_path) {
if (!first_cpu) {
return NULL;
}
monitor_set_cpu(first_cpu->cpu_index);
+ cpu = first_cpu;
}
- cpu_synchronize_state(cur_mon->mon_cpu);
- return cur_mon->mon_cpu;
+ cpu_synchronize_state(cpu);
+ return cpu;
}
CPUArchState *mon_get_cpu_env(void)
static void hmp_info_registers(Monitor *mon, const QDict *qdict)
{
- CPUState *cs = mon_get_cpu();
+ bool all_cpus = qdict_get_try_bool(qdict, "cpustate_all", false);
+ CPUState *cs;
- if (!cs) {
- monitor_printf(mon, "No CPU available\n");
- return;
+ if (all_cpus) {
+ CPU_FOREACH(cs) {
+ monitor_printf(mon, "\nCPU#%d\n", cs->cpu_index);
+ cpu_dump_state(cs, (FILE *)mon, monitor_fprintf, CPU_DUMP_FPU);
+ }
+ } else {
+ cs = mon_get_cpu();
+
+ if (!cs) {
+ monitor_printf(mon, "No CPU available\n");
+ return;
+ }
+
+ cpu_dump_state(cs, (FILE *)mon, monitor_fprintf, CPU_DUMP_FPU);
}
- cpu_dump_state(cs, (FILE *)mon, monitor_fprintf, CPU_DUMP_FPU);
}
+#ifdef CONFIG_TCG
static void hmp_info_jit(Monitor *mon, const QDict *qdict)
{
if (!tcg_enabled()) {
{
dump_opcount_info((FILE *)mon, monitor_fprintf);
}
+#endif
static void hmp_info_history(Monitor *mon, const QDict *qdict)
{
}
if (format == 'i') {
- int flags = 0;
-#ifdef TARGET_I386
- CPUArchState *env = mon_get_cpu_env();
- if (wsize == 2) {
- flags = 1;
- } else if (wsize == 4) {
- flags = 0;
- } else {
- /* as default we use the current CS size */
- flags = 0;
- if (env) {
-#ifdef TARGET_X86_64
- if ((env->efer & MSR_EFER_LMA) &&
- (env->segs[R_CS].flags & DESC_L_MASK))
- flags = 2;
- else
-#endif
- if (!(env->segs[R_CS].flags & DESC_B_MASK))
- flags = 1;
- }
- }
-#endif
-#ifdef TARGET_PPC
- CPUArchState *env = mon_get_cpu_env();
- flags = msr_le << 16;
- flags |= env->bfd_mach;
-#endif
- monitor_disas(mon, cs, addr, count, is_physical, flags);
+ monitor_disas(mon, cs, addr, count, is_physical);
return;
}
switch(format) {
case 'o':
- max_digits = (wsize * 8 + 2) / 3;
+ max_digits = DIV_ROUND_UP(wsize * 8, 3);
break;
default:
case 'x':
break;
case 'u':
case 'd':
- max_digits = (wsize * 8 * 10 + 32) / 33;
+ max_digits = DIV_ROUND_UP(wsize * 8 * 10, 33);
break;
case 'c':
wsize = 1;
static void hmp_info_mtree(Monitor *mon, const QDict *qdict)
{
bool flatview = qdict_get_try_bool(qdict, "flatview", false);
+ bool dispatch_tree = qdict_get_try_bool(qdict, "dispatch_tree", false);
- mtree_info((fprintf_function)monitor_printf, mon, flatview);
+ mtree_info((fprintf_function)monitor_printf, mon, flatview, dispatch_tree);
}
static void hmp_info_numa(Monitor *mon, const QDict *qdict)
{
int i;
- uint64_t *node_mem;
+ NumaNodeMem *node_mem;
CpuInfoList *cpu_list, *cpu;
cpu_list = qmp_query_cpus(&error_abort);
- node_mem = g_new0(uint64_t, nb_numa_nodes);
+ node_mem = g_new0(NumaNodeMem, nb_numa_nodes);
+
query_numa_node_mem(node_mem);
monitor_printf(mon, "%d nodes\n", nb_numa_nodes);
for (i = 0; i < nb_numa_nodes; i++) {
}
monitor_printf(mon, "\n");
monitor_printf(mon, "node %d size: %" PRId64 " MB\n", i,
- node_mem[i] >> 20);
+ node_mem[i].node_mem >> 20);
+ monitor_printf(mon, "node %d plugged: %" PRId64 " MB\n", i,
+ node_mem[i].node_plugged_mem >> 20);
}
qapi_free_CpuInfoList(cpu_list);
g_free(node_mem);
* the command is found in a sub-command table.
*/
static const mon_cmd_t *monitor_parse_command(Monitor *mon,
+ const char *cmdp_start,
const char **cmdp,
mon_cmd_t *table)
{
cmd = search_dispatch_table(table, cmdname);
if (!cmd) {
monitor_printf(mon, "unknown command: '%.*s'\n",
- (int)(p - *cmdp), *cmdp);
+ (int)(p - cmdp_start), cmdp_start);
return NULL;
}
*cmdp = p;
/* search sub command */
if (cmd->sub_table != NULL && *p != '\0') {
- return monitor_parse_command(mon, cmdp, cmd->sub_table);
+ return monitor_parse_command(mon, cmdp_start, cmdp, cmd->sub_table);
}
return cmd;
monitor_printf(mon, "Unknown unit suffix\n");
goto fail;
}
- qdict_put(qdict, key, qfloat_from_double(val));
+ qdict_put(qdict, key, qnum_from_double(val));
}
break;
case 'b':
QDict *qdict;
const mon_cmd_t *cmd;
- cmd = monitor_parse_command(mon, &cmdline, mon->cmd_table);
+ trace_handle_hmp_command(mon, cmdline);
+
+ cmd = monitor_parse_command(mon, cmdline, &cmdline, mon->cmd_table);
if (!cmd) {
return;
}
}
len = strlen(str);
readline_set_completion_index(rs, len);
- for (i = 0; NetClientDriver_lookup[i]; i++) {
- add_completion_option(rs, str, NetClientDriver_lookup[i]);
+ for (i = 0; i < NET_CLIENT_DRIVER__MAX; i++) {
+ add_completion_option(rs, str, NetClientDriver_str(i));
}
}
len = strlen(str);
readline_set_completion_index(rs, len);
for (i = 0; i < Q_KEY_CODE__MAX; i++) {
- if (!strncmp(str, QKeyCode_lookup[i], len)) {
- readline_add_completion(rs, QKeyCode_lookup[i]);
+ if (!strncmp(str, QKeyCode_str(i), len)) {
+ readline_add_completion(rs, QKeyCode_str(i));
}
}
}
return;
}
readline_set_completion_index(rs, strlen(str));
- for (i = 0; WatchdogExpirationAction_lookup[i]; i++) {
- add_completion_option(rs, str, WatchdogExpirationAction_lookup[i]);
+ for (i = 0; i < WATCHDOG_ACTION__MAX; i++) {
+ add_completion_option(rs, str, WatchdogAction_str(i));
}
}
if (nb_args == 2) {
int i;
for (i = 0; i < MIGRATION_CAPABILITY__MAX; i++) {
- const char *name = MigrationCapability_lookup[i];
+ const char *name = MigrationCapability_str(i);
if (!strncmp(str, name, len)) {
readline_add_completion(rs, name);
}
if (nb_args == 2) {
int i;
for (i = 0; i < MIGRATION_PARAMETER__MAX; i++) {
- const char *name = MigrationParameter_lookup[i];
+ const char *name = MigrationParameter_str(i);
if (!strncmp(str, name, len)) {
readline_add_completion(rs, name);
}
qdict_del(qdict, "id");
} /* else will fail qmp_dispatch() */
+ if (trace_event_get_state_backends(TRACE_HANDLE_QMP_COMMAND)) {
+ QString *req_json = qobject_to_json(req);
+ trace_handle_qmp_command(mon, qstring_get_str(req_json));
+ QDECREF(req_json);
+ }
+
rsp = qmp_dispatch(cur_mon->qmp.commands, req);
if (mon->qmp.commands == &qmp_cap_negotiation_commands) {
qdict = qdict_get_qdict(qobject_to_qdict(rsp), "error");
if (qdict
&& !g_strcmp0(qdict_get_try_str(qdict, "class"),
- QapiErrorClass_lookup[ERROR_CLASS_COMMAND_NOT_FOUND])) {
+ QapiErrorClass_str(ERROR_CLASS_COMMAND_NOT_FOUND))) {
/* Provide a more useful error message */
qdict_del(qdict, "desc");
qdict_put_str(qdict, "desc", "Expecting capabilities negotiation"
if (monitor_is_qmp(mon)) {
qemu_chr_fe_set_handlers(&mon->chr, monitor_can_read, monitor_qmp_read,
- monitor_qmp_event, mon, NULL, true);
+ monitor_qmp_event, NULL, mon, NULL, true);
qemu_chr_fe_set_echo(&mon->chr, true);
json_message_parser_init(&mon->qmp.parser, handle_qmp_command);
} else {
qemu_chr_fe_set_handlers(&mon->chr, monitor_can_read, monitor_read,
- monitor_event, mon, NULL, true);
+ monitor_event, NULL, mon, NULL, true);
}
qemu_mutex_lock(&monitor_lock);
qemu_mutex_unlock(&monitor_lock);
}
-static void bdrv_password_cb(void *opaque, const char *password,
- void *readline_opaque)
-{
- Monitor *mon = opaque;
- BlockDriverState *bs = readline_opaque;
- int ret = 0;
- Error *local_err = NULL;
-
- bdrv_add_key(bs, password, &local_err);
- if (local_err) {
- error_report_err(local_err);
- ret = -EPERM;
- }
- if (mon->password_completion_cb)
- mon->password_completion_cb(mon->password_opaque, ret);
-
- monitor_read_command(mon, 1);
-}
-
-int monitor_read_bdrv_key_start(Monitor *mon, BlockDriverState *bs,
- BlockCompletionFunc *completion_cb,
- void *opaque)
-{
- int err;
-
- monitor_printf(mon, "%s (%s) is encrypted.\n", bdrv_get_device_name(bs),
- bdrv_get_encrypted_filename(bs));
-
- mon->password_completion_cb = completion_cb;
- mon->password_opaque = opaque;
-
- err = monitor_read_password(mon, bdrv_password_cb, bs);
-
- if (err && completion_cb)
- completion_cb(opaque, err);
-
- return err;
-}
-
-int monitor_read_block_device_key(Monitor *mon, const char *device,
- BlockCompletionFunc *completion_cb,
- void *opaque)
-{
- Error *err = NULL;
- BlockBackend *blk;
-
- blk = blk_by_name(device);
- if (!blk) {
- monitor_printf(mon, "Device not found %s\n", device);
- return -1;
- }
- if (!blk_bs(blk)) {
- monitor_printf(mon, "Device '%s' has no medium\n", device);
- return -1;
- }
-
- bdrv_add_key(blk_bs(blk), NULL, &err);
- if (err) {
- error_free(err);
- return monitor_read_bdrv_key_start(mon, blk_bs(blk), completion_cb, opaque);
- }
-
- if (completion_cb) {
- completion_cb(opaque, 0);
- }
- return 0;
-}
-
QemuOptsList qemu_mon_opts = {
.name = "mon",
.implied_opt_name = "chardev",
projects / qemu.git / blobdiff