monitor.c 86.7 KB
Newer Older
B
bellard 已提交
1 2
/*
 * QEMU monitor
3
 *
B
bellard 已提交
4
 * Copyright (c) 2003-2004 Fabrice Bellard
5
 *
B
bellard 已提交
6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
24
#include <dirent.h>
P
pbrook 已提交
25
#include "hw/hw.h"
26
#include "hw/qdev.h"
P
pbrook 已提交
27 28 29 30
#include "hw/usb.h"
#include "hw/pcmcia.h"
#include "hw/pc.h"
#include "hw/pci.h"
R
Richard W.M. Jones 已提交
31
#include "hw/watchdog.h"
P
pbrook 已提交
32 33 34 35
#include "gdbstub.h"
#include "net.h"
#include "qemu-char.h"
#include "sysemu.h"
A
aliguori 已提交
36 37
#include "monitor.h"
#include "readline.h"
P
pbrook 已提交
38 39 40
#include "console.h"
#include "block.h"
#include "audio/audio.h"
41
#include "disas.h"
A
aliguori 已提交
42
#include "balloon.h"
43
#include "qemu-timer.h"
A
aliguori 已提交
44
#include "migration.h"
A
aliguori 已提交
45
#include "kvm.h"
46
#include "acl.h"
47 48 49
#include "qint.h"
#include "qdict.h"
#include "qstring.h"
T
ths 已提交
50

B
bellard 已提交
51
//#define DEBUG
B
bellard 已提交
52
//#define DEBUG_COMPLETION
B
bellard 已提交
53

54 55
/*
 * Supported types:
56
 *
57
 * 'F'          filename
B
bellard 已提交
58
 * 'B'          block device name
59
 * 's'          string (accept optional quote)
B
bellard 已提交
60 61
 * 'i'          32 bit integer
 * 'l'          target long (32 or 64 bit)
62 63
 * '/'          optional gdb-like print format (like "/10x")
 *
64 65 66
 * '?'          optional type (for all types, except '/')
 * '.'          other form of optional type (for 'i' and 'l')
 * '-'          optional parameter (eg. '-f')
67 68 69
 *
 */

A
aliguori 已提交
70
typedef struct mon_cmd_t {
B
bellard 已提交
71
    const char *name;
72
    const char *args_type;
73
    void *handler;
B
bellard 已提交
74 75
    const char *params;
    const char *help;
A
aliguori 已提交
76
} mon_cmd_t;
B
bellard 已提交
77

78 79 80 81 82 83 84 85
/* file descriptors passed via SCM_RIGHTS */
typedef struct mon_fd_t mon_fd_t;
struct mon_fd_t {
    char *name;
    int fd;
    LIST_ENTRY(mon_fd_t) next;
};

86 87
struct Monitor {
    CharDriverState *chr;
88 89 90 91 92 93 94 95
    int flags;
    int suspend_cnt;
    uint8_t outbuf[1024];
    int outbuf_index;
    ReadLineState *rs;
    CPUState *mon_cpu;
    BlockDriverCompletionFunc *password_completion_cb;
    void *password_opaque;
96
    LIST_HEAD(,mon_fd_t) fds;
97 98 99 100
    LIST_ENTRY(Monitor) entry;
};

static LIST_HEAD(mon_list, Monitor) mon_list;
101

A
aliguori 已提交
102 103
static const mon_cmd_t mon_cmds[];
static const mon_cmd_t info_cmds[];
B
bellard 已提交
104

105
Monitor *cur_mon = NULL;
A
aliguori 已提交
106

107 108
static void monitor_command_cb(Monitor *mon, const char *cmdline,
                               void *opaque);
109

110 111 112 113 114 115
static void monitor_read_command(Monitor *mon, int show_prompt)
{
    readline_start(mon->rs, "(qemu) ", 0, monitor_command_cb, NULL);
    if (show_prompt)
        readline_show_prompt(mon->rs);
}
B
bellard 已提交
116

117 118
static int monitor_read_password(Monitor *mon, ReadLineFunc *readline_func,
                                 void *opaque)
119
{
120 121 122 123 124 125 126 127
    if (mon->rs) {
        readline_start(mon->rs, "Password: ", 1, readline_func, opaque);
        /* prompt is printed on return from the command handler */
        return 0;
    } else {
        monitor_printf(mon, "terminal does not support password prompting\n");
        return -ENOTTY;
    }
128 129
}

A
aliguori 已提交
130
void monitor_flush(Monitor *mon)
131
{
132 133 134
    if (mon && mon->outbuf_index != 0 && mon->chr->focus == 0) {
        qemu_chr_write(mon->chr, mon->outbuf, mon->outbuf_index);
        mon->outbuf_index = 0;
135 136 137 138
    }
}

/* flush at every end of line or if the buffer is full */
A
aliguori 已提交
139
static void monitor_puts(Monitor *mon, const char *str)
140
{
T
ths 已提交
141
    char c;
142 143 144 145

    if (!mon)
        return;

146 147 148 149
    for(;;) {
        c = *str++;
        if (c == '\0')
            break;
B
bellard 已提交
150
        if (c == '\n')
151 152 153 154
            mon->outbuf[mon->outbuf_index++] = '\r';
        mon->outbuf[mon->outbuf_index++] = c;
        if (mon->outbuf_index >= (sizeof(mon->outbuf) - 1)
            || c == '\n')
A
aliguori 已提交
155
            monitor_flush(mon);
156 157 158
    }
}

A
aliguori 已提交
159
void monitor_vprintf(Monitor *mon, const char *fmt, va_list ap)
B
bellard 已提交
160
{
B
bellard 已提交
161 162
    char buf[4096];
    vsnprintf(buf, sizeof(buf), fmt, ap);
A
aliguori 已提交
163
    monitor_puts(mon, buf);
B
bellard 已提交
164 165
}

A
aliguori 已提交
166
void monitor_printf(Monitor *mon, const char *fmt, ...)
B
bellard 已提交
167
{
168 169
    va_list ap;
    va_start(ap, fmt);
A
aliguori 已提交
170
    monitor_vprintf(mon, fmt, ap);
171
    va_end(ap);
B
bellard 已提交
172 173
}

A
aliguori 已提交
174
void monitor_print_filename(Monitor *mon, const char *filename)
175 176 177 178
{
    int i;

    for (i = 0; filename[i]; i++) {
179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197
        switch (filename[i]) {
        case ' ':
        case '"':
        case '\\':
            monitor_printf(mon, "\\%c", filename[i]);
            break;
        case '\t':
            monitor_printf(mon, "\\t");
            break;
        case '\r':
            monitor_printf(mon, "\\r");
            break;
        case '\n':
            monitor_printf(mon, "\\n");
            break;
        default:
            monitor_printf(mon, "%c", filename[i]);
            break;
        }
198 199 200
    }
}

B
bellard 已提交
201 202 203 204
static int monitor_fprintf(FILE *stream, const char *fmt, ...)
{
    va_list ap;
    va_start(ap, fmt);
A
aliguori 已提交
205
    monitor_vprintf((Monitor *)stream, fmt, ap);
B
bellard 已提交
206 207 208 209
    va_end(ap);
    return 0;
}

B
bellard 已提交
210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229
static int compare_cmd(const char *name, const char *list)
{
    const char *p, *pstart;
    int len;
    len = strlen(name);
    p = list;
    for(;;) {
        pstart = p;
        p = strchr(p, '|');
        if (!p)
            p = pstart + strlen(pstart);
        if ((p - pstart) == len && !memcmp(pstart, name, len))
            return 1;
        if (*p == '\0')
            break;
        p++;
    }
    return 0;
}

A
aliguori 已提交
230 231
static void help_cmd_dump(Monitor *mon, const mon_cmd_t *cmds,
                          const char *prefix, const char *name)
B
bellard 已提交
232
{
A
aliguori 已提交
233
    const mon_cmd_t *cmd;
B
bellard 已提交
234 235 236

    for(cmd = cmds; cmd->name != NULL; cmd++) {
        if (!name || !strcmp(name, cmd->name))
A
aliguori 已提交
237 238
            monitor_printf(mon, "%s%s %s -- %s\n", prefix, cmd->name,
                           cmd->params, cmd->help);
B
bellard 已提交
239 240 241
    }
}

A
aliguori 已提交
242
static void help_cmd(Monitor *mon, const char *name)
B
bellard 已提交
243 244
{
    if (name && !strcmp(name, "info")) {
A
aliguori 已提交
245
        help_cmd_dump(mon, info_cmds, "info ", NULL);
B
bellard 已提交
246
    } else {
A
aliguori 已提交
247
        help_cmd_dump(mon, mon_cmds, "", name);
248
        if (name && !strcmp(name, "log")) {
B
blueswir1 已提交
249
            const CPULogItem *item;
A
aliguori 已提交
250 251
            monitor_printf(mon, "Log items (comma separated):\n");
            monitor_printf(mon, "%-10s %s\n", "none", "remove all logs");
252
            for(item = cpu_log_items; item->mask != 0; item++) {
A
aliguori 已提交
253
                monitor_printf(mon, "%-10s %s\n", item->name, item->help);
254 255
            }
        }
B
bellard 已提交
256 257 258
    }
}

259
static void do_help_cmd(Monitor *mon, const QDict *qdict)
260
{
261
    help_cmd(mon, qdict_get_try_str(qdict, "name"));
262 263
}

264
static void do_commit(Monitor *mon, const QDict *qdict)
B
bellard 已提交
265
{
G
Gerd Hoffmann 已提交
266 267
    int all_devices;
    DriveInfo *dinfo;
268
    const char *device = qdict_get_str(qdict, "device");
269

B
bellard 已提交
270
    all_devices = !strcmp(device, "all");
G
Gerd Hoffmann 已提交
271 272
    TAILQ_FOREACH(dinfo, &drives, next) {
        if (!all_devices)
L
Luiz Capitulino 已提交
273
            if (strcmp(bdrv_get_device_name(dinfo->bdrv), device))
G
Gerd Hoffmann 已提交
274 275
                continue;
        bdrv_commit(dinfo->bdrv);
B
bellard 已提交
276 277 278
    }
}

279
static void do_info(Monitor *mon, const QDict *qdict)
B
bellard 已提交
280
{
A
aliguori 已提交
281
    const mon_cmd_t *cmd;
282
    const char *item = qdict_get_try_str(qdict, "item");
A
aliguori 已提交
283
    void (*handler)(Monitor *);
B
bellard 已提交
284

285
    if (!item)
B
bellard 已提交
286 287
        goto help;
    for(cmd = info_cmds; cmd->name != NULL; cmd++) {
288
        if (compare_cmd(item, cmd->name))
B
bellard 已提交
289 290 291
            goto found;
    }
 help:
A
aliguori 已提交
292
    help_cmd(mon, "info");
B
bellard 已提交
293 294
    return;
 found:
295
    handler = cmd->handler;
A
aliguori 已提交
296
    handler(mon);
B
bellard 已提交
297 298
}

A
aliguori 已提交
299
static void do_info_version(Monitor *mon)
B
bellard 已提交
300
{
P
pbrook 已提交
301
    monitor_printf(mon, "%s\n", QEMU_VERSION QEMU_PKGVERSION);
B
bellard 已提交
302 303
}

A
aliguori 已提交
304
static void do_info_name(Monitor *mon)
T
ths 已提交
305 306
{
    if (qemu_name)
A
aliguori 已提交
307
        monitor_printf(mon, "%s\n", qemu_name);
T
ths 已提交
308 309
}

A
aurel32 已提交
310
#if defined(TARGET_I386)
A
aliguori 已提交
311
static void do_info_hpet(Monitor *mon)
A
aliguori 已提交
312
{
A
aliguori 已提交
313 314
    monitor_printf(mon, "HPET is %s by QEMU\n",
                   (no_hpet) ? "disabled" : "enabled");
A
aliguori 已提交
315
}
A
aurel32 已提交
316
#endif
A
aliguori 已提交
317

A
aliguori 已提交
318
static void do_info_uuid(Monitor *mon)
319
{
A
aliguori 已提交
320 321 322 323 324
    monitor_printf(mon, UUID_FMT "\n", qemu_uuid[0], qemu_uuid[1],
                   qemu_uuid[2], qemu_uuid[3], qemu_uuid[4], qemu_uuid[5],
                   qemu_uuid[6], qemu_uuid[7], qemu_uuid[8], qemu_uuid[9],
                   qemu_uuid[10], qemu_uuid[11], qemu_uuid[12], qemu_uuid[13],
                   qemu_uuid[14], qemu_uuid[15]);
325 326
}

B
bellard 已提交
327
/* get the current CPU defined by the user */
328
static int mon_set_cpu(int cpu_index)
B
bellard 已提交
329 330 331 332 333
{
    CPUState *env;

    for(env = first_cpu; env != NULL; env = env->next_cpu) {
        if (env->cpu_index == cpu_index) {
334
            cur_mon->mon_cpu = env;
B
bellard 已提交
335 336 337 338 339 340
            return 0;
        }
    }
    return -1;
}

341
static CPUState *mon_get_cpu(void)
B
bellard 已提交
342
{
343
    if (!cur_mon->mon_cpu) {
B
bellard 已提交
344 345
        mon_set_cpu(0);
    }
346
    cpu_synchronize_state(cur_mon->mon_cpu);
347
    return cur_mon->mon_cpu;
B
bellard 已提交
348 349
}

A
aliguori 已提交
350
static void do_info_registers(Monitor *mon)
351
{
B
bellard 已提交
352 353 354 355
    CPUState *env;
    env = mon_get_cpu();
    if (!env)
        return;
356
#ifdef TARGET_I386
A
aliguori 已提交
357
    cpu_dump_state(env, (FILE *)mon, monitor_fprintf,
B
bellard 已提交
358
                   X86_DUMP_FPU);
359
#else
A
aliguori 已提交
360
    cpu_dump_state(env, (FILE *)mon, monitor_fprintf,
B
bellard 已提交
361
                   0);
362 363 364
#endif
}

A
aliguori 已提交
365
static void do_info_cpus(Monitor *mon)
B
bellard 已提交
366 367 368 369 370 371 372
{
    CPUState *env;

    /* just to set the default cpu if not already done */
    mon_get_cpu();

    for(env = first_cpu; env != NULL; env = env->next_cpu) {
373
        cpu_synchronize_state(env);
A
aliguori 已提交
374
        monitor_printf(mon, "%c CPU #%d:",
375
                       (env == mon->mon_cpu) ? '*' : ' ',
A
aliguori 已提交
376
                       env->cpu_index);
B
bellard 已提交
377
#if defined(TARGET_I386)
A
aliguori 已提交
378 379
        monitor_printf(mon, " pc=0x" TARGET_FMT_lx,
                       env->eip + env->segs[R_CS].base);
B
bellard 已提交
380
#elif defined(TARGET_PPC)
A
aliguori 已提交
381
        monitor_printf(mon, " nip=0x" TARGET_FMT_lx, env->nip);
B
bellard 已提交
382
#elif defined(TARGET_SPARC)
A
aliguori 已提交
383 384
        monitor_printf(mon, " pc=0x" TARGET_FMT_lx " npc=0x" TARGET_FMT_lx,
                       env->pc, env->npc);
385
#elif defined(TARGET_MIPS)
A
aliguori 已提交
386
        monitor_printf(mon, " PC=0x" TARGET_FMT_lx, env->active_tc.PC);
B
bellard 已提交
387
#endif
388
        if (env->halted)
A
aliguori 已提交
389 390
            monitor_printf(mon, " (halted)");
        monitor_printf(mon, "\n");
B
bellard 已提交
391 392 393
    }
}

394
static void do_cpu_set(Monitor *mon, const QDict *qdict)
B
bellard 已提交
395
{
396
    int index = qdict_get_int(qdict, "index");
B
bellard 已提交
397
    if (mon_set_cpu(index) < 0)
A
aliguori 已提交
398
        monitor_printf(mon, "Invalid CPU index\n");
B
bellard 已提交
399 400
}

A
aliguori 已提交
401
static void do_info_jit(Monitor *mon)
B
bellard 已提交
402
{
A
aliguori 已提交
403
    dump_exec_info((FILE *)mon, monitor_fprintf);
B
bellard 已提交
404 405
}

