]>
Commit | Line | Data |
---|---|---|
ed7bda5d KW |
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> | |
164dafd1 | 27 | #include "hw/qdev-core.h" |
ed7bda5d | 28 | #include "monitor-internal.h" |
f9429c67 | 29 | #include "monitor/hmp.h" |
ed7bda5d KW |
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" | |
ed7bda5d KW |
39 | #include "trace.h" |
40 | ||
41 | static void monitor_command_cb(void *opaque, const char *cmdline, | |
42 | void *readline_opaque) | |
43 | { | |
44 | MonitorHMP *mon = opaque; | |
45 | ||
46 | monitor_suspend(&mon->common); | |
47 | handle_hmp_command(mon, cmdline); | |
48 | monitor_resume(&mon->common); | |
49 | } | |
50 | ||
51 | void monitor_read_command(MonitorHMP *mon, int show_prompt) | |
52 | { | |
53 | if (!mon->rs) { | |
54 | return; | |
55 | } | |
56 | ||
57 | readline_start(mon->rs, "(qemu) ", 0, monitor_command_cb, NULL); | |
58 | if (show_prompt) { | |
59 | readline_show_prompt(mon->rs); | |
60 | } | |
61 | } | |
62 | ||
63 | int monitor_read_password(MonitorHMP *mon, ReadLineFunc *readline_func, | |
64 | void *opaque) | |
65 | { | |
66 | if (mon->rs) { | |
67 | readline_start(mon->rs, "Password: ", 1, readline_func, opaque); | |
68 | /* prompt is printed on return from the command handler */ | |
69 | return 0; | |
70 | } else { | |
71 | monitor_printf(&mon->common, | |
72 | "terminal does not support password prompting\n"); | |
73 | return -ENOTTY; | |
74 | } | |
75 | } | |
76 | ||
77 | static int get_str(char *buf, int buf_size, const char **pp) | |
78 | { | |
79 | const char *p; | |
80 | char *q; | |
81 | int c; | |
82 | ||
83 | q = buf; | |
84 | p = *pp; | |
85 | while (qemu_isspace(*p)) { | |
86 | p++; | |
87 | } | |
88 | if (*p == '\0') { | |
89 | fail: | |
90 | *q = '\0'; | |
91 | *pp = p; | |
92 | return -1; | |
93 | } | |
94 | if (*p == '\"') { | |
95 | p++; | |
96 | while (*p != '\0' && *p != '\"') { | |
97 | if (*p == '\\') { | |
98 | p++; | |
99 | c = *p++; | |
100 | switch (c) { | |
101 | case 'n': | |
102 | c = '\n'; | |
103 | break; | |
104 | case 'r': | |
105 | c = '\r'; | |
106 | break; | |
107 | case '\\': | |
108 | case '\'': | |
109 | case '\"': | |
110 | break; | |
111 | default: | |
112 | printf("unsupported escape code: '\\%c'\n", c); | |
113 | goto fail; | |
114 | } | |
115 | if ((q - buf) < buf_size - 1) { | |
116 | *q++ = c; | |
117 | } | |
118 | } else { | |
119 | if ((q - buf) < buf_size - 1) { | |
120 | *q++ = *p; | |
121 | } | |
122 | p++; | |
123 | } | |
124 | } | |
125 | if (*p != '\"') { | |
126 | printf("unterminated string\n"); | |
127 | goto fail; | |
128 | } | |
129 | p++; | |
130 | } else { | |
131 | while (*p != '\0' && !qemu_isspace(*p)) { | |
132 | if ((q - buf) < buf_size - 1) { | |
133 | *q++ = *p; | |
134 | } | |
135 | p++; | |
136 | } | |
137 | } | |
138 | *q = '\0'; | |
139 | *pp = p; | |
140 | return 0; | |
141 | } | |
142 | ||
143 | #define MAX_ARGS 16 | |
144 | ||
145 | static void free_cmdline_args(char **args, int nb_args) | |
146 | { | |
147 | int i; | |
148 | ||
149 | assert(nb_args <= MAX_ARGS); | |
150 | ||
151 | for (i = 0; i < nb_args; i++) { | |
152 | g_free(args[i]); | |
153 | } | |
154 | ||
155 | } | |
156 | ||
157 | /* | |
158 | * Parse the command line to get valid args. | |
159 | * @cmdline: command line to be parsed. | |
160 | * @pnb_args: location to store the number of args, must NOT be NULL. | |
161 | * @args: location to store the args, which should be freed by caller, must | |
162 | * NOT be NULL. | |
163 | * | |
164 | * Returns 0 on success, negative on failure. | |
165 | * | |
166 | * NOTE: this parser is an approximate form of the real command parser. Number | |
167 | * of args have a limit of MAX_ARGS. If cmdline contains more, it will | |
168 | * return with failure. | |
169 | */ | |
170 | static int parse_cmdline(const char *cmdline, | |
171 | int *pnb_args, char **args) | |
172 | { | |
173 | const char *p; | |
174 | int nb_args, ret; | |
175 | char buf[1024]; | |
176 | ||
177 | p = cmdline; | |
178 | nb_args = 0; | |
179 | for (;;) { | |
180 | while (qemu_isspace(*p)) { | |
181 | p++; | |
182 | } | |
183 | if (*p == '\0') { | |
184 | break; | |
185 | } | |
186 | if (nb_args >= MAX_ARGS) { | |
187 | goto fail; | |
188 | } | |
189 | ret = get_str(buf, sizeof(buf), &p); | |
190 | if (ret < 0) { | |
191 | goto fail; | |
192 | } | |
193 | args[nb_args] = g_strdup(buf); | |
194 | nb_args++; | |
195 | } | |
196 | *pnb_args = nb_args; | |
197 | return 0; | |
198 | ||
199 | fail: | |
200 | free_cmdline_args(args, nb_args); | |
201 | return -1; | |
202 | } | |
203 | ||
204 | /* | |
205 | * Can command @cmd be executed in preconfig state? | |
206 | */ | |
207 | static bool cmd_can_preconfig(const HMPCommand *cmd) | |
208 | { | |
209 | if (!cmd->flags) { | |
210 | return false; | |
211 | } | |
212 | ||
213 | return strchr(cmd->flags, 'p'); | |
214 | } | |
215 | ||
4cd29274 PB |
216 | static bool cmd_available(const HMPCommand *cmd) |
217 | { | |
2f181fbd | 218 | return phase_check(PHASE_MACHINE_READY) || cmd_can_preconfig(cmd); |
4cd29274 PB |
219 | } |
220 | ||
ed7bda5d KW |
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 | ||
4cd29274 | 228 | if (!cmd_available(cmd)) { |
ed7bda5d KW |
229 | return; |
230 | } | |
231 | ||
232 | for (i = 0; i < prefix_args_nb; i++) { | |
233 | monitor_printf(mon, "%s ", prefix_args[i]); | |
234 | } | |
235 | monitor_printf(mon, "%s %s -- %s\n", cmd->name, cmd->params, cmd->help); | |
236 | } | |
237 | ||
238 | /* @args[@arg_index] is the valid command need to find in @cmds */ | |
239 | static void help_cmd_dump(Monitor *mon, const HMPCommand *cmds, | |
240 | char **args, int nb_args, int arg_index) | |
241 | { | |
242 | const HMPCommand *cmd; | |
243 | size_t i; | |
244 | ||
245 | /* No valid arg need to compare with, dump all in *cmds */ | |
246 | if (arg_index >= nb_args) { | |
247 | for (cmd = cmds; cmd->name != NULL; cmd++) { | |
248 | help_cmd_dump_one(mon, cmd, args, arg_index); | |
249 | } | |
250 | return; | |
251 | } | |
252 | ||
253 | /* Find one entry to dump */ | |
254 | for (cmd = cmds; cmd->name != NULL; cmd++) { | |
255 | if (hmp_compare_cmd(args[arg_index], cmd->name) && | |
4cd29274 | 256 | cmd_available(cmd)) { |
ed7bda5d KW |
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 | ||
5ec92f2d | 275 | void hmp_help_cmd(Monitor *mon, const char *name) |
ed7bda5d KW |
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"); | |
3183bb3f | 286 | monitor_printf(mon, "%-15s %s\n", "none", "remove all logs"); |
ed7bda5d | 287 | for (item = qemu_log_items; item->mask != 0; item++) { |
3183bb3f | 288 | monitor_printf(mon, "%-15s %s\n", item->name, item->help); |
ed7bda5d | 289 | } |
3183bb3f DZ |
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 | |
ed7bda5d KW |
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 | ||
8905770b MAL |
314 | static G_NORETURN G_GNUC_PRINTF(2, 3) |
315 | void expr_error(Monitor *mon, const char *fmt, ...) | |
ed7bda5d KW |
316 | { |
317 | va_list ap; | |
318 | va_start(ap, fmt); | |
319 | monitor_vprintf(mon, fmt, ap); | |
320 | monitor_printf(mon, "\n"); | |
321 | va_end(ap); | |
322 | siglongjmp(expr_env, 1); | |
323 | } | |
324 | ||
325 | static void next(void) | |
326 | { | |
327 | if (*pch != '\0') { | |
328 | pch++; | |
329 | while (qemu_isspace(*pch)) { | |
330 | pch++; | |
331 | } | |
332 | } | |
333 | } | |
334 | ||
335 | static int64_t expr_sum(Monitor *mon); | |
336 | ||
337 | static int64_t expr_unary(Monitor *mon) | |
338 | { | |
339 | int64_t n; | |
340 | char *p; | |
341 | int ret; | |
342 | ||
343 | switch (*pch) { | |
344 | case '+': | |
345 | next(); | |
346 | n = expr_unary(mon); | |
347 | break; | |
348 | case '-': | |
349 | next(); | |
350 | n = -expr_unary(mon); | |
351 | break; | |
352 | case '~': | |
353 | next(); | |
354 | n = ~expr_unary(mon); | |
355 | break; | |
356 | case '(': | |
357 | next(); | |
358 | n = expr_sum(mon); | |
359 | if (*pch != ')') { | |
360 | expr_error(mon, "')' expected"); | |
361 | } | |
362 | next(); | |
363 | break; | |
364 | case '\'': | |
365 | pch++; | |
366 | if (*pch == '\0') { | |
367 | expr_error(mon, "character constant expected"); | |
368 | } | |
369 | n = *pch; | |
370 | pch++; | |
371 | if (*pch != '\'') { | |
372 | expr_error(mon, "missing terminating \' character"); | |
373 | } | |
374 | next(); | |
375 | break; | |
376 | case '$': | |
377 | { | |
378 | char buf[128], *q; | |
379 | int64_t reg = 0; | |
380 | ||
381 | pch++; | |
382 | q = buf; | |
383 | while ((*pch >= 'a' && *pch <= 'z') || | |
384 | (*pch >= 'A' && *pch <= 'Z') || | |
385 | (*pch >= '0' && *pch <= '9') || | |
386 | *pch == '_' || *pch == '.') { | |
387 | if ((q - buf) < sizeof(buf) - 1) { | |
388 | *q++ = *pch; | |
389 | } | |
390 | pch++; | |
391 | } | |
392 | while (qemu_isspace(*pch)) { | |
393 | pch++; | |
394 | } | |
395 | *q = 0; | |
2fc5d01b | 396 | ret = get_monitor_def(mon, ®, buf); |
ed7bda5d KW |
397 | if (ret < 0) { |
398 | expr_error(mon, "unknown register"); | |
399 | } | |
400 | n = reg; | |
401 | } | |
402 | break; | |
403 | case '\0': | |
404 | expr_error(mon, "unexpected end of expression"); | |
405 | n = 0; | |
406 | break; | |
407 | default: | |
408 | errno = 0; | |
409 | n = strtoull(pch, &p, 0); | |
410 | if (errno == ERANGE) { | |
411 | expr_error(mon, "number too large"); | |
412 | } | |
413 | if (pch == p) { | |
414 | expr_error(mon, "invalid char '%c' in expression", *p); | |
415 | } | |
416 | pch = p; | |
417 | while (qemu_isspace(*pch)) { | |
418 | pch++; | |
419 | } | |
420 | break; | |
421 | } | |
422 | return n; | |
423 | } | |
424 | ||
425 | static int64_t expr_prod(Monitor *mon) | |
426 | { | |
427 | int64_t val, val2; | |
428 | int op; | |
429 | ||
430 | val = expr_unary(mon); | |
431 | for (;;) { | |
432 | op = *pch; | |
433 | if (op != '*' && op != '/' && op != '%') { | |
434 | break; | |
435 | } | |
436 | next(); | |
437 | val2 = expr_unary(mon); | |
438 | switch (op) { | |
439 | default: | |
440 | case '*': | |
441 | val *= val2; | |
442 | break; | |
443 | case '/': | |
444 | case '%': | |
445 | if (val2 == 0) { | |
446 | expr_error(mon, "division by zero"); | |
447 | } | |
448 | if (op == '/') { | |
449 | val /= val2; | |
450 | } else { | |
451 | val %= val2; | |
452 | } | |
453 | break; | |
454 | } | |
455 | } | |
456 | return val; | |
457 | } | |
458 | ||
459 | static int64_t expr_logic(Monitor *mon) | |
460 | { | |
461 | int64_t val, val2; | |
462 | int op; | |
463 | ||
464 | val = expr_prod(mon); | |
465 | for (;;) { | |
466 | op = *pch; | |
467 | if (op != '&' && op != '|' && op != '^') { | |
468 | break; | |
469 | } | |
470 | next(); | |
471 | val2 = expr_prod(mon); | |
472 | switch (op) { | |
473 | default: | |
474 | case '&': | |
475 | val &= val2; | |
476 | break; | |
477 | case '|': | |
478 | val |= val2; | |
479 | break; | |
480 | case '^': | |
481 | val ^= val2; | |
482 | break; | |
483 | } | |
484 | } | |
485 | return val; | |
486 | } | |
487 | ||
488 | static int64_t expr_sum(Monitor *mon) | |
489 | { | |
490 | int64_t val, val2; | |
491 | int op; | |
492 | ||
493 | val = expr_logic(mon); | |
494 | for (;;) { | |
495 | op = *pch; | |
496 | if (op != '+' && op != '-') { | |
497 | break; | |
498 | } | |
499 | next(); | |
500 | val2 = expr_logic(mon); | |
501 | if (op == '+') { | |
502 | val += val2; | |
503 | } else { | |
504 | val -= val2; | |
505 | } | |
506 | } | |
507 | return val; | |
508 | } | |
509 | ||
510 | static int get_expr(Monitor *mon, int64_t *pval, const char **pp) | |
511 | { | |
512 | pch = *pp; | |
513 | if (sigsetjmp(expr_env, 0)) { | |
514 | *pp = pch; | |
515 | return -1; | |
516 | } | |
517 | while (qemu_isspace(*pch)) { | |
518 | pch++; | |
519 | } | |
520 | *pval = expr_sum(mon); | |
521 | *pp = pch; | |
522 | return 0; | |
523 | } | |
524 | ||
525 | static int get_double(Monitor *mon, double *pval, const char **pp) | |
526 | { | |
527 | const char *p = *pp; | |
528 | char *tailp; | |
529 | double d; | |
530 | ||
531 | d = strtod(p, &tailp); | |
532 | if (tailp == p) { | |
533 | monitor_printf(mon, "Number expected\n"); | |
534 | return -1; | |
535 | } | |
536 | if (d != d || d - d != 0) { | |
537 | /* NaN or infinity */ | |
538 | monitor_printf(mon, "Bad number\n"); | |
539 | return -1; | |
540 | } | |
541 | *pval = d; | |
542 | *pp = tailp; | |
543 | return 0; | |
544 | } | |
545 | ||
546 | /* | |
547 | * Store the command-name in cmdname, and return a pointer to | |
548 | * the remaining of the command string. | |
549 | */ | |
550 | static const char *get_command_name(const char *cmdline, | |
551 | char *cmdname, size_t nlen) | |
552 | { | |
553 | size_t len; | |
554 | const char *p, *pstart; | |
555 | ||
556 | p = cmdline; | |
557 | while (qemu_isspace(*p)) { | |
558 | p++; | |
559 | } | |
560 | if (*p == '\0') { | |
561 | return NULL; | |
562 | } | |
563 | pstart = p; | |
564 | while (*p != '\0' && *p != '/' && !qemu_isspace(*p)) { | |
565 | p++; | |
566 | } | |
567 | len = p - pstart; | |
568 | if (len > nlen - 1) { | |
569 | len = nlen - 1; | |
570 | } | |
571 | memcpy(cmdname, pstart, len); | |
572 | cmdname[len] = '\0'; | |
573 | return p; | |
574 | } | |
575 | ||
576 | /** | |
577 | * Read key of 'type' into 'key' and return the current | |
578 | * 'type' pointer. | |
579 | */ | |
580 | static char *key_get_info(const char *type, char **key) | |
581 | { | |
582 | size_t len; | |
583 | char *p, *str; | |
584 | ||
585 | if (*type == ',') { | |
586 | type++; | |
587 | } | |
588 | ||
589 | p = strchr(type, ':'); | |
590 | if (!p) { | |
591 | *key = NULL; | |
592 | return NULL; | |
593 | } | |
594 | len = p - type; | |
595 | ||
596 | str = g_malloc(len + 1); | |
597 | memcpy(str, type, len); | |
598 | str[len] = '\0'; | |
599 | ||
600 | *key = str; | |
601 | return ++p; | |
602 | } | |
603 | ||
604 | static int default_fmt_format = 'x'; | |
605 | static int default_fmt_size = 4; | |
606 | ||
607 | static int is_valid_option(const char *c, const char *typestr) | |
608 | { | |
609 | char option[3]; | |
610 | ||
611 | option[0] = '-'; | |
612 | option[1] = *c; | |
613 | option[2] = '\0'; | |
614 | ||
615 | typestr = strstr(typestr, option); | |
616 | return (typestr != NULL); | |
617 | } | |
618 | ||
619 | static const HMPCommand *search_dispatch_table(const HMPCommand *disp_table, | |
620 | const char *cmdname) | |
621 | { | |
622 | const HMPCommand *cmd; | |
623 | ||
624 | for (cmd = disp_table; cmd->name != NULL; cmd++) { | |
625 | if (hmp_compare_cmd(cmdname, cmd->name)) { | |
626 | return cmd; | |
627 | } | |
628 | } | |
629 | ||
630 | return NULL; | |
631 | } | |
632 | ||
633 | /* | |
634 | * Parse command name from @cmdp according to command table @table. | |
635 | * If blank, return NULL. | |
636 | * Else, if no valid command can be found, report to @mon, and return | |
637 | * NULL. | |
638 | * Else, change @cmdp to point right behind the name, and return its | |
639 | * command table entry. | |
640 | * Do not assume the return value points into @table! It doesn't when | |
641 | * the command is found in a sub-command table. | |
642 | */ | |
643 | static const HMPCommand *monitor_parse_command(MonitorHMP *hmp_mon, | |
644 | const char *cmdp_start, | |
645 | const char **cmdp, | |
646 | HMPCommand *table) | |
647 | { | |
648 | Monitor *mon = &hmp_mon->common; | |
649 | const char *p; | |
650 | const HMPCommand *cmd; | |
651 | char cmdname[256]; | |
652 | ||
653 | /* extract the command name */ | |
654 | p = get_command_name(*cmdp, cmdname, sizeof(cmdname)); | |
655 | if (!p) { | |
656 | return NULL; | |
657 | } | |
658 | ||
659 | cmd = search_dispatch_table(table, cmdname); | |
660 | if (!cmd) { | |
661 | monitor_printf(mon, "unknown command: '%.*s'\n", | |
662 | (int)(p - cmdp_start), cmdp_start); | |
663 | return NULL; | |
664 | } | |
4cd29274 | 665 | if (!cmd_available(cmd)) { |
164dafd1 PB |
666 | monitor_printf(mon, "Command '%.*s' not available " |
667 | "until machine initialization has completed.\n", | |
ed7bda5d KW |
668 | (int)(p - cmdp_start), cmdp_start); |
669 | return NULL; | |
670 | } | |
671 | ||
672 | /* filter out following useless space */ | |
673 | while (qemu_isspace(*p)) { | |
674 | p++; | |
675 | } | |
676 | ||
677 | *cmdp = p; | |
678 | /* search sub command */ | |
679 | if (cmd->sub_table != NULL && *p != '\0') { | |
680 | return monitor_parse_command(hmp_mon, cmdp_start, cmdp, cmd->sub_table); | |
681 | } | |
682 | ||
683 | return cmd; | |
684 | } | |
685 | ||
686 | /* | |
687 | * Parse arguments for @cmd. | |
688 | * If it can't be parsed, report to @mon, and return NULL. | |
689 | * Else, insert command arguments into a QDict, and return it. | |
690 | * Note: On success, caller has to free the QDict structure. | |
691 | */ | |
692 | static QDict *monitor_parse_arguments(Monitor *mon, | |
693 | const char **endp, | |
694 | const HMPCommand *cmd) | |
695 | { | |
696 | const char *typestr; | |
697 | char *key; | |
698 | int c; | |
699 | const char *p = *endp; | |
700 | char buf[1024]; | |
701 | QDict *qdict = qdict_new(); | |
702 | ||
703 | /* parse the parameters */ | |
704 | typestr = cmd->args_type; | |
705 | for (;;) { | |
706 | typestr = key_get_info(typestr, &key); | |
707 | if (!typestr) { | |
708 | break; | |
709 | } | |
710 | c = *typestr; | |
711 | typestr++; | |
712 | switch (c) { | |
713 | case 'F': | |
714 | case 'B': | |
715 | case 's': | |
716 | { | |
717 | int ret; | |
718 | ||
719 | while (qemu_isspace(*p)) { | |
720 | p++; | |
721 | } | |
722 | if (*typestr == '?') { | |
723 | typestr++; | |
724 | if (*p == '\0') { | |
725 | /* no optional string: NULL argument */ | |
726 | break; | |
727 | } | |
728 | } | |
729 | ret = get_str(buf, sizeof(buf), &p); | |
730 | if (ret < 0) { | |
731 | switch (c) { | |
732 | case 'F': | |
733 | monitor_printf(mon, "%s: filename expected\n", | |
734 | cmd->name); | |
735 | break; | |
736 | case 'B': | |
737 | monitor_printf(mon, "%s: block device name expected\n", | |
738 | cmd->name); | |
739 | break; | |
740 | default: | |
741 | monitor_printf(mon, "%s: string expected\n", cmd->name); | |
742 | break; | |
743 | } | |
744 | goto fail; | |
745 | } | |
746 | qdict_put_str(qdict, key, buf); | |
747 | } | |
748 | break; | |
749 | case 'O': | |
750 | { | |
751 | QemuOptsList *opts_list; | |
752 | QemuOpts *opts; | |
753 | ||
754 | opts_list = qemu_find_opts(key); | |
755 | if (!opts_list || opts_list->desc->name) { | |
756 | goto bad_type; | |
757 | } | |
758 | while (qemu_isspace(*p)) { | |
759 | p++; | |
760 | } | |
761 | if (!*p) { | |
762 | break; | |
763 | } | |
764 | if (get_str(buf, sizeof(buf), &p) < 0) { | |
765 | goto fail; | |
766 | } | |
767 | opts = qemu_opts_parse_noisily(opts_list, buf, true); | |
768 | if (!opts) { | |
769 | goto fail; | |
770 | } | |
771 | qemu_opts_to_qdict(opts, qdict); | |
772 | qemu_opts_del(opts); | |
773 | } | |
774 | break; | |
775 | case '/': | |
776 | { | |
777 | int count, format, size; | |
778 | ||
779 | while (qemu_isspace(*p)) { | |
780 | p++; | |
781 | } | |
782 | if (*p == '/') { | |
783 | /* format found */ | |
784 | p++; | |
785 | count = 1; | |
786 | if (qemu_isdigit(*p)) { | |
787 | count = 0; | |
788 | while (qemu_isdigit(*p)) { | |
789 | count = count * 10 + (*p - '0'); | |
790 | p++; | |
791 | } | |
792 | } | |
793 | size = -1; | |
794 | format = -1; | |
795 | for (;;) { | |
796 | switch (*p) { | |
797 | case 'o': | |
798 | case 'd': | |
799 | case 'u': | |
800 | case 'x': | |
801 | case 'i': | |
802 | case 'c': | |
803 | format = *p++; | |
804 | break; | |
805 | case 'b': | |
806 | size = 1; | |
807 | p++; | |
808 | break; | |
809 | case 'h': | |
810 | size = 2; | |
811 | p++; | |
812 | break; | |
813 | case 'w': | |
814 | size = 4; | |
815 | p++; | |
816 | break; | |
817 | case 'g': | |
818 | case 'L': | |
819 | size = 8; | |
820 | p++; | |
821 | break; | |
822 | default: | |
823 | goto next; | |
824 | } | |
825 | } | |
826 | next: | |
827 | if (*p != '\0' && !qemu_isspace(*p)) { | |
828 | monitor_printf(mon, "invalid char in format: '%c'\n", | |
829 | *p); | |
830 | goto fail; | |
831 | } | |
832 | if (format < 0) { | |
833 | format = default_fmt_format; | |
834 | } | |
835 | if (format != 'i') { | |
836 | /* for 'i', not specifying a size gives -1 as size */ | |
837 | if (size < 0) { | |
838 | size = default_fmt_size; | |
839 | } | |
840 | default_fmt_size = size; | |
841 | } | |
842 | default_fmt_format = format; | |
843 | } else { | |
844 | count = 1; | |
845 | format = default_fmt_format; | |
846 | if (format != 'i') { | |
847 | size = default_fmt_size; | |
848 | } else { | |
849 | size = -1; | |
850 | } | |
851 | } | |
852 | qdict_put_int(qdict, "count", count); | |
853 | qdict_put_int(qdict, "format", format); | |
854 | qdict_put_int(qdict, "size", size); | |
855 | } | |
856 | break; | |
857 | case 'i': | |
858 | case 'l': | |
859 | case 'M': | |
860 | { | |
861 | int64_t val; | |
862 | ||
863 | while (qemu_isspace(*p)) { | |
864 | p++; | |
865 | } | |
866 | if (*typestr == '?' || *typestr == '.') { | |
867 | if (*typestr == '?') { | |
868 | if (*p == '\0') { | |
869 | typestr++; | |
870 | break; | |
871 | } | |
872 | } else { | |
873 | if (*p == '.') { | |
874 | p++; | |
875 | while (qemu_isspace(*p)) { | |
876 | p++; | |
877 | } | |
878 | } else { | |
879 | typestr++; | |
880 | break; | |
881 | } | |
882 | } | |
883 | typestr++; | |
884 | } | |
885 | if (get_expr(mon, &val, &p)) { | |
886 | goto fail; | |
887 | } | |
888 | /* Check if 'i' is greater than 32-bit */ | |
889 | if ((c == 'i') && ((val >> 32) & 0xffffffff)) { | |
890 | monitor_printf(mon, "\'%s\' has failed: ", cmd->name); | |
891 | monitor_printf(mon, "integer is for 32-bit values\n"); | |
892 | goto fail; | |
893 | } else if (c == 'M') { | |
894 | if (val < 0) { | |
895 | monitor_printf(mon, "enter a positive value\n"); | |
896 | goto fail; | |
897 | } | |
898 | val *= MiB; | |
899 | } | |
900 | qdict_put_int(qdict, key, val); | |
901 | } | |
902 | break; | |
903 | case 'o': | |
904 | { | |
905 | int ret; | |
906 | uint64_t val; | |
907 | const char *end; | |
908 | ||
909 | while (qemu_isspace(*p)) { | |
910 | p++; | |
911 | } | |
912 | if (*typestr == '?') { | |
913 | typestr++; | |
914 | if (*p == '\0') { | |
915 | break; | |
916 | } | |
917 | } | |
918 | ret = qemu_strtosz_MiB(p, &end, &val); | |
919 | if (ret < 0 || val > INT64_MAX) { | |
920 | monitor_printf(mon, "invalid size\n"); | |
921 | goto fail; | |
922 | } | |
923 | qdict_put_int(qdict, key, val); | |
924 | p = end; | |
925 | } | |
926 | break; | |
927 | case 'T': | |
928 | { | |
929 | double val; | |
930 | ||
931 | while (qemu_isspace(*p)) { | |
932 | p++; | |
933 | } | |
934 | if (*typestr == '?') { | |
935 | typestr++; | |
936 | if (*p == '\0') { | |
937 | break; | |
938 | } | |
939 | } | |
940 | if (get_double(mon, &val, &p) < 0) { | |
941 | goto fail; | |
942 | } | |
943 | if (p[0] && p[1] == 's') { | |
944 | switch (*p) { | |
945 | case 'm': | |
946 | val /= 1e3; p += 2; break; | |
947 | case 'u': | |
948 | val /= 1e6; p += 2; break; | |
949 | case 'n': | |
950 | val /= 1e9; p += 2; break; | |
951 | } | |
952 | } | |
953 | if (*p && !qemu_isspace(*p)) { | |
954 | monitor_printf(mon, "Unknown unit suffix\n"); | |
955 | goto fail; | |
956 | } | |
957 | qdict_put(qdict, key, qnum_from_double(val)); | |
958 | } | |
959 | break; | |
960 | case 'b': | |
961 | { | |
962 | const char *beg; | |
963 | bool val; | |
964 | ||
965 | while (qemu_isspace(*p)) { | |
966 | p++; | |
967 | } | |
968 | beg = p; | |
969 | while (qemu_isgraph(*p)) { | |
970 | p++; | |
971 | } | |
972 | if (p - beg == 2 && !memcmp(beg, "on", p - beg)) { | |
973 | val = true; | |
974 | } else if (p - beg == 3 && !memcmp(beg, "off", p - beg)) { | |
975 | val = false; | |
976 | } else { | |
977 | monitor_printf(mon, "Expected 'on' or 'off'\n"); | |
978 | goto fail; | |
979 | } | |
980 | qdict_put_bool(qdict, key, val); | |
981 | } | |
982 | break; | |
983 | case '-': | |
984 | { | |
985 | const char *tmp = p; | |
986 | int skip_key = 0; | |
26fcd766 | 987 | int ret; |
ed7bda5d KW |
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; | |
26fcd766 SR |
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); | |
ed7bda5d | 1024 | } else { |
26fcd766 | 1025 | /* has boolean option */ |
ed7bda5d KW |
1026 | p++; |
1027 | qdict_put_bool(qdict, key, true); | |
1028 | } | |
26fcd766 SR |
1029 | } else if (*typestr == 's') { |
1030 | typestr++; | |
ed7bda5d KW |
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 | ||
f9429c67 DB |
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 | ||
bf0c50d4 | 1095 | monitor_puts(mon, info->human_readable_text); |
f9429c67 DB |
1096 | } |
1097 | ||
1098 | static void handle_hmp_command_exec(Monitor *mon, | |
1099 | const HMPCommand *cmd, | |
1100 | QDict *qdict) | |
1101 | { | |
1102 | if (cmd->cmd_info_hrt) { | |
1103 | hmp_info_human_readable_text(mon, | |
1104 | cmd->cmd_info_hrt); | |
1105 | } else { | |
1106 | cmd->cmd(mon, qdict); | |
1107 | } | |
1108 | } | |
1109 | ||
bb4b9ead KW |
1110 | typedef struct HandleHmpCommandCo { |
1111 | Monitor *mon; | |
1112 | const HMPCommand *cmd; | |
1113 | QDict *qdict; | |
1114 | bool done; | |
1115 | } HandleHmpCommandCo; | |
1116 | ||
1117 | static void handle_hmp_command_co(void *opaque) | |
1118 | { | |
1119 | HandleHmpCommandCo *data = opaque; | |
f9429c67 | 1120 | handle_hmp_command_exec(data->mon, data->cmd, data->qdict); |
bb4b9ead KW |
1121 | monitor_set_cur(qemu_coroutine_self(), NULL); |
1122 | data->done = true; | |
1123 | } | |
1124 | ||
ed7bda5d KW |
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 | ||
f9429c67 | 1138 | if (!cmd->cmd && !cmd->cmd_info_hrt) { |
f0e48cbd GH |
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 | ||
ed7bda5d KW |
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 | ||
bb4b9ead KW |
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); | |
f9429c67 | 1158 | handle_hmp_command_exec(&mon->common, cmd, qdict); |
bb4b9ead KW |
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); | |
6bb68553 | 1170 | AIO_WAIT_WHILE_UNLOCKED(NULL, !data.done); |
bb4b9ead | 1171 | } |
ff04108a | 1172 | |
ed7bda5d KW |
1173 | qobject_unref(qdict); |
1174 | } | |
1175 | ||
1176 | static void cmd_completion(MonitorHMP *mon, const char *name, const char *list) | |
1177 | { | |
1178 | const char *p, *pstart; | |
1179 | char cmd[128]; | |
1180 | int len; | |
1181 | ||
1182 | p = list; | |
1183 | for (;;) { | |
1184 | pstart = p; | |
1185 | p = qemu_strchrnul(p, '|'); | |
1186 | len = p - pstart; | |
1187 | if (len > sizeof(cmd) - 2) { | |
1188 | len = sizeof(cmd) - 2; | |
1189 | } | |
1190 | memcpy(cmd, pstart, len); | |
1191 | cmd[len] = '\0'; | |
76f5801a | 1192 | readline_add_completion_of(mon->rs, name, cmd); |
ed7bda5d KW |
1193 | if (*p == '\0') { |
1194 | break; | |
1195 | } | |
1196 | p++; | |
1197 | } | |
1198 | } | |
1199 | ||
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 | ||
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 | ||
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; | |
52f50b1e | 1271 | const char *ptype, *old_ptype, *str; |
ed7bda5d KW |
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++) { | |
4cd29274 | 1284 | if (cmd_available(cmd)) { |
ed7bda5d KW |
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) && | |
4cd29274 | 1292 | cmd_available(cmd)) { |
ed7bda5d KW |
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) { | |
76f5801a | 1336 | readline_add_completion_of(mon->rs, str, blk_name(blk)); |
ed7bda5d KW |
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 | ||
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 | ||
1383 | static void monitor_read(void *opaque, const uint8_t *buf, int size) | |
1384 | { | |
947e4744 | 1385 | MonitorHMP *mon = container_of(opaque, MonitorHMP, common); |
ed7bda5d KW |
1386 | int i; |
1387 | ||
ed7bda5d KW |
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) { | |
947e4744 | 1394 | monitor_printf(&mon->common, "corrupted command\n"); |
ed7bda5d KW |
1395 | } else { |
1396 | handle_hmp_command(mon, (char *)buf); | |
1397 | } | |
1398 | } | |
ed7bda5d KW |
1399 | } |
1400 | ||
083b266f | 1401 | static void monitor_event(void *opaque, QEMUChrEvent event) |
ed7bda5d KW |
1402 | { |
1403 | Monitor *mon = opaque; | |
ed7bda5d KW |
1404 | |
1405 | switch (event) { | |
1406 | case CHR_EVENT_MUX_IN: | |
1407 | qemu_mutex_lock(&mon->mon_lock); | |
6ee7c82d PB |
1408 | if (mon->mux_out) { |
1409 | mon->mux_out = 0; | |
ed7bda5d | 1410 | monitor_resume(mon); |
ed7bda5d | 1411 | } |
6ee7c82d | 1412 | qemu_mutex_unlock(&mon->mon_lock); |
ed7bda5d KW |
1413 | break; |
1414 | ||
1415 | case CHR_EVENT_MUX_OUT: | |
6ee7c82d PB |
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); | |
ed7bda5d | 1422 | } |
ed7bda5d | 1423 | monitor_suspend(mon); |
6ee7c82d | 1424 | mon->mux_out = 1; |
ed7bda5d | 1425 | } |
ed7bda5d KW |
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); | |
6ee7c82d PB |
1432 | qemu_mutex_lock(&mon->mon_lock); |
1433 | mon->reset_seen = 1; | |
ed7bda5d | 1434 | if (!mon->mux_out) { |
6ee7c82d PB |
1435 | /* Suspend-resume forces the prompt to be printed. */ |
1436 | monitor_suspend(mon); | |
1437 | monitor_resume(mon); | |
ed7bda5d | 1438 | } |
6ee7c82d | 1439 | qemu_mutex_unlock(&mon->mon_lock); |
ed7bda5d KW |
1440 | mon_refcount++; |
1441 | break; | |
1442 | ||
1443 | case CHR_EVENT_CLOSED: | |
1444 | mon_refcount--; | |
1445 | monitor_fdsets_cleanup(); | |
1446 | break; | |
4904ca6a PMD |
1447 | |
1448 | case CHR_EVENT_BREAK: | |
1449 | /* Ignored */ | |
1450 | break; | |
ed7bda5d KW |
1451 | } |
1452 | } | |
1453 | ||
1454 | ||
1455 | /* | |
1456 | * These functions just adapt the readline interface in a typesafe way. We | |
1457 | * could cast function pointers but that discards compiler checks. | |
1458 | */ | |
9edc6313 | 1459 | static void G_GNUC_PRINTF(2, 3) monitor_readline_printf(void *opaque, |
ed7bda5d KW |
1460 | const char *fmt, ...) |
1461 | { | |
1462 | MonitorHMP *mon = opaque; | |
1463 | va_list ap; | |
1464 | va_start(ap, fmt); | |
1465 | monitor_vprintf(&mon->common, fmt, ap); | |
1466 | va_end(ap); | |
1467 | } | |
1468 | ||
1469 | static void monitor_readline_flush(void *opaque) | |
1470 | { | |
1471 | MonitorHMP *mon = opaque; | |
1472 | monitor_flush(&mon->common); | |
1473 | } | |
1474 | ||
8e9119a8 | 1475 | void monitor_init_hmp(Chardev *chr, bool use_readline, Error **errp) |
ed7bda5d KW |
1476 | { |
1477 | MonitorHMP *mon = g_new0(MonitorHMP, 1); | |
ed7bda5d | 1478 | |
8e9119a8 KW |
1479 | if (!qemu_chr_fe_init(&mon->common.chr, chr, errp)) { |
1480 | g_free(mon); | |
1481 | return; | |
1482 | } | |
1483 | ||
92082416 | 1484 | monitor_data_init(&mon->common, false, false, false); |
ed7bda5d | 1485 | |
fbfc29e3 | 1486 | mon->use_readline = use_readline; |
92082416 | 1487 | if (mon->use_readline) { |
ed7bda5d KW |
1488 | mon->rs = readline_init(monitor_readline_printf, |
1489 | monitor_readline_flush, | |
1490 | mon, | |
1491 | monitor_find_completion); | |
1492 | monitor_read_command(mon, 0); | |
1493 | } | |
1494 | ||
1495 | qemu_chr_fe_set_handlers(&mon->common.chr, monitor_can_read, monitor_read, | |
1496 | monitor_event, NULL, &mon->common, NULL, true); | |
1497 | monitor_list_append(&mon->common); | |
1498 | } |