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