A
aliguori 已提交
406
static void do_info_history(Monitor *mon)
B
bellard 已提交
407 408
{
    int i;
409
    const char *str;
410

411 412
    if (!mon->rs)
        return;
413 414
    i = 0;
    for(;;) {
415
        str = readline_get_history(mon->rs, i);
416 417
        if (!str)
            break;
A
aliguori 已提交
418
        monitor_printf(mon, "%d: '%s'\n", i, str);
B
bellard 已提交
419
        i++;
B
bellard 已提交
420 421 422
    }
}

423 424
#if defined(TARGET_PPC)
/* XXX: not implemented in other targets */
A
aliguori 已提交
425
static void do_info_cpu_stats(Monitor *mon)
426 427 428 429
{
    CPUState *env;

    env = mon_get_cpu();
A
aliguori 已提交
430
    cpu_dump_statistics(env, (FILE *)mon, &monitor_fprintf, 0);
431 432 433
}
#endif

434
static void do_quit(Monitor *mon, const QDict *qdict)
B
bellard 已提交
435 436 437 438
{
    exit(0);
}

A
aliguori 已提交
439
static int eject_device(Monitor *mon, BlockDriverState *bs, int force)
B
bellard 已提交
440 441 442 443
{
    if (bdrv_is_inserted(bs)) {
        if (!force) {
            if (!bdrv_is_removable(bs)) {
A
aliguori 已提交
444
                monitor_printf(mon, "device is not removable\n");
B
bellard 已提交
445 446 447
                return -1;
            }
            if (bdrv_is_locked(bs)) {
A
aliguori 已提交
448
                monitor_printf(mon, "device is locked\n");
B
bellard 已提交
449 450 451 452 453 454 455 456
                return -1;
            }
        }
        bdrv_close(bs);
    }
    return 0;
}

457
static void do_eject(Monitor *mon, const QDict *qdict)
B
bellard 已提交
458 459
{
    BlockDriverState *bs;
460 461
    int force = qdict_get_int(qdict, "force");
    const char *filename = qdict_get_str(qdict, "filename");
B
bellard 已提交
462

463
    bs = bdrv_find(filename);
B
bellard 已提交
464
    if (!bs) {
A
aliguori 已提交
465
        monitor_printf(mon, "device not found\n");
B
bellard 已提交
466 467
        return;
    }
A
aliguori 已提交
468
    eject_device(mon, bs, force);
B
bellard 已提交
469 470
}

A
aliguori 已提交
471 472
static void do_change_block(Monitor *mon, const char *device,
                            const char *filename, const char *fmt)
B
bellard 已提交
473 474
{
    BlockDriverState *bs;
475
    BlockDriver *drv = NULL;
B
bellard 已提交
476

477
    bs = bdrv_find(device);
B
bellard 已提交
478
    if (!bs) {
A
aliguori 已提交
479
        monitor_printf(mon, "device not found\n");
B
bellard 已提交
480 481
        return;
    }
482 483 484
    if (fmt) {
        drv = bdrv_find_format(fmt);
        if (!drv) {
A
aliguori 已提交
485
            monitor_printf(mon, "invalid format %s\n", fmt);
486 487 488
            return;
        }
    }
A
aliguori 已提交
489
    if (eject_device(mon, bs, 0) < 0)
B
bellard 已提交
490
        return;
491
    bdrv_open2(bs, filename, 0, drv);
A
aliguori 已提交
492
    monitor_read_bdrv_key_start(mon, bs, NULL, NULL);
493 494
}

A
aliguori 已提交
495 496
static void change_vnc_password_cb(Monitor *mon, const char *password,
                                   void *opaque)
497 498
{
    if (vnc_display_password(NULL, password) < 0)
A
aliguori 已提交
499
        monitor_printf(mon, "could not set VNC server password\n");
500

501
    monitor_read_command(mon, 1);
B
bellard 已提交
502 503
}

A
aliguori 已提交
504
static void do_change_vnc(Monitor *mon, const char *target, const char *arg)
505
{
506
    if (strcmp(target, "passwd") == 0 ||
507 508
        strcmp(target, "password") == 0) {
        if (arg) {
509
            char password[9];
510 511
            strncpy(password, arg, sizeof(password));
            password[sizeof(password) - 1] = '\0';
A
aliguori 已提交
512
            change_vnc_password_cb(mon, password, NULL);
513
        } else {
A
aliguori 已提交
514
            monitor_read_password(mon, change_vnc_password_cb, NULL);
515
        }
516
    } else {
517
        if (vnc_display_open(NULL, target) < 0)
A
aliguori 已提交
518
            monitor_printf(mon, "could not start VNC server on %s\n", target);
519
    }
520 521
}

522
static void do_change(Monitor *mon, const QDict *qdict)
523
{
524 525 526
    const char *device = qdict_get_str(qdict, "device");
    const char *target = qdict_get_str(qdict, "target");
    const char *arg = qdict_get_try_str(qdict, "arg");
527
    if (strcmp(device, "vnc") == 0) {
528
        do_change_vnc(mon, target, arg);
529
    } else {
530
        do_change_block(mon, device, target, arg);
531 532 533
    }
}

534
static void do_screen_dump(Monitor *mon, const QDict *qdict)
B
bellard 已提交
535
{
536
    vga_hw_screen_dump(qdict_get_str(qdict, "filename"));
B
bellard 已提交
537 538
}

539
static void do_logfile(Monitor *mon, const QDict *qdict)
P
pbrook 已提交
540
{
541
    cpu_set_log_filename(qdict_get_str(qdict, "filename"));
P
pbrook 已提交
542 543
}

544
static void do_log(Monitor *mon, const QDict *qdict)
545 546
{
    int mask;
547
    const char *items = qdict_get_str(qdict, "items");
548

549
    if (!strcmp(items, "none")) {
550 551
        mask = 0;
    } else {
552
        mask = cpu_str_to_log_mask(items);
553
        if (!mask) {
A
aliguori 已提交
554
            help_cmd(mon, "log");
555 556 557 558 559 560
            return;
        }
    }
    cpu_set_log(mask);
}

561
static void do_singlestep(Monitor *mon, const QDict *qdict)
562
{
563
    const char *option = qdict_get_try_str(qdict, "option");
564 565 566 567 568 569 570 571 572
    if (!option || !strcmp(option, "on")) {
        singlestep = 1;
    } else if (!strcmp(option, "off")) {
        singlestep = 0;
    } else {
        monitor_printf(mon, "unexpected option %s\n", option);
    }
}

573
static void do_stop(Monitor *mon, const QDict *qdict)
574 575 576 577
{
    vm_stop(EXCP_INTERRUPT);
}

578
static void encrypted_bdrv_it(void *opaque, BlockDriverState *bs);
579

A
aliguori 已提交
580 581 582 583 584
struct bdrv_iterate_context {
    Monitor *mon;
    int err;
};

585
static void do_cont(Monitor *mon, const QDict *qdict)
586
{
A
aliguori 已提交
587
    struct bdrv_iterate_context context = { mon, 0 };
588

A
aliguori 已提交
589
    bdrv_iterate(encrypted_bdrv_it, &context);
590
    /* only resume the vm if all keys are set and valid */
A
aliguori 已提交
591
    if (!context.err)
592
        vm_start();
593 594
}

595 596
static void bdrv_key_cb(void *opaque, int err)
{
A
aliguori 已提交
597 598
    Monitor *mon = opaque;

599 600
    /* another key was set successfully, retry to continue */
    if (!err)
601
        do_cont(mon, NULL);
602 603 604 605
}

static void encrypted_bdrv_it(void *opaque, BlockDriverState *bs)
{
A
aliguori 已提交
606
    struct bdrv_iterate_context *context = opaque;
607

A
aliguori 已提交
608 609 610 611
    if (!context->err && bdrv_key_required(bs)) {
        context->err = -EBUSY;
        monitor_read_bdrv_key_start(context->mon, bs, bdrv_key_cb,
                                    context->mon);
612 613 614
    }
}

615
static void do_gdbserver(Monitor *mon, const QDict *qdict)
616
{
617
    const char *device = qdict_get_try_str(qdict, "device");
618 619 620 621 622 623
    if (!device)
        device = "tcp::" DEFAULT_GDBSTUB_PORT;
    if (gdbserver_start(device) < 0) {
        monitor_printf(mon, "Could not open gdbserver on device '%s'\n",
                       device);
    } else if (strcmp(device, "none") == 0) {
624
        monitor_printf(mon, "Disabled gdbserver\n");
625
    } else {
626 627
        monitor_printf(mon, "Waiting for gdb connection on device '%s'\n",
                       device);
628 629 630
    }
}

631
static void do_watchdog_action(Monitor *mon, const QDict *qdict)
R
Richard W.M. Jones 已提交
632
{
633
    const char *action = qdict_get_str(qdict, "action");
R
Richard W.M. Jones 已提交
634 635 636 637 638
    if (select_watchdog_action(action) == -1) {
        monitor_printf(mon, "Unknown watchdog action '%s'\n", action);
    }
}

A
aliguori 已提交
639
static void monitor_printc(Monitor *mon, int c)
640
{
A
aliguori 已提交
641
    monitor_printf(mon, "'");
642 643
    switch(c) {
    case '\'':
A
aliguori 已提交
644
        monitor_printf(mon, "\\'");
645 646
        break;
    case '\\':
A
aliguori 已提交
647
        monitor_printf(mon, "\\\\");
648 649
        break;
    case '\n':
A
aliguori 已提交
650
        monitor_printf(mon, "\\n");
651 652
        break;
    case '\r':
A
aliguori 已提交
653
        monitor_printf(mon, "\\r");
654 655 656
        break;
    default:
        if (c >= 32 && c <= 126) {
A
aliguori 已提交
657
            monitor_printf(mon, "%c", c);
658
        } else {
A
aliguori 已提交
659
            monitor_printf(mon, "\\x%02x", c);
660 661 662
        }
        break;
    }
A
aliguori 已提交
663
    monitor_printf(mon, "'");
664 665
}

A
aliguori 已提交
666
static void memory_dump(Monitor *mon, int count, int format, int wsize,
667
                        target_phys_addr_t addr, int is_physical)
668
{
B
bellard 已提交
669
    CPUState *env;
670 671 672 673 674 675 676
    int nb_per_line, l, line_size, i, max_digits, len;
    uint8_t buf[16];
    uint64_t v;

    if (format == 'i') {
        int flags;
        flags = 0;
B
bellard 已提交
677 678 679
        env = mon_get_cpu();
        if (!env && !is_physical)
            return;
680
#ifdef TARGET_I386
681
        if (wsize == 2) {
682
            flags = 1;
683 684 685
        } else if (wsize == 4) {
            flags = 0;
        } else {
B
bellard 已提交
686
            /* as default we use the current CS size */
687
            flags = 0;
B
bellard 已提交
688 689
            if (env) {
#ifdef TARGET_X86_64
690
                if ((env->efer & MSR_EFER_LMA) &&
B
bellard 已提交
691 692 693 694 695 696 697
                    (env->segs[R_CS].flags & DESC_L_MASK))
                    flags = 2;
                else
#endif
                if (!(env->segs[R_CS].flags & DESC_B_MASK))
                    flags = 1;
            }
698 699
        }
#endif
A
aliguori 已提交
700
        monitor_disas(mon, env, addr, count, is_physical, flags);
701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729
        return;
    }

    len = wsize * count;
    if (wsize == 1)
        line_size = 8;
    else
        line_size = 16;
    nb_per_line = line_size / wsize;
    max_digits = 0;

    switch(format) {
    case 'o':
        max_digits = (wsize * 8 + 2) / 3;
        break;
    default:
    case 'x':
        max_digits = (wsize * 8) / 4;
        break;
    case 'u':
    case 'd':
        max_digits = (wsize * 8 * 10 + 32) / 33;
        break;
    case 'c':
        wsize = 1;
        break;
    }

    while (len > 0) {
730
        if (is_physical)
A
aliguori 已提交
731
            monitor_printf(mon, TARGET_FMT_plx ":", addr);
732
        else
A
aliguori 已提交
733
            monitor_printf(mon, TARGET_FMT_lx ":", (target_ulong)addr);
734 735 736 737 738 739
        l = len;
        if (l > line_size)
            l = line_size;
        if (is_physical) {
            cpu_physical_memory_rw(addr, buf, l, 0);
        } else {
B
bellard 已提交
740 741 742
            env = mon_get_cpu();
            if (!env)
                break;
743
            if (cpu_memory_rw_debug(env, addr, buf, l, 0) < 0) {
A
aliguori 已提交
744
                monitor_printf(mon, " Cannot access memory\n");
745 746
                break;
            }
747
        }
748
        i = 0;
749 750 751 752 753 754 755 756 757 758
        while (i < l) {
            switch(wsize) {
            default:
            case 1:
                v = ldub_raw(buf + i);
                break;
            case 2:
                v = lduw_raw(buf + i);
                break;
            case 4:
B
bellard 已提交
759
                v = (uint32_t)ldl_raw(buf + i);
760 761 762 763 764
                break;
            case 8:
                v = ldq_raw(buf + i);
                break;
            }
A
aliguori 已提交
765
            monitor_printf(mon, " ");
766 767
            switch(format) {
            case 'o':
A
aliguori 已提交
768
                monitor_printf(mon, "%#*" PRIo64, max_digits, v);
769 770
                break;
            case 'x':
A
aliguori 已提交
771
                monitor_printf(mon, "0x%0*" PRIx64, max_digits, v);
772 773
                break;
            case 'u':
A
aliguori 已提交
774
                monitor_printf(mon, "%*" PRIu64, max_digits, v);
775 776
                break;
            case 'd':
A
aliguori 已提交
777
                monitor_printf(mon, "%*" PRId64, max_digits, v);
778 779
                break;
            case 'c':
A
aliguori 已提交
780
                monitor_printc(mon, v);
781 782 783 784
                break;
            }
            i += wsize;
        }
A
aliguori 已提交
785
        monitor_printf(mon, "\n");
786 787 788 789 790
        addr += l;
        len -= l;
    }
}

791
static void do_memory_dump(Monitor *mon, const QDict *qdict)
792
{
793 794 795 796 797
    int count = qdict_get_int(qdict, "count");
    int format = qdict_get_int(qdict, "format");
    int size = qdict_get_int(qdict, "size");
    target_long addr = qdict_get_int(qdict, "addr");

A
aliguori 已提交
798
    memory_dump(mon, count, format, size, addr, 0);
799 800
}

801
static void do_physical_memory_dump(Monitor *mon, const QDict *qdict)
802
{
803 804 805 806 807
    int count = qdict_get_int(qdict, "count");
    int format = qdict_get_int(qdict, "format");
    int size = qdict_get_int(qdict, "size");
    target_phys_addr_t addr = qdict_get_int(qdict, "addr");

A
aliguori 已提交
808
    memory_dump(mon, count, format, size, addr, 1);
809 810
}

811
static void do_print(Monitor *mon, const QDict *qdict)
812
{
813 814 815
    int format = qdict_get_int(qdict, "format");
    target_phys_addr_t val = qdict_get_int(qdict, "val");

816
#if TARGET_PHYS_ADDR_BITS == 32
817 818
    switch(format) {
    case 'o':
A
aliguori 已提交
819
        monitor_printf(mon, "%#o", val);
820 821
        break;
    case 'x':
A
aliguori 已提交
822
        monitor_printf(mon, "%#x", val);
823 824
        break;
    case 'u':
A
aliguori 已提交
825
        monitor_printf(mon, "%u", val);
826 827 828
        break;
    default:
    case 'd':
A
aliguori 已提交
829
        monitor_printf(mon, "%d", val);
830 831
        break;
    case 'c':
A
aliguori 已提交
832
        monitor_printc(mon, val);
833 834
        break;
    }
B
bellard 已提交
835 836 837
#else
    switch(format) {
    case 'o':
A
aliguori 已提交
838
        monitor_printf(mon, "%#" PRIo64, val);
B
bellard 已提交
839 840
        break;
    case 'x':
A
aliguori 已提交
841
        monitor_printf(mon, "%#" PRIx64, val);
B
bellard 已提交
842 843
        break;
    case 'u':
A
aliguori 已提交
844
        monitor_printf(mon, "%" PRIu64, val);
B
bellard 已提交
845 846 847
        break;
    default:
    case 'd':
A
aliguori 已提交
848
        monitor_printf(mon, "%" PRId64, val);
B
bellard 已提交
849 850
        break;
    case 'c':
A
aliguori 已提交
851
        monitor_printc(mon, val);
B
bellard 已提交
852 853 854
        break;
    }
#endif
A
aliguori 已提交
855
    monitor_printf(mon, "\n");
856 857
}

