1505 lines
40 KiB
C
1505 lines
40 KiB
C
/*
|
|
* QEMU monitor
|
|
*
|
|
* Copyright (c) 2003-2004 Fabrice Bellard
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* 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 "hw/qdev-core.h"
|
|
#include "monitor-internal.h"
|
|
#include "monitor/hmp.h"
|
|
#include "qapi/error.h"
|
|
#include "qapi/qmp/qdict.h"
|
|
#include "qapi/qmp/qnum.h"
|
|
#include "qemu/config-file.h"
|
|
#include "qemu/ctype.h"
|
|
#include "qemu/cutils.h"
|
|
#include "qemu/log.h"
|
|
#include "qemu/option.h"
|
|
#include "qemu/units.h"
|
|
#include "sysemu/block-backend.h"
|
|
#include "sysemu/runstate.h"
|
|
#include "trace.h"
|
|
|
|
static void monitor_command_cb(void *opaque, const char *cmdline,
|
|
void *readline_opaque)
|
|
{
|
|
MonitorHMP *mon = opaque;
|
|
|
|
monitor_suspend(&mon->common);
|
|
handle_hmp_command(mon, cmdline);
|
|
monitor_resume(&mon->common);
|
|
}
|
|
|
|
void monitor_read_command(MonitorHMP *mon, int show_prompt)
|
|
{
|
|
if (!mon->rs) {
|
|
return;
|
|
}
|
|
|
|
readline_start(mon->rs, "(qemu) ", 0, monitor_command_cb, NULL);
|
|
if (show_prompt) {
|
|
readline_show_prompt(mon->rs);
|
|
}
|
|
}
|
|
|
|
int monitor_read_password(MonitorHMP *mon, ReadLineFunc *readline_func,
|
|
void *opaque)
|
|
{
|
|
if (mon->rs) {
|
|
readline_start(mon->rs, "Password: ", 1, readline_func, opaque);
|
|
/* prompt is printed on return from the command handler */
|
|
return 0;
|
|
} else {
|
|
monitor_printf(&mon->common,
|
|
"terminal does not support password prompting\n");
|
|
return -ENOTTY;
|
|
}
|
|
}
|
|
|
|
static int get_str(char *buf, int buf_size, const char **pp)
|
|
{
|
|
const char *p;
|
|
char *q;
|
|
int c;
|
|
|
|
q = buf;
|
|
p = *pp;
|
|
while (qemu_isspace(*p)) {
|
|
p++;
|
|
}
|
|
if (*p == '\0') {
|
|
fail:
|
|
*q = '\0';
|
|
*pp = p;
|
|
return -1;
|
|
}
|
|
if (*p == '\"') {
|
|
p++;
|
|
while (*p != '\0' && *p != '\"') {
|
|
if (*p == '\\') {
|
|
p++;
|
|
c = *p++;
|
|
switch (c) {
|
|
case 'n':
|
|
c = '\n';
|
|
break;
|
|
case 'r':
|
|
c = '\r';
|
|
break;
|
|
case '\\':
|
|
case '\'':
|
|
case '\"':
|
|
break;
|
|
default:
|
|
printf("unsupported escape code: '\\%c'\n", c);
|
|
goto fail;
|
|
}
|
|
if ((q - buf) < buf_size - 1) {
|
|
*q++ = c;
|
|
}
|
|
} else {
|
|
if ((q - buf) < buf_size - 1) {
|
|
*q++ = *p;
|
|
}
|
|
p++;
|
|
}
|
|
}
|
|
if (*p != '\"') {
|
|
printf("unterminated string\n");
|
|
goto fail;
|
|
}
|
|
p++;
|
|
} else {
|
|
while (*p != '\0' && !qemu_isspace(*p)) {
|
|
if ((q - buf) < buf_size - 1) {
|
|
*q++ = *p;
|
|
}
|
|
p++;
|
|
}
|
|
}
|
|
*q = '\0';
|
|
*pp = p;
|
|
return 0;
|
|
}
|
|
|
|
#define MAX_ARGS 16
|
|
|
|
static void free_cmdline_args(char **args, int nb_args)
|
|
{
|
|
int i;
|
|
|
|
assert(nb_args <= MAX_ARGS);
|
|
|
|
for (i = 0; i < nb_args; i++) {
|
|
g_free(args[i]);
|
|
}
|
|
|
|
}
|
|
|
|
/*
|
|
* Parse the command line to get valid args.
|
|
* @cmdline: command line to be parsed.
|
|
* @pnb_args: location to store the number of args, must NOT be NULL.
|
|
* @args: location to store the args, which should be freed by caller, must
|
|
* NOT be NULL.
|
|
*
|
|
* Returns 0 on success, negative on failure.
|
|
*
|
|
* NOTE: this parser is an approximate form of the real command parser. Number
|
|
* of args have a limit of MAX_ARGS. If cmdline contains more, it will
|
|
* return with failure.
|
|
*/
|
|
static int parse_cmdline(const char *cmdline,
|
|
int *pnb_args, char **args)
|
|
{
|
|
const char *p;
|
|
int nb_args, ret;
|
|
char buf[1024];
|
|
|
|
p = cmdline;
|
|
nb_args = 0;
|
|
for (;;) {
|
|
while (qemu_isspace(*p)) {
|
|
p++;
|
|
}
|
|
if (*p == '\0') {
|
|
break;
|
|
}
|
|
if (nb_args >= MAX_ARGS) {
|
|
goto fail;
|
|
}
|
|
ret = get_str(buf, sizeof(buf), &p);
|
|
if (ret < 0) {
|
|
goto fail;
|
|
}
|
|
args[nb_args] = g_strdup(buf);
|
|
nb_args++;
|
|
}
|
|
*pnb_args = nb_args;
|
|
return 0;
|
|
|
|
fail:
|
|
free_cmdline_args(args, nb_args);
|
|
return -1;
|
|
}
|
|
|
|
/*
|
|
* Can command @cmd be executed in preconfig state?
|
|
*/
|
|
static bool cmd_can_preconfig(const HMPCommand *cmd)
|
|
{
|
|
if (!cmd->flags) {
|
|
return false;
|
|
}
|
|
|
|
return strchr(cmd->flags, 'p');
|
|
}
|
|
|
|
static bool cmd_available(const HMPCommand *cmd)
|
|
{
|
|
return phase_check(PHASE_MACHINE_READY) || cmd_can_preconfig(cmd);
|
|
}
|
|
|
|
static void help_cmd_dump_one(Monitor *mon,
|
|
const HMPCommand *cmd,
|
|
char **prefix_args,
|
|
int prefix_args_nb)
|
|
{
|
|
int i;
|
|
|
|
if (!cmd_available(cmd)) {
|
|
return;
|
|
}
|
|
|
|
for (i = 0; i < prefix_args_nb; i++) {
|
|
monitor_printf(mon, "%s ", prefix_args[i]);
|
|
}
|
|
monitor_printf(mon, "%s %s -- %s\n", cmd->name, cmd->params, cmd->help);
|
|
}
|
|
|
|
/* @args[@arg_index] is the valid command need to find in @cmds */
|
|
static void help_cmd_dump(Monitor *mon, const HMPCommand *cmds,
|
|
char **args, int nb_args, int arg_index)
|
|
{
|
|
const HMPCommand *cmd;
|
|
size_t i;
|
|
|
|
/* No valid arg need to compare with, dump all in *cmds */
|
|
if (arg_index >= nb_args) {
|
|
for (cmd = cmds; cmd->name != NULL; cmd++) {
|
|
help_cmd_dump_one(mon, cmd, args, arg_index);
|
|
}
|
|
return;
|
|
}
|
|
|
|
/* Find one entry to dump */
|
|
for (cmd = cmds; cmd->name != NULL; cmd++) {
|
|
if (hmp_compare_cmd(args[arg_index], cmd->name) &&
|
|
cmd_available(cmd)) {
|
|
if (cmd->sub_table) {
|
|
/* continue with next arg */
|
|
help_cmd_dump(mon, cmd->sub_table,
|
|
args, nb_args, arg_index + 1);
|
|
} else {
|
|
help_cmd_dump_one(mon, cmd, args, arg_index);
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
/* Command not found */
|
|
monitor_printf(mon, "unknown command: '");
|
|
for (i = 0; i <= arg_index; i++) {
|
|
monitor_printf(mon, "%s%s", args[i], i == arg_index ? "'\n" : " ");
|
|
}
|
|
}
|
|
|
|
void help_cmd(Monitor *mon, const char *name)
|
|
{
|
|
char *args[MAX_ARGS];
|
|
int nb_args = 0;
|
|
|
|
/* 1. parse user input */
|
|
if (name) {
|
|
/* special case for log, directly dump and return */
|
|
if (!strcmp(name, "log")) {
|
|
const QEMULogItem *item;
|
|
monitor_printf(mon, "Log items (comma separated):\n");
|
|
monitor_printf(mon, "%-10s %s\n", "none", "remove all logs");
|
|
for (item = qemu_log_items; item->mask != 0; item++) {
|
|
monitor_printf(mon, "%-10s %s\n", item->name, item->help);
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (parse_cmdline(name, &nb_args, args) < 0) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
/* 2. dump the contents according to parsed args */
|
|
help_cmd_dump(mon, hmp_cmds, args, nb_args, 0);
|
|
|
|
free_cmdline_args(args, nb_args);
|
|
}
|
|
|
|
/*******************************************************************/
|
|
|
|
static const char *pch;
|
|
static sigjmp_buf expr_env;
|
|
|
|
static G_NORETURN G_GNUC_PRINTF(2, 3)
|
|
void expr_error(Monitor *mon, const char *fmt, ...)
|
|
{
|
|
va_list ap;
|
|
va_start(ap, fmt);
|
|
monitor_vprintf(mon, fmt, ap);
|
|
monitor_printf(mon, "\n");
|
|
va_end(ap);
|
|
siglongjmp(expr_env, 1);
|
|
}
|
|
|
|
static void next(void)
|
|
{
|
|
if (*pch != '\0') {
|
|
pch++;
|
|
while (qemu_isspace(*pch)) {
|
|
pch++;
|
|
}
|
|
}
|
|
}
|
|
|
|
static int64_t expr_sum(Monitor *mon);
|
|
|
|
static int64_t expr_unary(Monitor *mon)
|
|
{
|
|
int64_t n;
|
|
char *p;
|
|
int ret;
|
|
|
|
switch (*pch) {
|
|
case '+':
|
|
next();
|
|
n = expr_unary(mon);
|
|
break;
|
|
case '-':
|
|
next();
|
|
n = -expr_unary(mon);
|
|
break;
|
|
case '~':
|
|
next();
|
|
n = ~expr_unary(mon);
|
|
break;
|
|
case '(':
|
|
next();
|
|
n = expr_sum(mon);
|
|
if (*pch != ')') {
|
|
expr_error(mon, "')' expected");
|
|
}
|
|
next();
|
|
break;
|
|
case '\'':
|
|
pch++;
|
|
if (*pch == '\0') {
|
|
expr_error(mon, "character constant expected");
|
|
}
|
|
n = *pch;
|
|
pch++;
|
|
if (*pch != '\'') {
|
|
expr_error(mon, "missing terminating \' character");
|
|
}
|
|
next();
|
|
break;
|
|
case '$':
|
|
{
|
|
char buf[128], *q;
|
|
int64_t reg = 0;
|
|
|
|
pch++;
|
|
q = buf;
|
|
while ((*pch >= 'a' && *pch <= 'z') ||
|
|
(*pch >= 'A' && *pch <= 'Z') ||
|
|
(*pch >= '0' && *pch <= '9') ||
|
|
*pch == '_' || *pch == '.') {
|
|
if ((q - buf) < sizeof(buf) - 1) {
|
|
*q++ = *pch;
|
|
}
|
|
pch++;
|
|
}
|
|
while (qemu_isspace(*pch)) {
|
|
pch++;
|
|
}
|
|
*q = 0;
|
|
ret = get_monitor_def(mon, ®, buf);
|
|
if (ret < 0) {
|
|
expr_error(mon, "unknown register");
|
|
}
|
|
n = reg;
|
|
}
|
|
break;
|
|
case '\0':
|
|
expr_error(mon, "unexpected end of expression");
|
|
n = 0;
|
|
break;
|
|
default:
|
|
errno = 0;
|
|
n = strtoull(pch, &p, 0);
|
|
if (errno == ERANGE) {
|
|
expr_error(mon, "number too large");
|
|
}
|
|
if (pch == p) {
|
|
expr_error(mon, "invalid char '%c' in expression", *p);
|
|
}
|
|
pch = p;
|
|
while (qemu_isspace(*pch)) {
|
|
pch++;
|
|
}
|
|
break;
|
|
}
|
|
return n;
|
|
}
|
|
|
|
static int64_t expr_prod(Monitor *mon)
|
|
{
|
|
int64_t val, val2;
|
|
int op;
|
|
|
|
val = expr_unary(mon);
|
|
for (;;) {
|
|
op = *pch;
|
|
if (op != '*' && op != '/' && op != '%') {
|
|
break;
|
|
}
|
|
next();
|
|
val2 = expr_unary(mon);
|
|
switch (op) {
|
|
default:
|
|
case '*':
|
|
val *= val2;
|
|
break;
|
|
case '/':
|
|
case '%':
|
|
if (val2 == 0) {
|
|
expr_error(mon, "division by zero");
|
|
}
|
|
if (op == '/') {
|
|
val /= val2;
|
|
} else {
|
|
val %= val2;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return val;
|
|
}
|
|
|
|
static int64_t expr_logic(Monitor *mon)
|
|
{
|
|
int64_t val, val2;
|
|
int op;
|
|
|
|
val = expr_prod(mon);
|
|
for (;;) {
|
|
op = *pch;
|
|
if (op != '&' && op != '|' && op != '^') {
|
|
break;
|
|
}
|
|
next();
|
|
val2 = expr_prod(mon);
|
|
switch (op) {
|
|
default:
|
|
case '&':
|
|
val &= val2;
|
|
break;
|
|
case '|':
|
|
val |= val2;
|
|
break;
|
|
case '^':
|
|
val ^= val2;
|
|
break;
|
|
}
|
|
}
|
|
return val;
|
|
}
|
|
|
|
static int64_t expr_sum(Monitor *mon)
|
|
{
|
|
int64_t val, val2;
|
|
int op;
|
|
|
|
val = expr_logic(mon);
|
|
for (;;) {
|
|
op = *pch;
|
|
if (op != '+' && op != '-') {
|
|
break;
|
|
}
|
|
next();
|
|
val2 = expr_logic(mon);
|
|
if (op == '+') {
|
|
val += val2;
|
|
} else {
|
|
val -= val2;
|
|
}
|
|
}
|
|
return val;
|
|
}
|
|
|
|
static int get_expr(Monitor *mon, int64_t *pval, const char **pp)
|
|
{
|
|
pch = *pp;
|
|
if (sigsetjmp(expr_env, 0)) {
|
|
*pp = pch;
|
|
return -1;
|
|
}
|
|
while (qemu_isspace(*pch)) {
|
|
pch++;
|
|
}
|
|
*pval = expr_sum(mon);
|
|
*pp = pch;
|
|
return 0;
|
|
}
|
|
|
|
static int get_double(Monitor *mon, double *pval, const char **pp)
|
|
{
|
|
const char *p = *pp;
|
|
char *tailp;
|
|
double d;
|
|
|
|
d = strtod(p, &tailp);
|
|
if (tailp == p) {
|
|
monitor_printf(mon, "Number expected\n");
|
|
return -1;
|
|
}
|
|
if (d != d || d - d != 0) {
|
|
/* NaN or infinity */
|
|
monitor_printf(mon, "Bad number\n");
|
|
return -1;
|
|
}
|
|
*pval = d;
|
|
*pp = tailp;
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Store the command-name in cmdname, and return a pointer to
|
|
* the remaining of the command string.
|
|
*/
|
|
static const char *get_command_name(const char *cmdline,
|
|
char *cmdname, size_t nlen)
|
|
{
|
|
size_t len;
|
|
const char *p, *pstart;
|
|
|
|
p = cmdline;
|
|
while (qemu_isspace(*p)) {
|
|
p++;
|
|
}
|
|
if (*p == '\0') {
|
|
return NULL;
|
|
}
|
|
pstart = p;
|
|
while (*p != '\0' && *p != '/' && !qemu_isspace(*p)) {
|
|
p++;
|
|
}
|
|
len = p - pstart;
|
|
if (len > nlen - 1) {
|
|
len = nlen - 1;
|
|
}
|
|
memcpy(cmdname, pstart, len);
|
|
cmdname[len] = '\0';
|
|
return p;
|
|
}
|
|
|
|
/**
|
|
* Read key of 'type' into 'key' and return the current
|
|
* 'type' pointer.
|
|
*/
|
|
static char *key_get_info(const char *type, char **key)
|
|
{
|
|
size_t len;
|
|
char *p, *str;
|
|
|
|
if (*type == ',') {
|
|
type++;
|
|
}
|
|
|
|
p = strchr(type, ':');
|
|
if (!p) {
|
|
*key = NULL;
|
|
return NULL;
|
|
}
|
|
len = p - type;
|
|
|
|
str = g_malloc(len + 1);
|
|
memcpy(str, type, len);
|
|
str[len] = '\0';
|
|
|
|
*key = str;
|
|
return ++p;
|
|
}
|
|
|
|
static int default_fmt_format = 'x';
|
|
static int default_fmt_size = 4;
|
|
|
|
static int is_valid_option(const char *c, const char *typestr)
|
|
{
|
|
char option[3];
|
|
|
|
option[0] = '-';
|
|
option[1] = *c;
|
|
option[2] = '\0';
|
|
|
|
typestr = strstr(typestr, option);
|
|
return (typestr != NULL);
|
|
}
|
|
|
|
static const HMPCommand *search_dispatch_table(const HMPCommand *disp_table,
|
|
const char *cmdname)
|
|
{
|
|
const HMPCommand *cmd;
|
|
|
|
for (cmd = disp_table; cmd->name != NULL; cmd++) {
|
|
if (hmp_compare_cmd(cmdname, cmd->name)) {
|
|
return cmd;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* Parse command name from @cmdp according to command table @table.
|
|
* If blank, return NULL.
|
|
* Else, if no valid command can be found, report to @mon, and return
|
|
* NULL.
|
|
* Else, change @cmdp to point right behind the name, and return its
|
|
* command table entry.
|
|
* Do not assume the return value points into @table! It doesn't when
|
|
* the command is found in a sub-command table.
|
|
*/
|
|
static const HMPCommand *monitor_parse_command(MonitorHMP *hmp_mon,
|
|
const char *cmdp_start,
|
|
const char **cmdp,
|
|
HMPCommand *table)
|
|
{
|
|
Monitor *mon = &hmp_mon->common;
|
|
const char *p;
|
|
const HMPCommand *cmd;
|
|
char cmdname[256];
|
|
|
|
/* extract the command name */
|
|
p = get_command_name(*cmdp, cmdname, sizeof(cmdname));
|
|
if (!p) {
|
|
return NULL;
|
|
}
|
|
|
|
cmd = search_dispatch_table(table, cmdname);
|
|
if (!cmd) {
|
|
monitor_printf(mon, "unknown command: '%.*s'\n",
|
|
(int)(p - cmdp_start), cmdp_start);
|
|
return NULL;
|
|
}
|
|
if (!cmd_available(cmd)) {
|
|
monitor_printf(mon, "Command '%.*s' not available "
|
|
"until machine initialization has completed.\n",
|
|
(int)(p - cmdp_start), cmdp_start);
|
|
return NULL;
|
|
}
|
|
|
|
/* filter out following useless space */
|
|
while (qemu_isspace(*p)) {
|
|
p++;
|
|
}
|
|
|
|
*cmdp = p;
|
|
/* search sub command */
|
|
if (cmd->sub_table != NULL && *p != '\0') {
|
|
return monitor_parse_command(hmp_mon, cmdp_start, cmdp, cmd->sub_table);
|
|
}
|
|
|
|
return cmd;
|
|
}
|
|
|
|
/*
|
|
* Parse arguments for @cmd.
|
|
* If it can't be parsed, report to @mon, and return NULL.
|
|
* Else, insert command arguments into a QDict, and return it.
|
|
* Note: On success, caller has to free the QDict structure.
|
|
*/
|
|
static QDict *monitor_parse_arguments(Monitor *mon,
|
|
const char **endp,
|
|
const HMPCommand *cmd)
|
|
{
|
|
const char *typestr;
|
|
char *key;
|
|
int c;
|
|
const char *p = *endp;
|
|
char buf[1024];
|
|
QDict *qdict = qdict_new();
|
|
|
|
/* parse the parameters */
|
|
typestr = cmd->args_type;
|
|
for (;;) {
|
|
typestr = key_get_info(typestr, &key);
|
|
if (!typestr) {
|
|
break;
|
|
}
|
|
c = *typestr;
|
|
typestr++;
|
|
switch (c) {
|
|
case 'F':
|
|
case 'B':
|
|
case 's':
|
|
{
|
|
int ret;
|
|
|
|
while (qemu_isspace(*p)) {
|
|
p++;
|
|
}
|
|
if (*typestr == '?') {
|
|
typestr++;
|
|
if (*p == '\0') {
|
|
/* no optional string: NULL argument */
|
|
break;
|
|
}
|
|
}
|
|
ret = get_str(buf, sizeof(buf), &p);
|
|
if (ret < 0) {
|
|
switch (c) {
|
|
case 'F':
|
|
monitor_printf(mon, "%s: filename expected\n",
|
|
cmd->name);
|
|
break;
|
|
case 'B':
|
|
monitor_printf(mon, "%s: block device name expected\n",
|
|
cmd->name);
|
|
break;
|
|
default:
|
|
monitor_printf(mon, "%s: string expected\n", cmd->name);
|
|
break;
|
|
}
|
|
goto fail;
|
|
}
|
|
qdict_put_str(qdict, key, buf);
|
|
}
|
|
break;
|
|
case 'O':
|
|
{
|
|
QemuOptsList *opts_list;
|
|
QemuOpts *opts;
|
|
|
|
opts_list = qemu_find_opts(key);
|
|
if (!opts_list || opts_list->desc->name) {
|
|
goto bad_type;
|
|
}
|
|
while (qemu_isspace(*p)) {
|
|
p++;
|
|
}
|
|
if (!*p) {
|
|
break;
|
|
}
|
|
if (get_str(buf, sizeof(buf), &p) < 0) {
|
|
goto fail;
|
|
}
|
|
opts = qemu_opts_parse_noisily(opts_list, buf, true);
|
|
if (!opts) {
|
|
goto fail;
|
|
}
|
|
qemu_opts_to_qdict(opts, qdict);
|
|
qemu_opts_del(opts);
|
|
}
|
|
break;
|
|
case '/':
|
|
{
|
|
int count, format, size;
|
|
|
|
while (qemu_isspace(*p)) {
|
|
p++;
|
|
}
|
|
if (*p == '/') {
|
|
/* format found */
|
|
p++;
|
|
count = 1;
|
|
if (qemu_isdigit(*p)) {
|
|
count = 0;
|
|
while (qemu_isdigit(*p)) {
|
|
count = count * 10 + (*p - '0');
|
|
p++;
|
|
}
|
|
}
|
|
size = -1;
|
|
format = -1;
|
|
for (;;) {
|
|
switch (*p) {
|
|
case 'o':
|
|
case 'd':
|
|
case 'u':
|
|
case 'x':
|
|
case 'i':
|
|
case 'c':
|
|
format = *p++;
|
|
break;
|
|
case 'b':
|
|
size = 1;
|
|
p++;
|
|
break;
|
|
case 'h':
|
|
size = 2;
|
|
p++;
|
|
break;
|
|
case 'w':
|
|
size = 4;
|
|
p++;
|
|
break;
|
|
case 'g':
|
|
case 'L':
|
|
size = 8;
|
|
p++;
|
|
break;
|
|
default:
|
|
goto next;
|
|
}
|
|
}
|
|
next:
|
|
if (*p != '\0' && !qemu_isspace(*p)) {
|
|
monitor_printf(mon, "invalid char in format: '%c'\n",
|
|
*p);
|
|
goto fail;
|
|
}
|
|
if (format < 0) {
|
|
format = default_fmt_format;
|
|
}
|
|
if (format != 'i') {
|
|
/* for 'i', not specifying a size gives -1 as size */
|
|
if (size < 0) {
|
|
size = default_fmt_size;
|
|
}
|
|
default_fmt_size = size;
|
|
}
|
|
default_fmt_format = format;
|
|
} else {
|
|
count = 1;
|
|
format = default_fmt_format;
|
|
if (format != 'i') {
|
|
size = default_fmt_size;
|
|
} else {
|
|
size = -1;
|
|
}
|
|
}
|
|
qdict_put_int(qdict, "count", count);
|
|
qdict_put_int(qdict, "format", format);
|
|
qdict_put_int(qdict, "size", size);
|
|
}
|
|
break;
|
|
case 'i':
|
|
case 'l':
|
|
case 'M':
|
|
{
|
|
int64_t val;
|
|
|
|
while (qemu_isspace(*p)) {
|
|
p++;
|
|
}
|
|
if (*typestr == '?' || *typestr == '.') {
|
|
if (*typestr == '?') {
|
|
if (*p == '\0') {
|
|
typestr++;
|
|
break;
|
|
}
|
|
} else {
|
|
if (*p == '.') {
|
|
p++;
|
|
while (qemu_isspace(*p)) {
|
|
p++;
|
|
}
|
|
} else {
|
|
typestr++;
|
|
break;
|
|
}
|
|
}
|
|
typestr++;
|
|
}
|
|
if (get_expr(mon, &val, &p)) {
|
|
goto fail;
|
|
}
|
|
/* Check if 'i' is greater than 32-bit */
|
|
if ((c == 'i') && ((val >> 32) & 0xffffffff)) {
|
|
monitor_printf(mon, "\'%s\' has failed: ", cmd->name);
|
|
monitor_printf(mon, "integer is for 32-bit values\n");
|
|
goto fail;
|
|
} else if (c == 'M') {
|
|
if (val < 0) {
|
|
monitor_printf(mon, "enter a positive value\n");
|
|
goto fail;
|
|
}
|
|
val *= MiB;
|
|
}
|
|
qdict_put_int(qdict, key, val);
|
|
}
|
|
break;
|
|
case 'o':
|
|
{
|
|
int ret;
|
|
uint64_t val;
|
|
const char *end;
|
|
|
|
while (qemu_isspace(*p)) {
|
|
p++;
|
|
}
|
|
if (*typestr == '?') {
|
|
typestr++;
|
|
if (*p == '\0') {
|
|
break;
|
|
}
|
|
}
|
|
ret = qemu_strtosz_MiB(p, &end, &val);
|
|
if (ret < 0 || val > INT64_MAX) {
|
|
monitor_printf(mon, "invalid size\n");
|
|
goto fail;
|
|
}
|
|
qdict_put_int(qdict, key, val);
|
|
p = end;
|
|
}
|
|
break;
|
|
case 'T':
|
|
{
|
|
double val;
|
|
|
|
while (qemu_isspace(*p)) {
|
|
p++;
|
|
}
|
|
if (*typestr == '?') {
|
|
typestr++;
|
|
if (*p == '\0') {
|
|
break;
|
|
}
|
|
}
|
|
if (get_double(mon, &val, &p) < 0) {
|
|
goto fail;
|
|
}
|
|
if (p[0] && p[1] == 's') {
|
|
switch (*p) {
|
|
case 'm':
|
|
val /= 1e3; p += 2; break;
|
|
case 'u':
|
|
val /= 1e6; p += 2; break;
|
|
case 'n':
|
|
val /= 1e9; p += 2; break;
|
|
}
|
|
}
|
|
if (*p && !qemu_isspace(*p)) {
|
|
monitor_printf(mon, "Unknown unit suffix\n");
|
|
goto fail;
|
|
}
|
|
qdict_put(qdict, key, qnum_from_double(val));
|
|
}
|
|
break;
|
|
case 'b':
|
|
{
|
|
const char *beg;
|
|
bool val;
|
|
|
|
while (qemu_isspace(*p)) {
|
|
p++;
|
|
}
|
|
beg = p;
|
|
while (qemu_isgraph(*p)) {
|
|
p++;
|
|
}
|
|
if (p - beg == 2 && !memcmp(beg, "on", p - beg)) {
|
|
val = true;
|
|
} else if (p - beg == 3 && !memcmp(beg, "off", p - beg)) {
|
|
val = false;
|
|
} else {
|
|
monitor_printf(mon, "Expected 'on' or 'off'\n");
|
|
goto fail;
|
|
}
|
|
qdict_put_bool(qdict, key, val);
|
|
}
|
|
break;
|
|
case '-':
|
|
{
|
|
const char *tmp = p;
|
|
int skip_key = 0;
|
|
int ret;
|
|
/* option */
|
|
|
|
c = *typestr++;
|
|
if (c == '\0') {
|
|
goto bad_type;
|
|
}
|
|
while (qemu_isspace(*p)) {
|
|
p++;
|
|
}
|
|
if (*p == '-') {
|
|
p++;
|
|
if (c != *p) {
|
|
if (!is_valid_option(p, typestr)) {
|
|
monitor_printf(mon, "%s: unsupported option -%c\n",
|
|
cmd->name, *p);
|
|
goto fail;
|
|
} else {
|
|
skip_key = 1;
|
|
}
|
|
}
|
|
if (skip_key) {
|
|
p = tmp;
|
|
} else if (*typestr == 's') {
|
|
/* has option with string value */
|
|
typestr++;
|
|
tmp = p++;
|
|
while (qemu_isspace(*p)) {
|
|
p++;
|
|
}
|
|
ret = get_str(buf, sizeof(buf), &p);
|
|
if (ret < 0) {
|
|
monitor_printf(mon, "%s: value expected for -%c\n",
|
|
cmd->name, *tmp);
|
|
goto fail;
|
|
}
|
|
qdict_put_str(qdict, key, buf);
|
|
} else {
|
|
/* has boolean option */
|
|
p++;
|
|
qdict_put_bool(qdict, key, true);
|
|
}
|
|
} else if (*typestr == 's') {
|
|
typestr++;
|
|
}
|
|
}
|
|
break;
|
|
case 'S':
|
|
{
|
|
/* package all remaining string */
|
|
int len;
|
|
|
|
while (qemu_isspace(*p)) {
|
|
p++;
|
|
}
|
|
if (*typestr == '?') {
|
|
typestr++;
|
|
if (*p == '\0') {
|
|
/* no remaining string: NULL argument */
|
|
break;
|
|
}
|
|
}
|
|
len = strlen(p);
|
|
if (len <= 0) {
|
|
monitor_printf(mon, "%s: string expected\n",
|
|
cmd->name);
|
|
goto fail;
|
|
}
|
|
qdict_put_str(qdict, key, p);
|
|
p += len;
|
|
}
|
|
break;
|
|
default:
|
|
bad_type:
|
|
monitor_printf(mon, "%s: unknown type '%c'\n", cmd->name, c);
|
|
goto fail;
|
|
}
|
|
g_free(key);
|
|
key = NULL;
|
|
}
|
|
/* check that all arguments were parsed */
|
|
while (qemu_isspace(*p)) {
|
|
p++;
|
|
}
|
|
if (*p != '\0') {
|
|
monitor_printf(mon, "%s: extraneous characters at the end of line\n",
|
|
cmd->name);
|
|
goto fail;
|
|
}
|
|
|
|
return qdict;
|
|
|
|
fail:
|
|
qobject_unref(qdict);
|
|
g_free(key);
|
|
return NULL;
|
|
}
|
|
|
|
static void hmp_info_human_readable_text(Monitor *mon,
|
|
HumanReadableText *(*handler)(Error **))
|
|
{
|
|
Error *err = NULL;
|
|
g_autoptr(HumanReadableText) info = handler(&err);
|
|
|
|
if (hmp_handle_error(mon, err)) {
|
|
return;
|
|
}
|
|
|
|
monitor_printf(mon, "%s", info->human_readable_text);
|
|
}
|
|
|
|
static void handle_hmp_command_exec(Monitor *mon,
|
|
const HMPCommand *cmd,
|
|
QDict *qdict)
|
|
{
|
|
if (cmd->cmd_info_hrt) {
|
|
hmp_info_human_readable_text(mon,
|
|
cmd->cmd_info_hrt);
|
|
} else {
|
|
cmd->cmd(mon, qdict);
|
|
}
|
|
}
|
|
|
|
typedef struct HandleHmpCommandCo {
|
|
Monitor *mon;
|
|
const HMPCommand *cmd;
|
|
QDict *qdict;
|
|
bool done;
|
|
} HandleHmpCommandCo;
|
|
|
|
static void handle_hmp_command_co(void *opaque)
|
|
{
|
|
HandleHmpCommandCo *data = opaque;
|
|
handle_hmp_command_exec(data->mon, data->cmd, data->qdict);
|
|
monitor_set_cur(qemu_coroutine_self(), NULL);
|
|
data->done = true;
|
|
}
|
|
|
|
void handle_hmp_command(MonitorHMP *mon, const char *cmdline)
|
|
{
|
|
QDict *qdict;
|
|
const HMPCommand *cmd;
|
|
const char *cmd_start = cmdline;
|
|
|
|
trace_handle_hmp_command(mon, cmdline);
|
|
|
|
cmd = monitor_parse_command(mon, cmdline, &cmdline, hmp_cmds);
|
|
if (!cmd) {
|
|
return;
|
|
}
|
|
|
|
if (!cmd->cmd && !cmd->cmd_info_hrt) {
|
|
/* FIXME: is it useful to try autoload modules here ??? */
|
|
monitor_printf(&mon->common, "Command \"%.*s\" is not available.\n",
|
|
(int)(cmdline - cmd_start), cmd_start);
|
|
return;
|
|
}
|
|
|
|
qdict = monitor_parse_arguments(&mon->common, &cmdline, cmd);
|
|
if (!qdict) {
|
|
while (cmdline > cmd_start && qemu_isspace(cmdline[-1])) {
|
|
cmdline--;
|
|
}
|
|
monitor_printf(&mon->common, "Try \"help %.*s\" for more information\n",
|
|
(int)(cmdline - cmd_start), cmd_start);
|
|
return;
|
|
}
|
|
|
|
if (!cmd->coroutine) {
|
|
/* old_mon is non-NULL when called from qmp_human_monitor_command() */
|
|
Monitor *old_mon = monitor_set_cur(qemu_coroutine_self(), &mon->common);
|
|
handle_hmp_command_exec(&mon->common, cmd, qdict);
|
|
monitor_set_cur(qemu_coroutine_self(), old_mon);
|
|
} else {
|
|
HandleHmpCommandCo data = {
|
|
.mon = &mon->common,
|
|
.cmd = cmd,
|
|
.qdict = qdict,
|
|
.done = false,
|
|
};
|
|
Coroutine *co = qemu_coroutine_create(handle_hmp_command_co, &data);
|
|
monitor_set_cur(co, &mon->common);
|
|
aio_co_enter(qemu_get_aio_context(), co);
|
|
AIO_WAIT_WHILE(qemu_get_aio_context(), !data.done);
|
|
}
|
|
|
|
qobject_unref(qdict);
|
|
}
|
|
|
|
static void cmd_completion(MonitorHMP *mon, const char *name, const char *list)
|
|
{
|
|
const char *p, *pstart;
|
|
char cmd[128];
|
|
int len;
|
|
|
|
p = list;
|
|
for (;;) {
|
|
pstart = p;
|
|
p = qemu_strchrnul(p, '|');
|
|
len = p - pstart;
|
|
if (len > sizeof(cmd) - 2) {
|
|
len = sizeof(cmd) - 2;
|
|
}
|
|
memcpy(cmd, pstart, len);
|
|
cmd[len] = '\0';
|
|
if (name[0] == '\0' || !strncmp(name, cmd, strlen(name))) {
|
|
readline_add_completion(mon->rs, cmd);
|
|
}
|
|
if (*p == '\0') {
|
|
break;
|
|
}
|
|
p++;
|
|
}
|
|
}
|
|
|
|
static void file_completion(MonitorHMP *mon, const char *input)
|
|
{
|
|
DIR *ffs;
|
|
struct dirent *d;
|
|
char path[1024];
|
|
char file[1024], file_prefix[1024];
|
|
int input_path_len;
|
|
const char *p;
|
|
|
|
p = strrchr(input, '/');
|
|
if (!p) {
|
|
input_path_len = 0;
|
|
pstrcpy(file_prefix, sizeof(file_prefix), input);
|
|
pstrcpy(path, sizeof(path), ".");
|
|
} else {
|
|
input_path_len = p - input + 1;
|
|
memcpy(path, input, input_path_len);
|
|
if (input_path_len > sizeof(path) - 1) {
|
|
input_path_len = sizeof(path) - 1;
|
|
}
|
|
path[input_path_len] = '\0';
|
|
pstrcpy(file_prefix, sizeof(file_prefix), p + 1);
|
|
}
|
|
|
|
ffs = opendir(path);
|
|
if (!ffs) {
|
|
return;
|
|
}
|
|
for (;;) {
|
|
struct stat sb;
|
|
d = readdir(ffs);
|
|
if (!d) {
|
|
break;
|
|
}
|
|
|
|
if (strcmp(d->d_name, ".") == 0 || strcmp(d->d_name, "..") == 0) {
|
|
continue;
|
|
}
|
|
|
|
if (strstart(d->d_name, file_prefix, NULL)) {
|
|
memcpy(file, input, input_path_len);
|
|
if (input_path_len < sizeof(file)) {
|
|
pstrcpy(file + input_path_len, sizeof(file) - input_path_len,
|
|
d->d_name);
|
|
}
|
|
/*
|
|
* stat the file to find out if it's a directory.
|
|
* In that case add a slash to speed up typing long paths
|
|
*/
|
|
if (stat(file, &sb) == 0 && S_ISDIR(sb.st_mode)) {
|
|
pstrcat(file, sizeof(file), "/");
|
|
}
|
|
readline_add_completion(mon->rs, file);
|
|
}
|
|
}
|
|
closedir(ffs);
|
|
}
|
|
|
|
static const char *next_arg_type(const char *typestr)
|
|
{
|
|
const char *p = strchr(typestr, ':');
|
|
return (p != NULL ? ++p : typestr);
|
|
}
|
|
|
|
static void monitor_find_completion_by_table(MonitorHMP *mon,
|
|
const HMPCommand *cmd_table,
|
|
char **args,
|
|
int nb_args)
|
|
{
|
|
const char *cmdname;
|
|
int i;
|
|
const char *ptype, *old_ptype, *str, *name;
|
|
const HMPCommand *cmd;
|
|
BlockBackend *blk = NULL;
|
|
|
|
if (nb_args <= 1) {
|
|
/* command completion */
|
|
if (nb_args == 0) {
|
|
cmdname = "";
|
|
} else {
|
|
cmdname = args[0];
|
|
}
|
|
readline_set_completion_index(mon->rs, strlen(cmdname));
|
|
for (cmd = cmd_table; cmd->name != NULL; cmd++) {
|
|
if (cmd_available(cmd)) {
|
|
cmd_completion(mon, cmdname, cmd->name);
|
|
}
|
|
}
|
|
} else {
|
|
/* find the command */
|
|
for (cmd = cmd_table; cmd->name != NULL; cmd++) {
|
|
if (hmp_compare_cmd(args[0], cmd->name) &&
|
|
cmd_available(cmd)) {
|
|
break;
|
|
}
|
|
}
|
|
if (!cmd->name) {
|
|
return;
|
|
}
|
|
|
|
if (cmd->sub_table) {
|
|
/* do the job again */
|
|
monitor_find_completion_by_table(mon, cmd->sub_table,
|
|
&args[1], nb_args - 1);
|
|
return;
|
|
}
|
|
if (cmd->command_completion) {
|
|
cmd->command_completion(mon->rs, nb_args, args[nb_args - 1]);
|
|
return;
|
|
}
|
|
|
|
ptype = next_arg_type(cmd->args_type);
|
|
for (i = 0; i < nb_args - 2; i++) {
|
|
if (*ptype != '\0') {
|
|
ptype = next_arg_type(ptype);
|
|
while (*ptype == '?') {
|
|
ptype = next_arg_type(ptype);
|
|
}
|
|
}
|
|
}
|
|
str = args[nb_args - 1];
|
|
old_ptype = NULL;
|
|
while (*ptype == '-' && old_ptype != ptype) {
|
|
old_ptype = ptype;
|
|
ptype = next_arg_type(ptype);
|
|
}
|
|
switch (*ptype) {
|
|
case 'F':
|
|
/* file completion */
|
|
readline_set_completion_index(mon->rs, strlen(str));
|
|
file_completion(mon, str);
|
|
break;
|
|
case 'B':
|
|
/* block device name completion */
|
|
readline_set_completion_index(mon->rs, strlen(str));
|
|
while ((blk = blk_next(blk)) != NULL) {
|
|
name = blk_name(blk);
|
|
if (str[0] == '\0' ||
|
|
!strncmp(name, str, strlen(str))) {
|
|
readline_add_completion(mon->rs, name);
|
|
}
|
|
}
|
|
break;
|
|
case 's':
|
|
case 'S':
|
|
if (!strcmp(cmd->name, "help|?")) {
|
|
monitor_find_completion_by_table(mon, cmd_table,
|
|
&args[1], nb_args - 1);
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void monitor_find_completion(void *opaque,
|
|
const char *cmdline)
|
|
{
|
|
MonitorHMP *mon = opaque;
|
|
char *args[MAX_ARGS];
|
|
int nb_args, len;
|
|
|
|
/* 1. parse the cmdline */
|
|
if (parse_cmdline(cmdline, &nb_args, args) < 0) {
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* if the line ends with a space, it means we want to complete the
|
|
* next arg
|
|
*/
|
|
len = strlen(cmdline);
|
|
if (len > 0 && qemu_isspace(cmdline[len - 1])) {
|
|
if (nb_args >= MAX_ARGS) {
|
|
goto cleanup;
|
|
}
|
|
args[nb_args++] = g_strdup("");
|
|
}
|
|
|
|
/* 2. auto complete according to args */
|
|
monitor_find_completion_by_table(mon, hmp_cmds, args, nb_args);
|
|
|
|
cleanup:
|
|
free_cmdline_args(args, nb_args);
|
|
}
|
|
|
|
static void monitor_read(void *opaque, const uint8_t *buf, int size)
|
|
{
|
|
MonitorHMP *mon = container_of(opaque, MonitorHMP, common);
|
|
int i;
|
|
|
|
if (mon->rs) {
|
|
for (i = 0; i < size; i++) {
|
|
readline_handle_byte(mon->rs, buf[i]);
|
|
}
|
|
} else {
|
|
if (size == 0 || buf[size - 1] != 0) {
|
|
monitor_printf(&mon->common, "corrupted command\n");
|
|
} else {
|
|
handle_hmp_command(mon, (char *)buf);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void monitor_event(void *opaque, QEMUChrEvent event)
|
|
{
|
|
Monitor *mon = opaque;
|
|
MonitorHMP *hmp_mon = container_of(mon, MonitorHMP, common);
|
|
|
|
switch (event) {
|
|
case CHR_EVENT_MUX_IN:
|
|
qemu_mutex_lock(&mon->mon_lock);
|
|
mon->mux_out = 0;
|
|
qemu_mutex_unlock(&mon->mon_lock);
|
|
if (mon->reset_seen) {
|
|
readline_restart(hmp_mon->rs);
|
|
monitor_resume(mon);
|
|
monitor_flush(mon);
|
|
} else {
|
|
qatomic_mb_set(&mon->suspend_cnt, 0);
|
|
}
|
|
break;
|
|
|
|
case CHR_EVENT_MUX_OUT:
|
|
if (mon->reset_seen) {
|
|
if (qatomic_mb_read(&mon->suspend_cnt) == 0) {
|
|
monitor_printf(mon, "\n");
|
|
}
|
|
monitor_flush(mon);
|
|
monitor_suspend(mon);
|
|
} else {
|
|
qatomic_inc(&mon->suspend_cnt);
|
|
}
|
|
qemu_mutex_lock(&mon->mon_lock);
|
|
mon->mux_out = 1;
|
|
qemu_mutex_unlock(&mon->mon_lock);
|
|
break;
|
|
|
|
case CHR_EVENT_OPENED:
|
|
monitor_printf(mon, "QEMU %s monitor - type 'help' for more "
|
|
"information\n", QEMU_VERSION);
|
|
if (!mon->mux_out) {
|
|
readline_restart(hmp_mon->rs);
|
|
readline_show_prompt(hmp_mon->rs);
|
|
}
|
|
mon->reset_seen = 1;
|
|
mon_refcount++;
|
|
break;
|
|
|
|
case CHR_EVENT_CLOSED:
|
|
mon_refcount--;
|
|
monitor_fdsets_cleanup();
|
|
break;
|
|
|
|
case CHR_EVENT_BREAK:
|
|
/* Ignored */
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* These functions just adapt the readline interface in a typesafe way. We
|
|
* could cast function pointers but that discards compiler checks.
|
|
*/
|
|
static void G_GNUC_PRINTF(2, 3) monitor_readline_printf(void *opaque,
|
|
const char *fmt, ...)
|
|
{
|
|
MonitorHMP *mon = opaque;
|
|
va_list ap;
|
|
va_start(ap, fmt);
|
|
monitor_vprintf(&mon->common, fmt, ap);
|
|
va_end(ap);
|
|
}
|
|
|
|
static void monitor_readline_flush(void *opaque)
|
|
{
|
|
MonitorHMP *mon = opaque;
|
|
monitor_flush(&mon->common);
|
|
}
|
|
|
|
void monitor_init_hmp(Chardev *chr, bool use_readline, Error **errp)
|
|
{
|
|
MonitorHMP *mon = g_new0(MonitorHMP, 1);
|
|
|
|
if (!qemu_chr_fe_init(&mon->common.chr, chr, errp)) {
|
|
g_free(mon);
|
|
return;
|
|
}
|
|
|
|
monitor_data_init(&mon->common, false, false, false);
|
|
|
|
mon->use_readline = use_readline;
|
|
if (mon->use_readline) {
|
|
mon->rs = readline_init(monitor_readline_printf,
|
|
monitor_readline_flush,
|
|
mon,
|
|
monitor_find_completion);
|
|
monitor_read_command(mon, 0);
|
|
}
|
|
|
|
qemu_chr_fe_set_handlers(&mon->common.chr, monitor_can_read, monitor_read,
|
|
monitor_event, NULL, &mon->common, NULL, true);
|
|
monitor_list_append(&mon->common);
|
|
}
|