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