858
static void do_memory_save(Monitor *mon, const QDict *qdict)
B
bellard 已提交
859 860
{
    FILE *f;
861 862 863
    uint32_t size = qdict_get_int(qdict, "size");
    const char *filename = qdict_get_str(qdict, "filename");
    target_long addr = qdict_get_int(qdict, "val");
B
bellard 已提交
864 865 866 867 868 869 870 871 872 873
    uint32_t l;
    CPUState *env;
    uint8_t buf[1024];

    env = mon_get_cpu();
    if (!env)
        return;

    f = fopen(filename, "wb");
    if (!f) {
A
aliguori 已提交
874
        monitor_printf(mon, "could not open '%s'\n", filename);
B
bellard 已提交
875 876 877 878 879 880 881 882 883 884 885 886 887 888
        return;
    }
    while (size != 0) {
        l = sizeof(buf);
        if (l > size)
            l = size;
        cpu_memory_rw_debug(env, addr, buf, l, 0);
        fwrite(buf, 1, l, f);
        addr += l;
        size -= l;
    }
    fclose(f);
}

889
static void do_physical_memory_save(Monitor *mon, const QDict *qdict)
A
aurel32 已提交
890 891 892 893
{
    FILE *f;
    uint32_t l;
    uint8_t buf[1024];
894 895 896
    uint32_t size = qdict_get_int(qdict, "size");
    const char *filename = qdict_get_str(qdict, "filename");
    target_phys_addr_t addr = qdict_get_int(qdict, "val");
A
aurel32 已提交
897 898 899

    f = fopen(filename, "wb");
    if (!f) {
A
aliguori 已提交
900
        monitor_printf(mon, "could not open '%s'\n", filename);
A
aurel32 已提交
901 902 903 904 905 906 907 908 909 910 911 912 913 914 915
        return;
    }
    while (size != 0) {
        l = sizeof(buf);
        if (l > size)
            l = size;
        cpu_physical_memory_rw(addr, buf, l, 0);
        fwrite(buf, 1, l, f);
        fflush(f);
        addr += l;
        size -= l;
    }
    fclose(f);
}

916
static void do_sum(Monitor *mon, const QDict *qdict)
B
bellard 已提交
917 918 919 920
{
    uint32_t addr;
    uint8_t buf[1];
    uint16_t sum;
921 922
    uint32_t start = qdict_get_int(qdict, "start");
    uint32_t size = qdict_get_int(qdict, "size");
B
bellard 已提交
923 924 925 926 927 928 929 930

    sum = 0;
    for(addr = start; addr < (start + size); addr++) {
        cpu_physical_memory_rw(addr, buf, 1, 0);
        /* BSD sum algorithm ('sum' Unix command) */
        sum = (sum >> 1) | (sum << 15);
        sum += buf[0];
    }
A
aliguori 已提交
931
    monitor_printf(mon, "%05d\n", sum);
B
bellard 已提交
932 933
}

B
bellard 已提交
934 935 936 937 938 939 940 941
typedef struct {
    int keycode;
    const char *name;
} KeyDef;

static const KeyDef key_defs[] = {
    { 0x2a, "shift" },
    { 0x36, "shift_r" },
942

B
bellard 已提交
943 944
    { 0x38, "alt" },
    { 0xb8, "alt_r" },
945 946
    { 0x64, "altgr" },
    { 0xe4, "altgr_r" },
B
bellard 已提交
947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963
    { 0x1d, "ctrl" },
    { 0x9d, "ctrl_r" },

    { 0xdd, "menu" },

    { 0x01, "esc" },

    { 0x02, "1" },
    { 0x03, "2" },
    { 0x04, "3" },
    { 0x05, "4" },
    { 0x06, "5" },
    { 0x07, "6" },
    { 0x08, "7" },
    { 0x09, "8" },
    { 0x0a, "9" },
    { 0x0b, "0" },
964 965
    { 0x0c, "minus" },
    { 0x0d, "equal" },
B
bellard 已提交
966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998
    { 0x0e, "backspace" },

    { 0x0f, "tab" },
    { 0x10, "q" },
    { 0x11, "w" },
    { 0x12, "e" },
    { 0x13, "r" },
    { 0x14, "t" },
    { 0x15, "y" },
    { 0x16, "u" },
    { 0x17, "i" },
    { 0x18, "o" },
    { 0x19, "p" },

    { 0x1c, "ret" },

    { 0x1e, "a" },
    { 0x1f, "s" },
    { 0x20, "d" },
    { 0x21, "f" },
    { 0x22, "g" },
    { 0x23, "h" },
    { 0x24, "j" },
    { 0x25, "k" },
    { 0x26, "l" },

    { 0x2c, "z" },
    { 0x2d, "x" },
    { 0x2e, "c" },
    { 0x2f, "v" },
    { 0x30, "b" },
    { 0x31, "n" },
    { 0x32, "m" },
999 1000 1001
    { 0x33, "comma" },
    { 0x34, "dot" },
    { 0x35, "slash" },
1002

B
balrog 已提交
1003 1004
    { 0x37, "asterisk" },

B
bellard 已提交
1005
    { 0x39, "spc" },
B
bellard 已提交
1006
    { 0x3a, "caps_lock" },
B
bellard 已提交
1007 1008 1009 1010 1011 1012 1013 1014 1015 1016
    { 0x3b, "f1" },
    { 0x3c, "f2" },
    { 0x3d, "f3" },
    { 0x3e, "f4" },
    { 0x3f, "f5" },
    { 0x40, "f6" },
    { 0x41, "f7" },
    { 0x42, "f8" },
    { 0x43, "f9" },
    { 0x44, "f10" },
B
bellard 已提交
1017
    { 0x45, "num_lock" },
B
bellard 已提交
1018 1019
    { 0x46, "scroll_lock" },

1020 1021
    { 0xb5, "kp_divide" },
    { 0x37, "kp_multiply" },
T
ths 已提交
1022
    { 0x4a, "kp_subtract" },
1023 1024 1025
    { 0x4e, "kp_add" },
    { 0x9c, "kp_enter" },
    { 0x53, "kp_decimal" },
1026
    { 0x54, "sysrq" },
1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037

    { 0x52, "kp_0" },
    { 0x4f, "kp_1" },
    { 0x50, "kp_2" },
    { 0x51, "kp_3" },
    { 0x4b, "kp_4" },
    { 0x4c, "kp_5" },
    { 0x4d, "kp_6" },
    { 0x47, "kp_7" },
    { 0x48, "kp_8" },
    { 0x49, "kp_9" },
1038

B
bellard 已提交
1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057
    { 0x56, "<" },

    { 0x57, "f11" },
    { 0x58, "f12" },

    { 0xb7, "print" },

    { 0xc7, "home" },
    { 0xc9, "pgup" },
    { 0xd1, "pgdn" },
    { 0xcf, "end" },

    { 0xcb, "left" },
    { 0xc8, "up" },
    { 0xd0, "down" },
    { 0xcd, "right" },

    { 0xd2, "insert" },
    { 0xd3, "delete" },
1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074
#if defined(TARGET_SPARC) && !defined(TARGET_SPARC64)
    { 0xf0, "stop" },
    { 0xf1, "again" },
    { 0xf2, "props" },
    { 0xf3, "undo" },
    { 0xf4, "front" },
    { 0xf5, "copy" },
    { 0xf6, "open" },
    { 0xf7, "paste" },
    { 0xf8, "find" },
    { 0xf9, "cut" },
    { 0xfa, "lf" },
    { 0xfb, "help" },
    { 0xfc, "meta_l" },
    { 0xfd, "meta_r" },
    { 0xfe, "compose" },
#endif
B
bellard 已提交
1075 1076 1077 1078 1079 1080
    { 0, NULL },
};

static int get_keycode(const char *key)
{
    const KeyDef *p;
1081 1082
    char *endp;
    int ret;
B
bellard 已提交
1083 1084 1085 1086 1087

    for(p = key_defs; p->name != NULL; p++) {
        if (!strcmp(key, p->name))
            return p->keycode;
    }
1088 1089 1090 1091 1092
    if (strstart(key, "0x", NULL)) {
        ret = strtoul(key, &endp, 0);
        if (*endp == '\0' && ret >= 0x01 && ret <= 0xff)
            return ret;
    }
B
bellard 已提交
1093 1094 1095
    return -1;
}

1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113
#define MAX_KEYCODES 16
static uint8_t keycodes[MAX_KEYCODES];
static int nb_pending_keycodes;
static QEMUTimer *key_timer;

static void release_keys(void *opaque)
{
    int keycode;

    while (nb_pending_keycodes > 0) {
        nb_pending_keycodes--;
        keycode = keycodes[nb_pending_keycodes];
        if (keycode & 0x80)
            kbd_put_keycode(0xe0);
        kbd_put_keycode(keycode | 0x80);
    }
}

1114
static void do_sendkey(Monitor *mon, const QDict *qdict)
B
bellard 已提交
1115
{
1116 1117 1118
    char keyname_buf[16];
    char *separator;
    int keyname_len, keycode, i;
1119 1120 1121
    const char *string = qdict_get_str(qdict, "string");
    int has_hold_time = qdict_haskey(qdict, "hold_time");
    int hold_time = qdict_get_try_int(qdict, "hold_time", -1);
1122

1123 1124 1125 1126 1127 1128 1129
    if (nb_pending_keycodes > 0) {
        qemu_del_timer(key_timer);
        release_keys(NULL);
    }
    if (!has_hold_time)
        hold_time = 100;
    i = 0;
1130 1131 1132 1133 1134 1135
    while (1) {
        separator = strchr(string, '-');
        keyname_len = separator ? separator - string : strlen(string);
        if (keyname_len > 0) {
            pstrcpy(keyname_buf, sizeof(keyname_buf), string);
            if (keyname_len > sizeof(keyname_buf) - 1) {
A
aliguori 已提交
1136
                monitor_printf(mon, "invalid key: '%s...'\n", keyname_buf);
1137
                return;
B
bellard 已提交
1138
            }
1139
            if (i == MAX_KEYCODES) {
A
aliguori 已提交
1140
                monitor_printf(mon, "too many keys\n");
1141 1142 1143 1144 1145
                return;
            }
            keyname_buf[keyname_len] = 0;
            keycode = get_keycode(keyname_buf);
            if (keycode < 0) {
A
aliguori 已提交
1146
                monitor_printf(mon, "unknown key: '%s'\n", keyname_buf);
1147 1148
                return;
            }
1149
            keycodes[i++] = keycode;
B
bellard 已提交
1150
        }
1151
        if (!separator)
B
bellard 已提交
1152
            break;
1153
        string = separator + 1;
B
bellard 已提交
1154
    }
1155
    nb_pending_keycodes = i;
B
bellard 已提交
1156
    /* key down events */
1157
    for (i = 0; i < nb_pending_keycodes; i++) {
B
bellard 已提交
1158 1159 1160 1161 1162
        keycode = keycodes[i];
        if (keycode & 0x80)
            kbd_put_keycode(0xe0);
        kbd_put_keycode(keycode & 0x7f);
    }
1163
    /* delayed key up events */
1164 1165
    qemu_mod_timer(key_timer, qemu_get_clock(vm_clock) +
                    muldiv64(ticks_per_sec, hold_time, 1000));
B
bellard 已提交
1166 1167
}

B
bellard 已提交
1168 1169
static int mouse_button_state;

1170
static void do_mouse_move(Monitor *mon, const QDict *qdict)
B
bellard 已提交
1171 1172
{
    int dx, dy, dz;
1173 1174 1175
    const char *dx_str = qdict_get_str(qdict, "dx_str");
    const char *dy_str = qdict_get_str(qdict, "dy_str");
    const char *dz_str = qdict_get_try_str(qdict, "dz_str");
B
bellard 已提交
1176 1177 1178
    dx = strtol(dx_str, NULL, 0);
    dy = strtol(dy_str, NULL, 0);
    dz = 0;
1179
    if (dz_str)
B
bellard 已提交
1180 1181 1182 1183
        dz = strtol(dz_str, NULL, 0);
    kbd_mouse_event(dx, dy, dz, mouse_button_state);
}

1184
static void do_mouse_button(Monitor *mon, const QDict *qdict)
B
bellard 已提交
1185
{
1186
    int button_state = qdict_get_int(qdict, "button_state");
B
bellard 已提交
1187 1188 1189 1190
    mouse_button_state = button_state;
    kbd_mouse_event(0, 0, 0, mouse_button_state);
}

1191
static void do_ioport_read(Monitor *mon, const QDict *qdict)
B
bellard 已提交
1192
{
1193 1194 1195
    int size = qdict_get_int(qdict, "size");
    int addr = qdict_get_int(qdict, "addr");
    int has_index = qdict_haskey(qdict, "index");
B
bellard 已提交
1196 1197 1198 1199
    uint32_t val;
    int suffix;

    if (has_index) {
1200
        int index = qdict_get_int(qdict, "index");
1201
        cpu_outb(NULL, addr & IOPORTS_MASK, index & 0xff);
B
bellard 已提交
1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220
        addr++;
    }
    addr &= 0xffff;

    switch(size) {
    default:
    case 1:
        val = cpu_inb(NULL, addr);
        suffix = 'b';
        break;
    case 2:
        val = cpu_inw(NULL, addr);
        suffix = 'w';
        break;
    case 4:
        val = cpu_inl(NULL, addr);
        suffix = 'l';
        break;
    }
A
aliguori 已提交
1221 1222
    monitor_printf(mon, "port%c[0x%04x] = %#0*x\n",
                   suffix, addr, size * 2, val);
B
bellard 已提交
1223
}
B
bellard 已提交
1224

1225
static void do_ioport_write(Monitor *mon, const QDict *qdict)
J
Jan Kiszka 已提交
1226
{
1227 1228 1229 1230
    int size = qdict_get_int(qdict, "size");
    int addr = qdict_get_int(qdict, "addr");
    int val = qdict_get_int(qdict, "val");

J
Jan Kiszka 已提交
1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246
    addr &= IOPORTS_MASK;

    switch (size) {
    default:
    case 1:
        cpu_outb(NULL, addr, val);
        break;
    case 2:
        cpu_outw(NULL, addr, val);
        break;
    case 4:
        cpu_outl(NULL, addr, val);
        break;
    }
}

1247
static void do_boot_set(Monitor *mon, const QDict *qdict)
1248 1249
{
    int res;
1250
    const char *bootdevice = qdict_get_str(qdict, "bootdevice");
1251

J
Jan Kiszka 已提交
1252 1253 1254 1255 1256
    res = qemu_boot_set(bootdevice);
    if (res == 0) {
        monitor_printf(mon, "boot device list now set to %s\n", bootdevice);
    } else if (res > 0) {
        monitor_printf(mon, "setting boot device list failed\n");
1257
    } else {
A
aliguori 已提交
1258 1259
        monitor_printf(mon, "no function defined to set boot device list for "
                       "this architecture\n");
1260 1261 1262
    }
}

1263
static void do_system_reset(Monitor *mon, const QDict *qdict)
B
bellard 已提交
1264 1265 1266 1267
{
    qemu_system_reset_request();
}

1268
static void do_system_powerdown(Monitor *mon, const QDict *qdict)
B
bellard 已提交
1269 1270 1271 1272
{
    qemu_system_powerdown_request();
}

