cachepc-qemu

Fork of AMDESE/qemu with changes for cachepc side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-qemu
Log | Files | Refs | Submodules | LICENSE | sfeed.txt

hmp.c (39878B)

      1/*
      2 * QEMU monitor
      3 *
      4 * Copyright (c) 2003-2004 Fabrice Bellard
      5 *
      6 * Permission is hereby granted, free of charge, to any person obtaining a copy
      7 * of this software and associated documentation files (the "Software"), to deal
      8 * in the Software without restriction, including without limitation the rights
      9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
     10 * copies of the Software, and to permit persons to whom the Software is
     11 * furnished to do so, subject to the following conditions:
     12 *
     13 * The above copyright notice and this permission notice shall be included in
     14 * all copies or substantial portions of the Software.
     15 *
     16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
     17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
     18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
     19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
     20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
     21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
     22 * THE SOFTWARE.
     23 */
     24
     25#include "qemu/osdep.h"
     26#include <dirent.h>
     27#include "hw/qdev-core.h"
     28#include "monitor-internal.h"
     29#include "qapi/error.h"
     30#include "qapi/qmp/qdict.h"
     31#include "qapi/qmp/qnum.h"
     32#include "qemu/config-file.h"
     33#include "qemu/ctype.h"
     34#include "qemu/cutils.h"
     35#include "qemu/log.h"
     36#include "qemu/option.h"
     37#include "qemu/units.h"
     38#include "sysemu/block-backend.h"
     39#include "sysemu/runstate.h"
     40#include "trace.h"
     41
     42static void monitor_command_cb(void *opaque, const char *cmdline,
     43                               void *readline_opaque)
     44{
     45    MonitorHMP *mon = opaque;
     46
     47    monitor_suspend(&mon->common);
     48    handle_hmp_command(mon, cmdline);
     49    monitor_resume(&mon->common);
     50}
     51
     52void monitor_read_command(MonitorHMP *mon, int show_prompt)
     53{
     54    if (!mon->rs) {
     55        return;
     56    }
     57
     58    readline_start(mon->rs, "(qemu) ", 0, monitor_command_cb, NULL);
     59    if (show_prompt) {
     60        readline_show_prompt(mon->rs);
     61    }
     62}
     63
     64int monitor_read_password(MonitorHMP *mon, ReadLineFunc *readline_func,
     65                          void *opaque)
     66{
     67    if (mon->rs) {
     68        readline_start(mon->rs, "Password: ", 1, readline_func, opaque);
     69        /* prompt is printed on return from the command handler */
     70        return 0;
     71    } else {
     72        monitor_printf(&mon->common,
     73                       "terminal does not support password prompting\n");
     74        return -ENOTTY;
     75    }
     76}
     77
     78static int get_str(char *buf, int buf_size, const char **pp)
     79{
     80    const char *p;
     81    char *q;
     82    int c;
     83
     84    q = buf;
     85    p = *pp;
     86    while (qemu_isspace(*p)) {
     87        p++;
     88    }
     89    if (*p == '\0') {
     90    fail:
     91        *q = '\0';
     92        *pp = p;
     93        return -1;
     94    }
     95    if (*p == '\"') {
     96        p++;
     97        while (*p != '\0' && *p != '\"') {
     98            if (*p == '\\') {
     99                p++;
    100                c = *p++;
    101                switch (c) {
    102                case 'n':
    103                    c = '\n';
    104                    break;
    105                case 'r':
    106                    c = '\r';
    107                    break;
    108                case '\\':
    109                case '\'':
    110                case '\"':
    111                    break;
    112                default:
    113                    printf("unsupported escape code: '\\%c'\n", c);
    114                    goto fail;
    115                }
    116                if ((q - buf) < buf_size - 1) {
    117                    *q++ = c;
    118                }
    119            } else {
    120                if ((q - buf) < buf_size - 1) {
    121                    *q++ = *p;
    122                }
    123                p++;
    124            }
    125        }
    126        if (*p != '\"') {
    127            printf("unterminated string\n");
    128            goto fail;
    129        }
    130        p++;
    131    } else {
    132        while (*p != '\0' && !qemu_isspace(*p)) {
    133            if ((q - buf) < buf_size - 1) {
    134                *q++ = *p;
    135            }
    136            p++;
    137        }
    138    }
    139    *q = '\0';
    140    *pp = p;
    141    return 0;
    142}
    143
    144#define MAX_ARGS 16
    145
    146static void free_cmdline_args(char **args, int nb_args)
    147{
    148    int i;
    149
    150    assert(nb_args <= MAX_ARGS);
    151
    152    for (i = 0; i < nb_args; i++) {
    153        g_free(args[i]);
    154    }
    155
    156}
    157
    158/*
    159 * Parse the command line to get valid args.
    160 * @cmdline: command line to be parsed.
    161 * @pnb_args: location to store the number of args, must NOT be NULL.
    162 * @args: location to store the args, which should be freed by caller, must
    163 *        NOT be NULL.
    164 *
    165 * Returns 0 on success, negative on failure.
    166 *
    167 * NOTE: this parser is an approximate form of the real command parser. Number
    168 *       of args have a limit of MAX_ARGS. If cmdline contains more, it will
    169 *       return with failure.
    170 */
    171static int parse_cmdline(const char *cmdline,
    172                         int *pnb_args, char **args)
    173{
    174    const char *p;
    175    int nb_args, ret;
    176    char buf[1024];
    177
    178    p = cmdline;
    179    nb_args = 0;
    180    for (;;) {
    181        while (qemu_isspace(*p)) {
    182            p++;
    183        }
    184        if (*p == '\0') {
    185            break;
    186        }
    187        if (nb_args >= MAX_ARGS) {
    188            goto fail;
    189        }
    190        ret = get_str(buf, sizeof(buf), &p);
    191        if (ret < 0) {
    192            goto fail;
    193        }
    194        args[nb_args] = g_strdup(buf);
    195        nb_args++;
    196    }
    197    *pnb_args = nb_args;
    198    return 0;
    199
    200 fail:
    201    free_cmdline_args(args, nb_args);
    202    return -1;
    203}
    204
    205/*
    206 * Can command @cmd be executed in preconfig state?
    207 */
    208static bool cmd_can_preconfig(const HMPCommand *cmd)
    209{
    210    if (!cmd->flags) {
    211        return false;
    212    }
    213
    214    return strchr(cmd->flags, 'p');
    215}
    216
    217static bool cmd_available(const HMPCommand *cmd)
    218{
    219    return phase_check(PHASE_MACHINE_READY) || cmd_can_preconfig(cmd);
    220}
    221
    222static void help_cmd_dump_one(Monitor *mon,
    223                              const HMPCommand *cmd,
    224                              char **prefix_args,
    225                              int prefix_args_nb)
    226{
    227    int i;
    228
    229    if (!cmd_available(cmd)) {
    230        return;
    231    }
    232
    233    for (i = 0; i < prefix_args_nb; i++) {
    234        monitor_printf(mon, "%s ", prefix_args[i]);
    235    }
    236    monitor_printf(mon, "%s %s -- %s\n", cmd->name, cmd->params, cmd->help);
    237}
    238
    239/* @args[@arg_index] is the valid command need to find in @cmds */
    240static void help_cmd_dump(Monitor *mon, const HMPCommand *cmds,
    241                          char **args, int nb_args, int arg_index)
    242{
    243    const HMPCommand *cmd;
    244    size_t i;
    245
    246    /* No valid arg need to compare with, dump all in *cmds */
    247    if (arg_index >= nb_args) {
    248        for (cmd = cmds; cmd->name != NULL; cmd++) {
    249            help_cmd_dump_one(mon, cmd, args, arg_index);
    250        }
    251        return;
    252    }
    253
    254    /* Find one entry to dump */
    255    for (cmd = cmds; cmd->name != NULL; cmd++) {
    256        if (hmp_compare_cmd(args[arg_index], cmd->name) &&
    257            cmd_available(cmd)) {
    258            if (cmd->sub_table) {
    259                /* continue with next arg */
    260                help_cmd_dump(mon, cmd->sub_table,
    261                              args, nb_args, arg_index + 1);
    262            } else {
    263                help_cmd_dump_one(mon, cmd, args, arg_index);
    264            }
    265            return;
    266        }
    267    }
    268
    269    /* Command not found */
    270    monitor_printf(mon, "unknown command: '");
    271    for (i = 0; i <= arg_index; i++) {
    272        monitor_printf(mon, "%s%s", args[i], i == arg_index ? "'\n" : " ");
    273    }
    274}
    275
    276void help_cmd(Monitor *mon, const char *name)
    277{
    278    char *args[MAX_ARGS];
    279    int nb_args = 0;
    280
    281    /* 1. parse user input */
    282    if (name) {
    283        /* special case for log, directly dump and return */
    284        if (!strcmp(name, "log")) {
    285            const QEMULogItem *item;
    286            monitor_printf(mon, "Log items (comma separated):\n");
    287            monitor_printf(mon, "%-10s %s\n", "none", "remove all logs");
    288            for (item = qemu_log_items; item->mask != 0; item++) {
    289                monitor_printf(mon, "%-10s %s\n", item->name, item->help);
    290            }
    291            return;
    292        }
    293
    294        if (parse_cmdline(name, &nb_args, args) < 0) {
    295            return;
    296        }
    297    }
    298
    299    /* 2. dump the contents according to parsed args */
    300    help_cmd_dump(mon, hmp_cmds, args, nb_args, 0);
    301
    302    free_cmdline_args(args, nb_args);
    303}
    304
    305/*******************************************************************/
    306
    307static const char *pch;
    308static sigjmp_buf expr_env;
    309
    310static void GCC_FMT_ATTR(2, 3) QEMU_NORETURN
    311expr_error(Monitor *mon, const char *fmt, ...)
    312{
    313    va_list ap;
    314    va_start(ap, fmt);
    315    monitor_vprintf(mon, fmt, ap);
    316    monitor_printf(mon, "\n");
    317    va_end(ap);
    318    siglongjmp(expr_env, 1);
    319}
    320
    321static void next(void)
    322{
    323    if (*pch != '\0') {
    324        pch++;
    325        while (qemu_isspace(*pch)) {
    326            pch++;
    327        }
    328    }
    329}
    330
    331static int64_t expr_sum(Monitor *mon);
    332
    333static int64_t expr_unary(Monitor *mon)
    334{
    335    int64_t n;
    336    char *p;
    337    int ret;
    338
    339    switch (*pch) {
    340    case '+':
    341        next();
    342        n = expr_unary(mon);
    343        break;
    344    case '-':
    345        next();
    346        n = -expr_unary(mon);
    347        break;
    348    case '~':
    349        next();
    350        n = ~expr_unary(mon);
    351        break;
    352    case '(':
    353        next();
    354        n = expr_sum(mon);
    355        if (*pch != ')') {
    356            expr_error(mon, "')' expected");
    357        }
    358        next();
    359        break;
    360    case '\'':
    361        pch++;
    362        if (*pch == '\0') {
    363            expr_error(mon, "character constant expected");
    364        }
    365        n = *pch;
    366        pch++;
    367        if (*pch != '\'') {
    368            expr_error(mon, "missing terminating \' character");
    369        }
    370        next();
    371        break;
    372    case '$':
    373        {
    374            char buf[128], *q;
    375            int64_t reg = 0;
    376
    377            pch++;
    378            q = buf;
    379            while ((*pch >= 'a' && *pch <= 'z') ||
    380                   (*pch >= 'A' && *pch <= 'Z') ||
    381                   (*pch >= '0' && *pch <= '9') ||
    382                   *pch == '_' || *pch == '.') {
    383                if ((q - buf) < sizeof(buf) - 1) {
    384                    *q++ = *pch;
    385                }
    386                pch++;
    387            }
    388            while (qemu_isspace(*pch)) {
    389                pch++;
    390            }
    391            *q = 0;
    392            ret = get_monitor_def(mon, &reg, buf);
    393            if (ret < 0) {
    394                expr_error(mon, "unknown register");
    395            }
    396            n = reg;
    397        }
    398        break;
    399    case '\0':
    400        expr_error(mon, "unexpected end of expression");
    401        n = 0;
    402        break;
    403    default:
    404        errno = 0;
    405        n = strtoull(pch, &p, 0);
    406        if (errno == ERANGE) {
    407            expr_error(mon, "number too large");
    408        }
    409        if (pch == p) {
    410            expr_error(mon, "invalid char '%c' in expression", *p);
    411        }
    412        pch = p;
    413        while (qemu_isspace(*pch)) {
    414            pch++;
    415        }
    416        break;
    417    }
    418    return n;
    419}
    420
    421static int64_t expr_prod(Monitor *mon)
    422{
    423    int64_t val, val2;
    424    int op;
    425
    426    val = expr_unary(mon);
    427    for (;;) {
    428        op = *pch;
    429        if (op != '*' && op != '/' && op != '%') {
    430            break;
    431        }
    432        next();
    433        val2 = expr_unary(mon);
    434        switch (op) {
    435        default:
    436        case '*':
    437            val *= val2;
    438            break;
    439        case '/':
    440        case '%':
    441            if (val2 == 0) {
    442                expr_error(mon, "division by zero");
    443            }
    444            if (op == '/') {
    445                val /= val2;
    446            } else {
    447                val %= val2;
    448            }
    449            break;
    450        }
    451    }
    452    return val;
    453}
    454
    455static int64_t expr_logic(Monitor *mon)
    456{
    457    int64_t val, val2;
    458    int op;
    459
    460    val = expr_prod(mon);
    461    for (;;) {
    462        op = *pch;
    463        if (op != '&' && op != '|' && op != '^') {
    464            break;
    465        }
    466        next();
    467        val2 = expr_prod(mon);
    468        switch (op) {
    469        default:
    470        case '&':
    471            val &= val2;
    472            break;
    473        case '|':
    474            val |= val2;
    475            break;
    476        case '^':
    477            val ^= val2;
    478            break;
    479        }
    480    }
    481    return val;
    482}
    483
    484static int64_t expr_sum(Monitor *mon)
    485{
    486    int64_t val, val2;
    487    int op;
    488
    489    val = expr_logic(mon);
    490    for (;;) {
    491        op = *pch;
    492        if (op != '+' && op != '-') {
    493            break;
    494        }
    495        next();
    496        val2 = expr_logic(mon);
    497        if (op == '+') {
    498            val += val2;
    499        } else {
    500            val -= val2;
    501        }
    502    }
    503    return val;
    504}
    505
    506static int get_expr(Monitor *mon, int64_t *pval, const char **pp)
    507{
    508    pch = *pp;
    509    if (sigsetjmp(expr_env, 0)) {
    510        *pp = pch;
    511        return -1;
    512    }
    513    while (qemu_isspace(*pch)) {
    514        pch++;
    515    }
    516    *pval = expr_sum(mon);
    517    *pp = pch;
    518    return 0;
    519}
    520
    521static int get_double(Monitor *mon, double *pval, const char **pp)
    522{
    523    const char *p = *pp;
    524    char *tailp;
    525    double d;
    526
    527    d = strtod(p, &tailp);
    528    if (tailp == p) {
    529        monitor_printf(mon, "Number expected\n");
    530        return -1;
    531    }
    532    if (d != d || d - d != 0) {
    533        /* NaN or infinity */
    534        monitor_printf(mon, "Bad number\n");
    535        return -1;
    536    }
    537    *pval = d;
    538    *pp = tailp;
    539    return 0;
    540}
    541
    542/*
    543 * Store the command-name in cmdname, and return a pointer to
    544 * the remaining of the command string.
    545 */
    546static const char *get_command_name(const char *cmdline,
    547                                    char *cmdname, size_t nlen)
    548{
    549    size_t len;
    550    const char *p, *pstart;
    551
    552    p = cmdline;
    553    while (qemu_isspace(*p)) {
    554        p++;
    555    }
    556    if (*p == '\0') {
    557        return NULL;
    558    }
    559    pstart = p;
    560    while (*p != '\0' && *p != '/' && !qemu_isspace(*p)) {
    561        p++;
    562    }
    563    len = p - pstart;
    564    if (len > nlen - 1) {
    565        len = nlen - 1;
    566    }
    567    memcpy(cmdname, pstart, len);
    568    cmdname[len] = '\0';
    569    return p;
    570}
    571
    572/**
    573 * Read key of 'type' into 'key' and return the current
    574 * 'type' pointer.
    575 */
    576static char *key_get_info(const char *type, char **key)
    577{
    578    size_t len;
    579    char *p, *str;
    580
    581    if (*type == ',') {
    582        type++;
    583    }
    584
    585    p = strchr(type, ':');
    586    if (!p) {
    587        *key = NULL;
    588        return NULL;
    589    }
    590    len = p - type;
    591
    592    str = g_malloc(len + 1);
    593    memcpy(str, type, len);
    594    str[len] = '\0';
    595
    596    *key = str;
    597    return ++p;
    598}
    599
    600static int default_fmt_format = 'x';
    601static int default_fmt_size = 4;
    602
    603static int is_valid_option(const char *c, const char *typestr)
    604{
    605    char option[3];
    606
    607    option[0] = '-';
    608    option[1] = *c;
    609    option[2] = '\0';
    610
    611    typestr = strstr(typestr, option);
    612    return (typestr != NULL);
    613}
    614
    615static const HMPCommand *search_dispatch_table(const HMPCommand *disp_table,
    616                                               const char *cmdname)
    617{
    618    const HMPCommand *cmd;
    619
    620    for (cmd = disp_table; cmd->name != NULL; cmd++) {
    621        if (hmp_compare_cmd(cmdname, cmd->name)) {
    622            return cmd;
    623        }
    624    }
    625
    626    return NULL;
    627}
    628
    629/*
    630 * Parse command name from @cmdp according to command table @table.
    631 * If blank, return NULL.
    632 * Else, if no valid command can be found, report to @mon, and return
    633 * NULL.
    634 * Else, change @cmdp to point right behind the name, and return its
    635 * command table entry.
    636 * Do not assume the return value points into @table!  It doesn't when
    637 * the command is found in a sub-command table.
    638 */
    639static const HMPCommand *monitor_parse_command(MonitorHMP *hmp_mon,
    640                                               const char *cmdp_start,
    641                                               const char **cmdp,
    642                                               HMPCommand *table)
    643{
    644    Monitor *mon = &hmp_mon->common;
    645    const char *p;
    646    const HMPCommand *cmd;
    647    char cmdname[256];
    648
    649    /* extract the command name */
    650    p = get_command_name(*cmdp, cmdname, sizeof(cmdname));
    651    if (!p) {
    652        return NULL;
    653    }
    654
    655    cmd = search_dispatch_table(table, cmdname);
    656    if (!cmd) {
    657        monitor_printf(mon, "unknown command: '%.*s'\n",
    658                       (int)(p - cmdp_start), cmdp_start);
    659        return NULL;
    660    }
    661    if (!cmd_available(cmd)) {
    662        monitor_printf(mon, "Command '%.*s' not available "
    663                            "until machine initialization has completed.\n",
    664                       (int)(p - cmdp_start), cmdp_start);
    665        return NULL;
    666    }
    667
    668    /* filter out following useless space */
    669    while (qemu_isspace(*p)) {
    670        p++;
    671    }
    672
    673    *cmdp = p;
    674    /* search sub command */
    675    if (cmd->sub_table != NULL && *p != '\0') {
    676        return monitor_parse_command(hmp_mon, cmdp_start, cmdp, cmd->sub_table);
    677    }
    678
    679    return cmd;
    680}
    681
    682/*
    683 * Parse arguments for @cmd.
    684 * If it can't be parsed, report to @mon, and return NULL.
    685 * Else, insert command arguments into a QDict, and return it.
    686 * Note: On success, caller has to free the QDict structure.
    687 */
    688static QDict *monitor_parse_arguments(Monitor *mon,
    689                                      const char **endp,
    690                                      const HMPCommand *cmd)
    691{
    692    const char *typestr;
    693    char *key;
    694    int c;
    695    const char *p = *endp;
    696    char buf[1024];
    697    QDict *qdict = qdict_new();
    698
    699    /* parse the parameters */
    700    typestr = cmd->args_type;
    701    for (;;) {
    702        typestr = key_get_info(typestr, &key);
    703        if (!typestr) {
    704            break;
    705        }
    706        c = *typestr;
    707        typestr++;
    708        switch (c) {
    709        case 'F':
    710        case 'B':
    711        case 's':
    712            {
    713                int ret;
    714
    715                while (qemu_isspace(*p)) {
    716                    p++;
    717                }
    718                if (*typestr == '?') {
    719                    typestr++;
    720                    if (*p == '\0') {
    721                        /* no optional string: NULL argument */
    722                        break;
    723                    }
    724                }
    725                ret = get_str(buf, sizeof(buf), &p);
    726                if (ret < 0) {
    727                    switch (c) {
    728                    case 'F':
    729                        monitor_printf(mon, "%s: filename expected\n",
    730                                       cmd->name);
    731                        break;
    732                    case 'B':
    733                        monitor_printf(mon, "%s: block device name expected\n",
    734                                       cmd->name);
    735                        break;
    736                    default:
    737                        monitor_printf(mon, "%s: string expected\n", cmd->name);
    738                        break;
    739                    }
    740                    goto fail;
    741                }
    742                qdict_put_str(qdict, key, buf);
    743            }
    744            break;
    745        case 'O':
    746            {
    747                QemuOptsList *opts_list;
    748                QemuOpts *opts;
    749
    750                opts_list = qemu_find_opts(key);
    751                if (!opts_list || opts_list->desc->name) {
    752                    goto bad_type;
    753                }
    754                while (qemu_isspace(*p)) {
    755                    p++;
    756                }
    757                if (!*p) {
    758                    break;
    759                }
    760                if (get_str(buf, sizeof(buf), &p) < 0) {
    761                    goto fail;
    762                }
    763                opts = qemu_opts_parse_noisily(opts_list, buf, true);
    764                if (!opts) {
    765                    goto fail;
    766                }
    767                qemu_opts_to_qdict(opts, qdict);
    768                qemu_opts_del(opts);
    769            }
    770            break;
    771        case '/':
    772            {
    773                int count, format, size;
    774
    775                while (qemu_isspace(*p)) {
    776                    p++;
    777                }
    778                if (*p == '/') {
    779                    /* format found */
    780                    p++;
    781                    count = 1;
    782                    if (qemu_isdigit(*p)) {
    783                        count = 0;
    784                        while (qemu_isdigit(*p)) {
    785                            count = count * 10 + (*p - '0');
    786                            p++;
    787                        }
    788                    }
    789                    size = -1;
    790                    format = -1;
    791                    for (;;) {
    792                        switch (*p) {
    793                        case 'o':
    794                        case 'd':
    795                        case 'u':
    796                        case 'x':
    797                        case 'i':
    798                        case 'c':
    799                            format = *p++;
    800                            break;
    801                        case 'b':
    802                            size = 1;
    803                            p++;
    804                            break;
    805                        case 'h':
    806                            size = 2;
    807                            p++;
    808                            break;
    809                        case 'w':
    810                            size = 4;
    811                            p++;
    812                            break;
    813                        case 'g':
    814                        case 'L':
    815                            size = 8;
    816                            p++;
    817                            break;
    818                        default:
    819                            goto next;
    820                        }
    821                    }
    822                next:
    823                    if (*p != '\0' && !qemu_isspace(*p)) {
    824                        monitor_printf(mon, "invalid char in format: '%c'\n",
    825                                       *p);
    826                        goto fail;
    827                    }
    828                    if (format < 0) {
    829                        format = default_fmt_format;
    830                    }
    831                    if (format != 'i') {
    832                        /* for 'i', not specifying a size gives -1 as size */
    833                        if (size < 0) {
    834                            size = default_fmt_size;
    835                        }
    836                        default_fmt_size = size;
    837                    }
    838                    default_fmt_format = format;
    839                } else {
    840                    count = 1;
    841                    format = default_fmt_format;
    842                    if (format != 'i') {
    843                        size = default_fmt_size;
    844                    } else {
    845                        size = -1;
    846                    }
    847                }
    848                qdict_put_int(qdict, "count", count);
    849                qdict_put_int(qdict, "format", format);
    850                qdict_put_int(qdict, "size", size);
    851            }
    852            break;
    853        case 'i':
    854        case 'l':
    855        case 'M':
    856            {
    857                int64_t val;
    858
    859                while (qemu_isspace(*p)) {
    860                    p++;
    861                }
    862                if (*typestr == '?' || *typestr == '.') {
    863                    if (*typestr == '?') {
    864                        if (*p == '\0') {
    865                            typestr++;
    866                            break;
    867                        }
    868                    } else {
    869                        if (*p == '.') {
    870                            p++;
    871                            while (qemu_isspace(*p)) {
    872                                p++;
    873                            }
    874                        } else {
    875                            typestr++;
    876                            break;
    877                        }
    878                    }
    879                    typestr++;
    880                }
    881                if (get_expr(mon, &val, &p)) {
    882                    goto fail;
    883                }
    884                /* Check if 'i' is greater than 32-bit */
    885                if ((c == 'i') && ((val >> 32) & 0xffffffff)) {
    886                    monitor_printf(mon, "\'%s\' has failed: ", cmd->name);
    887                    monitor_printf(mon, "integer is for 32-bit values\n");
    888                    goto fail;
    889                } else if (c == 'M') {
    890                    if (val < 0) {
    891                        monitor_printf(mon, "enter a positive value\n");
    892                        goto fail;
    893                    }
    894                    val *= MiB;
    895                }
    896                qdict_put_int(qdict, key, val);
    897            }
    898            break;
    899        case 'o':
    900            {
    901                int ret;
    902                uint64_t val;
    903                const char *end;
    904
    905                while (qemu_isspace(*p)) {
    906                    p++;
    907                }
    908                if (*typestr == '?') {
    909                    typestr++;
    910                    if (*p == '\0') {
    911                        break;
    912                    }
    913                }
    914                ret = qemu_strtosz_MiB(p, &end, &val);
    915                if (ret < 0 || val > INT64_MAX) {
    916                    monitor_printf(mon, "invalid size\n");
    917                    goto fail;
    918                }
    919                qdict_put_int(qdict, key, val);
    920                p = end;
    921            }
    922            break;
    923        case 'T':
    924            {
    925                double val;
    926
    927                while (qemu_isspace(*p)) {
    928                    p++;
    929                }
    930                if (*typestr == '?') {
    931                    typestr++;
    932                    if (*p == '\0') {
    933                        break;
    934                    }
    935                }
    936                if (get_double(mon, &val, &p) < 0) {
    937                    goto fail;
    938                }
    939                if (p[0] && p[1] == 's') {
    940                    switch (*p) {
    941                    case 'm':
    942                        val /= 1e3; p += 2; break;
    943                    case 'u':
    944                        val /= 1e6; p += 2; break;
    945                    case 'n':
    946                        val /= 1e9; p += 2; break;
    947                    }
    948                }
    949                if (*p && !qemu_isspace(*p)) {
    950                    monitor_printf(mon, "Unknown unit suffix\n");
    951                    goto fail;
    952                }
    953                qdict_put(qdict, key, qnum_from_double(val));
    954            }
    955            break;
    956        case 'b':
    957            {
    958                const char *beg;
    959                bool val;
    960
    961                while (qemu_isspace(*p)) {
    962                    p++;
    963                }
    964                beg = p;
    965                while (qemu_isgraph(*p)) {
    966                    p++;
    967                }
    968                if (p - beg == 2 && !memcmp(beg, "on", p - beg)) {
    969                    val = true;
    970                } else if (p - beg == 3 && !memcmp(beg, "off", p - beg)) {
    971                    val = false;
    972                } else {
    973                    monitor_printf(mon, "Expected 'on' or 'off'\n");
    974                    goto fail;
    975                }
    976                qdict_put_bool(qdict, key, val);
    977            }
    978            break;
    979        case '-':
    980            {
    981                const char *tmp = p;
    982                int skip_key = 0;
    983                /* option */
    984
    985                c = *typestr++;
    986                if (c == '\0') {
    987                    goto bad_type;
    988                }
    989                while (qemu_isspace(*p)) {
    990                    p++;
    991                }
    992                if (*p == '-') {
    993                    p++;
    994                    if (c != *p) {
    995                        if (!is_valid_option(p, typestr)) {
    996                            monitor_printf(mon, "%s: unsupported option -%c\n",
    997                                           cmd->name, *p);
    998                            goto fail;
    999                        } else {
   1000                            skip_key = 1;
   1001                        }
   1002                    }
   1003                    if (skip_key) {
   1004                        p = tmp;
   1005                    } else {
   1006                        /* has option */
   1007                        p++;
   1008                        qdict_put_bool(qdict, key, true);
   1009                    }
   1010                }
   1011            }
   1012            break;
   1013        case 'S':
   1014            {
   1015                /* package all remaining string */
   1016                int len;
   1017
   1018                while (qemu_isspace(*p)) {
   1019                    p++;
   1020                }
   1021                if (*typestr == '?') {
   1022                    typestr++;
   1023                    if (*p == '\0') {
   1024                        /* no remaining string: NULL argument */
   1025                        break;
   1026                    }
   1027                }
   1028                len = strlen(p);
   1029                if (len <= 0) {
   1030                    monitor_printf(mon, "%s: string expected\n",
   1031                                   cmd->name);
   1032                    goto fail;
   1033                }
   1034                qdict_put_str(qdict, key, p);
   1035                p += len;
   1036            }
   1037            break;
   1038        default:
   1039        bad_type:
   1040            monitor_printf(mon, "%s: unknown type '%c'\n", cmd->name, c);
   1041            goto fail;
   1042        }
   1043        g_free(key);
   1044        key = NULL;
   1045    }
   1046    /* check that all arguments were parsed */
   1047    while (qemu_isspace(*p)) {
   1048        p++;
   1049    }
   1050    if (*p != '\0') {
   1051        monitor_printf(mon, "%s: extraneous characters at the end of line\n",
   1052                       cmd->name);
   1053        goto fail;
   1054    }
   1055
   1056    return qdict;
   1057
   1058fail:
   1059    qobject_unref(qdict);
   1060    g_free(key);
   1061    return NULL;
   1062}
   1063
   1064typedef struct HandleHmpCommandCo {
   1065    Monitor *mon;
   1066    const HMPCommand *cmd;
   1067    QDict *qdict;
   1068    bool done;
   1069} HandleHmpCommandCo;
   1070
   1071static void handle_hmp_command_co(void *opaque)
   1072{
   1073    HandleHmpCommandCo *data = opaque;
   1074    data->cmd->cmd(data->mon, data->qdict);
   1075    monitor_set_cur(qemu_coroutine_self(), NULL);
   1076    data->done = true;
   1077}
   1078
   1079void handle_hmp_command(MonitorHMP *mon, const char *cmdline)
   1080{
   1081    QDict *qdict;
   1082    const HMPCommand *cmd;
   1083    const char *cmd_start = cmdline;
   1084
   1085    trace_handle_hmp_command(mon, cmdline);
   1086
   1087    cmd = monitor_parse_command(mon, cmdline, &cmdline, hmp_cmds);
   1088    if (!cmd) {
   1089        return;
   1090    }
   1091
   1092    if (!cmd->cmd) {
   1093        /* FIXME: is it useful to try autoload modules here ??? */
   1094        monitor_printf(&mon->common, "Command \"%.*s\" is not available.\n",
   1095                       (int)(cmdline - cmd_start), cmd_start);
   1096        return;
   1097    }
   1098
   1099    qdict = monitor_parse_arguments(&mon->common, &cmdline, cmd);
   1100    if (!qdict) {
   1101        while (cmdline > cmd_start && qemu_isspace(cmdline[-1])) {
   1102            cmdline--;
   1103        }
   1104        monitor_printf(&mon->common, "Try \"help %.*s\" for more information\n",
   1105                       (int)(cmdline - cmd_start), cmd_start);
   1106        return;
   1107    }
   1108
   1109    if (!cmd->coroutine) {
   1110        /* old_mon is non-NULL when called from qmp_human_monitor_command() */
   1111        Monitor *old_mon = monitor_set_cur(qemu_coroutine_self(), &mon->common);
   1112        cmd->cmd(&mon->common, qdict);
   1113        monitor_set_cur(qemu_coroutine_self(), old_mon);
   1114    } else {
   1115        HandleHmpCommandCo data = {
   1116            .mon = &mon->common,
   1117            .cmd = cmd,
   1118            .qdict = qdict,
   1119            .done = false,
   1120        };
   1121        Coroutine *co = qemu_coroutine_create(handle_hmp_command_co, &data);
   1122        monitor_set_cur(co, &mon->common);
   1123        aio_co_enter(qemu_get_aio_context(), co);
   1124        AIO_WAIT_WHILE(qemu_get_aio_context(), !data.done);
   1125    }
   1126
   1127    qobject_unref(qdict);
   1128}
   1129
   1130static void cmd_completion(MonitorHMP *mon, const char *name, const char *list)
   1131{
   1132    const char *p, *pstart;
   1133    char cmd[128];
   1134    int len;
   1135
   1136    p = list;
   1137    for (;;) {
   1138        pstart = p;
   1139        p = qemu_strchrnul(p, '|');
   1140        len = p - pstart;
   1141        if (len > sizeof(cmd) - 2) {
   1142            len = sizeof(cmd) - 2;
   1143        }
   1144        memcpy(cmd, pstart, len);
   1145        cmd[len] = '\0';
   1146        if (name[0] == '\0' || !strncmp(name, cmd, strlen(name))) {
   1147            readline_add_completion(mon->rs, cmd);
   1148        }
   1149        if (*p == '\0') {
   1150            break;
   1151        }
   1152        p++;
   1153    }
   1154}
   1155
   1156static void file_completion(MonitorHMP *mon, const char *input)
   1157{
   1158    DIR *ffs;
   1159    struct dirent *d;
   1160    char path[1024];
   1161    char file[1024], file_prefix[1024];
   1162    int input_path_len;
   1163    const char *p;
   1164
   1165    p = strrchr(input, '/');
   1166    if (!p) {
   1167        input_path_len = 0;
   1168        pstrcpy(file_prefix, sizeof(file_prefix), input);
   1169        pstrcpy(path, sizeof(path), ".");
   1170    } else {
   1171        input_path_len = p - input + 1;
   1172        memcpy(path, input, input_path_len);
   1173        if (input_path_len > sizeof(path) - 1) {
   1174            input_path_len = sizeof(path) - 1;
   1175        }
   1176        path[input_path_len] = '\0';
   1177        pstrcpy(file_prefix, sizeof(file_prefix), p + 1);
   1178    }
   1179
   1180    ffs = opendir(path);
   1181    if (!ffs) {
   1182        return;
   1183    }
   1184    for (;;) {
   1185        struct stat sb;
   1186        d = readdir(ffs);
   1187        if (!d) {
   1188            break;
   1189        }
   1190
   1191        if (strcmp(d->d_name, ".") == 0 || strcmp(d->d_name, "..") == 0) {
   1192            continue;
   1193        }
   1194
   1195        if (strstart(d->d_name, file_prefix, NULL)) {
   1196            memcpy(file, input, input_path_len);
   1197            if (input_path_len < sizeof(file)) {
   1198                pstrcpy(file + input_path_len, sizeof(file) - input_path_len,
   1199                        d->d_name);
   1200            }
   1201            /*
   1202             * stat the file to find out if it's a directory.
   1203             * In that case add a slash to speed up typing long paths
   1204             */
   1205            if (stat(file, &sb) == 0 && S_ISDIR(sb.st_mode)) {
   1206                pstrcat(file, sizeof(file), "/");
   1207            }
   1208            readline_add_completion(mon->rs, file);
   1209        }
   1210    }
   1211    closedir(ffs);
   1212}
   1213
   1214static const char *next_arg_type(const char *typestr)
   1215{
   1216    const char *p = strchr(typestr, ':');
   1217    return (p != NULL ? ++p : typestr);
   1218}
   1219
   1220static void monitor_find_completion_by_table(MonitorHMP *mon,
   1221                                             const HMPCommand *cmd_table,
   1222                                             char **args,
   1223                                             int nb_args)
   1224{
   1225    const char *cmdname;
   1226    int i;
   1227    const char *ptype, *old_ptype, *str, *name;
   1228    const HMPCommand *cmd;
   1229    BlockBackend *blk = NULL;
   1230
   1231    if (nb_args <= 1) {
   1232        /* command completion */
   1233        if (nb_args == 0) {
   1234            cmdname = "";
   1235        } else {
   1236            cmdname = args[0];
   1237        }
   1238        readline_set_completion_index(mon->rs, strlen(cmdname));
   1239        for (cmd = cmd_table; cmd->name != NULL; cmd++) {
   1240            if (cmd_available(cmd)) {
   1241                cmd_completion(mon, cmdname, cmd->name);
   1242            }
   1243        }
   1244    } else {
   1245        /* find the command */
   1246        for (cmd = cmd_table; cmd->name != NULL; cmd++) {
   1247            if (hmp_compare_cmd(args[0], cmd->name) &&
   1248                cmd_available(cmd)) {
   1249                break;
   1250            }
   1251        }
   1252        if (!cmd->name) {
   1253            return;
   1254        }
   1255
   1256        if (cmd->sub_table) {
   1257            /* do the job again */
   1258            monitor_find_completion_by_table(mon, cmd->sub_table,
   1259                                             &args[1], nb_args - 1);
   1260            return;
   1261        }
   1262        if (cmd->command_completion) {
   1263            cmd->command_completion(mon->rs, nb_args, args[nb_args - 1]);
   1264            return;
   1265        }
   1266
   1267        ptype = next_arg_type(cmd->args_type);
   1268        for (i = 0; i < nb_args - 2; i++) {
   1269            if (*ptype != '\0') {
   1270                ptype = next_arg_type(ptype);
   1271                while (*ptype == '?') {
   1272                    ptype = next_arg_type(ptype);
   1273                }
   1274            }
   1275        }
   1276        str = args[nb_args - 1];
   1277        old_ptype = NULL;
   1278        while (*ptype == '-' && old_ptype != ptype) {
   1279            old_ptype = ptype;
   1280            ptype = next_arg_type(ptype);
   1281        }
   1282        switch (*ptype) {
   1283        case 'F':
   1284            /* file completion */
   1285            readline_set_completion_index(mon->rs, strlen(str));
   1286            file_completion(mon, str);
   1287            break;
   1288        case 'B':
   1289            /* block device name completion */
   1290            readline_set_completion_index(mon->rs, strlen(str));
   1291            while ((blk = blk_next(blk)) != NULL) {
   1292                name = blk_name(blk);
   1293                if (str[0] == '\0' ||
   1294                    !strncmp(name, str, strlen(str))) {
   1295                    readline_add_completion(mon->rs, name);
   1296                }
   1297            }
   1298            break;
   1299        case 's':
   1300        case 'S':
   1301            if (!strcmp(cmd->name, "help|?")) {
   1302                monitor_find_completion_by_table(mon, cmd_table,
   1303                                                 &args[1], nb_args - 1);
   1304            }
   1305            break;
   1306        default:
   1307            break;
   1308        }
   1309    }
   1310}
   1311
   1312static void monitor_find_completion(void *opaque,
   1313                                    const char *cmdline)
   1314{
   1315    MonitorHMP *mon = opaque;
   1316    char *args[MAX_ARGS];
   1317    int nb_args, len;
   1318
   1319    /* 1. parse the cmdline */
   1320    if (parse_cmdline(cmdline, &nb_args, args) < 0) {
   1321        return;
   1322    }
   1323
   1324    /*
   1325     * if the line ends with a space, it means we want to complete the
   1326     * next arg
   1327     */
   1328    len = strlen(cmdline);
   1329    if (len > 0 && qemu_isspace(cmdline[len - 1])) {
   1330        if (nb_args >= MAX_ARGS) {
   1331            goto cleanup;
   1332        }
   1333        args[nb_args++] = g_strdup("");
   1334    }
   1335
   1336    /* 2. auto complete according to args */
   1337    monitor_find_completion_by_table(mon, hmp_cmds, args, nb_args);
   1338
   1339cleanup:
   1340    free_cmdline_args(args, nb_args);
   1341}
   1342
   1343static void monitor_read(void *opaque, const uint8_t *buf, int size)
   1344{
   1345    MonitorHMP *mon = container_of(opaque, MonitorHMP, common);
   1346    int i;
   1347
   1348    if (mon->rs) {
   1349        for (i = 0; i < size; i++) {
   1350            readline_handle_byte(mon->rs, buf[i]);
   1351        }
   1352    } else {
   1353        if (size == 0 || buf[size - 1] != 0) {
   1354            monitor_printf(&mon->common, "corrupted command\n");
   1355        } else {
   1356            handle_hmp_command(mon, (char *)buf);
   1357        }
   1358    }
   1359}
   1360
   1361static void monitor_event(void *opaque, QEMUChrEvent event)
   1362{
   1363    Monitor *mon = opaque;
   1364    MonitorHMP *hmp_mon = container_of(mon, MonitorHMP, common);
   1365
   1366    switch (event) {
   1367    case CHR_EVENT_MUX_IN:
   1368        qemu_mutex_lock(&mon->mon_lock);
   1369        mon->mux_out = 0;
   1370        qemu_mutex_unlock(&mon->mon_lock);
   1371        if (mon->reset_seen) {
   1372            readline_restart(hmp_mon->rs);
   1373            monitor_resume(mon);
   1374            monitor_flush(mon);
   1375        } else {
   1376            qatomic_mb_set(&mon->suspend_cnt, 0);
   1377        }
   1378        break;
   1379
   1380    case CHR_EVENT_MUX_OUT:
   1381        if (mon->reset_seen) {
   1382            if (qatomic_mb_read(&mon->suspend_cnt) == 0) {
   1383                monitor_printf(mon, "\n");
   1384            }
   1385            monitor_flush(mon);
   1386            monitor_suspend(mon);
   1387        } else {
   1388            qatomic_inc(&mon->suspend_cnt);
   1389        }
   1390        qemu_mutex_lock(&mon->mon_lock);
   1391        mon->mux_out = 1;
   1392        qemu_mutex_unlock(&mon->mon_lock);
   1393        break;
   1394
   1395    case CHR_EVENT_OPENED:
   1396        monitor_printf(mon, "QEMU %s monitor - type 'help' for more "
   1397                       "information\n", QEMU_VERSION);
   1398        if (!mon->mux_out) {
   1399            readline_restart(hmp_mon->rs);
   1400            readline_show_prompt(hmp_mon->rs);
   1401        }
   1402        mon->reset_seen = 1;
   1403        mon_refcount++;
   1404        break;
   1405
   1406    case CHR_EVENT_CLOSED:
   1407        mon_refcount--;
   1408        monitor_fdsets_cleanup();
   1409        break;
   1410
   1411    case CHR_EVENT_BREAK:
   1412        /* Ignored */
   1413        break;
   1414    }
   1415}
   1416
   1417
   1418/*
   1419 * These functions just adapt the readline interface in a typesafe way.  We
   1420 * could cast function pointers but that discards compiler checks.
   1421 */
   1422static void GCC_FMT_ATTR(2, 3) monitor_readline_printf(void *opaque,
   1423                                                       const char *fmt, ...)
   1424{
   1425    MonitorHMP *mon = opaque;
   1426    va_list ap;
   1427    va_start(ap, fmt);
   1428    monitor_vprintf(&mon->common, fmt, ap);
   1429    va_end(ap);
   1430}
   1431
   1432static void monitor_readline_flush(void *opaque)
   1433{
   1434    MonitorHMP *mon = opaque;
   1435    monitor_flush(&mon->common);
   1436}
   1437
   1438void monitor_init_hmp(Chardev *chr, bool use_readline, Error **errp)
   1439{
   1440    MonitorHMP *mon = g_new0(MonitorHMP, 1);
   1441
   1442    if (!qemu_chr_fe_init(&mon->common.chr, chr, errp)) {
   1443        g_free(mon);
   1444        return;
   1445    }
   1446
   1447    monitor_data_init(&mon->common, false, false, false);
   1448
   1449    mon->use_readline = use_readline;
   1450    if (mon->use_readline) {
   1451        mon->rs = readline_init(monitor_readline_printf,
   1452                                monitor_readline_flush,
   1453                                mon,
   1454                                monitor_find_completion);
   1455        monitor_read_command(mon, 0);
   1456    }
   1457
   1458    qemu_chr_fe_set_handlers(&mon->common.chr, monitor_can_read, monitor_read,
   1459                             monitor_event, NULL, &mon->common, NULL, true);
   1460    monitor_list_append(&mon->common);
   1461}