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