B
bellard 已提交
1273
#if defined(TARGET_I386)
A
aliguori 已提交
1274
static void print_pte(Monitor *mon, uint32_t addr, uint32_t pte, uint32_t mask)
B
bellard 已提交
1275
{
A
aliguori 已提交
1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286
    monitor_printf(mon, "%08x: %08x %c%c%c%c%c%c%c%c\n",
                   addr,
                   pte & mask,
                   pte & PG_GLOBAL_MASK ? 'G' : '-',
                   pte & PG_PSE_MASK ? 'P' : '-',
                   pte & PG_DIRTY_MASK ? 'D' : '-',
                   pte & PG_ACCESSED_MASK ? 'A' : '-',
                   pte & PG_PCD_MASK ? 'C' : '-',
                   pte & PG_PWT_MASK ? 'T' : '-',
                   pte & PG_USER_MASK ? 'U' : '-',
                   pte & PG_RW_MASK ? 'W' : '-');
B
bellard 已提交
1287 1288
}

A
aliguori 已提交
1289
static void tlb_info(Monitor *mon)
B
bellard 已提交
1290
{
B
bellard 已提交
1291
    CPUState *env;
B
bellard 已提交
1292 1293 1294
    int l1, l2;
    uint32_t pgd, pde, pte;

B
bellard 已提交
1295 1296 1297 1298
    env = mon_get_cpu();
    if (!env)
        return;

B
bellard 已提交
1299
    if (!(env->cr[0] & CR0_PG_MASK)) {
A
aliguori 已提交
1300
        monitor_printf(mon, "PG disabled\n");
B
bellard 已提交
1301 1302 1303 1304 1305 1306 1307 1308
        return;
    }
    pgd = env->cr[3] & ~0xfff;
    for(l1 = 0; l1 < 1024; l1++) {
        cpu_physical_memory_read(pgd + l1 * 4, (uint8_t *)&pde, 4);
        pde = le32_to_cpu(pde);
        if (pde & PG_PRESENT_MASK) {
            if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) {
A
aliguori 已提交
1309
                print_pte(mon, (l1 << 22), pde, ~((1 << 20) - 1));
B
bellard 已提交
1310 1311
            } else {
                for(l2 = 0; l2 < 1024; l2++) {
1312
                    cpu_physical_memory_read((pde & ~0xfff) + l2 * 4,
B
bellard 已提交
1313 1314 1315
                                             (uint8_t *)&pte, 4);
                    pte = le32_to_cpu(pte);
                    if (pte & PG_PRESENT_MASK) {
A
aliguori 已提交
1316
                        print_pte(mon, (l1 << 22) + (l2 << 12),
1317
                                  pte & ~PG_PSE_MASK,
B
bellard 已提交
1318 1319 1320 1321 1322 1323 1324 1325
                                  ~0xfff);
                    }
                }
            }
        }
    }
}

A
aliguori 已提交
1326
static void mem_print(Monitor *mon, uint32_t *pstart, int *plast_prot,
B
bellard 已提交
1327 1328
                      uint32_t end, int prot)
{
B
bellard 已提交
1329 1330 1331
    int prot1;
    prot1 = *plast_prot;
    if (prot != prot1) {
B
bellard 已提交
1332
        if (*pstart != -1) {
A
aliguori 已提交
1333 1334 1335 1336 1337
            monitor_printf(mon, "%08x-%08x %08x %c%c%c\n",
                           *pstart, end, end - *pstart,
                           prot1 & PG_USER_MASK ? 'u' : '-',
                           'r',
                           prot1 & PG_RW_MASK ? 'w' : '-');
B
bellard 已提交
1338 1339 1340 1341 1342 1343 1344 1345 1346
        }
        if (prot != 0)
            *pstart = end;
        else
            *pstart = -1;
        *plast_prot = prot;
    }
}

A
aliguori 已提交
1347
static void mem_info(Monitor *mon)
B
bellard 已提交
1348
{
B
bellard 已提交
1349
    CPUState *env;
B
bellard 已提交
1350 1351 1352
    int l1, l2, prot, last_prot;
    uint32_t pgd, pde, pte, start, end;

B
bellard 已提交
1353 1354 1355 1356
    env = mon_get_cpu();
    if (!env)
        return;

B
bellard 已提交
1357
    if (!(env->cr[0] & CR0_PG_MASK)) {
A
aliguori 已提交
1358
        monitor_printf(mon, "PG disabled\n");
B
bellard 已提交
1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370
        return;
    }
    pgd = env->cr[3] & ~0xfff;
    last_prot = 0;
    start = -1;
    for(l1 = 0; l1 < 1024; l1++) {
        cpu_physical_memory_read(pgd + l1 * 4, (uint8_t *)&pde, 4);
        pde = le32_to_cpu(pde);
        end = l1 << 22;
        if (pde & PG_PRESENT_MASK) {
            if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) {
                prot = pde & (PG_USER_MASK | PG_RW_MASK | PG_PRESENT_MASK);
A
aliguori 已提交
1371
                mem_print(mon, &start, &last_prot, end, prot);
B
bellard 已提交
1372 1373
            } else {
                for(l2 = 0; l2 < 1024; l2++) {
1374
                    cpu_physical_memory_read((pde & ~0xfff) + l2 * 4,
B
bellard 已提交
1375 1376 1377 1378 1379 1380 1381 1382
                                             (uint8_t *)&pte, 4);
                    pte = le32_to_cpu(pte);
                    end = (l1 << 22) + (l2 << 12);
                    if (pte & PG_PRESENT_MASK) {
                        prot = pte & (PG_USER_MASK | PG_RW_MASK | PG_PRESENT_MASK);
                    } else {
                        prot = 0;
                    }
A
aliguori 已提交
1383
                    mem_print(mon, &start, &last_prot, end, prot);
B
bellard 已提交
1384 1385 1386 1387
                }
            }
        } else {
            prot = 0;
A
aliguori 已提交
1388
            mem_print(mon, &start, &last_prot, end, prot);
B
bellard 已提交
1389 1390 1391 1392 1393
        }
    }
}
#endif

A
aurel32 已提交
1394 1395
#if defined(TARGET_SH4)

A
aliguori 已提交
1396
static void print_tlb(Monitor *mon, int idx, tlb_t *tlb)
A
aurel32 已提交
1397
{
A
aliguori 已提交
1398 1399 1400 1401 1402 1403 1404 1405
    monitor_printf(mon, " tlb%i:\t"
                   "asid=%hhu vpn=%x\tppn=%x\tsz=%hhu size=%u\t"
                   "v=%hhu shared=%hhu cached=%hhu prot=%hhu "
                   "dirty=%hhu writethrough=%hhu\n",
                   idx,
                   tlb->asid, tlb->vpn, tlb->ppn, tlb->sz, tlb->size,
                   tlb->v, tlb->sh, tlb->c, tlb->pr,
                   tlb->d, tlb->wt);
A
aurel32 已提交
1406 1407
}

A
aliguori 已提交
1408
static void tlb_info(Monitor *mon)
A
aurel32 已提交
1409 1410 1411 1412
{
    CPUState *env = mon_get_cpu();
    int i;

A
aliguori 已提交
1413
    monitor_printf (mon, "ITLB:\n");
A
aurel32 已提交
1414
    for (i = 0 ; i < ITLB_SIZE ; i++)
A
aliguori 已提交
1415 1416
        print_tlb (mon, i, &env->itlb[i]);
    monitor_printf (mon, "UTLB:\n");
A
aurel32 已提交
1417
    for (i = 0 ; i < UTLB_SIZE ; i++)
A
aliguori 已提交
1418
        print_tlb (mon, i, &env->utlb[i]);
A
aurel32 已提交
1419 1420 1421 1422
}

#endif

A
aliguori 已提交
1423
static void do_info_kvm(Monitor *mon)
A
aliguori 已提交
1424 1425
{
#ifdef CONFIG_KVM
A
aliguori 已提交
1426
    monitor_printf(mon, "kvm support: ");
A
aliguori 已提交
1427
    if (kvm_enabled())
A
aliguori 已提交
1428
        monitor_printf(mon, "enabled\n");
A
aliguori 已提交
1429
    else
A
aliguori 已提交
1430
        monitor_printf(mon, "disabled\n");
A
aliguori 已提交
1431
#else
A
aliguori 已提交
1432
    monitor_printf(mon, "kvm support: not compiled\n");
A
aliguori 已提交
1433 1434 1435
#endif
}

1436 1437
static void do_info_numa(Monitor *mon)
{
1438
    int i;
1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454
    CPUState *env;

    monitor_printf(mon, "%d nodes\n", nb_numa_nodes);
    for (i = 0; i < nb_numa_nodes; i++) {
        monitor_printf(mon, "node %d cpus:", i);
        for (env = first_cpu; env != NULL; env = env->next_cpu) {
            if (env->numa_node == i) {
                monitor_printf(mon, " %d", env->cpu_index);
            }
        }
        monitor_printf(mon, "\n");
        monitor_printf(mon, "node %d size: %" PRId64 " MB\n", i,
            node_mem[i] >> 20);
    }
}

B
bellard 已提交
1455 1456
#ifdef CONFIG_PROFILER

A
aliguori 已提交
1457
static void do_info_profile(Monitor *mon)
B
bellard 已提交
1458 1459 1460 1461 1462
{
    int64_t total;
    total = qemu_time;
    if (total == 0)
        total = 1;
A
aliguori 已提交
1463 1464 1465 1466
    monitor_printf(mon, "async time  %" PRId64 " (%0.3f)\n",
                   dev_time, dev_time / (double)ticks_per_sec);
    monitor_printf(mon, "qemu time   %" PRId64 " (%0.3f)\n",
                   qemu_time, qemu_time / (double)ticks_per_sec);
B
bellard 已提交
1467 1468 1469 1470
    qemu_time = 0;
    dev_time = 0;
}
#else
A
aliguori 已提交
1471
static void do_info_profile(Monitor *mon)
B
bellard 已提交
1472
{
A
aliguori 已提交
1473
    monitor_printf(mon, "Internal profiler not compiled\n");
B
bellard 已提交
1474 1475 1476
}
#endif

B
bellard 已提交
1477 1478 1479
/* Capture support */
static LIST_HEAD (capture_list_head, CaptureState) capture_head;

A
aliguori 已提交
1480
static void do_info_capture(Monitor *mon)
B
bellard 已提交
1481 1482 1483 1484 1485
{
    int i;
    CaptureState *s;

    for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
A
aliguori 已提交
1486
        monitor_printf(mon, "[%d]: ", i);
B
bellard 已提交
1487 1488 1489 1490
        s->ops.info (s->opaque);
    }
}

1491
#ifdef HAS_AUDIO
1492
static void do_stop_capture(Monitor *mon, const QDict *qdict)
B
bellard 已提交
1493 1494
{
    int i;
1495
    int n = qdict_get_int(qdict, "n");
B
bellard 已提交
1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507
    CaptureState *s;

    for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
        if (i == n) {
            s->ops.destroy (s->opaque);
            LIST_REMOVE (s, entries);
            qemu_free (s);
            return;
        }
    }
}

1508 1509 1510 1511 1512 1513 1514 1515 1516
static void do_wav_capture(Monitor *mon, const QDict *qdict)
{
    const char *path = qdict_get_str(qdict, "path");
    int has_freq = qdict_haskey(qdict, "freq");
    int freq = qdict_get_try_int(qdict, "freq", -1);
    int has_bits = qdict_haskey(qdict, "bits");
    int bits = qdict_get_try_int(qdict, "bits", -1);
    int has_channels = qdict_haskey(qdict, "nchannels");
    int nchannels = qdict_get_try_int(qdict, "nchannels", -1);
B
bellard 已提交
1517 1518 1519 1520 1521 1522 1523 1524 1525
    CaptureState *s;

    s = qemu_mallocz (sizeof (*s));

    freq = has_freq ? freq : 44100;
    bits = has_bits ? bits : 16;
    nchannels = has_channels ? nchannels : 2;

    if (wav_start_capture (s, path, freq, bits, nchannels)) {
A
aliguori 已提交
1526
        monitor_printf(mon, "Faied to add wave capture\n");
B
bellard 已提交
1527 1528 1529 1530 1531 1532
        qemu_free (s);
    }
    LIST_INSERT_HEAD (&capture_head, s, entries);
}
#endif

A
aurel32 已提交
1533
#if defined(TARGET_I386)
1534
static void do_inject_nmi(Monitor *mon, const QDict *qdict)
A
aurel32 已提交
1535 1536
{
    CPUState *env;
1537
    int cpu_index = qdict_get_int(qdict, "cpu_index");
A
aurel32 已提交
1538 1539 1540 1541 1542 1543 1544 1545 1546

    for (env = first_cpu; env != NULL; env = env->next_cpu)
        if (env->cpu_index == cpu_index) {
            cpu_interrupt(env, CPU_INTERRUPT_NMI);
            break;
        }
}
#endif

A
aliguori 已提交
1547
static void do_info_status(Monitor *mon)
A
aurel32 已提交
1548
{
1549 1550 1551 1552 1553 1554 1555
    if (vm_running) {
        if (singlestep) {
            monitor_printf(mon, "VM status: running (single step mode)\n");
        } else {
            monitor_printf(mon, "VM status: running\n");
        }
    } else
A
aliguori 已提交
1556
       monitor_printf(mon, "VM status: paused\n");
A
aurel32 已提交
1557 1558 1559
}


1560
static void do_balloon(Monitor *mon, const QDict *qdict)
A
aliguori 已提交
1561
{
1562
    int value = qdict_get_int(qdict, "value");
A
aliguori 已提交
1563 1564 1565 1566
    ram_addr_t target = value;
    qemu_balloon(target << 20);
}

A
aliguori 已提交
1567
static void do_info_balloon(Monitor *mon)
A
aliguori 已提交
1568 1569 1570 1571
{
    ram_addr_t actual;

    actual = qemu_balloon_status();
A
aliguori 已提交
1572
    if (kvm_enabled() && !kvm_has_sync_mmu())
A
aliguori 已提交
1573 1574
        monitor_printf(mon, "Using KVM without synchronous MMU, "
                       "ballooning disabled\n");
A
aliguori 已提交
1575
    else if (actual == 0)
A
aliguori 已提交
1576
        monitor_printf(mon, "Ballooning not activated in VM\n");
A
aliguori 已提交
1577
    else
A
aliguori 已提交
1578
        monitor_printf(mon, "balloon: actual=%d\n", (int)(actual >> 20));
A
aliguori 已提交
1579 1580
}

J
Jan Kiszka 已提交
1581
static qemu_acl *find_acl(Monitor *mon, const char *name)
1582
{
J
Jan Kiszka 已提交
1583
    qemu_acl *acl = qemu_acl_find(name);
1584 1585

    if (!acl) {
J
Jan Kiszka 已提交
1586
        monitor_printf(mon, "acl: unknown list '%s'\n", name);
1587
    }
J
Jan Kiszka 已提交
1588 1589 1590
    return acl;
}

1591
static void do_acl_show(Monitor *mon, const QDict *qdict)
J
Jan Kiszka 已提交
1592
{
1593
    const char *aclname = qdict_get_str(qdict, "aclname");
J
Jan Kiszka 已提交
1594 1595 1596
    qemu_acl *acl = find_acl(mon, aclname);
    qemu_acl_entry *entry;
    int i = 0;
1597

J
Jan Kiszka 已提交
1598
    if (acl) {
1599
        monitor_printf(mon, "policy: %s\n",
1600
                       acl->defaultDeny ? "deny" : "allow");
1601 1602 1603
        TAILQ_FOREACH(entry, &acl->entries, next) {
            i++;
            monitor_printf(mon, "%d: %s %s\n", i,
J
Jan Kiszka 已提交
1604
                           entry->deny ? "deny" : "allow", entry->match);
1605
        }
J
Jan Kiszka 已提交
1606 1607 1608
    }
}

1609
static void do_acl_reset(Monitor *mon, const QDict *qdict)
J
Jan Kiszka 已提交
1610
{
1611
    const char *aclname = qdict_get_str(qdict, "aclname");
J
Jan Kiszka 已提交
1612 1613 1614
    qemu_acl *acl = find_acl(mon, aclname);

    if (acl) {
1615 1616
        qemu_acl_reset(acl);
        monitor_printf(mon, "acl: removed all rules\n");
J
Jan Kiszka 已提交
1617 1618 1619
    }
}

