monitor/hmp.c

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