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
monitor_command_cb(void * opaque,const char * cmdline,void * readline_opaque)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
monitor_read_command(MonitorHMP * mon,int show_prompt)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
monitor_read_password(MonitorHMP * mon,ReadLineFunc * readline_func,void * opaque)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
get_str(char * buf,int buf_size,const char ** pp)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
free_cmdline_args(char ** args,int nb_args)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 */
parse_cmdline(const char * cmdline,int * pnb_args,char ** args)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 */
cmd_can_preconfig(const HMPCommand * cmd)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
cmd_available(const HMPCommand * cmd)216 static bool cmd_available(const HMPCommand *cmd)
217 {
218 return phase_check(PHASE_MACHINE_READY) || cmd_can_preconfig(cmd);
219 }
220
help_cmd_dump_one(Monitor * mon,const HMPCommand * cmd,char ** prefix_args,int prefix_args_nb)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 */
help_cmd_dump(Monitor * mon,const HMPCommand * cmds,char ** args,int nb_args,int arg_index)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
hmp_help_cmd(Monitor * mon,const char * name)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)
expr_error(Monitor * mon,const char * fmt,...)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
next(void)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
expr_unary(Monitor * mon)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
expr_prod(Monitor * mon)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
expr_logic(Monitor * mon)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
expr_sum(Monitor * mon)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
get_expr(Monitor * mon,int64_t * pval,const char ** pp)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
get_double(Monitor * mon,double * pval,const char ** pp)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 */
get_command_name(const char * cmdline,char * cmdname,size_t nlen)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 */
key_get_info(const char * type,char ** key)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
is_valid_option(const char * c,const char * typestr)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
search_dispatch_table(const HMPCommand * disp_table,const char * cmdname)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 */
monitor_parse_command(MonitorHMP * hmp_mon,const char * cmdp_start,const char ** cmdp,HMPCommand * table)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 */
monitor_parse_arguments(Monitor * mon,const char ** endp,const HMPCommand * cmd)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
hmp_info_human_readable_text(Monitor * mon,HumanReadableText * (* handler)(Error **))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
handle_hmp_command_exec(Monitor * mon,const HMPCommand * cmd,QDict * qdict)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
handle_hmp_command_co(void * opaque)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
handle_hmp_command(MonitorHMP * mon,const char * cmdline)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_UNLOCKED(NULL, !data.done);
1171 }
1172
1173 qobject_unref(qdict);
1174 }
1175
cmd_completion(MonitorHMP * mon,const char * name,const char * list)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 readline_add_completion_of(mon->rs, name, cmd);
1193 if (*p == '\0') {
1194 break;
1195 }
1196 p++;
1197 }
1198 }
1199
file_completion(MonitorHMP * mon,const char * input)1200 static void file_completion(MonitorHMP *mon, const char *input)
1201 {
1202 DIR *ffs;
1203 struct dirent *d;
1204 char path[1024];
1205 char file[1024], file_prefix[1024];
1206 int input_path_len;
1207 const char *p;
1208
1209 p = strrchr(input, '/');
1210 if (!p) {
1211 input_path_len = 0;
1212 pstrcpy(file_prefix, sizeof(file_prefix), input);
1213 pstrcpy(path, sizeof(path), ".");
1214 } else {
1215 input_path_len = p - input + 1;
1216 memcpy(path, input, input_path_len);
1217 if (input_path_len > sizeof(path) - 1) {
1218 input_path_len = sizeof(path) - 1;
1219 }
1220 path[input_path_len] = '\0';
1221 pstrcpy(file_prefix, sizeof(file_prefix), p + 1);
1222 }
1223
1224 ffs = opendir(path);
1225 if (!ffs) {
1226 return;
1227 }
1228 for (;;) {
1229 struct stat sb;
1230 d = readdir(ffs);
1231 if (!d) {
1232 break;
1233 }
1234
1235 if (strcmp(d->d_name, ".") == 0 || strcmp(d->d_name, "..") == 0) {
1236 continue;
1237 }
1238
1239 if (strstart(d->d_name, file_prefix, NULL)) {
1240 memcpy(file, input, input_path_len);
1241 if (input_path_len < sizeof(file)) {
1242 pstrcpy(file + input_path_len, sizeof(file) - input_path_len,
1243 d->d_name);
1244 }
1245 /*
1246 * stat the file to find out if it's a directory.
1247 * In that case add a slash to speed up typing long paths
1248 */
1249 if (stat(file, &sb) == 0 && S_ISDIR(sb.st_mode)) {
1250 pstrcat(file, sizeof(file), "/");
1251 }
1252 readline_add_completion(mon->rs, file);
1253 }
1254 }
1255 closedir(ffs);
1256 }
1257
next_arg_type(const char * typestr)1258 static const char *next_arg_type(const char *typestr)
1259 {
1260 const char *p = strchr(typestr, ':');
1261 return (p != NULL ? ++p : typestr);
1262 }
1263
monitor_find_completion_by_table(MonitorHMP * mon,const HMPCommand * cmd_table,char ** args,int nb_args)1264 static void monitor_find_completion_by_table(MonitorHMP *mon,
1265 const HMPCommand *cmd_table,
1266 char **args,
1267 int nb_args)
1268 {
1269 const char *cmdname;
1270 int i;
1271 const char *ptype, *old_ptype, *str;
1272 const HMPCommand *cmd;
1273 BlockBackend *blk = NULL;
1274
1275 if (nb_args <= 1) {
1276 /* command completion */
1277 if (nb_args == 0) {
1278 cmdname = "";
1279 } else {
1280 cmdname = args[0];
1281 }
1282 readline_set_completion_index(mon->rs, strlen(cmdname));
1283 for (cmd = cmd_table; cmd->name != NULL; cmd++) {
1284 if (cmd_available(cmd)) {
1285 cmd_completion(mon, cmdname, cmd->name);
1286 }
1287 }
1288 } else {
1289 /* find the command */
1290 for (cmd = cmd_table; cmd->name != NULL; cmd++) {
1291 if (hmp_compare_cmd(args[0], cmd->name) &&
1292 cmd_available(cmd)) {
1293 break;
1294 }
1295 }
1296 if (!cmd->name) {
1297 return;
1298 }
1299
1300 if (cmd->sub_table) {
1301 /* do the job again */
1302 monitor_find_completion_by_table(mon, cmd->sub_table,
1303 &args[1], nb_args - 1);
1304 return;
1305 }
1306 if (cmd->command_completion) {
1307 cmd->command_completion(mon->rs, nb_args, args[nb_args - 1]);
1308 return;
1309 }
1310
1311 ptype = next_arg_type(cmd->args_type);
1312 for (i = 0; i < nb_args - 2; i++) {
1313 if (*ptype != '\0') {
1314 ptype = next_arg_type(ptype);
1315 while (*ptype == '?') {
1316 ptype = next_arg_type(ptype);
1317 }
1318 }
1319 }
1320 str = args[nb_args - 1];
1321 old_ptype = NULL;
1322 while (*ptype == '-' && old_ptype != ptype) {
1323 old_ptype = ptype;
1324 ptype = next_arg_type(ptype);
1325 }
1326 switch (*ptype) {
1327 case 'F':
1328 /* file completion */
1329 readline_set_completion_index(mon->rs, strlen(str));
1330 file_completion(mon, str);
1331 break;
1332 case 'B':
1333 /* block device name completion */
1334 readline_set_completion_index(mon->rs, strlen(str));
1335 while ((blk = blk_next(blk)) != NULL) {
1336 readline_add_completion_of(mon->rs, str, blk_name(blk));
1337 }
1338 break;
1339 case 's':
1340 case 'S':
1341 if (!strcmp(cmd->name, "help|?")) {
1342 monitor_find_completion_by_table(mon, cmd_table,
1343 &args[1], nb_args - 1);
1344 }
1345 break;
1346 default:
1347 break;
1348 }
1349 }
1350 }
1351
monitor_find_completion(void * opaque,const char * cmdline)1352 static void monitor_find_completion(void *opaque,
1353 const char *cmdline)
1354 {
1355 MonitorHMP *mon = opaque;
1356 char *args[MAX_ARGS];
1357 int nb_args, len;
1358
1359 /* 1. parse the cmdline */
1360 if (parse_cmdline(cmdline, &nb_args, args) < 0) {
1361 return;
1362 }
1363
1364 /*
1365 * if the line ends with a space, it means we want to complete the
1366 * next arg
1367 */
1368 len = strlen(cmdline);
1369 if (len > 0 && qemu_isspace(cmdline[len - 1])) {
1370 if (nb_args >= MAX_ARGS) {
1371 goto cleanup;
1372 }
1373 args[nb_args++] = g_strdup("");
1374 }
1375
1376 /* 2. auto complete according to args */
1377 monitor_find_completion_by_table(mon, hmp_cmds, args, nb_args);
1378
1379 cleanup:
1380 free_cmdline_args(args, nb_args);
1381 }
1382
monitor_read(void * opaque,const uint8_t * buf,int size)1383 static void monitor_read(void *opaque, const uint8_t *buf, int size)
1384 {
1385 MonitorHMP *mon = container_of(opaque, MonitorHMP, common);
1386 int i;
1387
1388 if (mon->rs) {
1389 for (i = 0; i < size; i++) {
1390 readline_handle_byte(mon->rs, buf[i]);
1391 }
1392 } else {
1393 if (size == 0 || buf[size - 1] != 0) {
1394 monitor_printf(&mon->common, "corrupted command\n");
1395 } else {
1396 handle_hmp_command(mon, (char *)buf);
1397 }
1398 }
1399 }
1400
monitor_event(void * opaque,QEMUChrEvent event)1401 static void monitor_event(void *opaque, QEMUChrEvent event)
1402 {
1403 Monitor *mon = opaque;
1404
1405 switch (event) {
1406 case CHR_EVENT_MUX_IN:
1407 qemu_mutex_lock(&mon->mon_lock);
1408 if (mon->mux_out) {
1409 mon->mux_out = 0;
1410 monitor_resume(mon);
1411 }
1412 qemu_mutex_unlock(&mon->mon_lock);
1413 break;
1414
1415 case CHR_EVENT_MUX_OUT:
1416 qemu_mutex_lock(&mon->mon_lock);
1417 if (!mon->mux_out) {
1418 if (mon->reset_seen && !mon->suspend_cnt) {
1419 monitor_puts_locked(mon, "\n");
1420 } else {
1421 monitor_flush_locked(mon);
1422 }
1423 monitor_suspend(mon);
1424 mon->mux_out = 1;
1425 }
1426 qemu_mutex_unlock(&mon->mon_lock);
1427 break;
1428
1429 case CHR_EVENT_OPENED:
1430 monitor_printf(mon, "QEMU %s monitor - type 'help' for more "
1431 "information\n", QEMU_VERSION);
1432 qemu_mutex_lock(&mon->mon_lock);
1433 mon->reset_seen = 1;
1434 if (!mon->mux_out) {
1435 /* Suspend-resume forces the prompt to be printed. */
1436 monitor_suspend(mon);
1437 monitor_resume(mon);
1438 }
1439 qemu_mutex_unlock(&mon->mon_lock);
1440 break;
1441
1442 case CHR_EVENT_CLOSED:
1443 monitor_fdsets_cleanup();
1444 break;
1445
1446 case CHR_EVENT_BREAK:
1447 /* Ignored */
1448 break;
1449 }
1450 }
1451
1452
1453 /*
1454 * These functions just adapt the readline interface in a typesafe way. We
1455 * could cast function pointers but that discards compiler checks.
1456 */
monitor_readline_printf(void * opaque,const char * fmt,...)1457 static void G_GNUC_PRINTF(2, 3) monitor_readline_printf(void *opaque,
1458 const char *fmt, ...)
1459 {
1460 MonitorHMP *mon = opaque;
1461 va_list ap;
1462 va_start(ap, fmt);
1463 monitor_vprintf(&mon->common, fmt, ap);
1464 va_end(ap);
1465 }
1466
monitor_readline_flush(void * opaque)1467 static void monitor_readline_flush(void *opaque)
1468 {
1469 MonitorHMP *mon = opaque;
1470 monitor_flush(&mon->common);
1471 }
1472
monitor_init_hmp(Chardev * chr,bool use_readline,Error ** errp)1473 void monitor_init_hmp(Chardev *chr, bool use_readline, Error **errp)
1474 {
1475 MonitorHMP *mon = g_new0(MonitorHMP, 1);
1476
1477 if (!qemu_chr_fe_init(&mon->common.chr, chr, errp)) {
1478 g_free(mon);
1479 return;
1480 }
1481
1482 monitor_data_init(&mon->common, false, false, false);
1483
1484 mon->use_readline = use_readline;
1485 if (mon->use_readline) {
1486 mon->rs = readline_init(monitor_readline_printf,
1487 monitor_readline_flush,
1488 mon,
1489 monitor_find_completion);
1490 monitor_read_command(mon, 0);
1491 }
1492
1493 qemu_chr_fe_set_handlers(&mon->common.chr, monitor_can_read, monitor_read,
1494 monitor_event, NULL, &mon->common, NULL, true);
1495 monitor_list_append(&mon->common);
1496 }
1497