1620
static void do_acl_policy(Monitor *mon, const QDict *qdict)
J
Jan Kiszka 已提交
1621
{
1622 1623
    const char *aclname = qdict_get_str(qdict, "aclname");
    const char *policy = qdict_get_str(qdict, "policy");
J
Jan Kiszka 已提交
1624
    qemu_acl *acl = find_acl(mon, aclname);
1625

J
Jan Kiszka 已提交
1626 1627
    if (acl) {
        if (strcmp(policy, "allow") == 0) {
1628 1629
            acl->defaultDeny = 0;
            monitor_printf(mon, "acl: policy set to 'allow'\n");
J
Jan Kiszka 已提交
1630
        } else if (strcmp(policy, "deny") == 0) {
1631 1632 1633
            acl->defaultDeny = 1;
            monitor_printf(mon, "acl: policy set to 'deny'\n");
        } else {
J
Jan Kiszka 已提交
1634 1635
            monitor_printf(mon, "acl: unknown policy '%s', "
                           "expected 'deny' or 'allow'\n", policy);
1636
        }
J
Jan Kiszka 已提交
1637 1638
    }
}
1639

1640
static void do_acl_add(Monitor *mon, const QDict *qdict)
J
Jan Kiszka 已提交
1641
{
1642 1643 1644 1645 1646
    const char *aclname = qdict_get_str(qdict, "aclname");
    const char *match = qdict_get_str(qdict, "match");
    const char *policy = qdict_get_str(qdict, "policy");
    int has_index = qdict_haskey(qdict, "index");
    int index = qdict_get_try_int(qdict, "index", -1);
J
Jan Kiszka 已提交
1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657
    qemu_acl *acl = find_acl(mon, aclname);
    int deny, ret;

    if (acl) {
        if (strcmp(policy, "allow") == 0) {
            deny = 0;
        } else if (strcmp(policy, "deny") == 0) {
            deny = 1;
        } else {
            monitor_printf(mon, "acl: unknown policy '%s', "
                           "expected 'deny' or 'allow'\n", policy);
1658 1659 1660 1661 1662 1663 1664 1665 1666 1667
            return;
        }
        if (has_index)
            ret = qemu_acl_insert(acl, deny, match, index);
        else
            ret = qemu_acl_append(acl, deny, match);
        if (ret < 0)
            monitor_printf(mon, "acl: unable to add acl entry\n");
        else
            monitor_printf(mon, "acl: added rule at position %d\n", ret);
J
Jan Kiszka 已提交
1668 1669
    }
}
1670

1671
static void do_acl_remove(Monitor *mon, const QDict *qdict)
J
Jan Kiszka 已提交
1672
{
1673 1674
    const char *aclname = qdict_get_str(qdict, "aclname");
    const char *match = qdict_get_str(qdict, "match");
J
Jan Kiszka 已提交
1675 1676
    qemu_acl *acl = find_acl(mon, aclname);
    int ret;
1677

J
Jan Kiszka 已提交
1678
    if (acl) {
1679 1680 1681 1682 1683
        ret = qemu_acl_remove(acl, match);
        if (ret < 0)
            monitor_printf(mon, "acl: no matching acl entry\n");
        else
            monitor_printf(mon, "acl: removed rule at position %d\n", ret);
1684 1685 1686
    }
}

1687
#if defined(TARGET_I386)
1688
static void do_inject_mce(Monitor *mon, const QDict *qdict)
1689 1690
{
    CPUState *cenv;
1691 1692 1693 1694 1695 1696
    int cpu_index = qdict_get_int(qdict, "cpu_index");
    int bank = qdict_get_int(qdict, "bank");
    uint64_t status = qdict_get_int(qdict, "status");
    uint64_t mcg_status = qdict_get_int(qdict, "mcg_status");
    uint64_t addr = qdict_get_int(qdict, "addr");
    uint64_t misc = qdict_get_int(qdict, "misc");
1697 1698 1699 1700 1701 1702 1703 1704 1705

    for (cenv = first_cpu; cenv != NULL; cenv = cenv->next_cpu)
        if (cenv->cpu_index == cpu_index && cenv->mcg_cap) {
            cpu_inject_x86_mce(cenv, bank, status, mcg_status, addr, misc);
            break;
        }
}
#endif

1706
static void do_getfd(Monitor *mon, const QDict *qdict)
1707
{
1708
    const char *fdname = qdict_get_str(qdict, "fdname");
1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746
    mon_fd_t *monfd;
    int fd;

    fd = qemu_chr_get_msgfd(mon->chr);
    if (fd == -1) {
        monitor_printf(mon, "getfd: no file descriptor supplied via SCM_RIGHTS\n");
        return;
    }

    if (qemu_isdigit(fdname[0])) {
        monitor_printf(mon, "getfd: monitor names may not begin with a number\n");
        return;
    }

    fd = dup(fd);
    if (fd == -1) {
        monitor_printf(mon, "Failed to dup() file descriptor: %s\n",
                       strerror(errno));
        return;
    }

    LIST_FOREACH(monfd, &mon->fds, next) {
        if (strcmp(monfd->name, fdname) != 0) {
            continue;
        }

        close(monfd->fd);
        monfd->fd = fd;
        return;
    }

    monfd = qemu_mallocz(sizeof(mon_fd_t));
    monfd->name = qemu_strdup(fdname);
    monfd->fd = fd;

    LIST_INSERT_HEAD(&mon->fds, monfd, next);
}

1747
static void do_closefd(Monitor *mon, const QDict *qdict)
1748
{
1749
    const char *fdname = qdict_get_str(qdict, "fdname");
1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767
    mon_fd_t *monfd;

    LIST_FOREACH(monfd, &mon->fds, next) {
        if (strcmp(monfd->name, fdname) != 0) {
            continue;
        }

        LIST_REMOVE(monfd, next);
        close(monfd->fd);
        qemu_free(monfd->name);
        qemu_free(monfd);
        return;
    }

    monitor_printf(mon, "Failed to find file descriptor named %s\n",
                   fdname);
}

1768
static void do_loadvm(Monitor *mon, const QDict *qdict)
J
Juan Quintela 已提交
1769 1770
{
    int saved_vm_running  = vm_running;
1771
    const char *name = qdict_get_str(qdict, "name");
J
Juan Quintela 已提交
1772 1773 1774

    vm_stop(0);

1775
    if (load_vmstate(mon, name) >= 0 && saved_vm_running)
J
Juan Quintela 已提交
1776 1777 1778
        vm_start();
}

1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802
int monitor_get_fd(Monitor *mon, const char *fdname)
{
    mon_fd_t *monfd;

    LIST_FOREACH(monfd, &mon->fds, next) {
        int fd;

        if (strcmp(monfd->name, fdname) != 0) {
            continue;
        }

        fd = monfd->fd;

        /* caller takes ownership of fd */
        LIST_REMOVE(monfd, next);
        qemu_free(monfd->name);
        qemu_free(monfd);

        return fd;
    }

    return -1;
}

A
aliguori 已提交
1803
static const mon_cmd_t mon_cmds[] = {
1804
#include "qemu-monitor.h"
1805
    { NULL, NULL, },
B
bellard 已提交
1806 1807
};

1808
/* Please update qemu-monitor.hx when adding or changing commands */
A
aliguori 已提交
1809
static const mon_cmd_t info_cmds[] = {
B
bellard 已提交
1810
    { "version", "", do_info_version,
B
blueswir1 已提交
1811
      "", "show the version of QEMU" },
1812
    { "network", "", do_info_network,
B
bellard 已提交
1813
      "", "show the network state" },
1814 1815
    { "chardev", "", qemu_chr_info,
      "", "show the character devices" },
A
aliguori 已提交
1816
    { "block", "", bdrv_info,
B
bellard 已提交
1817
      "", "show the block devices" },
A
aliguori 已提交
1818
    { "blockstats", "", bdrv_info_stats,
1819
      "", "show block device statistics" },
1820 1821
    { "registers", "", do_info_registers,
      "", "show the cpu registers" },
B
bellard 已提交
1822 1823
    { "cpus", "", do_info_cpus,
      "", "show infos for each CPU" },
B
bellard 已提交
1824 1825
    { "history", "", do_info_history,
      "", "show the command line history", },
1826 1827
    { "irq", "", irq_info,
      "", "show the interrupts statistics (if available)", },
1828 1829
    { "pic", "", pic_info,
      "", "show i8259 (PIC) state", },
B
bellard 已提交
1830 1831
    { "pci", "", pci_info,
      "", "show PCI info", },
A
aurel32 已提交
1832
#if defined(TARGET_I386) || defined(TARGET_SH4)
B
bellard 已提交
1833 1834
    { "tlb", "", tlb_info,
      "", "show virtual to physical memory mappings", },
A
aurel32 已提交
1835 1836
#endif
#if defined(TARGET_I386)
B
bellard 已提交
1837 1838
    { "mem", "", mem_info,
      "", "show the active virtual memory mappings", },
A
aliguori 已提交
1839 1840
    { "hpet", "", do_info_hpet,
      "", "show state of HPET", },
B
bellard 已提交
1841
#endif
B
bellard 已提交
1842 1843
    { "jit", "", do_info_jit,
      "", "show dynamic compiler info", },
A
aliguori 已提交
1844
    { "kvm", "", do_info_kvm,
B
blueswir1 已提交
1845
      "", "show KVM information", },
1846 1847
    { "numa", "", do_info_numa,
      "", "show NUMA information", },
B
bellard 已提交
1848 1849 1850 1851
    { "usb", "", usb_info,
      "", "show guest USB devices", },
    { "usbhost", "", usb_host_info,
      "", "show host USB devices", },
B
bellard 已提交
1852 1853
    { "profile", "", do_info_profile,
      "", "show profiling information", },
B
bellard 已提交
1854
    { "capture", "", do_info_capture,
B
bellard 已提交
1855
      "", "show capture information" },
B
bellard 已提交
1856
    { "snapshots", "", do_info_snapshots,
B
bellard 已提交
1857
      "", "show the currently saved VM snapshots" },
A
aurel32 已提交
1858 1859
    { "status", "", do_info_status,
      "", "show the current VM status (running|paused)" },
1860 1861
    { "pcmcia", "", pcmcia_info,
      "", "show guest PCMCIA status" },
1862 1863
    { "mice", "", do_info_mice,
      "", "show which guest mouse is receiving events" },
B
bellard 已提交
1864 1865
    { "vnc", "", do_info_vnc,
      "", "show the vnc server status"},
T
ths 已提交
1866 1867
    { "name", "", do_info_name,
      "", "show the current VM name" },
1868 1869
    { "uuid", "", do_info_uuid,
      "", "show the current VM UUID" },
1870 1871 1872 1873
#if defined(TARGET_PPC)
    { "cpustats", "", do_info_cpu_stats,
      "", "show CPU statistics", },
#endif
1874
#if defined(CONFIG_SLIRP)
1875 1876
    { "usernet", "", do_info_usernet,
      "", "show user network stack connection states", },
1877
#endif
A
aliguori 已提交
1878
    { "migrate", "", do_info_migrate, "", "show migration status" },
A
aliguori 已提交
1879 1880
    { "balloon", "", do_info_balloon,
      "", "show balloon information" },
1881 1882
    { "qtree", "", do_info_qtree,
      "", "show device tree" },
G
Gerd Hoffmann 已提交
1883 1884
    { "qdm", "", do_info_qdm,
      "", "show qdev device model list" },
B
bellard 已提交
1885 1886 1887
    { NULL, NULL, },
};

1888 1889 1890 1891 1892
/*******************************************************************/

static const char *pch;
static jmp_buf expr_env;

B
bellard 已提交
1893 1894 1895
#define MD_TLONG 0
#define MD_I32   1

1896 1897 1898
typedef struct MonitorDef {
    const char *name;
    int offset;
B
blueswir1 已提交
1899
    target_long (*get_value)(const struct MonitorDef *md, int val);
B
bellard 已提交
1900
    int type;
1901 1902
} MonitorDef;

B
bellard 已提交
1903
#if defined(TARGET_I386)
B
blueswir1 已提交
1904
static target_long monitor_get_pc (const struct MonitorDef *md, int val)
B
bellard 已提交
1905
{
B
bellard 已提交
1906 1907 1908 1909
    CPUState *env = mon_get_cpu();
    if (!env)
        return 0;
    return env->eip + env->segs[R_CS].base;
B
bellard 已提交
1910 1911 1912
}
#endif

1913
#if defined(TARGET_PPC)
B
blueswir1 已提交
1914
static target_long monitor_get_ccr (const struct MonitorDef *md, int val)
1915
{
B
bellard 已提交
1916
    CPUState *env = mon_get_cpu();
1917 1918 1919
    unsigned int u;
    int i;

B
bellard 已提交
1920 1921 1922
    if (!env)
        return 0;

1923 1924
    u = 0;
    for (i = 0; i < 8; i++)
1925
        u |= env->crf[i] << (32 - (4 * i));
1926 1927 1928 1929

    return u;
}

B
blueswir1 已提交
1930
static target_long monitor_get_msr (const struct MonitorDef *md, int val)
1931
{
B
bellard 已提交
1932 1933 1934
    CPUState *env = mon_get_cpu();
    if (!env)
        return 0;
1935
    return env->msr;
1936 1937
}

B
blueswir1 已提交
1938
static target_long monitor_get_xer (const struct MonitorDef *md, int val)
1939
{
B
bellard 已提交
1940 1941 1942
    CPUState *env = mon_get_cpu();
    if (!env)
        return 0;
A
aurel32 已提交
1943
    return env->xer;
1944
}
1945

B
blueswir1 已提交
1946
static target_long monitor_get_decr (const struct MonitorDef *md, int val)
1947
{
B
bellard 已提交
1948 1949 1950 1951
    CPUState *env = mon_get_cpu();
    if (!env)
        return 0;
    return cpu_ppc_load_decr(env);
1952 1953
}

B
blueswir1 已提交
1954
static target_long monitor_get_tbu (const struct MonitorDef *md, int val)
1955
{
B
bellard 已提交
1956 1957 1958 1959
    CPUState *env = mon_get_cpu();
    if (!env)
        return 0;
    return cpu_ppc_load_tbu(env);
1960 1961
}

B
blueswir1 已提交
1962
static target_long monitor_get_tbl (const struct MonitorDef *md, int val)
1963
{
B
bellard 已提交
1964 1965 1966 1967
    CPUState *env = mon_get_cpu();
    if (!env)
        return 0;
    return cpu_ppc_load_tbl(env);
1968
}
1969 1970
#endif

1971
#if defined(TARGET_SPARC)
B
bellard 已提交
1972
#ifndef TARGET_SPARC64
B
blueswir1 已提交
1973
static target_long monitor_get_psr (const struct MonitorDef *md, int val)
1974
{
B
bellard 已提交
1975 1976 1977 1978
    CPUState *env = mon_get_cpu();
    if (!env)
        return 0;
    return GET_PSR(env);
1979
}
B
bellard 已提交
1980
#endif
1981

B
blueswir1 已提交
1982
static target_long monitor_get_reg(const struct MonitorDef *md, int val)
1983
{
B
bellard 已提交
1984 1985 1986 1987
    CPUState *env = mon_get_cpu();
    if (!env)
        return 0;
    return env->regwptr[val];
1988 1989 1990
}
#endif

