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