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