B
blueswir1 已提交
1991
static const MonitorDef monitor_defs[] = {
1992
#ifdef TARGET_I386
B
bellard 已提交
1993 1994

#define SEG(name, seg) \
B
bellard 已提交
1995
    { name, offsetof(CPUState, segs[seg].selector), NULL, MD_I32 },\
B
bellard 已提交
1996
    { name ".base", offsetof(CPUState, segs[seg].base) },\
B
bellard 已提交
1997
    { name ".limit", offsetof(CPUState, segs[seg].limit), NULL, MD_I32 },
B
bellard 已提交
1998

1999 2000 2001 2002 2003 2004 2005
    { "eax", offsetof(CPUState, regs[0]) },
    { "ecx", offsetof(CPUState, regs[1]) },
    { "edx", offsetof(CPUState, regs[2]) },
    { "ebx", offsetof(CPUState, regs[3]) },
    { "esp|sp", offsetof(CPUState, regs[4]) },
    { "ebp|fp", offsetof(CPUState, regs[5]) },
    { "esi", offsetof(CPUState, regs[6]) },
B
bellard 已提交
2006
    { "edi", offsetof(CPUState, regs[7]) },
B
bellard 已提交
2007 2008 2009 2010 2011 2012 2013 2014 2015 2016
#ifdef TARGET_X86_64
    { "r8", offsetof(CPUState, regs[8]) },
    { "r9", offsetof(CPUState, regs[9]) },
    { "r10", offsetof(CPUState, regs[10]) },
    { "r11", offsetof(CPUState, regs[11]) },
    { "r12", offsetof(CPUState, regs[12]) },
    { "r13", offsetof(CPUState, regs[13]) },
    { "r14", offsetof(CPUState, regs[14]) },
    { "r15", offsetof(CPUState, regs[15]) },
#endif
2017
    { "eflags", offsetof(CPUState, eflags) },
B
bellard 已提交
2018 2019 2020 2021
    { "eip", offsetof(CPUState, eip) },
    SEG("cs", R_CS)
    SEG("ds", R_DS)
    SEG("es", R_ES)
B
bellard 已提交
2022
    SEG("ss", R_SS)
B
bellard 已提交
2023 2024 2025
    SEG("fs", R_FS)
    SEG("gs", R_GS)
    { "pc", 0, monitor_get_pc, },
2026
#elif defined(TARGET_PPC)
J
j_mayer 已提交
2027
    /* General purpose registers */
2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059
    { "r0", offsetof(CPUState, gpr[0]) },
    { "r1", offsetof(CPUState, gpr[1]) },
    { "r2", offsetof(CPUState, gpr[2]) },
    { "r3", offsetof(CPUState, gpr[3]) },
    { "r4", offsetof(CPUState, gpr[4]) },
    { "r5", offsetof(CPUState, gpr[5]) },
    { "r6", offsetof(CPUState, gpr[6]) },
    { "r7", offsetof(CPUState, gpr[7]) },
    { "r8", offsetof(CPUState, gpr[8]) },
    { "r9", offsetof(CPUState, gpr[9]) },
    { "r10", offsetof(CPUState, gpr[10]) },
    { "r11", offsetof(CPUState, gpr[11]) },
    { "r12", offsetof(CPUState, gpr[12]) },
    { "r13", offsetof(CPUState, gpr[13]) },
    { "r14", offsetof(CPUState, gpr[14]) },
    { "r15", offsetof(CPUState, gpr[15]) },
    { "r16", offsetof(CPUState, gpr[16]) },
    { "r17", offsetof(CPUState, gpr[17]) },
    { "r18", offsetof(CPUState, gpr[18]) },
    { "r19", offsetof(CPUState, gpr[19]) },
    { "r20", offsetof(CPUState, gpr[20]) },
    { "r21", offsetof(CPUState, gpr[21]) },
    { "r22", offsetof(CPUState, gpr[22]) },
    { "r23", offsetof(CPUState, gpr[23]) },
    { "r24", offsetof(CPUState, gpr[24]) },
    { "r25", offsetof(CPUState, gpr[25]) },
    { "r26", offsetof(CPUState, gpr[26]) },
    { "r27", offsetof(CPUState, gpr[27]) },
    { "r28", offsetof(CPUState, gpr[28]) },
    { "r29", offsetof(CPUState, gpr[29]) },
    { "r30", offsetof(CPUState, gpr[30]) },
    { "r31", offsetof(CPUState, gpr[31]) },
J
j_mayer 已提交
2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094
    /* Floating point registers */
    { "f0", offsetof(CPUState, fpr[0]) },
    { "f1", offsetof(CPUState, fpr[1]) },
    { "f2", offsetof(CPUState, fpr[2]) },
    { "f3", offsetof(CPUState, fpr[3]) },
    { "f4", offsetof(CPUState, fpr[4]) },
    { "f5", offsetof(CPUState, fpr[5]) },
    { "f6", offsetof(CPUState, fpr[6]) },
    { "f7", offsetof(CPUState, fpr[7]) },
    { "f8", offsetof(CPUState, fpr[8]) },
    { "f9", offsetof(CPUState, fpr[9]) },
    { "f10", offsetof(CPUState, fpr[10]) },
    { "f11", offsetof(CPUState, fpr[11]) },
    { "f12", offsetof(CPUState, fpr[12]) },
    { "f13", offsetof(CPUState, fpr[13]) },
    { "f14", offsetof(CPUState, fpr[14]) },
    { "f15", offsetof(CPUState, fpr[15]) },
    { "f16", offsetof(CPUState, fpr[16]) },
    { "f17", offsetof(CPUState, fpr[17]) },
    { "f18", offsetof(CPUState, fpr[18]) },
    { "f19", offsetof(CPUState, fpr[19]) },
    { "f20", offsetof(CPUState, fpr[20]) },
    { "f21", offsetof(CPUState, fpr[21]) },
    { "f22", offsetof(CPUState, fpr[22]) },
    { "f23", offsetof(CPUState, fpr[23]) },
    { "f24", offsetof(CPUState, fpr[24]) },
    { "f25", offsetof(CPUState, fpr[25]) },
    { "f26", offsetof(CPUState, fpr[26]) },
    { "f27", offsetof(CPUState, fpr[27]) },
    { "f28", offsetof(CPUState, fpr[28]) },
    { "f29", offsetof(CPUState, fpr[29]) },
    { "f30", offsetof(CPUState, fpr[30]) },
    { "f31", offsetof(CPUState, fpr[31]) },
    { "fpscr", offsetof(CPUState, fpscr) },
    /* Next instruction pointer */
B
bellard 已提交
2095
    { "nip|pc", offsetof(CPUState, nip) },
2096 2097
    { "lr", offsetof(CPUState, lr) },
    { "ctr", offsetof(CPUState, ctr) },
2098
    { "decr", 0, &monitor_get_decr, },
2099
    { "ccr", 0, &monitor_get_ccr, },
J
j_mayer 已提交
2100
    /* Machine state register */
2101 2102
    { "msr", 0, &monitor_get_msr, },
    { "xer", 0, &monitor_get_xer, },
2103 2104
    { "tbu", 0, &monitor_get_tbu, },
    { "tbl", 0, &monitor_get_tbl, },
J
j_mayer 已提交
2105 2106 2107 2108 2109
#if defined(TARGET_PPC64)
    /* Address space register */
    { "asr", offsetof(CPUState, asr) },
#endif
    /* Segment registers */
2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127
    { "sdr1", offsetof(CPUState, sdr1) },
    { "sr0", offsetof(CPUState, sr[0]) },
    { "sr1", offsetof(CPUState, sr[1]) },
    { "sr2", offsetof(CPUState, sr[2]) },
    { "sr3", offsetof(CPUState, sr[3]) },
    { "sr4", offsetof(CPUState, sr[4]) },
    { "sr5", offsetof(CPUState, sr[5]) },
    { "sr6", offsetof(CPUState, sr[6]) },
    { "sr7", offsetof(CPUState, sr[7]) },
    { "sr8", offsetof(CPUState, sr[8]) },
    { "sr9", offsetof(CPUState, sr[9]) },
    { "sr10", offsetof(CPUState, sr[10]) },
    { "sr11", offsetof(CPUState, sr[11]) },
    { "sr12", offsetof(CPUState, sr[12]) },
    { "sr13", offsetof(CPUState, sr[13]) },
    { "sr14", offsetof(CPUState, sr[14]) },
    { "sr15", offsetof(CPUState, sr[15]) },
    /* Too lazy to put BATs and SPRs ... */
2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163
#elif defined(TARGET_SPARC)
    { "g0", offsetof(CPUState, gregs[0]) },
    { "g1", offsetof(CPUState, gregs[1]) },
    { "g2", offsetof(CPUState, gregs[2]) },
    { "g3", offsetof(CPUState, gregs[3]) },
    { "g4", offsetof(CPUState, gregs[4]) },
    { "g5", offsetof(CPUState, gregs[5]) },
    { "g6", offsetof(CPUState, gregs[6]) },
    { "g7", offsetof(CPUState, gregs[7]) },
    { "o0", 0, monitor_get_reg },
    { "o1", 1, monitor_get_reg },
    { "o2", 2, monitor_get_reg },
    { "o3", 3, monitor_get_reg },
    { "o4", 4, monitor_get_reg },
    { "o5", 5, monitor_get_reg },
    { "o6", 6, monitor_get_reg },
    { "o7", 7, monitor_get_reg },
    { "l0", 8, monitor_get_reg },
    { "l1", 9, monitor_get_reg },
    { "l2", 10, monitor_get_reg },
    { "l3", 11, monitor_get_reg },
    { "l4", 12, monitor_get_reg },
    { "l5", 13, monitor_get_reg },
    { "l6", 14, monitor_get_reg },
    { "l7", 15, monitor_get_reg },
    { "i0", 16, monitor_get_reg },
    { "i1", 17, monitor_get_reg },
    { "i2", 18, monitor_get_reg },
    { "i3", 19, monitor_get_reg },
    { "i4", 20, monitor_get_reg },
    { "i5", 21, monitor_get_reg },
    { "i6", 22, monitor_get_reg },
    { "i7", 23, monitor_get_reg },
    { "pc", offsetof(CPUState, pc) },
    { "npc", offsetof(CPUState, npc) },
    { "y", offsetof(CPUState, y) },
B
bellard 已提交
2164
#ifndef TARGET_SPARC64
2165 2166
    { "psr", 0, &monitor_get_psr, },
    { "wim", offsetof(CPUState, wim) },
B
bellard 已提交
2167
#endif
2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201
    { "tbr", offsetof(CPUState, tbr) },
    { "fsr", offsetof(CPUState, fsr) },
    { "f0", offsetof(CPUState, fpr[0]) },
    { "f1", offsetof(CPUState, fpr[1]) },
    { "f2", offsetof(CPUState, fpr[2]) },
    { "f3", offsetof(CPUState, fpr[3]) },
    { "f4", offsetof(CPUState, fpr[4]) },
    { "f5", offsetof(CPUState, fpr[5]) },
    { "f6", offsetof(CPUState, fpr[6]) },
    { "f7", offsetof(CPUState, fpr[7]) },
    { "f8", offsetof(CPUState, fpr[8]) },
    { "f9", offsetof(CPUState, fpr[9]) },
    { "f10", offsetof(CPUState, fpr[10]) },
    { "f11", offsetof(CPUState, fpr[11]) },
    { "f12", offsetof(CPUState, fpr[12]) },
    { "f13", offsetof(CPUState, fpr[13]) },
    { "f14", offsetof(CPUState, fpr[14]) },
    { "f15", offsetof(CPUState, fpr[15]) },
    { "f16", offsetof(CPUState, fpr[16]) },
    { "f17", offsetof(CPUState, fpr[17]) },
    { "f18", offsetof(CPUState, fpr[18]) },
    { "f19", offsetof(CPUState, fpr[19]) },
    { "f20", offsetof(CPUState, fpr[20]) },
    { "f21", offsetof(CPUState, fpr[21]) },
    { "f22", offsetof(CPUState, fpr[22]) },
    { "f23", offsetof(CPUState, fpr[23]) },
    { "f24", offsetof(CPUState, fpr[24]) },
    { "f25", offsetof(CPUState, fpr[25]) },
    { "f26", offsetof(CPUState, fpr[26]) },
    { "f27", offsetof(CPUState, fpr[27]) },
    { "f28", offsetof(CPUState, fpr[28]) },
    { "f29", offsetof(CPUState, fpr[29]) },
    { "f30", offsetof(CPUState, fpr[30]) },
    { "f31", offsetof(CPUState, fpr[31]) },
B
bellard 已提交
2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227
#ifdef TARGET_SPARC64
    { "f32", offsetof(CPUState, fpr[32]) },
    { "f34", offsetof(CPUState, fpr[34]) },
    { "f36", offsetof(CPUState, fpr[36]) },
    { "f38", offsetof(CPUState, fpr[38]) },
    { "f40", offsetof(CPUState, fpr[40]) },
    { "f42", offsetof(CPUState, fpr[42]) },
    { "f44", offsetof(CPUState, fpr[44]) },
    { "f46", offsetof(CPUState, fpr[46]) },
    { "f48", offsetof(CPUState, fpr[48]) },
    { "f50", offsetof(CPUState, fpr[50]) },
    { "f52", offsetof(CPUState, fpr[52]) },
    { "f54", offsetof(CPUState, fpr[54]) },
    { "f56", offsetof(CPUState, fpr[56]) },
    { "f58", offsetof(CPUState, fpr[58]) },
    { "f60", offsetof(CPUState, fpr[60]) },
    { "f62", offsetof(CPUState, fpr[62]) },
    { "asi", offsetof(CPUState, asi) },
    { "pstate", offsetof(CPUState, pstate) },
    { "cansave", offsetof(CPUState, cansave) },
    { "canrestore", offsetof(CPUState, canrestore) },
    { "otherwin", offsetof(CPUState, otherwin) },
    { "wstate", offsetof(CPUState, wstate) },
    { "cleanwin", offsetof(CPUState, cleanwin) },
    { "fprs", offsetof(CPUState, fprs) },
#endif
2228 2229 2230 2231
#endif
    { NULL },
};

A
aliguori 已提交
2232
static void expr_error(Monitor *mon, const char *msg)
B
bellard 已提交
2233
{
A
aliguori 已提交
2234
    monitor_printf(mon, "%s\n", msg);
2235 2236 2237
    longjmp(expr_env, 1);
}

B
bellard 已提交
2238
/* return 0 if OK, -1 if not found, -2 if no CPU defined */
B
bellard 已提交
2239
static int get_monitor_def(target_long *pval, const char *name)
2240
{
B
blueswir1 已提交
2241
    const MonitorDef *md;
B
bellard 已提交
2242 2243
    void *ptr;

2244 2245 2246
    for(md = monitor_defs; md->name != NULL; md++) {
        if (compare_cmd(name, md->name)) {
            if (md->get_value) {
2247
                *pval = md->get_value(md, md->offset);
2248
            } else {
B
bellard 已提交
2249 2250 2251 2252
                CPUState *env = mon_get_cpu();
                if (!env)
                    return -2;
                ptr = (uint8_t *)env + md->offset;
B
bellard 已提交
2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263
                switch(md->type) {
                case MD_I32:
                    *pval = *(int32_t *)ptr;
                    break;
                case MD_TLONG:
                    *pval = *(target_long *)ptr;
                    break;
                default:
                    *pval = 0;
                    break;
                }
2264 2265 2266 2267 2268 2269 2270 2271 2272
            }
            return 0;
        }
    }
    return -1;
}

static void next(void)
{
2273
    if (*pch != '\0') {
2274
        pch++;
2275
        while (qemu_isspace(*pch))
2276 2277 2278 2279
            pch++;
    }
}

A
aliguori 已提交
2280
static int64_t expr_sum(Monitor *mon);
2281

