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