Merge remote-tracking branch 'remotes/armbru/tags/pull-qapi-2021-09-25-v2' into staging
[qemu.git] / 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 }