A
aliguori 已提交
2282
static int64_t expr_unary(Monitor *mon)
2283
{
B
blueswir1 已提交
2284
    int64_t n;
2285
    char *p;
B
bellard 已提交
2286
    int ret;
2287 2288 2289 2290

    switch(*pch) {
    case '+':
        next();
A
aliguori 已提交
2291
        n = expr_unary(mon);
2292 2293 2294
        break;
    case '-':
        next();
A
aliguori 已提交
2295
        n = -expr_unary(mon);
2296 2297 2298
        break;
    case '~':
        next();
A
aliguori 已提交
2299
        n = ~expr_unary(mon);
2300 2301 2302
        break;
    case '(':
        next();
A
aliguori 已提交
2303
        n = expr_sum(mon);
2304
        if (*pch != ')') {
A
aliguori 已提交
2305
            expr_error(mon, "')' expected");
2306 2307 2308
        }
        next();
        break;
B
bellard 已提交
2309 2310 2311
    case '\'':
        pch++;
        if (*pch == '\0')
A
aliguori 已提交
2312
            expr_error(mon, "character constant expected");
B
bellard 已提交
2313 2314 2315
        n = *pch;
        pch++;
        if (*pch != '\'')
A
aliguori 已提交
2316
            expr_error(mon, "missing terminating \' character");
B
bellard 已提交
2317 2318
        next();
        break;
2319 2320 2321
    case '$':
        {
            char buf[128], *q;
2322
            target_long reg=0;
2323

2324 2325 2326 2327 2328
            pch++;
            q = buf;
            while ((*pch >= 'a' && *pch <= 'z') ||
                   (*pch >= 'A' && *pch <= 'Z') ||
                   (*pch >= '0' && *pch <= '9') ||
B
bellard 已提交
2329
                   *pch == '_' || *pch == '.') {
2330 2331 2332 2333
                if ((q - buf) < sizeof(buf) - 1)
                    *q++ = *pch;
                pch++;
            }
2334
            while (qemu_isspace(*pch))
2335 2336
                pch++;
            *q = 0;
2337
            ret = get_monitor_def(&reg, buf);
B
bellard 已提交
2338
            if (ret == -1)
A
aliguori 已提交
2339
                expr_error(mon, "unknown register");
2340
            else if (ret == -2)
A
aliguori 已提交
2341
                expr_error(mon, "no cpu defined");
2342
            n = reg;
2343 2344 2345
        }
        break;
    case '\0':
A
aliguori 已提交
2346
        expr_error(mon, "unexpected end of expression");
2347 2348 2349
        n = 0;
        break;
    default:
2350
#if TARGET_PHYS_ADDR_BITS > 32
B
bellard 已提交
2351 2352
        n = strtoull(pch, &p, 0);
#else
2353
        n = strtoul(pch, &p, 0);
B
bellard 已提交
2354
#endif
2355
        if (pch == p) {
A
aliguori 已提交
2356
            expr_error(mon, "invalid char in expression");
2357 2358
        }
        pch = p;
2359
        while (qemu_isspace(*pch))
2360 2361 2362 2363 2364 2365 2366
            pch++;
        break;
    }
    return n;
}


A
aliguori 已提交
2367
static int64_t expr_prod(Monitor *mon)
2368
{
B
blueswir1 已提交
2369
    int64_t val, val2;
B
bellard 已提交
2370
    int op;
2371

A
aliguori 已提交
2372
    val = expr_unary(mon);
2373 2374 2375 2376 2377
    for(;;) {
        op = *pch;
        if (op != '*' && op != '/' && op != '%')
            break;
        next();
A
aliguori 已提交
2378
        val2 = expr_unary(mon);
2379 2380 2381 2382 2383 2384 2385
        switch(op) {
        default:
        case '*':
            val *= val2;
            break;
        case '/':
        case '%':
2386
            if (val2 == 0)
A
aliguori 已提交
2387
                expr_error(mon, "division by zero");
2388 2389 2390 2391 2392 2393 2394 2395 2396 2397
            if (op == '/')
                val /= val2;
            else
                val %= val2;
            break;
        }
    }
    return val;
}

A
aliguori 已提交
2398
static int64_t expr_logic(Monitor *mon)
2399
{
B
blueswir1 已提交
2400
    int64_t val, val2;
B
bellard 已提交
2401
    int op;
2402

A
aliguori 已提交
2403
    val = expr_prod(mon);
2404 2405 2406 2407 2408
    for(;;) {
        op = *pch;
        if (op != '&' && op != '|' && op != '^')
            break;
        next();
A
aliguori 已提交
2409
        val2 = expr_prod(mon);
2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425
        switch(op) {
        default:
        case '&':
            val &= val2;
            break;
        case '|':
            val |= val2;
            break;
        case '^':
            val ^= val2;
            break;
        }
    }
    return val;
}

A
aliguori 已提交
2426
static int64_t expr_sum(Monitor *mon)
2427
{
B
blueswir1 已提交
2428
    int64_t val, val2;
B
bellard 已提交
2429
    int op;
2430

A
aliguori 已提交
2431
    val = expr_logic(mon);
2432 2433 2434 2435 2436
    for(;;) {
        op = *pch;
        if (op != '+' && op != '-')
            break;
        next();
A
aliguori 已提交
2437
        val2 = expr_logic(mon);
2438 2439 2440 2441 2442 2443 2444 2445
        if (op == '+')
            val += val2;
        else
            val -= val2;
    }
    return val;
}

A
aliguori 已提交
2446
static int get_expr(Monitor *mon, int64_t *pval, const char **pp)
2447 2448 2449 2450 2451 2452
{
    pch = *pp;
    if (setjmp(expr_env)) {
        *pp = pch;
        return -1;
    }
2453
    while (qemu_isspace(*pch))
2454
        pch++;
A
aliguori 已提交
2455
    *pval = expr_sum(mon);
2456 2457 2458 2459 2460 2461 2462 2463 2464 2465
    *pp = pch;
    return 0;
}

static int get_str(char *buf, int buf_size, const char **pp)
{
    const char *p;
    char *q;
    int c;

B
bellard 已提交
2466
    q = buf;
2467
    p = *pp;
2468
    while (qemu_isspace(*p))
2469 2470 2471
        p++;
    if (*p == '\0') {
    fail:
B
bellard 已提交
2472
        *q = '\0';
2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507
        *pp = p;
        return -1;
    }
    if (*p == '\"') {
        p++;
        while (*p != '\0' && *p != '\"') {
            if (*p == '\\') {
                p++;
                c = *p++;
                switch(c) {
                case 'n':
                    c = '\n';
                    break;
                case 'r':
                    c = '\r';
                    break;
                case '\\':
                case '\'':
                case '\"':
                    break;
                default:
                    qemu_printf("unsupported escape code: '\\%c'\n", c);
                    goto fail;
                }
                if ((q - buf) < buf_size - 1) {
                    *q++ = c;
                }
            } else {
                if ((q - buf) < buf_size - 1) {
                    *q++ = *p;
                }
                p++;
            }
        }
        if (*p != '\"') {
B
bellard 已提交
2508
            qemu_printf("unterminated string\n");
2509 2510 2511 2512
            goto fail;
        }
        p++;
    } else {
2513
        while (*p != '\0' && !qemu_isspace(*p)) {
2514 2515 2516 2517 2518 2519
            if ((q - buf) < buf_size - 1) {
                *q++ = *p;
            }
            p++;
        }
    }
B
bellard 已提交
2520
    *q = '\0';
2521 2522 2523 2524
    *pp = p;
    return 0;
}

2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550
/*
 * Store the command-name in cmdname, and return a pointer to
 * the remaining of the command string.
 */
static const char *get_command_name(const char *cmdline,
                                    char *cmdname, size_t nlen)
{
    size_t len;
    const char *p, *pstart;

    p = cmdline;
    while (qemu_isspace(*p))
        p++;
    if (*p == '\0')
        return NULL;
    pstart = p;
    while (*p != '\0' && *p != '/' && !qemu_isspace(*p))
        p++;
    len = p - pstart;
    if (len > nlen - 1)
        len = nlen - 1;
    memcpy(cmdname, pstart, len);
    cmdname[len] = '\0';
    return p;
}

2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577
/**
 * Read key of 'type' into 'key' and return the current
 * 'type' pointer.
 */
static char *key_get_info(const char *type, char **key)
{
    size_t len;
    char *p, *str;

    if (*type == ',')
        type++;

    p = strchr(type, ':');
    if (!p) {
        *key = NULL;
        return NULL;
    }
    len = p - type;

    str = qemu_malloc(len + 1);
    memcpy(str, type, len);
    str[len] = '\0';

    *key = str;
    return ++p;
}

2578 2579 2580 2581 2582
static int default_fmt_format = 'x';
static int default_fmt_size = 4;

#define MAX_ARGS 16

2583 2584 2585
static const mon_cmd_t *monitor_parse_command(Monitor *mon,
                                              const char *cmdline,
                                              QDict *qdict)
2586
{
2587
    const char *p, *typestr;
2588
    int c;
A
aliguori 已提交
2589
    const mon_cmd_t *cmd;
2590 2591
    char cmdname[256];
    char buf[1024];
2592
    char *key;
B
bellard 已提交
2593 2594

#ifdef DEBUG
A
aliguori 已提交
2595
    monitor_printf(mon, "command='%s'\n", cmdline);
B
bellard 已提交
2596
#endif
2597

2598
    /* extract the command name */
2599 2600
    p = get_command_name(cmdline, cmdname, sizeof(cmdname));
    if (!p)
2601
        return NULL;
2602

2603
    /* find the command */
A
aliguori 已提交
2604
    for(cmd = mon_cmds; cmd->name != NULL; cmd++) {
2605
        if (compare_cmd(cmdname, cmd->name))
L
Luiz Capitulino 已提交
2606 2607 2608 2609 2610
            break;
    }

    if (cmd->name == NULL) {
        monitor_printf(mon, "unknown command: '%s'\n", cmdname);
2611
        return NULL;
2612 2613 2614 2615
    }

    /* parse the parameters */
    typestr = cmd->args_type;
B
bellard 已提交
2616
    for(;;) {
2617 2618
        typestr = key_get_info(typestr, &key);
        if (!typestr)
B
bellard 已提交
2619
            break;
2620
        c = *typestr;
2621 2622 2623
        typestr++;
        switch(c) {
        case 'F':
B
bellard 已提交
2624
        case 'B':
2625 2626 2627
        case 's':
            {
                int ret;
2628

2629
                while (qemu_isspace(*p))
2630 2631 2632 2633 2634
                    p++;
                if (*typestr == '?') {
                    typestr++;
                    if (*p == '\0') {
                        /* no optional string: NULL argument */
2635
                        break;
2636 2637 2638 2639
                    }
                }
                ret = get_str(buf, sizeof(buf), &p);
                if (ret < 0) {
B
bellard 已提交
2640 2641
                    switch(c) {
                    case 'F':
A
aliguori 已提交
2642 2643
                        monitor_printf(mon, "%s: filename expected\n",
                                       cmdname);
B
bellard 已提交
2644 2645
                        break;
                    case 'B':
A
aliguori 已提交
2646 2647
                        monitor_printf(mon, "%s: block device name expected\n",
                                       cmdname);
B
bellard 已提交
2648 2649
                        break;
                    default:
A
aliguori 已提交
2650
                        monitor_printf(mon, "%s: string expected\n", cmdname);
B
bellard 已提交
2651 2652
                        break;
                    }
2653 2654
                    goto fail;
                }
2655
                qdict_put(qdict, key, qstring_from_str(buf));
2656
            }
B
bellard 已提交
2657
            break;
2658 2659 2660
        case '/':
            {
                int count, format, size;
2661

2662
                while (qemu_isspace(*p))
2663 2664 2665 2666 2667
                    p++;
                if (*p == '/') {
                    /* format found */
                    p++;
                    count = 1;
2668
                    if (qemu_isdigit(*p)) {
2669
                        count = 0;
2670
                        while (qemu_isdigit(*p)) {
2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708
                            count = count * 10 + (*p - '0');
                            p++;
                        }
                    }
                    size = -1;
                    format = -1;
                    for(;;) {
                        switch(*p) {
                        case 'o':
                        case 'd':
                        case 'u':
                        case 'x':
                        case 'i':
                        case 'c':
                            format = *p++;
                            break;
                        case 'b':
                            size = 1;
                            p++;
                            break;
                        case 'h':
                            size = 2;
                            p++;
                            break;
                        case 'w':
                            size = 4;
                            p++;
                            break;
                        case 'g':
                        case 'L':
                            size = 8;
                            p++;
                            break;
                        default:
                            goto next;
                        }
                    }
                next:
2709
                    if (*p != '\0' && !qemu_isspace(*p)) {
A
aliguori 已提交
2710 2711
                        monitor_printf(mon, "invalid char in format: '%c'\n",
                                       *p);
2712 2713 2714 2715
                        goto fail;
                    }
                    if (format < 0)
                        format = default_fmt_format;
2716 2717 2718 2719
                    if (format != 'i') {
                        /* for 'i', not specifying a size gives -1 as size */
                        if (size < 0)
                            size = default_fmt_size;
A
aurel32 已提交
2720
                        default_fmt_size = size;
2721
                    }
2722 2723 2724 2725
                    default_fmt_format = format;
                } else {
                    count = 1;
                    format = default_fmt_format;
2726 2727 2728 2729 2730
                    if (format != 'i') {
                        size = default_fmt_size;
                    } else {
                        size = -1;
                    }
2731
                }
2732 2733 2734
                qdict_put(qdict, "count", qint_from_int(count));
                qdict_put(qdict, "format", qint_from_int(format));
                qdict_put(qdict, "size", qint_from_int(size));
2735
            }
B
bellard 已提交
2736
            break;
2737
        case 'i':
B
bellard 已提交
2738
        case 'l':
2739
            {
B
blueswir1 已提交
2740
                int64_t val;
2741

2742
                while (qemu_isspace(*p))
2743
                    p++;
B
bellard 已提交
2744 2745
                if (*typestr == '?' || *typestr == '.') {
                    if (*typestr == '?') {
2746 2747 2748 2749
                        if (*p == '\0') {
                            typestr++;
                            break;
                        }
B
bellard 已提交
2750 2751 2752
                    } else {
                        if (*p == '.') {
                            p++;
2753
                            while (qemu_isspace(*p))
B
bellard 已提交
2754 2755
                                p++;
                        } else {
2756 2757
                            typestr++;
                            break;
B
bellard 已提交
2758 2759
                        }
                    }
B
bellard 已提交
2760
                    typestr++;
2761
                }
A
aliguori 已提交
2762
                if (get_expr(mon, &val, &p))
2763
                    goto fail;
2764 2765 2766 2767 2768 2769
                /* Check if 'i' is greater than 32-bit */
                if ((c == 'i') && ((val >> 32) & 0xffffffff)) {
                    monitor_printf(mon, "\'%s\' has failed: ", cmdname);
                    monitor_printf(mon, "integer is for 32-bit values\n");
                    goto fail;
                }
2770
                qdict_put(qdict, key, qint_from_int(val));
2771 2772 2773 2774 2775 2776
            }
            break;
        case '-':
            {
                int has_option;
                /* option */
2777

2778 2779 2780
                c = *typestr++;
                if (c == '\0')
                    goto bad_type;
2781
                while (qemu_isspace(*p))
2782 2783 2784 2785 2786
                    p++;
                has_option = 0;
                if (*p == '-') {
                    p++;
                    if (*p != c) {
A
aliguori 已提交
2787 2788
                        monitor_printf(mon, "%s: unsupported option -%c\n",
                                       cmdname, *p);
2789 2790 2791 2792 2793
                        goto fail;
                    }
                    p++;
                    has_option = 1;
                }
2794
                qdict_put(qdict, key, qint_from_int(has_option));
2795 2796 2797 2798
            }
            break;
        default:
        bad_type:
A
aliguori 已提交
2799
            monitor_printf(mon, "%s: unknown type '%c'\n", cmdname, c);
2800 2801
            goto fail;
        }
2802 2803
        qemu_free(key);
        key = NULL;
B
bellard 已提交
2804
    }
2805
    /* check that all arguments were parsed */
2806
    while (qemu_isspace(*p))
2807 2808
        p++;
    if (*p != '\0') {
A
aliguori 已提交
2809 2810
        monitor_printf(mon, "%s: extraneous characters at the end of line\n",
                       cmdname);
2811
        goto fail;
B
bellard 已提交
2812
    }
2813

2814
    return cmd;
G
Gerd Hoffmann 已提交
2815

2816
fail:
2817
    qemu_free(key);
2818 2819 2820 2821 2822 2823 2824 2825 2826 2827
    return NULL;
}

static void monitor_handle_command(Monitor *mon, const char *cmdline)
{
    QDict *qdict;
    const mon_cmd_t *cmd;

    qdict = qdict_new();

L
Luiz Capitulino 已提交
2828
    cmd = monitor_parse_command(mon, cmdline, qdict);
2829 2830 2831 2832 2833 2834 2835 2836 2837 2838 2839
    if (cmd) {
        void (*handler)(Monitor *mon, const QDict *qdict);

        qemu_errors_to_mon(mon);

        handler = cmd->handler;
        handler(mon, qdict);

        qemu_errors_to_previous();
    }

2840
    QDECREF(qdict);
B
bellard 已提交
2841 2842
}

