* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
+
#include "qemu/osdep.h"
#include <dirent.h>
-#include "qemu-common.h"
#include "cpu.h"
#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"
#include "sysemu/hw_accel.h"
#include "qemu/acl.h"
#include "sysemu/tpm.h"
+#include "qapi/qmp/qdict.h"
#include "qapi/qmp/qerror.h"
-#include "qapi/qmp/types.h"
+#include "qapi/qmp/qnum.h"
+#include "qapi/qmp/qstring.h"
#include "qapi/qmp/qjson.h"
#include "qapi/qmp/json-streamer.h"
#include "qapi/qmp/json-parser.h"
#include "exec/memory.h"
#include "exec/exec-all.h"
#include "qemu/log.h"
-#include "qmp-commands.h"
+#include "qemu/option.h"
#include "hmp.h"
#include "qemu/thread.h"
#include "block/qapi.h"
+#include "qapi/qapi-commands.h"
+#include "qapi/qapi-events.h"
+#include "qapi/error.h"
#include "qapi/qmp-event.h"
-#include "qapi-event.h"
-#include "qmp-introspect.h"
+#include "qapi/qapi-introspect.h"
#include "sysemu/qtest.h"
#include "sysemu/cpus.h"
#include "qemu/cutils.h"
-#include "qapi/qmp/dispatch.h"
#if defined(TARGET_S390X)
#include "hw/s390x/storage-keys.h"
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));
* visit_type_SchemaInfoList() into a SchemaInfoList, then marshal it
* to QObject with generated output marshallers, every time. Instead,
* we do it in test-qobject-input-visitor.c, just to make sure
- * qapi-introspect.py's output actually conforms to the schema.
+ * qapi-gen.py's output actually conforms to the schema.
*/
static void qmp_query_qmp_schema(QDict *qdict, QObject **ret_data,
Error **errp)
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)
+static CPUState *mon_get_cpu_sync(bool synchronize)
{
- 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;
+ if (synchronize) {
+ cpu_synchronize_state(cpu);
+ }
+ return cpu;
+}
+
+CPUState *mon_get_cpu(void)
+{
+ return mon_get_cpu_sync(true);
}
CPUArchState *mon_get_cpu_env(void)
int monitor_get_cpu_index(void)
{
- CPUState *cs = mon_get_cpu();
+ CPUState *cs = mon_get_cpu_sync(false);
return cs ? cs->cpu_index : UNASSIGNED_CPU_INDEX;
}
}
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;
trace_handle_hmp_command(mon, cmdline);
- cmd = monitor_parse_command(mon, &cmdline, mon->cmd_table);
+ 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);
}
{
const char *cmdname;
int i;
- const char *ptype, *str, *name;
+ const char *ptype, *old_ptype, *str, *name;
const mon_cmd_t *cmd;
BlockBackend *blk = NULL;
}
}
str = args[nb_args - 1];
- while (*ptype == '-' && ptype[1] != '\0') {
+ old_ptype = NULL;
+ while (*ptype == '-' && old_ptype != ptype) {
+ old_ptype = ptype;
ptype = next_arg_type(ptype);
}
switch(*ptype) {
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"
},{
.name = "chardev",
.type = QEMU_OPT_STRING,
- },{
- .name = "default", /* deprecated */
- .type = QEMU_OPT_BOOL,
},{
.name = "pretty",
.type = QEMU_OPT_BOOL,
projects / qemu.git / blobdiff