B
bellard 已提交
2843 2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860
static void cmd_completion(const char *name, const char *list)
{
    const char *p, *pstart;
    char cmd[128];
    int len;

    p = list;
    for(;;) {
        pstart = p;
        p = strchr(p, '|');
        if (!p)
            p = pstart + strlen(pstart);
        len = p - pstart;
        if (len > sizeof(cmd) - 2)
            len = sizeof(cmd) - 2;
        memcpy(cmd, pstart, len);
        cmd[len] = '\0';
        if (name[0] == '\0' || !strncmp(name, cmd, strlen(name))) {
2861
            readline_add_completion(cur_mon->rs, cmd);
B
bellard 已提交
2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877
        }
        if (*p == '\0')
            break;
        p++;
    }
}

static void file_completion(const char *input)
{
    DIR *ffs;
    struct dirent *d;
    char path[1024];
    char file[1024], file_prefix[1024];
    int input_path_len;
    const char *p;

2878
    p = strrchr(input, '/');
B
bellard 已提交
2879 2880 2881
    if (!p) {
        input_path_len = 0;
        pstrcpy(file_prefix, sizeof(file_prefix), input);
B
blueswir1 已提交
2882
        pstrcpy(path, sizeof(path), ".");
B
bellard 已提交
2883 2884 2885 2886 2887 2888 2889 2890 2891
    } else {
        input_path_len = p - input + 1;
        memcpy(path, input, input_path_len);
        if (input_path_len > sizeof(path) - 1)
            input_path_len = sizeof(path) - 1;
        path[input_path_len] = '\0';
        pstrcpy(file_prefix, sizeof(file_prefix), p + 1);
    }
#ifdef DEBUG_COMPLETION
A
aliguori 已提交
2892 2893
    monitor_printf(cur_mon, "input='%s' path='%s' prefix='%s'\n",
                   input, path, file_prefix);
B
bellard 已提交
2894 2895 2896 2897 2898 2899 2900 2901 2902 2903 2904
#endif
    ffs = opendir(path);
    if (!ffs)
        return;
    for(;;) {
        struct stat sb;
        d = readdir(ffs);
        if (!d)
            break;
        if (strstart(d->d_name, file_prefix, NULL)) {
            memcpy(file, input, input_path_len);
B
blueswir1 已提交
2905 2906 2907
            if (input_path_len < sizeof(file))
                pstrcpy(file + input_path_len, sizeof(file) - input_path_len,
                        d->d_name);
B
bellard 已提交
2908 2909 2910 2911 2912
            /* stat the file to find out if it's a directory.
             * In that case add a slash to speed up typing long paths
             */
            stat(file, &sb);
            if(S_ISDIR(sb.st_mode))
B
blueswir1 已提交
2913
                pstrcat(file, sizeof(file), "/");
2914
            readline_add_completion(cur_mon->rs, file);
B
bellard 已提交
2915 2916 2917 2918 2919
        }
    }
    closedir(ffs);
}

2920
static void block_completion_it(void *opaque, BlockDriverState *bs)
B
bellard 已提交
2921
{
2922
    const char *name = bdrv_get_device_name(bs);
B
bellard 已提交
2923 2924 2925 2926
    const char *input = opaque;

    if (input[0] == '\0' ||
        !strncmp(name, (char *)input, strlen(input))) {
2927
        readline_add_completion(cur_mon->rs, name);
B
bellard 已提交
2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941
    }
}

/* NOTE: this parser is an approximate form of the real command parser */
static void parse_cmdline(const char *cmdline,
                         int *pnb_args, char **args)
{
    const char *p;
    int nb_args, ret;
    char buf[1024];

    p = cmdline;
    nb_args = 0;
    for(;;) {
2942
        while (qemu_isspace(*p))
B
bellard 已提交
2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956
            p++;
        if (*p == '\0')
            break;
        if (nb_args >= MAX_ARGS)
            break;
        ret = get_str(buf, sizeof(buf), &p);
        args[nb_args] = qemu_strdup(buf);
        nb_args++;
        if (ret < 0)
            break;
    }
    *pnb_args = nb_args;
}

2957 2958 2959 2960 2961 2962
static const char *next_arg_type(const char *typestr)
{
    const char *p = strchr(typestr, ':');
    return (p != NULL ? ++p : typestr);
}

2963
static void monitor_find_completion(const char *cmdline)
B
bellard 已提交
2964 2965 2966 2967 2968
{
    const char *cmdname;
    char *args[MAX_ARGS];
    int nb_args, i, len;
    const char *ptype, *str;
A
aliguori 已提交
2969
    const mon_cmd_t *cmd;
2970
    const KeyDef *key;
B
bellard 已提交
2971 2972 2973 2974

    parse_cmdline(cmdline, &nb_args, args);
#ifdef DEBUG_COMPLETION
    for(i = 0; i < nb_args; i++) {
A
aliguori 已提交
2975
        monitor_printf(cur_mon, "arg%d = '%s'\n", i, (char *)args[i]);
B
bellard 已提交
2976 2977 2978 2979 2980 2981
    }
#endif

    /* if the line ends with a space, it means we want to complete the
       next arg */
    len = strlen(cmdline);
2982
    if (len > 0 && qemu_isspace(cmdline[len - 1])) {
B
bellard 已提交
2983 2984 2985 2986 2987 2988 2989 2990 2991 2992
        if (nb_args >= MAX_ARGS)
            return;
        args[nb_args++] = qemu_strdup("");
    }
    if (nb_args <= 1) {
        /* command completion */
        if (nb_args == 0)
            cmdname = "";
        else
            cmdname = args[0];
2993
        readline_set_completion_index(cur_mon->rs, strlen(cmdname));
A
aliguori 已提交
2994
        for(cmd = mon_cmds; cmd->name != NULL; cmd++) {
B
bellard 已提交
2995 2996 2997 2998
            cmd_completion(cmdname, cmd->name);
        }
    } else {
        /* find the command */
A
aliguori 已提交
2999
        for(cmd = mon_cmds; cmd->name != NULL; cmd++) {
B
bellard 已提交
3000 3001 3002 3003 3004
            if (compare_cmd(args[0], cmd->name))
                goto found;
        }
        return;
    found:
3005
        ptype = next_arg_type(cmd->args_type);
B
bellard 已提交
3006 3007
        for(i = 0; i < nb_args - 2; i++) {
            if (*ptype != '\0') {
3008
                ptype = next_arg_type(ptype);
B
bellard 已提交
3009
                while (*ptype == '?')
3010
                    ptype = next_arg_type(ptype);
B
bellard 已提交
3011 3012 3013
            }
        }
        str = args[nb_args - 1];
3014 3015 3016
        if (*ptype == '-' && ptype[1] != '\0') {
            ptype += 2;
        }
B
bellard 已提交
3017 3018 3019
        switch(*ptype) {
        case 'F':
            /* file completion */
3020
            readline_set_completion_index(cur_mon->rs, strlen(str));
B
bellard 已提交
3021 3022 3023 3024
            file_completion(str);
            break;
        case 'B':
            /* block device name completion */
3025
            readline_set_completion_index(cur_mon->rs, strlen(str));
B
bellard 已提交
3026 3027
            bdrv_iterate(block_completion_it, (void *)str);
            break;
B
bellard 已提交
3028 3029 3030
        case 's':
            /* XXX: more generic ? */
            if (!strcmp(cmd->name, "info")) {
3031
                readline_set_completion_index(cur_mon->rs, strlen(str));
B
bellard 已提交
3032 3033 3034
                for(cmd = info_cmds; cmd->name != NULL; cmd++) {
                    cmd_completion(str, cmd->name);
                }
3035
            } else if (!strcmp(cmd->name, "sendkey")) {
B
blueswir1 已提交
3036 3037 3038
                char *sep = strrchr(str, '-');
                if (sep)
                    str = sep + 1;
3039
                readline_set_completion_index(cur_mon->rs, strlen(str));
3040 3041 3042
                for(key = key_defs; key->name != NULL; key++) {
                    cmd_completion(str, key->name);
                }
3043 3044 3045 3046 3047
            } else if (!strcmp(cmd->name, "help|?")) {
                readline_set_completion_index(cur_mon->rs, strlen(str));
                for (cmd = mon_cmds; cmd->name != NULL; cmd++) {
                    cmd_completion(str, cmd->name);
                }
B
bellard 已提交
3048 3049
            }
            break;
B
bellard 已提交
3050 3051 3052 3053 3054 3055 3056 3057
        default:
            break;
        }
    }
    for(i = 0; i < nb_args; i++)
        qemu_free(args[i]);
}

3058
static int monitor_can_read(void *opaque)
B
bellard 已提交
3059
{
3060 3061 3062
    Monitor *mon = opaque;

    return (mon->suspend_cnt == 0) ? 128 : 0;
B
bellard 已提交
3063 3064
}

3065
static void monitor_read(void *opaque, const uint8_t *buf, int size)
B
bellard 已提交
3066
{
3067
    Monitor *old_mon = cur_mon;
3068
    int i;
A
aliguori 已提交
3069

3070 3071
    cur_mon = opaque;

3072 3073 3074 3075 3076 3077 3078 3079 3080
    if (cur_mon->rs) {
        for (i = 0; i < size; i++)
            readline_handle_byte(cur_mon->rs, buf[i]);
    } else {
        if (size == 0 || buf[size - 1] != 0)
            monitor_printf(cur_mon, "corrupted command\n");
        else
            monitor_handle_command(cur_mon, (char *)buf);
    }
B
bellard 已提交
3081

3082 3083
    cur_mon = old_mon;
}
3084

A
aliguori 已提交
3085
static void monitor_command_cb(Monitor *mon, const char *cmdline, void *opaque)
B
bellard 已提交
3086
{
3087
    monitor_suspend(mon);
A
aliguori 已提交
3088
    monitor_handle_command(mon, cmdline);
3089
    monitor_resume(mon);
3090 3091
}

3092
int monitor_suspend(Monitor *mon)
3093
{
3094 3095
    if (!mon->rs)
        return -ENOTTY;
3096
    mon->suspend_cnt++;
3097
    return 0;
3098 3099
}

A
aliguori 已提交
3100
void monitor_resume(Monitor *mon)
3101
{
3102 3103
    if (!mon->rs)
        return;
3104 3105
    if (--mon->suspend_cnt == 0)
        readline_show_prompt(mon->rs);
B
bellard 已提交
3106 3107
}

3108
static void monitor_event(void *opaque, int event)
3109
{
A
aliguori 已提交
3110 3111
    Monitor *mon = opaque;

3112 3113 3114 3115 3116 3117 3118 3119 3120 3121 3122 3123 3124
    switch (event) {
    case CHR_EVENT_MUX_IN:
        readline_restart(mon->rs);
        monitor_resume(mon);
        monitor_flush(mon);
        break;

    case CHR_EVENT_MUX_OUT:
        if (mon->suspend_cnt == 0)
            monitor_printf(mon, "\n");
        monitor_flush(mon);
        monitor_suspend(mon);
        break;
3125

3126 3127 3128 3129 3130 3131 3132
    case CHR_EVENT_RESET:
        monitor_printf(mon, "QEMU %s monitor - type 'help' for more "
                       "information\n", QEMU_VERSION);
        if (mon->chr->focus == 0)
            readline_show_prompt(mon->rs);
        break;
    }
3133 3134
}

3135 3136 3137 3138 3139 3140 3141 3142 3143

/*
 * Local variables:
 *  c-indent-level: 4
 *  c-basic-offset: 4
 *  tab-width: 8
 * End:
 */

3144
void monitor_init(CharDriverState *chr, int flags)
B
bellard 已提交
3145
{
3146
    static int is_first_init = 1;
3147
    Monitor *mon;
T
ths 已提交
3148 3149

    if (is_first_init) {
3150
        key_timer = qemu_new_timer(vm_clock, release_keys, NULL);
T
ths 已提交
3151 3152
        is_first_init = 0;
    }
3153 3154

    mon = qemu_mallocz(sizeof(*mon));
T
ths 已提交
3155

3156
    mon->chr = chr;
3157
    mon->flags = flags;
3158 3159
    if (mon->chr->focus != 0)
        mon->suspend_cnt = 1; /* mux'ed monitors start suspended */
3160 3161 3162 3163
    if (flags & MONITOR_USE_READLINE) {
        mon->rs = readline_init(mon, monitor_find_completion);
        monitor_read_command(mon, 0);
    }
3164

3165 3166
    qemu_chr_add_handlers(chr, monitor_can_read, monitor_read, monitor_event,
                          mon);
3167 3168

    LIST_INSERT_HEAD(&mon_list, mon, entry);
3169
    if (!cur_mon || (flags & MONITOR_IS_DEFAULT))
3170
        cur_mon = mon;
B
bellard 已提交
3171 3172
}

A
aliguori 已提交
3173
static void bdrv_password_cb(Monitor *mon, const char *password, void *opaque)
B
bellard 已提交
3174
{
3175 3176
    BlockDriverState *bs = opaque;
    int ret = 0;
B
bellard 已提交
3177

3178
    if (bdrv_set_key(bs, password) != 0) {
A
aliguori 已提交
3179
        monitor_printf(mon, "invalid password\n");
3180
        ret = -EPERM;
B
bellard 已提交
3181
    }
3182 3183
    if (mon->password_completion_cb)
        mon->password_completion_cb(mon->password_opaque, ret);
3184

3185
    monitor_read_command(mon, 1);
B
bellard 已提交
3186
}
3187

A
aliguori 已提交
3188
void monitor_read_bdrv_key_start(Monitor *mon, BlockDriverState *bs,
3189 3190
                                 BlockDriverCompletionFunc *completion_cb,
                                 void *opaque)
3191
{
3192 3193
    int err;

3194 3195 3196 3197 3198
    if (!bdrv_key_required(bs)) {
        if (completion_cb)
            completion_cb(opaque, 0);
        return;
    }
3199

A
aliguori 已提交
3200 3201
    monitor_printf(mon, "%s (%s) is encrypted.\n", bdrv_get_device_name(bs),
                   bdrv_get_encrypted_filename(bs));
3202

3203 3204
    mon->password_completion_cb = completion_cb;
    mon->password_opaque = opaque;
3205

3206 3207 3208 3209
    err = monitor_read_password(mon, bdrv_password_cb, bs);

    if (err && completion_cb)
        completion_cb(opaque, err);
3210
}
G
Gerd Hoffmann 已提交
3211 3212 3213 3214 3215 3216 3217 3218 3219 3220 3221 3222 3223 3224

typedef struct QemuErrorSink QemuErrorSink;
struct QemuErrorSink {
    enum {
        ERR_SINK_FILE,
        ERR_SINK_MONITOR,
    } dest;
    union {
        FILE    *fp;
        Monitor *mon;
    };
    QemuErrorSink *previous;
};

B
Blue Swirl 已提交
3225
static QemuErrorSink *qemu_error_sink;
G
Gerd Hoffmann 已提交
3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253 3254 3255 3256 3257 3258 3259 3260 3261 3262 3263 3264 3265 3266 3267 3268 3269 3270 3271 3272 3273 3274 3275 3276

void qemu_errors_to_file(FILE *fp)
{
    QemuErrorSink *sink;

    sink = qemu_mallocz(sizeof(*sink));
    sink->dest = ERR_SINK_FILE;
    sink->fp = fp;
    sink->previous = qemu_error_sink;
    qemu_error_sink = sink;
}

void qemu_errors_to_mon(Monitor *mon)
{
    QemuErrorSink *sink;

    sink = qemu_mallocz(sizeof(*sink));
    sink->dest = ERR_SINK_MONITOR;
    sink->mon = mon;
    sink->previous = qemu_error_sink;
    qemu_error_sink = sink;
}

void qemu_errors_to_previous(void)
{
    QemuErrorSink *sink;

    assert(qemu_error_sink != NULL);
    sink = qemu_error_sink;
    qemu_error_sink = sink->previous;
    qemu_free(sink);
}

void qemu_error(const char *fmt, ...)
{
    va_list args;

    assert(qemu_error_sink != NULL);
    switch (qemu_error_sink->dest) {
    case ERR_SINK_FILE:
        va_start(args, fmt);
        vfprintf(qemu_error_sink->fp, fmt, args);
        va_end(args);
        break;
    case ERR_SINK_MONITOR:
        va_start(args, fmt);
        monitor_vprintf(qemu_error_sink->mon, fmt, args);
        va_end(args);
        break;
    }
}